Java Tile.setExplored方法代码示例

import net.sf.freecol.common.model.Tile; //导入方法依赖的package包/类
public void testToggleHorses() {
    Game game = ServerTestHelper.startServerGame(getTestMap(plains));

    Player dutch = game.getPlayerByNationId("model.nation.dutch");
    Tile tile1 = game.getMap().getTile(5, 8);
    tile1.setExplored(dutch, true);
    ServerUnit scout = new ServerUnit(game, tile1, dutch, colonistType);

    // make sure unit has all moves left
    ServerTestHelper.newTurn();

    assertEquals(scout.getInitialMovesLeft(), scout.getMovesLeft());
    int colonistMoves = scout.getMovesLeft();
    scout.changeRole(scoutRole, 1);

    ServerTestHelper.newTurn();

    assertTrue("Scout should have more moves than a colonist",
               scout.getMovesLeft() > colonistMoves);
    scout.changeRole(spec().getDefaultRole(), 0);

    ServerTestHelper.newTurn();

    assertEquals(scout.getMovesLeft(), colonistMoves);
}
 

import net.sf.freecol.common.model.Tile; //导入方法依赖的package包/类
private static int workLeftFor(UnitType unitType, TileType tileType,
                               TileImprovementType whichWork) {
    Game game = getStandardGame();
    game = ServerTestHelper.startServerGame(getTestMap(tileType));
    final InGameController igc = ServerTestHelper.getInGameController();

    ServerPlayer dutch = (ServerPlayer)game.getPlayerByNationId("model.nation.dutch");
    Tile tile = game.getMap().getTile(3, 3);
    assertEquals(tile.getType(), tileType);

    Unit unit = new ServerUnit(game, tile, dutch, unitType, pioneerRole);
    tile.setOwner(dutch);
    tile.setExplored(dutch, true);
    igc.changeWorkImprovementType(dutch, unit, whichWork);
    return unit.getWorkTurnsLeft();
}
 

import net.sf.freecol.common.model.Tile; //导入方法依赖的package包/类
/**
 * Makes the entire map visible or invisible.
 *
 * @param reveal If true, reveal the map, if false, hide it.
 * @return A list of tiles whose visibility changed.
 */
public Set<Tile> exploreMap(boolean reveal) {
    Set<Tile> result = new HashSet<>();
    for (Tile t : transform(getGame().getMap().getAllTiles(),
                            t -> hasExplored(t) != reveal)) {
        t.setExplored(this, reveal);//-vis(this)
        result.add(t);
    }
    invalidateCanSeeTiles();//+vis(this)
    if (!reveal) {
        for (Settlement s : getSettlementList()) exploreForSettlement(s);
        for (Unit u : getUnitList()) exploreForUnit(u);
    }
    return result;
}
 

import net.sf.freecol.common.model.Tile; //导入方法依赖的package包/类
public void testSimpleMove() {
    Game game = ServerTestHelper.startServerGame(getTestMap(plains));
    Map map = game.getMap();

    FreeColClient client = null;
    try {
        client = ClientTestHelper
                .startClient(ServerTestHelper.getServer(), spec());

        Player dutch = game.getPlayerByNationId("model.nation.dutch");
        Tile plain1 = map.getTile(5, 8);
        plain1.setExplored(dutch, true);
        Tile plain2 = map.getTile(5, 7);
        plain2.setExplored(dutch, true);

        Unit hardyPioneer = new ServerUnit(game, plain1, dutch,
                pioneerType);

        client.getPreGameController().startGameHandler();
        assertEquals(plain1.getNeighbourOrNull(Direction.NE), plain2);
        client.getInGameController().moveDirection(hardyPioneer,
                Direction.NE, false);
    } finally {
        if (client != null) {
            ClientTestHelper.stopClient(client);
        }
    }
}
 

import net.sf.freecol.common.model.Tile; //导入方法依赖的package包/类
public void testEuropeanMeetsIndianSettlement() throws Exception {
    Game game = ServerTestHelper.startServerGame(getTestMap(plains));
    Map map = game.getMap();
    InGameController igc = ServerTestHelper.getInGameController();

    ServerPlayer dutch = (ServerPlayer) game.getPlayerByNationId("model.nation.dutch");
    ServerPlayer iroquois = (ServerPlayer) game.getPlayerByNationId("model.nation.iroquois");
    Tile tile1 = map.getTile(5, 8);
    tile1.setExplored(dutch, true);
    Tile tile2 = map.getTile(4, 8);
    tile2.setExplored(dutch, true);
    Tile tile3 = map.getTile(3, 8);
    tile3.setExplored(dutch, true);

    assertFalse(iroquois.hasContacted(dutch));
    assertFalse(dutch.hasContacted(iroquois));

    FreeColTestCase.IndianSettlementBuilder builder = new FreeColTestCase.IndianSettlementBuilder(game);
    IndianSettlement is = builder.player(iroquois).settlementTile(tile3)
        .skillToTeach(null).build();
    ServerUnit colonist = new ServerUnit(game, tile1, dutch, colonistType);
    colonist.setState(Unit.UnitState.FORTIFYING);
    colonist.setState(Unit.UnitState.FORTIFIED);
    igc.move(dutch, colonist, tile2);

    assertTrue(iroquois.hasContacted(dutch));
    assertTrue(dutch.hasContacted(iroquois));
    assertEquals(Stance.PEACE, iroquois.getStance(dutch));
    assertEquals(Stance.PEACE, dutch.getStance(iroquois));

    assertNotNull(iroquois.getTension(dutch));
    assertNotNull(is.getAlarm(dutch));
}
 

import net.sf.freecol.common.model.Tile; //导入方法依赖的package包/类
public void testPioneerDiesNotLosesEquipment() {
    final Game game = ServerTestHelper.startServerGame(getTestMap());
    final Map map = game.getMap();
    final InGameController igc = ServerTestHelper.getInGameController();

    ServerPlayer dutch = (ServerPlayer)game.getPlayerByNationId("model.nation.dutch");
    ServerPlayer french = (ServerPlayer)game.getPlayerByNationId("model.nation.french");
    Tile tile1 = map.getTile(5, 8);
    tile1.setExplored(dutch, true);
    tile1.setExplored(french, true);
    Tile tile2 = map.getTile(4, 8);
    tile2.setExplored(dutch, true);
    tile2.setExplored(french, true);
    Unit pioneer = new ServerUnit(game, tile1, dutch, colonistType, pioneerRole);
    Unit soldier = new ServerUnit(game, tile2, french, veteranType, dragoonRole);
    soldier.setMovesLeft(1);

    // Soldier wins and kills the pioneer
    List<CombatResult> crs
        = fakeAttackResult(CombatResult.WIN, soldier, pioneer);
    checkCombat("Soldier v Pioneer", crs,
                CombatResult.WIN, CombatResult.SLAUGHTER_UNIT);
    igc.combat(french, soldier, pioneer, crs);

    assertTrue("Pioneer should be dead",
               pioneer.isDisposed());
}
 

import net.sf.freecol.common.model.Tile; //导入方法依赖的package包/类
public void testColonistDemotedBySoldier() {
    final Game game = ServerTestHelper.startServerGame(getTestMap(plains));
    final Map map = game.getMap();
    final InGameController igc = ServerTestHelper.getInGameController();

    ServerPlayer dutch = (ServerPlayer)game.getPlayerByNationId("model.nation.dutch");
    ServerPlayer french = (ServerPlayer)game.getPlayerByNationId("model.nation.french");
    igc.changeStance(dutch, Stance.WAR, french, true);

    Tile tile1 = map.getTile(5, 8);
    tile1.setExplored(dutch, true);
    tile1.setExplored(french, true);
    Tile tile2 = map.getTile(4, 8);
    tile2.setExplored(dutch, true);
    tile2.setExplored(french, true);

    Unit colonist = new ServerUnit(game, tile1, dutch, colonistType);
    assertTrue("Colonists should be capturable",
               colonist.hasAbility(Ability.CAN_BE_CAPTURED));
    Unit soldier = new ServerUnit(game, tile2, french, colonistType);
    assertTrue("Soldier should be capturable",
               soldier.hasAbility(Ability.CAN_BE_CAPTURED));
    soldier.changeRole(soldierRole, 1);
    assertFalse("Armed soldier should not be capturable",
                soldier.hasAbility(Ability.CAN_BE_CAPTURED));

    // Colonist loses and is captured
    List<CombatResult> crs
        = fakeAttackResult(CombatResult.LOSE, colonist, soldier);
    checkCombat("Colonist v Soldier", crs,
                CombatResult.LOSE, CombatResult.CAPTURE_UNIT);
    igc.combat(dutch, colonist, soldier, crs);

    assertEquals("Colonist should still be a colonist",
                 colonistType, colonist.getType());
    assertEquals("Colonist should be captured",
                 french, colonist.getOwner());
    assertEquals("Colonist should have moved to the soldier tile",
                 tile2, colonist.getTile());
}
 

import net.sf.freecol.common.model.Tile; //导入方法依赖的package包/类
public void testScoutDiesNotLosesEquipment() {
    final Game game = ServerTestHelper.startServerGame(getTestMap());
    final Map map = game.getMap();
    final InGameController igc = ServerTestHelper.getInGameController();
    
    ServerPlayer dutch = (ServerPlayer)game.getPlayerByNationId("model.nation.dutch");
    ServerPlayer french = (ServerPlayer)game.getPlayerByNationId("model.nation.french");
    igc.changeStance(dutch, Stance.WAR, french, true);

    Tile tile1 = map.getTile(5, 8);
    tile1.setExplored(dutch, true);
    tile1.setExplored(french, true);
    Tile tile2 = map.getTile(4, 8);
    tile2.setExplored(dutch, true);
    tile2.setExplored(french, true);
    Unit scout = new ServerUnit(game, tile1, dutch, colonistType,
                                scoutRole);
    Unit soldier = new ServerUnit(game, tile2, french, veteranType,
                                  soldierRole);
    scout.setMovesLeft(1);

    // Soldier wins and kills the scout
    List<CombatResult> crs
        = fakeAttackResult(CombatResult.WIN, soldier, scout);
    checkCombat("Soldier v scout", crs,
                CombatResult.WIN, CombatResult.SLAUGHTER_UNIT);
    igc.combat(french, soldier, scout, crs);

    assertTrue("Scout should be dead",
               scout.isDisposed());
    assertEquals(soldierRole, soldier.getRole());
}
 

import net.sf.freecol.common.model.Tile; //导入方法依赖的package包/类
public void testEuropeanMeetsNative() throws Exception {
    Game game = ServerTestHelper.startServerGame(getTestMap(plains));
    Map map = game.getMap();
    InGameController igc = ServerTestHelper.getInGameController();

    ServerPlayer dutch = (ServerPlayer) game.getPlayerByNationId("model.nation.dutch");
    ServerPlayer iroquois = (ServerPlayer) game.getPlayerByNationId("model.nation.iroquois");
    Tile tile1 = map.getTile(6, 8);
    tile1.setExplored(dutch, true);
    Tile tile2 = map.getTile(5, 8);
    tile2.setExplored(dutch, true);
    Tile tile3 = map.getTile(4, 8);
    tile3.setExplored(dutch, true);

    assertFalse(iroquois.hasContacted(dutch));
    assertFalse(dutch.hasContacted(iroquois));

    ServerUnit colonist = new ServerUnit(game, tile1, dutch, colonistType);
    colonist.setState(Unit.UnitState.FORTIFYING);
    colonist.setState(Unit.UnitState.FORTIFIED);
    ServerUnit soldier = new ServerUnit(game, tile3, iroquois, braveType);
    assertNotNull(soldier);

    igc.move(dutch, colonist, tile2);

    assertTrue(iroquois.hasContacted(dutch));
    assertTrue(dutch.hasContacted(iroquois));
    assertEquals(Stance.PEACE, iroquois.getStance(dutch));
    assertEquals(Stance.PEACE, dutch.getStance(iroquois));

    assertNotNull(iroquois.getTension(dutch));
}
 

import net.sf.freecol.common.model.Tile; //导入方法依赖的package包/类
public void testNativeMeetsColony() throws Exception {
    Game game = ServerTestHelper.startServerGame(getTestMap(plains));
    Map map = game.getMap();
    InGameController igc = ServerTestHelper.getInGameController();

    ServerPlayer apache = (ServerPlayer) game.getPlayerByNationId("model.nation.apache");
    ServerPlayer dutch = (ServerPlayer) game.getPlayerByNationId("model.nation.dutch");
    Tile tile1 = map.getTile(5, 8);
    tile1.setExplored(dutch, true);
    Tile tile2 = map.getTile(4, 8);
    tile2.setExplored(dutch, true);
    Tile tile3 = map.getTile(3, 8);
    tile3.setExplored(dutch, true);

    assertFalse(dutch.hasContacted(apache));
    assertFalse(apache.hasContacted(dutch));

    Colony colony = getStandardColony(1, 5, 8);
    assertNotNull(colony);
    ServerUnit brave = new ServerUnit(game, tile3, apache, braveType);
    igc.move(apache, brave, tile2);

    assertTrue(dutch.hasContacted(apache));
    assertTrue(apache.hasContacted(dutch));
    assertEquals(Stance.PEACE, dutch.getStance(apache));
    assertEquals(Stance.PEACE, apache.getStance(dutch));
}
 

import net.sf.freecol.common.model.Tile; //导入方法依赖的package包/类
public void testScoutDefeatedBySoldier() {
    final Game game = ServerTestHelper.startServerGame(getTestMap(plains));
    final Map map = game.getMap();
    final InGameController igc = ServerTestHelper.getInGameController();

    ServerPlayer dutch = (ServerPlayer)game.getPlayerByNationId("model.nation.dutch");
    ServerPlayer french = (ServerPlayer)game.getPlayerByNationId("model.nation.french");
    igc.changeStance(dutch, Stance.WAR, french, true);

    Tile tile1 = map.getTile(5, 8);
    tile1.setExplored(dutch, true);
    tile1.setExplored(french, true);
    Tile tile2 = map.getTile(4, 8);
    tile2.setExplored(dutch, true);
    tile2.setExplored(french, true);
    Unit scout = new ServerUnit(game, tile1, dutch, colonistType,
                                scoutRole);
    Unit soldier = new ServerUnit(game, tile2, french, colonistType,
                                  soldierRole);

    // Scout loses and is slaughtered
    List<CombatResult> crs
        = fakeAttackResult(CombatResult.LOSE, scout, soldier);
    checkCombat("Scout v Soldier", crs,
                CombatResult.LOSE, CombatResult.SLAUGHTER_UNIT);
    igc.combat(dutch, scout, soldier, crs);

    assertTrue("Scout should be disposed",
               scout.isDisposed());
    assertEquals(soldierRole, soldier.getRole());
}
 

import net.sf.freecol.common.model.Tile; //导入方法依赖的package包/类
public void testShipMeetsShip() throws Exception {
    Game game = ServerTestHelper.startServerGame(getTestMap(ocean));
    Map map = game.getMap();
    InGameController igc = ServerTestHelper.getInGameController();

    ServerPlayer dutch = (ServerPlayer) game.getPlayerByNationId("model.nation.dutch");
    ServerPlayer french = (ServerPlayer) game.getPlayerByNationId("model.nation.french");
    Tile tile1 = map.getTile(5, 8);
    tile1.setExplored(dutch, true);
    tile1.setExplored(french, true);
    Tile tile2 = map.getTile(4, 8);
    tile2.setExplored(dutch, true);
    tile2.setExplored(french, true);
    Tile tile3 = map.getTile(3, 8);
    tile3.setExplored(dutch, true);
    tile3.setExplored(french, true);

    assertFalse(french.hasContacted(dutch));
    assertFalse(dutch.hasContacted(french));

    ServerUnit ship1 = new ServerUnit(game, tile1, dutch, galleonType);
    ship1.setState(Unit.UnitState.FORTIFYING);
    ship1.setState(Unit.UnitState.FORTIFIED);
    ServerUnit ship2 = new ServerUnit(game, tile3, french, galleonType);
    assertNotNull(ship2);
    igc.move(dutch, ship1, tile2);

    assertFalse(french.hasContacted(dutch));
    assertFalse(dutch.hasContacted(french));
    assertEquals(Stance.UNCONTACTED, french.getStance(dutch));
    assertEquals(Stance.UNCONTACTED, dutch.getStance(french));
}
 

import net.sf.freecol.common.model.Tile; //导入方法依赖的package包/类
public void testDragoonDemotedBySoldier() {
    final Game game = ServerTestHelper.startServerGame(getTestMap(plains));
    final Map map = game.getMap();
    final InGameController igc = ServerTestHelper.getInGameController();

    ServerPlayer dutch = (ServerPlayer)game.getPlayerByNationId("model.nation.dutch");
    ServerPlayer french = (ServerPlayer)game.getPlayerByNationId("model.nation.french");
    igc.changeStance(dutch, Stance.WAR, french, true);

    Tile tile1 = map.getTile(5, 8);
    tile1.setExplored(dutch, true);
    tile1.setExplored(french, true);
    Tile tile2 = map.getTile(4, 8);
    tile2.setExplored(dutch, true);
    tile2.setExplored(french, true);
    Unit dragoon = new ServerUnit(game, tile1, dutch,
                                  colonistType, dragoonRole);
    ServerTestHelper.newTurn();

    assertEquals("Dragoon has 12 moves",
                 12, dragoon.getInitialMovesLeft());
    assertEquals("Dragoon has 12 moves left",
                 12, dragoon.getMovesLeft());
    Unit soldier = new ServerUnit(game, tile2, french,
                                  colonistType, soldierRole);

    // Dragoon loses and loses horses
    List<CombatResult> crs
        = fakeAttackResult(CombatResult.LOSE, dragoon, soldier);
    checkCombat("Dragoon v soldier (1)", crs,
        CombatResult.LOSE, CombatResult.LOSE_EQUIP);
    igc.combat(dutch, dragoon, soldier, crs);

    assertEquals("Attacker should be a colonist", colonistType,
                 dragoon.getType());
    assertEquals("Attacker should be Dutch", dutch,
                 dragoon.getOwner());
    assertEquals("Attacker should be on tile1", tile1,
                 dragoon.getTile());
    assertEquals("Attacker should be a soldier", soldierRole,
                 dragoon.getRole());
    assertTrue("Attacker should still be armed",
               dragoon.isArmed());
    assertFalse("Attacker should not still be mounted",
                dragoon.isMounted());
    assertEquals("Attacker has 3 moves", 3,
                 dragoon.getInitialMovesLeft());
    assertEquals("Attacker has 0 moves left", 0,
                 dragoon.getMovesLeft());

    crs = fakeAttackResult(CombatResult.LOSE, dragoon, soldier);
    checkCombat("Dragoon v soldier (2)", crs,
        CombatResult.LOSE, CombatResult.LOSE_EQUIP);
    igc.combat(dutch, dragoon, soldier, crs);

    assertEquals("Attacker should be a colonist", colonistType,
                 dragoon.getType());
    assertEquals("Attacker should be Dutch", dutch,
                 dragoon.getOwner());
    assertEquals("Attacker should be on tile1", tile1,
                 dragoon.getTile());
    assertTrue("Attacker should have default role",
               dragoon.hasDefaultRole());

    crs = fakeAttackResult(CombatResult.WIN, soldier, dragoon);
    checkCombat("Soldier v ex-dragoon", crs,
                CombatResult.WIN, CombatResult.CAPTURE_UNIT);
    igc.combat(french, soldier, dragoon, crs);

    assertEquals("Defender should be a colonist", colonistType,
                 dragoon.getType());
    assertEquals("Defender should be French", french,
                 dragoon.getOwner());
    assertEquals("Defender should be on tile2", tile2,
                 dragoon.getTile());
}
 

import net.sf.freecol.common.model.Tile; //导入方法依赖的package包/类
public void testArtilleryDemotedBySoldier() {
    final Game game = ServerTestHelper.startServerGame(getTestMap(plains));
    final Map map = game.getMap();
    final InGameController igc = ServerTestHelper.getInGameController();

    ServerPlayer dutch = (ServerPlayer)game.getPlayerByNationId("model.nation.dutch");
    ServerPlayer french = (ServerPlayer)game.getPlayerByNationId("model.nation.french");
    igc.changeStance(dutch, Stance.WAR, french, true);

    Tile tile1 = map.getTile(5, 8);
    tile1.setExplored(dutch, true);
    tile1.setExplored(french, true);
    Tile tile2 = map.getTile(4, 8);
    tile2.setExplored(dutch, true);
    tile2.setExplored(french, true);
    Unit artillery = new ServerUnit(game, tile1, dutch, artilleryType);
    Unit soldier = new ServerUnit(game, tile2, french, colonistType, soldierRole);
    assertEquals("Artillery should demote to damaged artillery",
                 damagedArtilleryType,
                 artillery.getUnitChange(UnitChangeType.DEMOTION).to);

    // Artillery loses and is demoted
    List<CombatResult> crs
        = fakeAttackResult(CombatResult.LOSE, artillery, soldier);
    checkCombat("Artillery v Soldier (1)", crs,
        CombatResult.LOSE, CombatResult.DEMOTE_UNIT);
    igc.combat(dutch, artillery, soldier, crs);

    assertEquals("Artillery should be damaged artillery",
                 damagedArtilleryType, artillery.getType());
    assertEquals("Artillery should be Dutch",
                 dutch, artillery.getOwner());
    assertEquals("Artillery should be on Tile1",
                 tile1, artillery.getTile());

    // Artillery loses and is slaughtered
    crs = fakeAttackResult(CombatResult.LOSE, artillery, soldier);
    checkCombat("Artillery v Soldier (2)", crs,
        CombatResult.LOSE, CombatResult.SLAUGHTER_UNIT);
    igc.combat(dutch, artillery, soldier, crs);

    assertTrue("Artillery should be disposed",
               artillery.isDisposed());
}
 

import net.sf.freecol.common.model.Tile; //导入方法依赖的package包/类
public void testUnarmedAttack() {
    final Game game =  ServerTestHelper.startServerGame(getTestMap(plains));
    final Map map = game.getMap();
    final InGameController igc = ServerTestHelper.getInGameController();

    ServerPlayer dutch = (ServerPlayer)game.getPlayerByNationId("model.nation.dutch");
    ServerPlayer french = (ServerPlayer)game.getPlayerByNationId("model.nation.french");
    igc.changeStance(french, Stance.WAR, dutch, true);

    dutch.addAbility(new Ability(Ability.INDEPENDENCE_DECLARED));
    Tile tile1 = map.getTile(5, 8);
    tile1.setExplored(dutch, true);
    tile1.setExplored(french, true);
    Tile tile2 = map.getTile(4, 8);
    tile2.setExplored(dutch, true);
    tile2.setExplored(french, true);
    // Create Colonial Regular with default role (impossible:-)
    Unit colonial = new ServerUnit(game, tile1, dutch, colonialType,
                                   spec().getDefaultRole());
    assertEquals("Must be Colonial Regular",
                 colonialType, colonial.getType());
    assertEquals("Only has default base offence",
                 UnitType.DEFAULT_OFFENCE, colonial.getType().getBaseOffence());
    assertEquals("Only has default base defence",
                 UnitType.DEFAULT_DEFENCE, colonial.getType().getBaseDefence());
    assertTrue("Has default role", colonial.hasDefaultRole());

    // Create Veteran Soldier with default role
    Unit soldier = new ServerUnit(game, tile2, french, veteranType);
    assertTrue("Veteran is armed",
               soldier.isArmed());
    assertTrue("Veteran is an offensive unit",
               soldier.isOffensiveUnit());
    assertEquals("Has soldier role", soldierRole,
                 soldier.getRole());

    // Colonial regulars should never be unarmed
    assertEquals("Unarmed Colonial Regular can not attack!",
                 Unit.MoveType.MOVE_NO_ATTACK_CIVILIAN,
                 colonial.getMoveType(tile2));
    colonial.changeRole(soldierRole, 1);
    assertEquals("Colonial Regular can attack",
                 Unit.MoveType.ATTACK_UNIT,
                 colonial.getMoveType(tile2));

    // Veteran attacks and demotes the Colonial Regular
    List<CombatResult> crs
        = fakeAttackResult(CombatResult.WIN, soldier, colonial);
    checkCombat("Soldier v Colonial (1)", crs,
        CombatResult.WIN, CombatResult.LOSE_EQUIP, CombatResult.DEMOTE_UNIT);
    igc.combat(french, soldier, colonial, crs);

    assertEquals("Colonial Regular is demoted",
                 veteranType, colonial.getType());

    // Veteran attacks and captures the Colonial Regular
    crs = fakeAttackResult(CombatResult.WIN, soldier, colonial);
    checkCombat("Soldier v Colonial (2)", crs,
        CombatResult.WIN, CombatResult.CAPTURE_UNIT);
    igc.combat(french, soldier, colonial, crs);

    assertEquals("Colonial Regular is demoted",
                 colonistType, colonial.getType());
    assertEquals("Colonial Regular should be captured",
                 french, colonial.getOwner());
    assertEquals("Colonial Regular is moved to the Veterans tile",
                 tile2, colonial.getTile());
}