Unity3D仿星露谷物语开发44之收集农作物

已于 2025-05-17 19:03:12 修改
阅读量1.3k 收藏 14
点赞数 9
分类专栏： 游戏 Unity 文章标签： 游戏 游戏引擎 前端 unity
于 2025-05-17 19:02:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/benben044/article/details/148027992
版权

1、目标

在土地中挖掘后，洒下种子后逐渐成长，然后使用篮子收集成熟后的农作物，工具栏中也会相应地增加该农作物。

2、修改CropStandard的参数

Assets -> Prefabs -> Crop下的CropStandard，修改其Box Collider 2D的Size(Y)值为0.5。

3、修改GridCursor.cs脚本

添加如下代码：

[SerializeField] private SO_CropDetailsList so_CropDetailsList = null;

在IsCursorValidForTool函数中添加case ItemType.Collecting_tool代码：

private bool IsCursorValidForTool(GridPropertyDetails gridPropertyDetails, ItemDetails itemDetails)
{
    // Switch on tool
    switch (itemDetails.itemType)
    {
        case ItemType.Hoeing_tool:
            if (gridPropertyDetails.isDiggable == true && gridPropertyDetails.daysSinceDug == -1)
            {
                #region Need to get any items at location so we can check if they are reapable
                // Get world position for cursor
                Vector3 cursorWorldPosition = new Vector3(GetWorldPositionForCursor().x + 0.5f, GetWorldPositionForCursor().y + 0.5f, 0f);

                // Get list of items at cursor location
                List<Item> itemList = new List<Item>();

                HelperMethods.GetComponentsAtBoxLocation<Item>(out itemList, cursorWorldPosition, Settings.cursorSize, 0f);
                #endregion

                // Loop through items found to see if any are reapable type - we are not goint to let the player dig where there are reapable scenary items
                bool foundReapable = false;

                foreach(Item item in itemList)
                {
                    if(InventoryManager.Instance.GetItemDetails(item.ItemCode).itemType == ItemType.Reapable_scenary)
                    {
                        foundReapable = true;
                        break;
                    }
                }

                if (foundReapable)
                {
                    return false;
                }
                else
                {
                    return true;
                }

            }
            else
            {
                return false;
            }

        case ItemType.Watering_tool:
            if(gridPropertyDetails.daysSinceDug > -1 && gridPropertyDetails.daysSinceWatered == -1)
            {
                return true;
            }
            else
            {
                return false;
            }

        case ItemType.Collecting_tool:
            // Check if item can be harvested with item selected, check item is fully grown

            // Check if seed planted
            if(gridPropertyDetails.seedItemCode != -1)
            {
                // Get crop details for seed 
                CropDetails cropDetails = so_CropDetailsList.GetCropDetails(gridPropertyDetails.seedItemCode);

                // if crop details found
                if(cropDetails != null)
                {
                    // Check if crop fully grown
                    if(gridPropertyDetails.growthDays >= cropDetails.totalGrowthDays)
                    {
                        // Check if crop can be harvested with tool selected
                        if (cropDetails.CanUseToolToHarvestCrop(itemDetails.itemCode))
                        {
                            return true;
                        }
                        else
                        {
                            return false;
                        }
                    }
                    else
                    {
                        return false;
                    }
                }
            }

            return false;

         default:
            return false;
           
    }

}

4、配置UIPanel的信息

Hierarchy -> PersistentScene -> UI -> MainGameUICanvas -> UICanvasGroup -> UIPanel，

配置SO_CropDetailsList的信息：

5、测试光标效果

种植完防风草，然后等待它们成长。

使用basket工具，发现只有成熟的防风草才会显示绿色光标，否则显示红色光标。

6、修改GridPropertiesManager.cs脚本

添加如下代码：

 /// <summary>
 /// Returns the Crop object at the gridX, gridY position or null if no crop was found
 /// </summary>
 /// <param name="gridPropertyDetails"></param>
 /// <returns></returns>
 public Crop GetCropObjectAtGridLocation(GridPropertyDetails gridPropertyDetails)
 {
     Vector3 worldPosition = grid.GetCellCenterWorld(new Vector3Int(gridPropertyDetails.gridX, gridPropertyDetails.gridY, 0));
     Collider2D[] collider2DArray = Physics2D.OverlapPointAll(worldPosition);

     // Loop through colliders to get crop game object
     Crop crop = null;

     for(int i = 0; i < collider2DArray.Length; i++)
     {
         crop = collider2DArray[i].gameObject.GetComponentInParent<Crop>();
         if (crop != null && crop.cropGridPosition == new Vector2Int(gridPropertyDetails.gridX, gridPropertyDetails.gridY))
             break;

         crop = collider2DArray[i].gameObject.GetComponentInChildren<Crop>();
         if(crop != null && crop.cropGridPosition == new Vector2Int(gridPropertyDetails.gridX, gridPropertyDetails.gridY))
             break;
     }

     return crop;
 }


/// <summary>
/// Returns Crop Details for the provided seedItemCode
/// </summary>
/// <param name="seedItemCode"></param>
/// <returns></returns>
public CropDetails GetCropDetails(int seedItemCode)
{
    return so_CropDetailList.GetCropDetails(seedItemCode);
}

7、修改Settings.cs脚本

添加如下代码：

    public static float pickAnimationPause = 1f;
    public static float afterPickAnimationPause = 0.2f;

8、修改Player.cs脚本

添加两个属性

    private WaitForSeconds afterPickAnimationPause;
    private WaitForSeconds pickAnimationPause;

在Start函数中增加如下代码：

pickAnimationPause = new WaitForSeconds(Settings.pickAnimationPause);
afterPickAnimationPause = new WaitForSeconds(Settings.afterPickAnimationPause);

在ProcessPlayerClickInput函数中增加如下代码：

case ItemType.Collecting_tool:

在ProcessPlayerClickInputTool函数中添加如下代码：

case ItemType.Collecting_tool:
    if (gridCursor.CursorPositionIsValid)
    {
        CollectInPlayerDirection(gridPropertyDetails, itemDetails, playerDirection);
    }
    break;

添加CollectInPlayerDirection函数代码如下：

private void CollectInPlayerDirection(GridPropertyDetails gridPropertyDetails, ItemDetails equippedItemDetails, Vector3Int playerDirection)
{
    StartCoroutine(CollectInPlayerDirectionRoutine(gridPropertyDetails, equippedItemDetails, playerDirection));
}

添加CollectInPlayerDirectionRoutine函数代码如下：

private IEnumerator CollectInPlayerDirectionRoutine(GridPropertyDetails gridPropertyDetails, ItemDetails equippedItemDetails, Vector3Int playerDirection)
{
    PlayerInputIsDisabled = true;
    playerToolUseDisabled = true;

    ProcessCropWithEquippedItemInPlayerDirection(playerDirection, equippedItemDetails, gridPropertyDetails);

    yield return pickAnimationPause; // 执行完ProcessCropWithEquippedItemInPlayerDirection的时间

    // After animation pause
    yield return afterPickAnimationPause;

    PlayerInputIsDisabled = false;
    playerToolUseDisabled = false;
}

添加ProcessCropWithEquippedItemInPlayerDirection函数代码如下：


    /// <summary>
    /// Method processes crop with equipped item in player direction
    /// </summary>
    /// <param name="playerDirection"></param>
    /// <param name="equippedItemDetails"></param>
    /// <param name="gridPropertyDetails"></param>
    private void ProcessCropWithEquippedItemInPlayerDirection(Vector3Int playerDirection, ItemDetails equippedItemDetails, GridPropertyDetails gridPropertyDetails)
    {
        switch (equippedItemDetails.itemType)
        {
            case ItemType.Collecting_tool:

                if(playerDirection == Vector3Int.right)
                {
                    isPickingRight = true;
                }
                else if(playerDirection == Vector3Int.left)
                {
                    isPickingLeft = true;
                }
                else if(playerDirection == Vector3Int.up)
                {
                    isPickingUp = true;
                }
                else if(playerDirection == Vector3Int.down)
                {
                    isPickingDown = true;
                }
                break;

            case ItemType.none:
                break;
        }

        // Get crop at cursor grid location
        Crop crop = GridPropertiesManager.Instance.GetCropObjectAtGridLocation(gridPropertyDetails);

        // Execute Process Tool Action For crop
        if(crop != null)
        {
            switch (equippedItemDetails.itemType)
            {
                case ItemType.Collecting_tool:
                    crop.ProcessToolAction(equippedItemDetails);
                    break;
            }
        }
    }

此时，Player.cs完整的代码如下：

using System.Collections;
using System.Collections.Generic;
using Unity.VisualScripting;
using UnityEngine;

public class Player : SingletonMonobehaviour<Player>
{
    public GameObject canyonOakTreePrefab;
    private WaitForSeconds afterUseToolAnimationPause;
    private WaitForSeconds useToolAnimationPause;
    private WaitForSeconds afterLiftToolAnimationPause;
    private WaitForSeconds liftToolAnimationPause;
    private WaitForSeconds afterPickAnimationPause;
    private WaitForSeconds pickAnimationPause;

    private bool playerToolUseDisabled = false;  // 如果玩家正在使用某个道具，其他道具将被禁用

    private AnimationOverrides animationOverrides;  // 动画重写控制器
    private GridCursor gridCursor;
    private Cursor cursor;
    private List<CharacterAttribute> characterAttributeCustomisationList;  // 目标动作列表

    [Tooltip("Should be populated in the prefab with the equippped item sprite renderer")]
    [SerializeField] private SpriteRenderer equippedItemSpriteRenderer = null; // 武器的图片

    // Player attributes that can be swapped
    private CharacterAttribute armsCharacterAttribute;
    private CharacterAttribute toolCharacterAttribute;


    private float xInput;
    private float yInput;
    private bool isWalking;
    private bool isRunning;
    private bool isIdle;
    private bool isCarrying = false;
    private ToolEffect toolEffect = ToolEffect.none;
    private bool isUsingToolRight;
    private bool isUsingToolLeft;
    private bool isUsingToolUp;
    private bool isUsingToolDown;
    private bool isLiftingToolRight;
    private bool isLiftingToolLeft;
    private bool isLiftingToolUp;
    private bool isLiftingToolDown;
    private bool isPickingRight;
    private bool isPickingLeft;
    private bool isPickingUp;
    private bool isPickingDown;
    private bool isSwingToolRight;
    private bool isSwingToolLeft;
    private bool isSwingToolUp;
    private bool isSwingToolDown;

    private Camera mainCamera;

    private Rigidbody2D rigidbody2D;

    private Direction playerDirection;

    private float movementSpeed;

    private bool _playerInputIsDisabled = false;

    public bool PlayerInputIsDisabled { get => _playerInputIsDisabled; set => _playerInputIsDisabled = value; }

    protected override void Awake()
    {
        base.Awake();

        rigidbody2D = GetComponent<Rigidbody2D>();

        animationOverrides = GetComponentInChildren<AnimationOverrides>();

        // Initialise swappable character attributes
        armsCharacterAttribute = new CharacterAttribute(CharacterPartAnimator.arms, PartVariantColour.none, PartVariantType.none);
        toolCharacterAttribute = new CharacterAttribute(CharacterPartAnimator.tool, PartVariantColour.none, PartVariantType.none);

        // Initialise character attribute list
        characterAttributeCustomisationList = new List<CharacterAttribute>();

        mainCamera = Camera.main;
    }

    private void OnDisable()
    {
        EventHandler.BeforeSceneUnloadFadeOutEvent -= DisablePlayerInputAndResetMovement;
        EventHandler.AfterSceneLoadFadeInEvent -= EnablePlayerInput;
    }


    private void OnEnable()
    {
        EventHandler.BeforeSceneUnloadFadeOutEvent += DisablePlayerInputAndResetMovement;
        EventHandler.AfterSceneLoadFadeInEvent += EnablePlayerInput;
    }

    private void Start()
    {
        gridCursor = FindObjectOfType<GridCursor>();
        cursor = FindObjectOfType<Cursor>();
        useToolAnimationPause = new WaitForSeconds(Settings.useToolAnimationPause);
        afterUseToolAnimationPause = new WaitForSeconds(Settings.afterUseToolAnimationPause);
        liftToolAnimationPause = new WaitForSeconds(Settings.liftToolAnimationPause);
        afterLiftToolAnimationPause = new WaitForSeconds(Settings.afterLiftToolAnimationPause);
        pickAnimationPause = new WaitForSeconds(Settings.pickAnimationPause);
        afterPickAnimationPause = new WaitForSeconds(Settings.afterPickAnimationPause);
    }

    private void Update()
    {
        #region  Player Input

        if (!PlayerInputIsDisabled)
        {
            ResetAnimationTrigger();

            PlayerMovementInput();

            PlayerWalkInput();

            PlayerClickInput();

            PlayerTestInput();

            // Send event to any listeners for player movement input
            EventHandler.CallMovementEvent(xInput, yInput, isWalking, isRunning, isIdle, isCarrying, toolEffect,
                    isUsingToolRight, isUsingToolLeft, isUsingToolUp, isUsingToolDown,
                    isLiftingToolRight, isLiftingToolLeft, isLiftingToolUp, isLiftingToolDown,
                    isPickingRight, isPickingLeft, isPickingUp, isPickingDown,
                    isSwingToolRight, isSwingToolLeft, isSwingToolUp, isSwingToolDown,
                    false, false, false, false);
        }


        #endregion Player Input
    }

    private void FixedUpdate()
    {
        PlayerMovement();
    }

    /// <summary>
    /// 展示拿东西的动画
    /// </summary>
    /// <param name="itemCode"></param>
    public void ShowCarriedItem(int itemCode)
    {
        ItemDetails itemDetails = InventoryManager.Instance.GetItemDetails(itemCode);
        if(itemDetails != null)
        {
            equippedItemSpriteRenderer.sprite = itemDetails.itemSprite;
            equippedItemSpriteRenderer.color = new Color(1f, 1f, 1f, 1f);

            // Apply 'carry' character arms customisation
            armsCharacterAttribute.partVariantType = PartVariantType.carry;
            characterAttributeCustomisationList.Clear();
            characterAttributeCustomisationList.Add(armsCharacterAttribute);
            animationOverrides.ApplyCharacterCustomisationParameters(characterAttributeCustomisationList);

            isCarrying = true;
        }
    }


    public void ClearCarriedItem()
    {
        equippedItemSpriteRenderer.sprite = null;
        equippedItemSpriteRenderer.color = new Color(1f, 1f, 1f, 0f);

        // Apply base character arms customisation
        armsCharacterAttribute.partVariantType = PartVariantType.none;
        characterAttributeCustomisationList.Clear();
        characterAttributeCustomisationList.Add(armsCharacterAttribute);
        animationOverrides.ApplyCharacterCustomisationParameters(characterAttributeCustomisationList);

        isCarrying = false;
    }

    private void PlayerMovement()
    {
        Vector2 move = new Vector2(xInput * movementSpeed * Time.deltaTime, yInput * movementSpeed * Time.deltaTime);
        rigidbody2D.MovePosition(rigidbody2D.position + move);
    }


    private void ResetAnimationTrigger()
    {
        toolEffect = ToolEffect.none;
        isUsingToolRight = false;
        isUsingToolLeft = false;
        isUsingToolUp = false;
        isUsingToolDown = false;
        isLiftingToolRight = false;
        isLiftingToolLeft = false;
        isLiftingToolUp = false;
        isLiftingToolDown = false;
        isPickingRight = false;
        isPickingLeft = false;
        isPickingUp = false;
        isPickingDown = false;
        isSwingToolRight = false;
        isSwingToolLeft = false;
        isSwingToolUp = false;
        isSwingToolDown = false;
    }

    private void PlayerMovementInput()
    {
        xInput = Input.GetAxisRaw("Horizontal");
        yInput = Input.GetAxisRaw("Vertical");

        // 斜着移动
        if (xInput != 0 && yInput != 0) 
        {
            xInput = xInput * 0.71f;
            yInput = yInput * 0.71f;
        }

        // 在移动
        if (xInput != 0 || yInput != 0) 
        {
            isRunning = true;
            isWalking = false;
            isIdle = false;
            movementSpeed = Settings.runningSpeed;

            // Capture player direction for save game
            if (xInput < 0)
            {
                playerDirection = Direction.left;
            }
            else if (xInput > 0)
            {
                playerDirection = Direction.right;
            }
            else if (yInput < 0)
            {
                playerDirection = Direction.down;
            }
            else
            {
                playerDirection = Direction.up;
            }

        }
        else if(xInput == 0 && yInput == 0)
        {
            isRunning = false;
            isWalking = false;
            isIdle = true;
        }
    }

    // 按住Shift键移动为walk
    private void PlayerWalkInput()
    {
        if(Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift))
        {
            isRunning = false;
            isWalking = true;
            isIdle = false;
            movementSpeed = Settings.walkingSpeed;
        }
        else
        {
            isRunning = true;
            isWalking = false;
            isIdle = false;
            movementSpeed = Settings.runningSpeed;
        }
    }

    private void PlayerClickInput()
    {
        if (!playerToolUseDisabled)
        {

            if (Input.GetMouseButton(0))
            {

                if (gridCursor.CursorIsEnabled || cursor.CursorIsEnable)
                {
                    // Get Cursor Grid Position
                    Vector3Int cursorGridPosition = gridCursor.GetGridPositionForCursor();

                    // Get Player Grid Position
                    Vector3Int playerGridPosition = gridCursor.GetGridPositionForPlayer();
                    ProcessPlayerClickInput(cursorGridPosition, playerGridPosition);
                }
            }
        }
    }

    private void ProcessPlayerClickInput(Vector3Int cursorGridPosition, Vector3Int playerGridPosition)
    {
        ResetMovement();

        Vector3Int playerDirection = GetPlayerClickDirection(cursorGridPosition, playerGridPosition);

        // Get Selected item details
        ItemDetails itemDetails = InventoryManager.Instance.GetSelectedInventoryItemDetails(InventoryLocation.player);

        // Get Grid property details at cursor position (the GridCursor validation routine ensures that grid property details are not null)
        GridPropertyDetails gridPropertyDetails = GridPropertiesManager.Instance.GetGridPropertyDetails(cursorGridPosition.x, cursorGridPosition.y);



        if(itemDetails != null)
        {
            switch (itemDetails.itemType)
            {
                case ItemType.Seed:
                    if (Input.GetMouseButtonDown(0))
                    {
                        ProcessPlayerClickInputSeed(gridPropertyDetails, itemDetails);
                    }
                    break;
                case ItemType.Commodity:
                    if (Input.GetMouseButtonDown(0))
                    {
                        ProcessPlayerClickInputCommodity(itemDetails);
                    }
                    break;

                case ItemType.Watering_tool:
                case ItemType.Hoeing_tool:
                case ItemType.Reaping_tool:
                case ItemType.Collecting_tool:
                    ProcessPlayerClickInputTool(gridPropertyDetails, itemDetails, playerDirection);
                    break;
                case ItemType.none:
                    break;
                case ItemType.count:
                    break;

                default:
                    break;
            }
        }
    }


    private Vector3Int GetPlayerClickDirection(Vector3Int cursorGridPosition, Vector3Int playerGridPosition) 
    {
        if(cursorGridPosition.x > playerGridPosition.x)
        {
            return Vector3Int.right;
        }
        else if(cursorGridPosition.x < playerGridPosition.x)
        {
            return Vector3Int.left;
        }
        else if(cursorGridPosition.y > playerGridPosition.y)
        {
            return Vector3Int.up;
        }
        else
        {
            return Vector3Int.down;
        }
    }

    private Vector3Int GetPlayerDirection(Vector3 cursorPosition, Vector3 playerPosition)
    {
        if(
            cursorPosition.x > playerPosition.x
            &&
            cursorPosition.y < (playerPosition.y + cursor.ItemUseRadius / 2f)
            &&
            cursorPosition.y > (playerPosition.y - cursor.ItemUseRadius / 2f)
            )
        {
            return Vector3Int.right;
        }
        else if(
            cursorPosition.x < playerPosition.x
            &&
            cursorPosition.y < (playerPosition.y + cursor.ItemUseRadius / 2f)
            &&
            cursorPosition.y > (playerPosition.y - cursor.ItemUseRadius / 2f)
            )
        {
            return Vector3Int.left;
        }
        else if(cursorPosition.y > playerPosition.y)
        {
            return Vector3Int.up;
        }
        else
        {
            return Vector3Int.down;
        }
    }



    private void ProcessPlayerClickInputSeed(GridPropertyDetails gridPropertyDetails, ItemDetails itemDetails)
    {
        if(itemDetails.canBeDropped && gridCursor.CursorPositionIsValid && gridPropertyDetails.daysSinceDug > -1 && gridPropertyDetails.seedItemCode == -1)
        {
            PlantSeedAtCursor(gridPropertyDetails, itemDetails);
        }
        else if (itemDetails.canBeDropped && gridCursor.CursorPositionIsValid)
        {
            EventHandler.CallDropSelectedItemEvent();
        }
    }

    private void PlantSeedAtCursor(GridPropertyDetails gridPropertyDetails, ItemDetails itemDetails)
    {
        // update grid properties with seed details
        gridPropertyDetails.seedItemCode = itemDetails.itemCode;
        gridPropertyDetails.growthDays = 0;

        // Display planted crop at grid property details
        GridPropertiesManager.Instance.DisplayPlantedCrop(gridPropertyDetails);

        // Remove item from inventory
        EventHandler.CallRemoveSelectedItemFromInventoryEvent();
    }


    private void ProcessPlayerClickInputCommodity(ItemDetails itemDetails)
    {
        if(itemDetails.canBeDropped && gridCursor.CursorPositionIsValid)
        {
            EventHandler.CallDropSelectedItemEvent();
        }
    }

    private void ProcessPlayerClickInputTool(GridPropertyDetails gridPropertyDetails, ItemDetails itemDetails, Vector3Int playerDirection)
    {
        // Switch on tool
        switch (itemDetails.itemType)
        {
            case ItemType.Hoeing_tool:
                if (gridCursor.CursorPositionIsValid)
                {
                    HoeGroundAtCursor(gridPropertyDetails, playerDirection);
                }
                break;

            case ItemType.Watering_tool:
                if (gridCursor.CursorPositionIsValid)
                {
                    WaterGroundAtCursor(gridPropertyDetails, playerDirection);
                }
                break;

            case ItemType.Collecting_tool:
                if (gridCursor.CursorPositionIsValid)
                {
                    CollectInPlayerDirection(gridPropertyDetails, itemDetails, playerDirection);
                }
                break;

            case ItemType.Reaping_tool:
                if (cursor.CursorPositionIsValid)
                {
                    playerDirection = GetPlayerDirection(cursor.GetWorldPositionForCursor(), GetPlayerCentrePosition());
                    ReapInPlayerDirectionAtCursor(itemDetails, playerDirection);
                }
                break;

            default:
                break;

        }
    }

    private void ReapInPlayerDirectionAtCursor(ItemDetails itemDetails, Vector3Int playerDirection)
    {
        StartCoroutine(ReapInPlayerDirectionAtCursorRoutine(itemDetails, playerDirection));
    }

    private IEnumerator ReapInPlayerDirectionAtCursorRoutine(ItemDetails itemDetails, Vector3Int playerDirection)
    {
        PlayerInputIsDisabled = true;
        playerToolUseDisabled = true;

        // Set tool animation to scythe in override animation
        toolCharacterAttribute.partVariantType = PartVariantType.scythe;
        characterAttributeCustomisationList.Clear();
        characterAttributeCustomisationList.Add(toolCharacterAttribute);
        animationOverrides.ApplyCharacterCustomisationParameters(characterAttributeCustomisationList);

        // Reap in player direction
        UseToolInPlayerDirection(itemDetails, playerDirection);

        yield return useToolAnimationPause;

        PlayerInputIsDisabled = false;
        playerToolUseDisabled = false;
    }

    private void UseToolInPlayerDirection(ItemDetails equippedItemDetails, Vector3Int playerDirection)
    {
        if (Input.GetMouseButton(0))
        {
            switch (equippedItemDetails.itemType)
            {
                case ItemType.Reaping_tool:
                    if(playerDirection == Vector3Int.right)
                    {
                        isSwingToolRight = true;
                    }
                    else if(playerDirection == Vector3Int.left)
                    {
                        isSwingToolLeft = true;
                    }
                    else if(playerDirection == Vector3Int.up)
                    {
                        isSwingToolUp = true;
                    }
                    else if(playerDirection == Vector3Int.down)
                    {
                        isSwingToolDown = true;
                    }
                    break;
            }


            // Define centre point of square which will be used for collision testing，检测碰撞的中心点位置
            Vector2 point = new Vector2(GetPlayerCentrePosition().x + playerDirection.x * (equippedItemDetails.itemUseRadius / 2f),
                GetPlayerCentrePosition().y + playerDirection.y * (equippedItemDetails.itemUseRadius / 2f));

            // Define size of the square which will be used for collision testing
            Vector2 size = new Vector2(equippedItemDetails.itemUseRadius, equippedItemDetails.itemUseRadius);

            // Get Item components with 2D collider located in the square at the centre point defined (2d colliders tested limited to maxCollidersToTestPerReapSwing)
            Item[] itemArray = HelperMethods.GetComponentsAtBoxLocationNonAlloc<Item>(Settings.maxCollidersToTestPerReapSwing, point, size, 0f);

            int reapableItemCount = 0;

            // Loop through all items retrieved
            for(int i = itemArray.Length - 1; i >= 0; i--)
            {
                if(itemArray[i] != null)
                {
                    // Destory item game object if reapable
                    if (InventoryManager.Instance.GetItemDetails(itemArray[i].ItemCode).itemType == ItemType.Reapable_scenary)
                    {
                        // Effect position
                        Vector3 effectPosition = new Vector3(itemArray[i].transform.position.x, itemArray[i].transform.position.y + Settings.gridCellSize / 2f,
                            itemArray[i].transform.position.z);

                        // Trigger reaping effect
                        EventHandler.CallHarvestActionEffectEvent(effectPosition, HarvestActionEffect.reaping);

                        Destroy(itemArray[i].gameObject);

                        reapableItemCount++;
                        if (reapableItemCount >= Settings.maxTargetComponentsToDestroyPerReapSwing)
                            break;
                    }
                }
            }


        }
    }



    private void WaterGroundAtCursor(GridPropertyDetails gridPropertyDetails, Vector3Int playerDirection) 
    { 
        // Trigger animation
        StartCoroutine(WaterGroundAtCursorRoutine(playerDirection, gridPropertyDetails));
    }

    private IEnumerator WaterGroundAtCursorRoutine(Vector3Int playerDirection, GridPropertyDetails gridPropertyDetails) 
    {
        PlayerInputIsDisabled = true;
        playerToolUseDisabled = true;

        // Set tool animation to watering can in override animation
        toolCharacterAttribute.partVariantType = PartVariantType.wateringCan;
        characterAttributeCustomisationList.Clear();
        characterAttributeCustomisationList.Add(toolCharacterAttribute);
        animationOverrides.ApplyCharacterCustomisationParameters(characterAttributeCustomisationList);

        toolEffect = ToolEffect.watering;

        if(playerDirection == Vector3Int.right)
        {
            isLiftingToolRight = true;
        }
        else if(playerDirection == Vector3Int.left)
        {
            isLiftingToolLeft = true;
        }
        else if(playerDirection == Vector3Int.up)
        {
            isLiftingToolUp = true;
        }
        else if(playerDirection == Vector3Int.down)
        {
            isLiftingToolDown = true;
        }

        yield return liftToolAnimationPause;

        // Set Grid property details for watered ground
        if(gridPropertyDetails.daysSinceWatered == -1)
        {
            gridPropertyDetails.daysSinceWatered = 0;
        }

        // Set grid property to watered
        GridPropertiesManager.Instance.SetGridPropertyDetails(gridPropertyDetails.gridX, gridPropertyDetails.gridY, gridPropertyDetails);

        // Display watered grid tiles
        GridPropertiesManager.Instance.DisplayWateredGround(gridPropertyDetails);


        // After animation pause
        yield return afterLiftToolAnimationPause;

        PlayerInputIsDisabled = false;
        playerToolUseDisabled = false;
    }

    private void CollectInPlayerDirection(GridPropertyDetails gridPropertyDetails, ItemDetails equippedItemDetails, Vector3Int playerDirection)
    {
        StartCoroutine(CollectInPlayerDirectionRoutine(gridPropertyDetails, equippedItemDetails, playerDirection));
    }


    private IEnumerator CollectInPlayerDirectionRoutine(GridPropertyDetails gridPropertyDetails, ItemDetails equippedItemDetails, Vector3Int playerDirection)
    {
        PlayerInputIsDisabled = true;
        playerToolUseDisabled = true;

        ProcessCropWithEquippedItemInPlayerDirection(playerDirection, equippedItemDetails, gridPropertyDetails);

        yield return pickAnimationPause; // 执行完ProcessCropWithEquippedItemInPlayerDirection的时间

        // After animation pause
        yield return afterPickAnimationPause;

        PlayerInputIsDisabled = false;
        playerToolUseDisabled = false;
    }

    /// <summary>
    /// Method processes crop with equipped item in player direction
    /// </summary>
    /// <param name="playerDirection"></param>
    /// <param name="equippedItemDetails"></param>
    /// <param name="gridPropertyDetails"></param>
    private void ProcessCropWithEquippedItemInPlayerDirection(Vector3Int playerDirection, ItemDetails equippedItemDetails, GridPropertyDetails gridPropertyDetails)
    {
        switch (equippedItemDetails.itemType)
        {
            case ItemType.Collecting_tool:

                if(playerDirection == Vector3Int.right)
                {
                    isPickingRight = true;
                }
                else if(playerDirection == Vector3Int.left)
                {
                    isPickingLeft = true;
                }
                else if(playerDirection == Vector3Int.up)
                {
                    isPickingUp = true;
                }
                else if(playerDirection == Vector3Int.down)
                {
                    isPickingDown = true;
                }
                break;

            case ItemType.none:
                break;
        }

        // Get crop at cursor grid location
        Crop crop = GridPropertiesManager.Instance.GetCropObjectAtGridLocation(gridPropertyDetails);

        // Execute Process Tool Action For crop
        if(crop != null)
        {
            switch (equippedItemDetails.itemType)
            {
                case ItemType.Collecting_tool:
                    crop.ProcessToolAction(equippedItemDetails);
                    break;
            }
        }
    }


    private void HoeGroundAtCursor(GridPropertyDetails gridPropertyDetails, Vector3Int playerDirection) 
    {
        // Trigger animation
        StartCoroutine(HoeGroundAtCursorRoutine(playerDirection, gridPropertyDetails));
    }

    private IEnumerator HoeGroundAtCursorRoutine(Vector3Int playerDirection, GridPropertyDetails gridPropertyDetails)
    {
        PlayerInputIsDisabled = true;
        playerToolUseDisabled = true;

        // Set tool animation to hoe in override animation
        toolCharacterAttribute.partVariantType = PartVariantType.hoe;
        characterAttributeCustomisationList.Clear();
        characterAttributeCustomisationList.Add(toolCharacterAttribute);
        animationOverrides.ApplyCharacterCustomisationParameters(characterAttributeCustomisationList);

        if(playerDirection == Vector3Int.right)
        {
            isUsingToolRight = true;
        }
        else if(playerDirection == Vector3Int.left)
        {
            isUsingToolLeft = true;
        }
        else if(playerDirection == Vector3Int.up)
        {
            isUsingToolUp = true;
        }
        else if(playerDirection == Vector3Int.down)
        {
            isUsingToolDown = true;
        }

        yield return useToolAnimationPause;

        // Set Grid property details for dug ground
        if(gridPropertyDetails.daysSinceDug == -1)
        {
            gridPropertyDetails.daysSinceDug = 0;
        }

        // Set grid property to dug
        GridPropertiesManager.Instance.SetGridPropertyDetails(gridPropertyDetails.gridX, gridPropertyDetails.gridY, gridPropertyDetails);

        // Display dug grid tiles
        GridPropertiesManager.Instance.DisplayDugGround(gridPropertyDetails);

        // After animation pause
        yield return afterUseToolAnimationPause;

        PlayerInputIsDisabled = false;
        playerToolUseDisabled = false;
    }


    public Vector3 GetPlayerViewportPosition()
    {
        // Vector3 viewport position for player (0,0) viewport bottom left, (1,1) viewport top right
        return mainCamera.WorldToViewportPoint(gameObject.transform.position);
    }

    public Vector3 GetPlayerCentrePosition()
    {
        return new Vector3(transform.position.x, transform.position.y + Settings.playerCentreYOffset, transform.position.z);
    }

    public void DisablePlayerInputAndResetMovement()
    {
        DisablePlayerInpupt();
        ResetMovement();

        // Send event to any listeners for player movement input
        EventHandler.CallMovementEvent(xInput, yInput, isWalking, isRunning, isIdle, isCarrying, toolEffect,
                isUsingToolRight, isUsingToolLeft, isUsingToolUp, isUsingToolDown,
                isLiftingToolRight, isLiftingToolLeft, isLiftingToolUp, isLiftingToolDown,
                isPickingRight, isPickingLeft, isPickingUp, isPickingDown,
                isSwingToolRight, isSwingToolLeft, isSwingToolUp, isSwingToolDown,
                false, false, false, false);
    }

    private void ResetMovement()
    {
        // Reset movement
        xInput = 0f;
        yInput = 0f;
        isRunning = false;
        isWalking = false;
        isIdle = true;
    }

    public void DisablePlayerInpupt()
    {
        PlayerInputIsDisabled = true;
    }


    public void EnablePlayerInput()
    {
        PlayerInputIsDisabled = false;
    }



    /// <summary>
    /// Temp routine for test input
    /// </summary>
    private void PlayerTestInput()
    {
        // Trigger Advance Time
        if (Input.GetKeyDown(KeyCode.T))
        {
            TimeManager.Instance.TestAdvanceGameMinute();
        }

        // Trigger Advance Day
        if (Input.GetKeyDown(KeyCode.G))
        {
            TimeManager.Instance.TestAdvanceGameDay();
        }

        // Test scene unload / load
        if (Input.GetKeyDown(KeyCode.L))
        {
            SceneControllerManager.Instance.FadeAndLoadScene(SceneName.Scene1_Farm.ToString(), transform.position);
        }

        // Test object pool
        if (Input.GetMouseButtonDown(1))
        {
            GameObject tree = PoolManager.Instance.ReuseObject(canyonOakTreePrefab, mainCamera.ScreenToWorldPoint(new Vector3(Input.mousePosition.x,
                Input.mousePosition.y, -mainCamera.transform.position.z)), Quaternion.identity);
            tree.SetActive(true);
        }
    }
}

9、修改Crop.cs脚本

完整代码如下：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Crop : MonoBehaviour
{
    [HideInInspector]
    public Vector2Int cropGridPosition;

    private int harvestActionCount = 0;

    public void ProcessToolAction(ItemDetails equippedItemDetails)
    {
        // Get grid property details
        GridPropertyDetails gridPropertyDetails = GridPropertiesManager.Instance.GetGridPropertyDetails(cropGridPosition.x, cropGridPosition.y);

        if (gridPropertyDetails == null)
            return;

        // Get seed item details
        ItemDetails seedItemDetails = InventoryManager.Instance.GetItemDetails(gridPropertyDetails.seedItemCode);
        if(seedItemDetails == null) return;

        // Get crop details
        CropDetails cropDetails = GridPropertiesManager.Instance.GetCropDetails(seedItemDetails.itemCode);
        if (cropDetails == null) return;

        // Get required harvest actions for tool（收获此农作物所需的操作次数）
        int requiredHarvestActions = cropDetails.RequiredHarvestActionsForTool(equippedItemDetails.itemCode);
        if (requiredHarvestActions == -1) return;

        // Increment harvest action count
        harvestActionCount++;

        // Check if required harvest actions made
        if (harvestActionCount >= requiredHarvestActions)
            HarvestCrop(cropDetails, gridPropertyDetails);

    }


    private void HarvestCrop(CropDetails cropDetails, GridPropertyDetails gridPropertyDetails)
    {
        // Delete crop from grid properties
        gridPropertyDetails.seedItemCode = -1;
        gridPropertyDetails.growthDays = -1;
        gridPropertyDetails.daysSinceLastHarvest = -1;
        gridPropertyDetails.daysSinceWatered = -1;

        GridPropertiesManager.Instance.SetGridPropertyDetails(gridPropertyDetails.gridX, gridPropertyDetails.gridY, gridPropertyDetails);

        HarvestActions(cropDetails, gridPropertyDetails);
    }

    private void HarvestActions(CropDetails cropDetails, GridPropertyDetails gridPropertyDetails)
    {
        SpawnHarvestedItems(cropDetails);

        Destroy(gameObject);  // destory当前Crop类所挂载的实例
    }

    private void SpawnHarvestedItems(CropDetails cropDetails)
    {
        // Spawn the item(s) to be produced
        for(int i = 0; i < cropDetails.cropProducedItemCode.Length; i++)
        {
            int cropsToProduce;

            // Calculate how many crops to produce
            if (cropDetails.cropProducedMinQuantity[i] == cropDetails.cropProducedMaxQuantity[i] ||
                cropDetails.cropProducedMaxQuantity[i] < cropDetails.cropProducedMinQuantity[i])
            {
                cropsToProduce = cropDetails.cropProducedMinQuantity[i];
            }
            else
            {
                cropsToProduce = Random.Range(cropDetails.cropProducedMinQuantity[i], cropDetails.cropProducedMaxQuantity[i] + 1);
            }

            for(int j = 0; j < cropsToProduce; j++)
            {
                Vector3 spawnPosition;
                if (cropDetails.spawnCropProducedAtPlayerPosition)
                {
                    // Add item to the players inventory
                    InventoryManager.Instance.AddItem(InventoryLocation.player, cropDetails.cropProducedItemCode[i]);
                }
                else
                {
                    // Random position
                    spawnPosition = new Vector3(transform.position.x + Random.Range(-1f, 1f), transform.position.y + Random.Range(-1f, 1f), 0f);
                    SceneItemsManager.Instance.InstantiateSceneItem(cropDetails.cropProducedItemCode[i], spawnPosition);
                }
            }
        }
    }

}

10、修改InventoryManager.cs脚本

添加如下代码：

public void AddItem(InventoryLocation inventoryLocation, int itemCode)
{
    List<InventoryItem> inventoryList = inventoryLists[(int)inventoryLocation];

    // Check if inventory already contains the item
    int itemPosition = FindItemInInventory(inventoryLocation, itemCode);

    if(itemPosition != -1)
    {
        AddItemPosition(inventoryList, itemCode, itemPosition);
    }
    else
    {
        AddItemPosition(inventoryList, itemCode);
    }

    // Send event that inventory has been updated
    EventHandler.CallInventoryUpdatedEvent(inventoryLocation, inventoryLists[(int)inventoryLocation]);
}

11、修改SceneItemsManager.cs脚本

增加如下代码：

private void InstantiateSceneItem(int ItemCode, Vector3 position)
{
    GameObject itemGameObject = Instantiate(itemPrefab, position, Quaternion.identity, parentItem);
    Item item = itemGameObject.GetComponent<Item>();
    item.ItemCode = ItemCode;
}

12、修改SO_CropDetailsList的配置

修改10006的配置：

勾选spawnCropProducedAtPlayerPosition，使得收获的农作物在Inventory中展示。

13、运行游戏

防风草种子成熟后，点击篮子进行采摘，则防风草会出现在最后一个Slot中。

如果Slot之前已经有防风草了，则会直接往上加数量。

Unity3D仿星露谷物语开发12之创建道具列表
benben044的专栏
12-31 715
道具是游戏的核心部分，道具包括你可以拾取的东西，你可以使用的工具和你能种的东西等。本节就是创建道具的信息类。同时了解ScriptableObject类的使用。
Unity3D仿星露谷物语开发9之创建农场Scene
benben044的专栏
12-29 1375
绘制农场的场景。通过不同Sorting Layer控制物体的显示优先级，绘制Tilemap地图，添加Tilemap Collider碰撞器，同时添加Composite Collider碰撞器优化性能
Unity3D仿星露谷物语开发43之农作物生长
benben044的专栏
05-16 593
把防风草种子种在地里，并展示植物种子，防风草种子将随着时间变化而生长成植株。
Unity3D仿星露谷物语开发45之收集农作物特效
benben044的专栏
05-18 678
收集农作物的特效制作。
Unity3D仿星露谷物语开发1之游戏架构
benben044的专栏
12-12 653
仿星露谷物语开发的游戏架构介绍
asset文件夹路径 unity_Unity还原星露谷物语2：种地篇数据读写+TileMap
weixin_39790510的博客
12-26 801
大家好，我是想对 使用炎拳的炎拳，上一篇星露谷中我完成了人物的移动并搭建了一个简单的界面，这篇就来瞅瞅星露谷的地是怎么种的。首先看看游戏中的种地的过程：大致上完成一次耕种，需要这几个步骤：选中锄头—开垦一块地—选择种子种下—浇水；同时种子会随时间的流逝成长，长到有叶片后人物走过，会触发一个庄稼动一下的动画~所以这里我要做的功能就清晰了，先整个庄稼的预制体，其中包含所需的图片文字素材，然后点击一下土...
游戏开发全流程及其工具详解
lixiemang8887的博客
03-19 771
通过结合多个流程和工具的实际应用，游戏开发涵盖了从创意到成品的全程，每个阶段都有专门的工具和技术进行支持。无论是小型独立游戏的开发，还是大型3A项目的开发，都可以根据项目需求选择适当的工具链，确保高效、协同的开发过程。在实际应用中，工具和技术的选择需根据团队规模、项目需求以及预算进行调整，灵活的工具组合是提升开发效率和游戏品质的关键。
软件工程领域UI设计的游戏界面设计策略
项目管理的博客
05-05 1164
游戏界面（Game UI）是玩家与游戏交互的第一入口：从新手引导到战斗操作，从装备升级到社交聊天，界面设计直接影响玩家留存率与体验满意度。本文聚焦软件工程视角下的游戏UI设计策略，探讨如何通过系统化方法（而非仅依赖“美感”）设计出高效、沉浸、稳定的游戏界面。本文从“核心概念→原理模型→实战案例→趋势挑战”四步展开：先用生活案例解释游戏UI的关键术语；再通过数学模型与代码示例拆解设计逻辑；接着用《幻想大陆》项目实战演示全流程；最后分析未来技术对游戏UI的影响。
Unity3D仿星露谷物语开发27之创建新场景
benben044的专栏
02-09 842
创建一个新的场景，复习一下Tile Palette的使用。
Unity3D仿星露谷物语开发4之创建角色
benben044的专栏
12-19 756
创建一个角色，同时摄像机始终跟着角色移动，即角色始终位于屏幕中间。
Unity3D仿星露谷物语开发8之角色移动
benben044的专栏
12-22 1151
通过键盘上的上下左右控制角色移动，默认情况下是run，按住Shift为walk。
制作一款打飞机游戏49：敌人抖动
wskongdesheng的专栏
05-15 472
蛇形敌人如果你玩过一些射击游戏（shmups），尤其是老式的射击游戏，你可能会遇到一种敌人，它们像蛇一样移动。我想在我们的游戏中实现这种效果。这种动态的感觉非常棒，我们完全有能力通过动画来实现它。
《Cryptical Path》开发诀窍：像玩游戏一样开发一款类Rogue游戏
unityofficial的博客
05-16 1072
游戏开发，恰似玩一个类Rogue游戏——本质是不断迭代的过程。你奋力前行，以为找到了正确路径，却突然碰壁、失败、重头再来，唯一不同的是：这一次的你，比从前更聪明了一点。我们开发这款类Rogue地牢探险游戏的历程也不例外。最初，我们专注于打造一个响应迅速、反馈爽快的游戏体验，但很快意识到，仅仅拥有优秀的"3C"要素（角色、操控、视角）是远远不够的。《Cryptical Path》缺乏的是一个鲜明的个性——那种能真正让它与众不同的特质。我们一直在苦苦寻觅一个既能体现最初愿景，又独具特色的核心元素。
游戏盾的功有哪些？
最新发布
wochenglong的博客
05-19 331
游戏盾的功能主要包括以下几方面：
Blender建小房子流程
Jesui的博客
05-18 137
方便工作流的一些做法。
贪吃蛇游戏消息通知功能开发全解析
2403_89107873的博客
05-15 978
文章概述了贪吃蛇游戏中新增的消息通知功能与提示界面的实现过程。消息通知功能通过右上角的铃铛图标（🔔）展示，未读消息时铃铛会显示小红点并摇晃，点击后可查看公告详情，阅读后红点消失。公告数据采用数组存储，包含id、title和content字段，支持列表与详情双视图。交互界面开发涉及铃铛图标、通知面板和动态列表的DOM元素设计，未读提示逻辑通过CSS动画实现铃铛摇晃。动态渲染机制根据公告数据实时生成列表，点击条目展示详情。面板控制逻辑通过铃铛点击和关闭按钮实现展开/收起操作。提示界面通过问号图标（❓）触发
一个简单点的js的h5页面实现地铁快跑的小游戏
小屁孩大帅-保密的博客
05-15 967
游戏操作很简单：点击"开始游戏"按钮或按空格键开始，然后通过点击或按空格键让角色跳跃，避开障碍物。当角色碰到障碍物时，游戏结束，可以点击"重新开始"按钮再次游戏。以下是一个简化版的"地铁快跑"小游戏H5页面实现。这个游戏包含基本的角色跳跃、障碍物生成和计分系统，使用Canvas绘图技术实现。这个实现是简化版的，没有包含原版游戏的所有功能，但已经具备了核心的游戏体验。你可以直接运行代码开始游戏。
Unity实用技能-UI定位总结
m0_52058484的博客
05-19 152
本文总结了Unity中UI定位的实用技能，主要涉及如何实现UI的自动定位功能
PAW3950DM-T5QU游戏级光导航芯片
嵌入式软硬件叶玄
05-19 9
PixArt Imaging推出的PAW3950DM-T5QU是一款专为高端游戏设计的低功耗导航芯片，具备在玻璃表面进行精准操作的能力。该芯片采用16针DIP封装，内置照明光源，支持高速、高分辨率和高精度的运动检测，最高可达30,000 CPI。其特色功能包括自动表面切换、升降检测、可编程性及多种模式（游戏、玻璃、办公室等），确保在不同环境下提供最佳性能。此外，芯片支持手动升降截止校准、角度捕捉和自调整帧率，适用于职业玩家和休闲用户，提供卓越的游戏体验。
unity3D仿星露谷
02-28
### 关于Unity3D开发类似星露谷游戏的教程和资源 #### 使用ScriptableObject管理物品数据 为了实现类似于《星露谷物语》中的复杂道具系统，在Unity3D中可以利用`ScriptableObject`来高效管理和扩展各类物品属性。通过编写继承自`ScriptableObject`的C#脚本，能够创建可序列化的资产文件(.asset)，这些文件可用于定义游戏中不同类型的工具、作物或其他交互对象[^3]。 ```csharp using UnityEngine; [CreateAssetMenu(fileName = "NewItem", menuName = "Game/Item")] public class Item : ScriptableObject { public string itemName; public Sprite icon; public int value; } ``` 此代码片段展示了如何声明一个新的`ScriptableObject`类型——`Item`，并为其添加基本字段用于表示名称、图标以及价值等信息。借助内置编辑器功能，开发者可以在Inspector视窗内直观地设置各项参数而无需修改源码。 #### 参考完整的项目案例 对于希望深入学习整个流程的新手而言，《制作100个Unity游戏》系列提供了详尽的教学指导，特别是其中有关2D横板卷轴动作类别的章节，虽然侧重点有所不同，但许多概念和技术同样适用于模拟经营风格的作品。该系列不仅涵盖了基础理论还分享了实际操作经验，并提供完整工程下载链接供读者参考实践[^1]。 #### 设计思路与规划建议 针对想要模仿特定作品如《星露谷物语》的新晋创作者来说，遵循一套系统的创作方法论至关重要。这包括但不限于：确定核心玩法机制；构建世界背景故事框架；设计角色成长路径等内容策划工作。同时也要注意平衡难度曲线，确保玩家体验流畅自然[^2]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值