// public Room getLair()
// {
// return fLair;
// }
public Room getRandomLair(bool force_create)
{
// Find room without door and only one entrance
int passages = 1;
bool allow_door = false;
while (true)
{
Sequence seq = new Sequence(2, this.getNumRooms());
//seq.remove(fHermit.getRoomNumber());
seq.remove(this.getRoom(1).getPassage(1).getRoomNumber());
seq.remove(this.getRoom(1).getPassage(2).getRoomNumber());
while (seq.count() > 0)
{
int no = seq.remove();
Room room = this.getRoom(no);
if (room.isLair())
{
continue;
}
if ((allow_door || !room.hasDoor()) && room.getNumPassages() <= passages)
{
while (room.getNumPassages() > 1)
{
Room other = room.getRandomPassage();
if (other != null && other.getRoomNumber() != 1)
{
room.removePassage(other);
other.removePassage(room);
Room[] path = this.findRoute(room, other, null, USE_LOCKED_DOORS);
if (path.Length == 0)
{
room.addPassage(other);
other.addPassage(room);
// try another room
break;
}
}
}
if (room.getNumPassages() <= 1)
{
return(room);
}
}
}
if (allow_door)
{
if (force_create)
{
passages++;
if (passages > 3)
{
return(null);
}
allow_door = false;
}
else
{
break;
}
}
else
{
allow_door = true;
}
}
return(null); // uncomment
// return this.getRoom(1);
}
virtual public int applyDamage(int damage, int count)
{
Utility.Assert(count > 0, "Monster.applyDamage count > 0");
fStationary = false;
int remaining = 0;
if (damage > 0)
{
remaining = damage - fHitPoints;
fHitPoints -= damage;
}
if (this.isAlive())
{
if (fTargetRoom == null)
{
bool wasHunting = fHunting;
Utility.Trace(this.getMonsterDescription() + " is wounded and follows hearing");
Room room = this.followHearing();
if (fTargetRoom == null && room != null)
{
fTargetRoom = room;
}
// still act surprised
fHunting = wasHunting;
if (fTargetRoom == null)
{
bool open_door = false;
if (fRoom.hasDoor() && fRoom.isDoorOpen() && !fRoom.isExitDoor())
{
open_door = true;
}
int num = fRoom.getNumPassages();
if (open_door)
{
num++;
}
if (num > 0)
{
int passage = ((count - 1) % num) + 1;
if (open_door && passage == num)
{
fTargetRoom = fRoom.fDoor;
}
else if (fRoom.isPassable(passage))
{
fTargetRoom = fRoom.getPassage(passage);
}
else
{
if (fTargetRoom == null)
{
fTargetRoom = fRoom.getRandomPassage(fLastRoom);
}
if (fTargetRoom != null && GameEngine.instance.hasMonster(fTargetRoom))
{
fTargetRoom = fRoom.getRandomPassage();
}
}
if (fTargetRoom != null)
{
room = fTargetRoom.getRandomPassage(fRoom);
if (room != fRoom)
{
fTargetRoom = room;
}
}
}
}
// if (fTargetRoom == null)
// fTargetRoom = fRoom.getRandomPassage(fLastRoom);
// if (fTargetRoom != null && GameEngine.instance.hasMonster(fTargetRoom))
// fTargetRoom = fRoom.getRandomPassage();
}
Utility.Trace(this.getMonsterDescription() + " is wounded and makes noise");
this.makeNoise(Player.kFightNoise);
}
else
{
Utility.Trace(this.getMonsterDescription() + " is killed and makes noise");
this.makeNoise(Player.kFightNoise);
}
return(remaining);
}
public void initialize()
{
Utility.Trace("Maze - initialize");
if (GameEngine.instance.fDungeon.fCompleted)
{
sExploredRooms = new bool[GameEngine.kMaxNumRooms];
for (int i = 0; i < GameEngine.kMaxNumRooms; i++)
{
sExploredRooms[i] = true;
}
}
else
{
sExploredRooms = new bool[GameEngine.kMaxNumRooms];
for (int i = 0; i < GameEngine.kMaxNumRooms; i++)
{
sExploredRooms[i] = false;
}
}
int no; // = GameEngine.rand.range(2, fNumRooms);
// each room should have at least two exits
for (int iRoom = 1; iRoom <= fNumRooms; iRoom++)
{
Room room = this.getRoom(iRoom);
// each room shall have two exits
for (int iPassage = 1; iPassage <= 2; iPassage++)
{
Sequence seq = new Sequence(2, fNumRooms);
seq.remove(iRoom);
bool hasPassage = false;
do
{
no = seq.remove();
hasPassage = false;
if (room.hasPassage(this.getRoom(no)))
{
hasPassage = true;
}
Room tmpRoom = this.getRoom(no);
if (tmpRoom.hasPassage(this.getRoom(iRoom)))
{
hasPassage = true;
}
} while (seq.count() > 0 && hasPassage);
if (!hasPassage)
{
room.addPassage(this.getRoom(no));
}
}
}
// normalize passages, i.e. make sure they "double-back"
for (int iRoom = 1; iRoom <= fNumRooms; iRoom++)
{
Room room = this.getRoom(iRoom);
// each room shall have two exits
for (int iPassage = 1; iPassage <= room.getNumPassages(); iPassage++)
{
Room otherRoom = room.getPassage(iPassage);
if (!otherRoom.hasPassage(room))
{
otherRoom.addPassage(room);
}
}
}
if (debug)
{
Room room = this.getRoom(1);
room.addStaff(new Staff(null, Staff.BRONZE));
room.fDragonSwords = room.fDragonSwords + 1;
room.fSerpentShields = room.fSerpentShields + 1;
room.fPit = true;
room.addPassage(fExit);
room.createDoor(fExit);
fExit.addPassage(room);
}
// Create normal doors
Room fromRoom = null;
Room toRoom = null;
int num_doors = this.getNumRooms() / 10;
for (int iDoor = 1; iDoor <= num_doors + 1; iDoor++)
{
bool proceed = false;
bool done = false;
do
{
proceed = false;
// Find a room with no door
do
{
done = true;
no = GameEngine.rand.range(2, fNumRooms);
fromRoom = this.getRoom(no);
if (fromRoom.hasDoor())
{
done = false;
}
} while (!done);
// Find a passage to a room without a door
for (int i = 0; i < 10; i++)
{
int index = GameEngine.rand.range(1, fromRoom.getNumPassages());
toRoom = fromRoom.getPassage(index);
if (!toRoom.hasDoor() && toRoom.getRoomNumber() != 1)
{
proceed = true;
break;
}
}
} while (!proceed);
// Convert the passage to a doorway
if (iDoor <= num_doors)
{
Utility.Trace("Create door from " + fromRoom.getRoomNumber() + " to " + toRoom.getRoomNumber());
fromRoom.createDoor(toRoom);
toRoom.createDoor(fromRoom);
if (GameEngine.rand.range(1, 2) == 1)
{
fromRoom.fPoisoned = true;
toRoom.fPoisoned = true;
}
}
else
{
// Convert the last door to two exit-doors
Utility.Trace("Create exit doors in rooms " + fromRoom.getRoomNumber() + " and " + toRoom.getRoomNumber());
fromRoom.removePassage(toRoom);
fromRoom.addPassage(fExit);
fromRoom.createDoor(fExit);
fExit.addPassage(fromRoom);
toRoom.removePassage(fromRoom);
toRoom.addPassage(fExit);
toRoom.createDoor(fExit);
fExit.addPassage(toRoom);
if (GameEngine.rand.range(1, 2) == 1)
{
fromRoom.fPoisoned = true;
toRoom.fPoisoned = true;
}
}
}
Utility.Trace("Removing passages...");
// Go through the maze and remove one passage from each room
for (int iRoom = 2; iRoom <= this.getNumRooms(); iRoom++)
{
int rnd = GameEngine.rand.range(0, 100);
if (rnd >= GameEngine.instance.fSparseFactor)
{
continue;
}
Room room = this.getRoom(iRoom);
int passages = room.getNumPassages();
if (room.hasDoor() && !room.isExitDoor())
{
passages++;
}
if (passages > 1)
{
Room other = room.getRandomPassage();
if (other != null && other.getRoomNumber() != 1)
{
Utility.Trace("Removing passage between room " + room.getRoomNumber() + " and " + other.getRoomNumber());
room.removePassage(other);
other.removePassage(room);
// Since the janitor can pass through doors,
// it should be allowed to have rooms with only
// a single door and no passages!
// USE_LOCKED_DOORS
// However, make sure there are at least one or two keys within reach
// from the initial room (1)
Room[] path = this.findRoute(room, other, null, USE_LOCKED_DOORS);
if (path.Length == 0)
{
Utility.Trace("Reinserting passage between room " + room.getRoomNumber() + " and " + other.getRoomNumber());
room.addPassage(other);
other.addPassage(room);
}
}
}
}
Utility.Trace("Creating portcullises...");
int num_portcullis = this.getNumRooms() / 5;
num_portcullis = GameEngine.rand.range(0, num_portcullis);
int iPortcullis = 0;
Sequence sRooms = new Sequence(1, this.getNumRooms());
while (sRooms.count() > 0)
{
no = sRooms.remove();
Room from = this.getRoom(no);
if (from.getNumPassages() > 0)
{
no = GameEngine.rand.range(1, from.getNumPassages());
if (from.fPortcullis[no - 1] == Room.kPortcullisNone)
{
Room to = from.getPassage(no);
Utility.Trace("Creating portcullis in passage between room " + from.getRoomNumber() + " and " + to.getRoomNumber());
from.fPortcullis[no - 1] = Room.kPortcullisOpen;
to.createPortcullis(from);
++iPortcullis;
}
}
if (iPortcullis >= num_portcullis)
{
break;
}
}
Utility.Trace("Janitor...");
// int numPassages = 3;
// if (fNumRooms < 10)
// numPassages = 0;
fJanitor = this.getRoom(GameEngine.rand.range(2, fNumRooms));
fJanitorTarget = fJanitor;
fJanitorUnlockedDoor = null;
// fJanitorRaisedPortcullis = null;
}
protected Room huntPrey()
{
// if (fLastHunt != null)
// fHunting = true;
// if alive player in room, stay and fight
// if (GameEngine.instance.hasPlayer(fRoom))
// return fRoom;
// else follow trail (if present)
Room room = fRoom.getHearCandidate(this.getHearing());
if (room != null)
{
Utility.Trace(this.getMonsterDescription() + " is following hearing from room " + fRoom.getRoomNumber() + " to " + room.getRoomNumber());
// + " and makes noise");
// this.makeNoise(Player.kFightNoise, fRoom);
}
else
{
room = fRoom.getScentCandidate();
if (room != null)
{
Utility.Trace(this.getMonsterDescription() + " is following scent from room " + fRoom.getRoomNumber() + " to " + room.getRoomNumber());
}
}
// if alive player in room, stay and fight,
// unless there is another player in the next room!
// if alive player in room, stay and fight, unless there is fighting to be had in another room, in which
// case the monster has a hard time deciding...
if (room != null)
{
if (fTargetRoom == null)
{
fTargetRoom = room.getRandomPassage(fRoom);
if (fTargetRoom == fRoom)
{
fTargetRoom = room;
}
}
if (GameEngine.instance.hasPlayer(fRoom))
{
if (GameEngine.rand.range(0, 1) == 0)
{
return(fRoom);
}
}
}
// if (GameEngine.instance.hasPlayer(fRoom))
// {
// if (room != null && !GameEngine.instance.hasPlayer(room))
// {
// return fRoom;
// }
// }
fHunting = true;
if (room == null && fTargetRoom != null)
{
Room[] path = GameEngine.instance.fMaze.findRoute(fRoom, fTargetRoom, null, Maze.USE_OPEN_DOORS);
if (path.Length > 0)
{
room = path[0];
}
}
else if (room != null)
{
if (!fRoom.isPassable(room))
{
room = fRoom.getRandomPassage(fLastRoom);
}
}
if (room == null)
{
fHunting = false;
}
else
{
fStationary = false;
}
if (fHunting)
{
// Utility.Trace(this.getMonsterDescription() + " hunts prey and makes noise");
// this.makeNoise(Player.kFightNoise);
}
return(room);
}
