示例#1
0
    public void ShowMovableTerrain()
    {
        switch (playerReference.character)
        {
        case CharacterType.Torito:

            DefineMovableTerrain();

            MapManager._Instance.InitMapTilesMaterial();              // Force Tiling to Cleanup before applying movable terrains

            foreach (GameObject target in MapManager._Instance.terrainList)
            {
                for (int i = 0; i < movablePositions.Count; i++)
                {
                    TerrainCubeData tempData = target.GetComponent <TerrainCubeData> ();

                    if (tempData.gridPosition.posX == movablePositions [i].posX && tempData.gridPosition.posY == movablePositions [i].posY)
                    {
                        tempData.ChangeMaterial(MapManager._Instance.materialPool [6], false);
                    }
                }
            }
            break;

        default:
            break;
        }
    }
示例#2
0
    public void OnAbilityCheckTerrain()
    {
        ObjectFacing facingSample;

        int moveRangeX = MapManager._Instance.sizeX;
        int moveRangeY = MapManager._Instance.sizeY;

        int tempX = movementReference.positionX;
        int tempY = movementReference.positionY;

        if (selectableTargets.Count != 0)
        {
            selectableTargets.Clear();
        }

        if (playerReference.isAbilityActive)
        {
            // X+ Check - East
            for (int i = tempX; i < moveRangeX; i++)
            {
                facingSample = ObjectFacing.East;

                GameObject targetObject = MapManager._Instance.RequestMapTile(i + 1, tempY);

//			print ("TargetObject: " + targetObject.transform.name);

                if (targetObject != null)
                {
                    TerrainCubeData tempData = targetObject.GetComponent <TerrainCubeData> ();

                    if (tempData.occupant == null)
                    {
                        tempData.ChangeMaterial(MapManager._Instance.materialPool [7], false);
                    }
                    else
                    {
                        // Insert Code Check Condition Here!
                        SelectTargetObjectType(tempData.occupant.GetComponent <MapObjectData> ().type, tempData, targetObject, facingSample);
                        lastObjectChecked = null;
                        break;
                    }
                    lastObjectChecked = targetObject;
                }
                else
                {
                    if (lastObjectChecked != null)
                    {
                        lastObjectChecked.GetComponent <TerrainCubeData>().ChangeMaterial(MapManager._Instance.materialPool[3], false);
                        selectableTargets.Add(lastObjectChecked.GetComponent <TerrainCubeData>().gridPosition);
                        lastObjectChecked = null; // Last object cleanup after finishing line sweep.
                        break;
                    }
                }
            }

            // Y+ Check - North
            for (int i = tempY; i < moveRangeY; i++)
            {
                facingSample = ObjectFacing.North;

                GameObject targetObject = MapManager._Instance.RequestMapTile(tempX, i + 1);

//				print ("Current TilePosition: " + targetObject.GetComponent<TerrainCubeData>().gridPosition.posY);

                if (targetObject != null)
                {
                    TerrainCubeData tempData = targetObject.GetComponent <TerrainCubeData> ();

                    if (tempData.occupant == null)
                    {
                        tempData.ChangeMaterial(MapManager._Instance.materialPool [7], false);
                    }
                    else
                    {
                        SelectTargetObjectType(tempData.occupant.GetComponent <MapObjectData> ().type, tempData, targetObject, facingSample);
                        lastObjectChecked = null;
                        break;
                    }

                    lastObjectChecked = targetObject;
                }
                else
                {
                    if (lastObjectChecked != null)
                    {
                        lastObjectChecked.GetComponent <TerrainCubeData>().ChangeMaterial(MapManager._Instance.materialPool[3], false);
                        selectableTargets.Add(lastObjectChecked.GetComponent <TerrainCubeData>().gridPosition);
                        lastObjectChecked = null; // Last object cleanup after finishing line sweep.
                        break;
                    }
                }
            }

            // X- Check - West
            for (int i = tempX; i >= 0; i--)
            {
                facingSample = ObjectFacing.West;

                GameObject targetObject = MapManager._Instance.RequestMapTile(i - 1, tempY);

                //			print ("TargetObject: " + targetObject.transform.name);

                if (targetObject != null)
                {
                    TerrainCubeData tempData = targetObject.GetComponent <TerrainCubeData> ();

                    if (tempData.occupant == null)
                    {
                        tempData.ChangeMaterial(MapManager._Instance.materialPool [7], false);
                    }
                    else
                    {
                        SelectTargetObjectType(tempData.occupant.GetComponent <MapObjectData> ().type, tempData, targetObject, facingSample);
                        lastObjectChecked = null;
                        break;
                    }

                    lastObjectChecked = targetObject;
                }
                else
                {
                    if (lastObjectChecked != null)
                    {
                        lastObjectChecked.GetComponent <TerrainCubeData>().ChangeMaterial(MapManager._Instance.materialPool[3], false);
                        selectableTargets.Add(lastObjectChecked.GetComponent <TerrainCubeData>().gridPosition);
                        lastObjectChecked = null; // Last object cleanup after finishing line sweep.
                        break;
                    }
                }
            }

            // Y- Check - South
            for (int i = tempY; i >= 0; i--)
            {
                facingSample = ObjectFacing.South;

                GameObject targetObject = MapManager._Instance.RequestMapTile(tempX, i - 1);

                if (targetObject != null)
                {
                    TerrainCubeData tempData = targetObject.GetComponent <TerrainCubeData> ();

                    if (tempData.occupant == null)
                    {
                        tempData.ChangeMaterial(MapManager._Instance.materialPool[7], false);
                    }
                    else
                    {
                        SelectTargetObjectType(tempData.occupant.GetComponent <MapObjectData> ().type, tempData, targetObject, facingSample);
                        lastObjectChecked = null;
                        break;
                    }

                    lastObjectChecked = targetObject;
                }
                else
                {
                    if (lastObjectChecked != null)
                    {
                        lastObjectChecked.GetComponent <TerrainCubeData>().ChangeMaterial(MapManager._Instance.materialPool[3], false);
                        selectableTargets.Add(lastObjectChecked.GetComponent <TerrainCubeData>().gridPosition);
                        lastObjectChecked = null; // Last object cleanup after finishing line sweep.
                        break;
                    }
                }
            }
        }
    }
示例#3
0
    void SelectTargetObjectType(ObjectType inputType, TerrainCubeData inputData, GameObject inputTerrain, ObjectFacing inputFacing)
    {
        switch (inputType)
        {
        // Case doesn't allow movement effect on wall.
        case ObjectType.Wall:

            // Preemptive check to avoid null-reference if Player is adyacent to a wall.
            if (lastObjectChecked != null)
            {
                selectableTargets.Add(lastObjectChecked.GetComponent <TerrainCubeData>().gridPosition);
                lastObjectChecked.GetComponent <TerrainCubeData>().ChangeMaterial(MapManager._Instance.materialPool[3], false);
            }
            break;

        case ObjectType.Enemy:
            if (lastObjectChecked != null)
            {
                selectableTargets.Add(inputTerrain.GetComponent <TerrainCubeData>().gridPosition);
                inputData.ChangeMaterial(MapManager._Instance.materialPool[3], false);
            }
            break;


        case ObjectType.Goal:
            if (lastObjectChecked != null)
            {
                selectableTargets.Add(inputTerrain.GetComponent <TerrainCubeData> ().gridPosition);
                inputData.ChangeMaterial(MapManager._Instance.materialPool [3], false);
            }
            break;

        case ObjectType.Player:
            if (lastObjectChecked != null)
            {
                selectableTargets.Add(inputTerrain.GetComponent <TerrainCubeData>().gridPosition);
                inputData.ChangeMaterial(MapManager._Instance.materialPool[3], false);
            }

            break;

        case ObjectType.DirectionalMove:
            if (CheckFacing(inputFacing, inputTerrain.GetComponent <TerrainCubeData> ().occupant.GetComponent <ObjectMovement> ().facingConfig))
            {
                selectableTargets.Add(inputTerrain.GetComponent <TerrainCubeData> ().gridPosition);
                inputData.ChangeMaterial(MapManager._Instance.materialPool [3], false);
            }
            else
            {
                if (lastObjectChecked != null)
                {
                    selectableTargets.Add(lastObjectChecked.GetComponent <TerrainCubeData>().gridPosition);
                    lastObjectChecked.GetComponent <TerrainCubeData>().ChangeMaterial(MapManager._Instance.materialPool[3], false);
                }
            }
            break;

        default:
            break;
        }
    }