Ejemplo n.º 1
0
    public List <Token> getPickableTokens()
    {
        CaseBehavior currentCell = caseActuelle.GetComponent <CaseBehavior>();

        if (currentCell.isNonWoundedEnemyPresent(gameObject))
        {
            return(new List <Token>());                                                 // cannot pick an object when a non wounded enemy is present
        }
        List <Token> result = new List <Token>();

        foreach (Token token in currentCell.tokens_)
        {
            if (token.GetComponent <CharacterBehavior>() != null)
            {
                CharacterBehavior otherCharacter = token.GetComponent <CharacterBehavior>();
                if (otherCharacter != this && otherCharacter.affiliationJoueur == affiliationJoueur && otherCharacter.wounded && otherCharacter.tokenHolder != this)
                {
                    result.Add(token);                                                                                                                                                  // can autopick wounded ally that the character doesn't already carry
                }
            }
            else // item
            {
                // TODO: Fix the case where an ally thief is standing on the pit
                if (token.GetComponent <Item_Corde>() != null && currentCell.type == CaseBehavior.typeCase.caseFosse && currentCell.isOtherAllyPresent(this))
                {
                    continue; // cannot pick a rope on a pit where an ally is standing
                }
                if (token.tokenHolder != this)
                {
                    result.Add(token); // can pick an item that the character doesn't already carry
                }
            }
        }
        return(result);
    }
Ejemplo n.º 2
0
    // The first fighter will always be the action character, and the second, the target character.
    public List <CharacterBehavior> SearchFighters(CharacterBehavior attacker, CharacterBehavior opponent)
    {
        List <CharacterBehavior>  fighters = new List <CharacterBehavior>();
        Queue <CharacterBehavior> queue    = new Queue <CharacterBehavior>();

        System.Action <CharacterBehavior> SelectFighter = (fighter) =>
        {
            if (!fighters.Contains(fighter))
            {
                fighters.Add(fighter);
                queue.Enqueue(fighter);
            }
        };

        SelectFighter(attacker);
        SelectFighter(opponent);

        while (queue.Count > 0)
        {
            CharacterBehavior currentFighter = queue.Dequeue();
            CaseBehavior      currentCell    = currentFighter.caseActuelle.GetComponent <CaseBehavior>();

            // Propagate in all directions
            for (int dir = 0; dir < 4; ++dir)
            {
                if (!currentCell.debordement(dir) && currentCell.cheminDegage(currentCell.versDirection(dir)))
                {
                    CaseBehavior nextCell = currentCell.getCaseVers(dir);

                    if (nextCell.isCaseRevealed() && nextCell.cheminDegage(nextCell.versDirection(CaseBehavior.opposee(dir))) && nextCell.enemyFighterPresent(currentFighter.gameObject))
                    {
                        if (nextCell.isNonWoundedEnemyPresent(currentFighter.gameObject))
                        {
                            foreach (CharacterBehavior character in nextCell.characters)
                            {
                                SelectFighter(character);
                            }
                        }
                    }
                }
            }
        }

        return(fighters);
    }
Ejemplo n.º 3
0
 public virtual bool canStopOnCell(CaseBehavior currentCase)
 {
     return(currentCase.fosseNonBloquante() && !currentCase.isNonWoundedEnemyPresent(gameObject));
 }
Ejemplo n.º 4
0
    // Recherche A* iterative de deplacement et saut
    void SearchPath(CaseBehavior startCell, int depth, bool jump)
    {
        Queue <CaseBehavior> queue = new Queue <CaseBehavior>();

        RegisterAction(ActionType.WALK, startCell, 0);
        if (jump)
        {
            RegisterAction(ActionType.JUMP, startCell, 0);
        }
        if (depth > 0)
        {
            queue.Enqueue(startCell);
        }

        // Proof that this iterative BFS (Broad-First-Search) has no redundancy:
        // If we can only jump through a cell, there will be only one register of this cell.
        // If we can jump and move through the same cell (therefore as first move), then the code will discard the jump.
        // Since the priority increase with depth, no cell will be registered twice for move (due to register priority check)
        // As a conclusion: we guarantee no redundant check.
        while (queue.Count > 0)
        {
            CaseBehavior currentCell = queue.Dequeue();
            int          priority    = GetActionPriority(ActionType.WALK, currentCell); // 0: init, depth: stop, MAX: JumpStart

            Debug.Assert(!currentCharacter.surLaRegletteAdverse(currentCell));

            // Propagate in all directions
            for (int dir = 0; dir < 4; ++dir)
            {
                if (!currentCell.debordement(dir) && currentCell.cheminDegage(currentCell.versDirection(dir)))
                {
                    CaseBehavior nextCell = currentCell.getCaseVers(dir);
                    if (nextCell.isCaseRevealed() && nextCell.cheminDegage(nextCell.versDirection(CaseBehavior.opposee(dir))) && (currentCharacter is CB_Magicien || !nextCell.isNonWoundedEnemyPresent(currentCharacter.gameObject)))
                    {
                        // Si la case suivante est traversable et le mouvement precedent n'est pas un saut, enregistrer un mouvement.
                        if (currentCharacter.canCrossCell(nextCell) && priority != MAX_PRIORITY)
                        {
                            if (priority + 1 == depth)
                            {
                                // Si ce n'est pas la case finale, on doit pouvoir terminer le mouvement sur cette case.
                                // WARNING: le cas d'un couloir de plusieurs cases contenant plusieur cases non finales n'est pas pris en compte.
                                //          (possibilite d'effectuer un mouvement qui devra etre annule par la suite)
                                if (currentCharacter.canStayOnCell(nextCell))
                                {
                                    RegisterAction(ActionType.WALK, nextCell, priority + 1, currentCell);
                                }
                            }
                            else
                            {
                                // propage le mouvement si besoin.
                                if (RegisterAction(ActionType.WALK, nextCell, priority + 1, currentCell) && !currentCharacter.surLaRegletteAdverse(nextCell))
                                {
                                    queue.Enqueue(nextCell);
                                }
                            }
                        }
                        // si le saut est permis et que c'est le premier mouvement, initier un saut
                        else if (priority == 0 && jump)
                        {
                            if (RegisterAction(ActionType.JUMP, nextCell, 1, currentCell))
                            {
                                queue.Enqueue(nextCell);
                            }
                        }
                        // sinon si le mouvement precedent etait un saut, enregistrer la fin du saut si possible.
                        else if (priority == MAX_PRIORITY && currentCharacter.canStayOnCell(nextCell))
                        {
                            RegisterAction(ActionType.JUMP, nextCell, 2, currentCell);
                        }
                    }
                }
            }
        }
    }
Ejemplo n.º 5
0
 public override bool canCrossCell(CaseBehavior currentCase)
 {
     return(!currentCase.isNonWoundedEnemyPresent(gameObject));
 }