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); }
// 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); }
public virtual bool canStopOnCell(CaseBehavior currentCase) { return(currentCase.fosseNonBloquante() && !currentCase.isNonWoundedEnemyPresent(gameObject)); }
// 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); } } } } } }
public override bool canCrossCell(CaseBehavior currentCase) { return(!currentCase.isNonWoundedEnemyPresent(gameObject)); }