Пример #1
0
  /**
   * Implements Speed special movement/attack model.
   *
   * @param board
   * @param mtkn
   * @return
   */
  public List<Vector2D> powerMovementSystemSpeed(Board board, MovablePlayerToken mtkn) {
    List<Vector2D> movements = new ArrayList<Vector2D>();
    List<Vector2D> extraMovements = new ArrayList<Vector2D>();
    // Make consecutive movements:
    int x = mtkn.getCol();
    int y = mtkn.getRow();

    movements.add(new Vector2D(y - 1, x));
    movements.add(new Vector2D(y + 1, x));
    movements.add(new Vector2D(y, x - 1));
    movements.add(new Vector2D(y, x + 1));

    movements = validInBoard(movements);
    movements = validInPlayer(board, movements);

    for (int k = 0; k < movements.size(); k++) {
      if (board.getToken(movements.get(k).y, movements.get(k).x).getOwn()
          != this.getTurn().otherSide()) {
        extraMovements.add(new Vector2D(movements.get(k).y - 1, movements.get(k).x));
        extraMovements.add(new Vector2D(movements.get(k).y + 1, movements.get(k).x));
        extraMovements.add(new Vector2D(movements.get(k).y, movements.get(k).x - 1));
        extraMovements.add(new Vector2D(movements.get(k).y, movements.get(k).x + 1));
      }
    }

    extraMovements = validInBoard(extraMovements);
    extraMovements = validInPlayer(board, extraMovements);

    movements.addAll(extraMovements);

    return movements;
  }
Пример #2
0
  public void moveToken(Board board, MovablePlayerToken src, Vector2D trgloc) {
    // A move happens only between a movablePlayerToken and Grass token:

    // Swap tokens:
    int tmpc = src.getCol();
    int tmpr = src.getRow();
    // Update position of source token:
    this.insertToken2Board(board, src, trgloc.y, trgloc.x);
    // fill the space with grass:
    this.insertToken2Board(board, StrategoBoard.grassToken, tmpr, tmpc);
  }
Пример #3
0
  /**
   * Implements Range special attack model.
   *
   * @param board
   * @param mtkn
   * @return
   */
  public List<Vector2D> powerMovementSystemRange(Board board, MovablePlayerToken mtkn) {
    List<Vector2D> movements = new ArrayList<Vector2D>();

    int x = mtkn.getCol();
    int y = mtkn.getRow();

    for (int i = -2; i <= 2; i++) {
      for (int j = -2; j <= 2; j++) {
        movements.add(new Vector2D(y + i, x + j));
      }
    }

    movements = validInBoard(movements);
    movements = validInPlayer(board, movements);

    // Because this system implements ranged attack,
    // valid targets are only enemy tokens:
    movements = validForAttack(board, movements);

    return movements;
  }
Пример #4
0
 /**
  * <b>pre-condition</b>: The Token to exist in Board. Computes valid movement locations for the
  * token in board.
  *
  * @param board
  * @param tkn
  * @return
  */
 public List<Vector2D> tokenSelection(Board board, Token tkn) {
   // List<Vector2D> moveLocations = new ArrayList<Vector2D>();
   this.moveLocations = new ArrayList<Vector2D>();
   // Determine if action is valid (is permitted):
   if (tkn instanceof MovablePlayerToken) {
     // Get available positions for movement/attack
     // based on token class:
     MovablePlayerToken mtkn = (MovablePlayerToken) tkn;
     // Special movement pattern for scouts, based on state of the board:
     if (mtkn instanceof Scout) {
       this.moveLocations = movementSystemScout(board, (Scout) mtkn);
     } else {
       // Get ABSOLUTE board locations:
       this.moveLocations = mtkn.getMovePattern();
       // Vector2D pos = new Vector2D(mtkn.getRow(),mtkn.getCol());
       // Check what locations are valid on the board:
       this.moveLocations = validInBoard(this.moveLocations);
       this.moveLocations = validInPlayer(board, this.moveLocations);
     }
   }
   // else return empty valid move locations:
   return this.moveLocations;
 }
Пример #5
0
 /**
  * Saves the lost (input) Token and places it back to the board in the first empty position. If no
  * empty position Token is not saved.
  *
  * @param board
  * @param tkn
  * @return
  */
 public boolean saveToken(Board board, MovablePlayerToken tkn) {
   // Check if input Token is indeed killed;
   if (tkn.getCol() >= 0) {
     return false;
   }
   // Move the selected Token into the board (if possible!):
   if (getTurn().side().pname.equals("Fire")) {
     // find the first empty spot:
     for (int k = 0; k < 30; k++) {
       int r = k / 10 + 5;
       int c = k % 10;
       if (board.getToken(r, c) instanceof Grass) {
         this.insertToken2Board(board, tkn, r, c);
         return true;
       }
     }
   }
   return false;
 }
Пример #6
0
 public void attackToken(
     Board board, MovablePlayerToken src, PlayerToken trg, boolean specialPower) {
   // An attack happens only between PlayerTokens:
   // perform attack method of source token:
   String outcome = "";
   // No need for an extra attack method, just interpret differently the results.
   if (specialPower && (src instanceof SpecialMovablePlayerToken)) {
     SpecialMovablePlayerToken scltkn = (SpecialMovablePlayerToken) src;
     outcome = scltkn.specialAttackTo(trg);
   } else {
     outcome = src.attackTo(trg);
   }
   if (outcome.equals("won")) {
     // Save location:
     int tmpc = trg.getCol();
     int tmpr = trg.getRow();
     // Remove token that lost from the board:
     takeToken(board, trg);
     // move token that won to its place:
     this.moveToken(board, src, new Vector2D(tmpr, tmpc));
   } else if (outcome.equals("lost")) {
     // Remove token that lost from the board:
     takeToken(board, src);
   } else if (outcome.equals("tie")) {
     // remove both tokens from the board:
     takeToken(board, src);
     takeToken(board, trg);
   } else if (outcome.equals("wonNotMove")) {
     // Remove token that lost from the board:
     takeToken(board, trg);
   } else if (outcome.equals("nothing")) {
     // Nothing happens in the board.
   } else if (outcome.equals("convert")) {
     // Target Token is converted to the other side (probably
     // due to cookies)..
     convertToken(board, trg);
   }
 }
Пример #7
0
  /**
   * Performs an action from source token to the target token. Actions can be: 1. Nothing (action
   * not permitted) 2. Move (valid movement action) 3. Attack (valid attack action)
   *
   * @param src The source token
   * @param trg The target token
   * @return The outcome of the action was successful. False: no action whatsoever.
   */
  public boolean tokenAction(
      Board board,
      Token src,
      Token trg,
      Vector2D trgloc,
      StrategoAppViewer viewer,
      boolean specialPower) {
    // List<Vector2D> moveLocations = new ArrayList<Vector2D>();
    // Determine if action is valid (is permitted):
    // Token action is already validated by the viewer, but the controller ought to check:
    // (in case viewer is not used):
    boolean found = false;
    // Get available positions for movement/attack:
    if (specialPower) {
      this.moveLocations = tokenSpecialSelection(board, src);
    } else {
      this.moveLocations = tokenSelection(board, src);
    }

    for (int i = 0; i < this.moveLocations.size(); i++) {
      if ((trgloc.y == this.moveLocations.get(i).y) && (trgloc.x == this.moveLocations.get(i).x)) {
        found = true;
        break;
      }
    }
    // if no valid movement/token detected: do not execute action:
    if (!found) {
      return false;
    }
    // Now that the movement is permitted:
    // Check what token action to perform:
    if (trg instanceof BackgroundToken) {
      // Grass is the only move-onto background token:
      this.moveToken(board, (MovablePlayerToken) src, trgloc);
    } else {
      // else this is an attack:
      this.attackToken(board, (MovablePlayerToken) src, (PlayerToken) trg, specialPower);
    }

    MovablePlayerToken saviour = null;
    // Check if a token moved in enemy's back row:

    for (int k = 0; k < getTurn().side().tokens.size(); k++) {
      if (getTurn().side().pname == "Fire") {
        if ((getTurn().side().tokens.get(k).getRow() == 0)) {
          saviour = (MovablePlayerToken) getTurn().side().tokens.get(k);
        }
      } else {
        if ((getTurn().side().tokens.get(k).getRow() == 7)) {
          saviour = (MovablePlayerToken) getTurn().side().tokens.get(k);
        }
      }
    }
    // Scouts can not save tokens:
    if (saviour instanceof Scout) {
      saviour = null;
    } else if (getTurn().side().getTotalSaves() > 2) {
      // Can not save more than twice:
      saviour = null;
    } else if ((saviour != null) && saviour.savedToken()) {
      // Can not save more than twice:
      // Get a random Token to save:
      for (int k = 0; k < getTurn().side().tokens.size(); k++) {
        if (getTurn().side().tokens.get(k).getCol() < 0) {
          if (getTurn().side().tokens.get(k) instanceof MovablePlayerToken) {
            if (saveToken(board, (MovablePlayerToken) getTurn().side().tokens.get(k))) {
              break;
            }
          }
        }
      }
    }

    // if player turn completed successfully, check if winning condition:
    getTurn().setWinner(doWeHaveAWinner(board, getTurn()));
    // Else change sides:
    if (getTurn().getWinner() == null) {
      getTurn().flip();
    } else {
      endGame(getTurn());
    }

    return true;
  }