예제 #1
0
    void AStarFun()
    {
//		//A* function
//		Debug.Log("map is null?:"+(map == null));
//		Debug.Log ("mapMat is null?:" + (map.gridMat == null));
        Stack <Grid> outGrids = AStar.CalcPath(startGrid, endGrid, map);

        while (outGrids != null && outGrids.Count > 0)
        {
            Grid _oGrid = outGrids.Pop();
            _oGrid.GetComponentInChildren <MeshRenderer> ().material.color = Color.yellow;
        }
    }
예제 #2
0
    void CommandUpdate()
    {
        switch (command)
        {
        case COMMAND.NONE:
            command = COMMAND.MOVE;
            break;

        case COMMAND.MOVE:


            VectorInt2   _enemyVi     = enemy.StandGrid.Vi;
            VectorInt2[] _moveViArray = Util.GetViCricleByRadius(enemy.enemyData.speed);

            Grid       _betterMoveGrid = null;
            VectorInt2 _closeVi        = VectorInt2.Zero;
            //temp get player
            Player _player = PlayerController.Instance.PlayerEntity;

            foreach (var _moveVi in _moveViArray)
            {
                VectorInt2 _resultMoveVi = _enemyVi + _moveVi;

                if (_resultMoveVi < VectorInt2.Zero || _resultMoveVi > (map.Edge - VectorInt2.One))
                {
                    continue;
                }
                if (map.gridMat [_resultMoveVi.x, _resultMoveVi.y] is BuildGrid)
                {
                    continue;
                }
                if (map.gridMat [_resultMoveVi.x, _resultMoveVi.y].Owner != null)
                {
                    continue;
                }

                VectorInt2 _tempVi = _resultMoveVi - _player.StandGrid.Vi;
                if (_closeVi == VectorInt2.Zero)
                {
                    _closeVi        = _tempVi;
                    _betterMoveGrid = map.gridMat [_resultMoveVi.x, _resultMoveVi.y];
                }
                else if (_closeVi > _tempVi)
                {
                    _closeVi        = _tempVi;
                    _betterMoveGrid = map.gridMat [_resultMoveVi.x, _resultMoveVi.y];
                }
            }

            getMoveGrids = AStar.CalcPath(enemy.StandGrid, _betterMoveGrid, map);

            command = COMMAND.DOING;

            MoveEnemy(enemy, getMoveGrids);

            //--select next command by enemy
//			command = COMMAND.ATTACK;
//			command = COMMAND.DEFENSE;
            break;

        case COMMAND.ATTACK:
            break;

        case COMMAND.BUILD:
            break;

        case COMMAND.DEFENSE:
            break;

        case COMMAND.CANCEL:
            break;

        case COMMAND.DOING:
            break;

        case COMMAND.END:
            break;

        case COMMAND.DONE:
        {
            command = COMMAND.NONE;
            RoundEndEnemy(enemy);
        }
        break;

        default:
            throw new System.ArgumentOutOfRangeException();
        }

        prevCommand = command;
    }
예제 #3
0
    void CommandUpdate()
    {
        switch (command)
        {
        case COMMAND.NONE:
            break;

        case COMMAND.MOVE:
        {
            if (prevCommand != COMMAND.MOVE)
            {
                getActiveGirds.Clear();
                if (gridSelect != null)
                {
                    gridSelect.gameObject.SetActive(false);
                }
            }

            #region showMoveRange
            VectorInt2 _playerVi = player.StandGrid.Vi;

            VectorInt2[] _moveViArray = Util.GetViCricleByRadius(player.playerData.speed);

            getActiveGirds.Clear();

            foreach (var _moveVi in _moveViArray)
            {
                VectorInt2 _resultMoveVi = _playerVi + _moveVi;
                if (_resultMoveVi < VectorInt2.Zero || _resultMoveVi > (map.Edge - VectorInt2.One))
                {
                    continue;
                }
                if (map.gridMat [_resultMoveVi.x, _resultMoveVi.y] is BuildGrid)
                {
                    continue;
                }
                getActiveGirds.Add(map.gridMat[_resultMoveVi.x, _resultMoveVi.y]);
                map.gridMat [_resultMoveVi.x, _resultMoveVi.y].SetGridColor(Color.blue);
            }
            #endregion

            //ray cast
            Ray        _ray = Camera.main.ScreenPointToRay(Input.mousePosition);
            RaycastHit _hit = new RaycastHit();

            if (Physics.Raycast(_ray, out _hit, 1000f))
            {
                Grid _grid = _hit.collider.GetComponentInParent <Grid> ();

                if (_grid == null)
                {
                    break;
                }

                if (!getActiveGirds.Contains(_grid))
                {
                    break;
                }

                if (gridSelect != null)
                {
                    gridSelect.gameObject.SetActive(true);
                    gridSelect.transform.position = _grid.transform.position;
                }

                if (_grid.Owner == null)
                {
                    getMoveGrids = AStar.CalcPath(player.StandGrid, _grid, map);

                    //press mouse button 0
                    if (Input.GetMouseButtonDown(0))
                    {
                        if (EventSystem.current.IsPointerOverGameObject())
                        {
                            break;
                        }

                        if (gridSelect != null)
                        {
                            gridSelect.gameObject.SetActive(false);
                        }

                        command = COMMAND.DOING;
                        //move player
                        MovePlayer(player, getMoveGrids);


                        break;
                    }
                }
            }
        }
        break;

        case COMMAND.ATTACK:
        {
            if (prevCommand != COMMAND.ATTACK)
            {
                getActiveGirds.Clear();
                if (gridSelect != null)
                {
                    gridSelect.gameObject.SetActive(false);
                }
            }

            if (map != null && player.StandGrid != null)
            {
                #region show AttackRange

                //获得玩家所在grid的坐标
                VectorInt2 _playerVi = player.StandGrid.Vi;

                VectorInt2[] _attackViArray = Util.GetViCricleByRadius(1);

                getActiveGirds.Clear();

                foreach (var _attackVi in _attackViArray)
                {
                    VectorInt2 _resultAttackVi = _playerVi + _attackVi;
                    if (_resultAttackVi < VectorInt2.Zero || _resultAttackVi > (map.Edge - VectorInt2.One))
                    {
                        continue;
                    }
                    if (map.gridMat [_resultAttackVi.x, _resultAttackVi.y] is BuildGrid)
                    {
                        continue;
                    }
                    getActiveGirds.Add(map.gridMat[_resultAttackVi.x, _resultAttackVi.y]);
                    map.gridMat [_resultAttackVi.x, _resultAttackVi.y].SetGridColor(Color.magenta);
                }

                #endregion


                Ray        _ray = Camera.main.ScreenPointToRay(Input.mousePosition);
                RaycastHit _hit = new RaycastHit();

                if (Physics.Raycast(_ray, out _hit, 1000f))
                {
                    Grid _grid = _hit.collider.GetComponentInParent <Grid> ();

                    if (_grid == null)
                    {
                        break;
                    }

                    if (!getActiveGirds.Contains(_grid))
                    {
                        break;
                    }

                    if (gridSelect != null)
                    {
                        gridSelect.gameObject.SetActive(true);
                        gridSelect.transform.position = _grid.transform.position;
                    }

                    if (_grid.Owner != null)
                    {
                        if (Input.GetMouseButtonDown(0))
                        {
                            if (EventSystem.current.IsPointerOverGameObject())
                            {
                                break;
                            }
                            if (gridSelect != null)
                            {
                                gridSelect.gameObject.SetActive(false);
                            }
                            command = COMMAND.DOING;
                            PlayerFight(player, _grid.Owner);
                            break;
                        }
                    }
                }
            }
        }
        break;

        case COMMAND.BUILD:
        {
            if (prevCommand != COMMAND.BUILD)
            {
                getActiveGirds.Clear();
                if (gridSelect != null)
                {
                    gridSelect.gameObject.SetActive(false);
                }
            }

            if (map != null && player.StandGrid != null)
            {
                #region show build range

                //获得玩家所在grid的坐标
                VectorInt2 _playerVi = player.StandGrid.Vi;

                VectorInt2[] _buildViArray = Util.GetViCricleByRadius(1);

                getActiveGirds.Clear();

                foreach (var _buildVi in _buildViArray)
                {
                    VectorInt2 _resultBuildVi = _playerVi + _buildVi;
                    if (_resultBuildVi < VectorInt2.Zero || _resultBuildVi > (map.Edge - VectorInt2.One))
                    {
                        continue;
                    }
                    if (map.gridMat [_resultBuildVi.x, _resultBuildVi.y] is BuildGrid)
                    {
                        continue;
                    }

                    getActiveGirds.Add(map.gridMat[_resultBuildVi.x, _resultBuildVi.y]);

                    map.gridMat [_resultBuildVi.x, _resultBuildVi.y].SetGridColor(Color.green);
                }

                #endregion

                Ray        _ray = Camera.main.ScreenPointToRay(Input.mousePosition);
                RaycastHit _hit = new RaycastHit();

                if (Physics.Raycast(_ray, out _hit, 1000f))
                {
                    Grid _grid = _hit.collider.GetComponentInParent <Grid> ();

                    if (_grid == null)
                    {
                        break;
                    }
                    ;

                    if (!getActiveGirds.Contains(_grid))
                    {
                        break;
                    }

                    if (gridSelect != null)
                    {
                        gridSelect.gameObject.SetActive(true);
                        gridSelect.transform.position = _grid.transform.position;
                    }

                    if (_grid.Owner == null)
                    {
                        if (Input.GetMouseButtonDown(0))
                        {
                            if (UnityEngine.EventSystems.EventSystem.current.IsPointerOverGameObject())
                            {
                                break;
                            }

                            if (gridSelect != null)
                            {
                                gridSelect.gameObject.SetActive(false);
                            }

                            command = COMMAND.DOING;
                            PlayerBuild(player, _grid);

                            break;
                        }
                    }
                }
            }
        }
        break;

        case COMMAND.DEFENSE:
        {
        }
        break;

        case COMMAND.CANCEL:
        {
        }
        break;

        case COMMAND.DOING:
        {
        }
        break;

        case COMMAND.END:
        {
            PlayerEnd();
        }
        break;

        case COMMAND.DONE:
        {
            command = COMMAND.NONE;
        }
        break;

        default:
            throw new System.ArgumentOutOfRangeException();
        }

        prevCommand = command;
    }