Пример #1
0
    //-----------------------------------------------------------------------------------------------------


    //移動できたら移動して移動できたかどうかを返す-----------------------------------------------------------
    bool EnemyCardMove(CardMain enemyMoveCard, Square nowSquare, PRIORITY_DIRECTION priority)
    {
        List <Field.DIRECTION> directions = EnemyDirectionSorting(enemyMoveCard, priority);

        if (directions.Count == 0)
        {
            return(false);
        }


        List <Field.DIRECTION> enemyDirection = new List <Field.DIRECTION>( );

        for (int i = 0; i < directions.Count; i++)
        {
            enemyDirection.Add(directions[i]);

            List <Field.DIRECTION> preDirection = enemyMoveCard.Card_Data_Direction;
            enemyMoveCard.Card_Data_Direction = enemyDirection;              //一時的にエネミーのカードの移動先を書き換えている。

            List <Square> moveSquare = _field.MovePossibleSquare(enemyMoveCard, enemyMoveCard.Card_Data._directionOfTravel, nowSquare);

            if (moveSquare.Count == 0)
            {
                enemyMoveCard.Card_Data_Direction = preDirection;
                enemyDirection.Remove(directions[i]);
                continue;
            }

            MoveCard(enemyMoveCard, nowSquare, moveSquare[0]);                          //あとでこの関数の役割を分けないといけない
            enemyMoveCard.Card_Data_Direction = preDirection;
            return(true);
        }

        return(false);
    }
Пример #2
0
    //-------------------------------------------------------------------------------------------------------


    //エネミーカードの移動したくてかつできる場所を優先順位が高い順に抽出する-------------------------
    List <Field.DIRECTION> EnemyDirectionSorting(CardMain card, PRIORITY_DIRECTION priorityDirection)
    {
        Field.DIRECTION[] enemyDirections = null;

        switch (priorityDirection)
        {
        case PRIORITY_DIRECTION.RIGHT_PRIORITY:
            Field.DIRECTION[] right = { Field.DIRECTION.RIGHT };
            enemyDirections = right;
            break;

        case PRIORITY_DIRECTION.LEFT_PRIORITY:
            Field.DIRECTION[] left = { Field.DIRECTION.LEFT };
            enemyDirections = left;
            break;

        case PRIORITY_DIRECTION.NORMAR:
            Field.DIRECTION[] normarDirections = { Field.DIRECTION.FORWAED,
                                                   Field.DIRECTION.LEFT_FORWARD,
                                                   Field.DIRECTION.RIGHT_FORWARD,
                                                   Field.DIRECTION.RIGHT,
                                                   Field.DIRECTION.LEFT };

            enemyDirections = normarDirections;
            break;
        }

        List <Field.DIRECTION> direction = new List <Field.DIRECTION>( );

        for (int i = 0; i < enemyDirections.Length; i++)
        {
            for (int j = 0; j < card.Card_Data._directionOfTravel.Count; j++)
            {
                if (card.Card_Data._directionOfTravel[j] != enemyDirections[i])
                {
                    continue;
                }
                direction.Add(card.Card_Data._directionOfTravel[j]);
            }
        }

        return(direction);
    }
Пример #3
0
    //------------------------------------------------------------------------------------------------


    //第一優先カード移動-------------------------------------------------------------------------------------
    //移動したかどうかをboolで返す
    bool FirstPriorityMoveCard( )
    {
        for (int i = 0; i < ConstantStorehouse.SQUARE_ROW_NUM; i++)
        {
            Square square = _field.getSquare(i);

            if (square == null)
            {
                continue;
            }
            if (square.On_Card == null)
            {
                continue;
            }
            if (square.On_Card.gameObject.tag != ConstantStorehouse.TAG_PLAYER1)
            {
                continue;
            }

            Square             onEnemyCardSquare  = null;
            PRIORITY_DIRECTION priority_direction = PRIORITY_DIRECTION.NORMAR;
            if (i + 1 < 4)                      //一列目の左端を超えてなかったら
            {
                onEnemyCardSquare  = _field.getSquare(i + 1);
                priority_direction = PRIORITY_DIRECTION.RIGHT_PRIORITY;
            }

            if (i - 1 > -1)                 //一列目の右端を超えていなかったら
            {
                if (onEnemyCardSquare == null)
                {
                    onEnemyCardSquare  = _field.getSquare(i - 1);
                    priority_direction = PRIORITY_DIRECTION.LEFT_PRIORITY;
                }
            }

            if (onEnemyCardSquare == null)
            {
                continue;
            }
            if (onEnemyCardSquare.On_Card == null)
            {
                continue;
            }
            if (onEnemyCardSquare.On_Card.gameObject.tag != ConstantStorehouse.TAG_PLAYER2)
            {
                continue;
            }

            CardMain enemyMoveCard = null;
            enemyMoveCard = onEnemyCardSquare.On_Card;

            int nowAP = _enemyActivePoint.Point_Num;
            if (enemyMoveCard.Card_Data._necessaryAP > nowAP)
            {
                continue;
            }
            if (enemyMoveCard.Action_Count >= enemyMoveCard.MAX_ACTION_COUNT)
            {
                continue;
            }

            if (!EnemyCardMove(enemyMoveCard, onEnemyCardSquare, priority_direction))
            {
                continue;
            }

            return(true);
        }

        return(false);
    }