For the behavior implementation, a programmer proposed rather than building different plant objects with their unique traits built in, that we create scripts for each unique behavior and add it as a component of the plant object to help with reusability which will help avoid repetitive code.

I agreed with this statement and proposed to add interfaces so that we could add unique behaviors when they were tied to an event that all plants share. For example, we wanted the pumpkin's  behavior to have: On harvest, change regular dirt tile to exhausted.

Interface Script: IOnHarvest.cs

The written code below is what an interface looks like and we can create more based on what we'll need (OnPlant, On Water, etc.). 

public interface IOnHarvest

{

    // writing this means this is a

  // required function to implement on inheriting

    void OnHarvest();

}

Behavior Script: ChangeTileOnHarvest.cs

By inheriting from IOnHarvest interface, we are saying that implementing OnHarvest() is required for this behavior. 

public class ChangeTileOnHarvest : MonoBehaviour, IOnHarvest

{

    ...

    public void OnHarvest()

    {

        // change tile from regular tile to exhausted tile

        GameObject currTile = plantRef.gameObject.transform.parent.gameObject;

        currTile.GetComponent<BaseTile>().ChangeTileType(tile);

    }

}

Script: BasePlant.cs

Now when we create a new plant using the BasePlant script, we can just check to see if the IOnHarvest interface component exists, if it does we will call the correlating function. If it doesn't exist, it will proceed as normal.

public void Harvest()

{

    // add to score for end screen

    LevelManager.instance.scoreManager.AddScore(Data.Reward);

    // check if we have additional harvest behaviors to run

    // that are unique to the plant

    foreach (var component in GetComponents<IOnHarvest>())

    {

        component.OnHarvest();

    }

    // destroy plant

    Destroy(gameObject);

}

To make the game interesting, the team wanted to be able to place plants of different shapes and sizes. The wheat which represents our most basic plant takes up one tile and the pumpkin is currently planned to take up 3 tiles as a 1x3. We will worry about rotating plants but we wanted to get the base implementation of this first.

We already know what the size of the plant is in code because designers will have this property set in the plant's scriptable object by adding in their coordinates in the shape array. An example of the pumpkin is shown below:

Then I programmed a check for when the player tries to plant something that is bigger than a 1x1:

public bool CanPlacePlant(PlantObject plantData, Transform originTile)

{

    // already has a plant on this tile, can skip the check since we can't plant

    if (originTile.childCount > 0) return false;

    // if plant is bigger than 1x1 tile

    if (plantData.shape.Length > 0) 

    {

// GetShapeCoordinates will use the shape array as an offset to know what the coordinates

 // on the grid we're planting is 

        GameObject[] relativeTiles = TileManager.Instance.GetShapeCoordinates(plantData, originTile);

// if it's false, it means one or more coordinates are out of bounds of the grid

        if (relativeTiles.Length != plantData.shape.Length) return false;

        // check that all tiles are available

        foreach (var tile in relativeTiles)

        {

            // tile doesn't exist, out of bounds or a plant exists here

            if (tile == null || tile.GetComponent<BaseTile>().RootTile)

            {

                return false;

            }

            // check that it's okay for plant to be on this tiletype

            if (plantData.tileToPlantOn != tile.GetComponent<BaseTile>().Data)

            {

                return false;

            }

        }

        // passed all checks therefore it's placement is valid

        return true;

    }

    return false;

}