public void Start()
{
isRunning = true;
while (isRunning)
{
// Check for scene change
if (sceneChanged)
{
CurrentScene = newScene;
newScene = null;
sceneChanged = false;
}
// Check if the game is still running.
if (TCODConsole.isWindowClosed() || CurrentScene == null)
{
Stop();
break;
}
// Update
CurrentScene.Update(TCODSystem.getLastFrameLength());
// Render
TCODConsole.root.clear();
CurrentScene.Render(TCODSystem.getLastFrameLength());
TCODConsole.flush();
// Handle user input
CheckForKeyboardEvents();
CheckForMouseEvents();
}
CleanUp();
}
public void render(bool flush)
{
TCODConsole.root.clear();
if (gameStatus == GameStatus.LOADING)
{
loadingGui.render();
}
else if (gameStatus == GameStatus.DEFEAT)
{
defeatGui.render();
}
else
{
currentLevel.render();
if (player != null)
{
player.render();
}
if (player != null)
{
TCODConsole.root.print(1, screenHeight - 2, string.Format("HP : {0}/{1}",
(int)player.getDestructible().hp, (int)player.getDestructible().maxHp));
}
gui.render();
messageGui.render();
currentLevel.renderGui();
menuGui.render();
}
TCODConsole.flush();
}
public bool Show()
{
var x = (TCODConsole.root.getWidth() / 2) - (Message.Length / 2 + 2);
var width = Math.Max(13, Message.Length + 4); // Two for padding and two for the border
var y = (TCODConsole.root.getHeight() / 2) - 3;
var height = 6;
TCODConsole.root.setForegroundColor(Foreground);
TCODConsole.root.setBackgroundColor(Background);
TCODConsole.root.printFrame(x, y, width, height, true, TCODBackgroundFlag.Set);
TCODConsole.root.print(x + 2, y + 2, Message);
TCODConsole.root.print(x + (width / 2) - 4, y + 3, "[Y] / [N]");
TCODConsole.flush();
TCODKey key = null;
var character = 'N';
do
{
key = TCODConsole.waitForKeypress(true);
character = char.ToUpper(key.Character);
} while(character != 'Y' && character != 'N');
return(character == 'Y');
}
private void end()
{
TCODConsole.root.clear();
TCODConsole.root.setForegroundColor(TCODColor.red);
TCODConsole.root.print(35, 25, "You died");
TCODConsole.flush();
TCODConsole.waitForKeypress(true);
}
private void Draw(uint elapsedTime)
{
TCODConsole.root.clear();
foreach (var window in _windowsStack)
{
window.OnDraw();
}
TCODConsole.flush();
}
public void debugRender(int iterations)
{
for (int i = 0; i < iterations; i++)
{
TCODConsole.flush();
}
level.render();
level.update();
}
public DungeonGenerator(Level level)
: base(level)
{
TCODRandom rng = TCODRandom.getInstance();
roomTries = rng.getInt(minRoomTries, maxRoomTries);
windingPercent = rng.getInt(5, 100);
roomExtraSize = rng.getInt(0, 5);
extraConnectorChance = rng.getInt(10, 100);
regions = new int[map.width, map.height];
if (debugDraw)
{
map.showAllTiles = true;
Program.engine.update();
TCODConsole.root.clear();
TCODConsole.flush();
}
addRooms();
Program.engine.loadingGui.loading++;
Program.engine.render();
roomNumber = currentRegion + 1;
startRegion();
for (var y = 1; y < map.height; y += 2)
{
for (var x = 1; x < map.width; x += 2)
{
if (map.isWall(x, y))
{
continue;
}
growMaze(x, y);
}
}
connectRegions();
addRandomJuctions();
Program.engine.loadingGui.loading++;
Program.engine.render();
removeDeadEnds();
Program.engine.loadingGui.loading++;
Program.engine.render();
smooth();
Program.engine.loadingGui.loading = 10;
Program.engine.render();
if (debugDraw)
{
map.showAllTiles = false;
Program.engine.update();
}
}
private void draw()
{
TCODConsole.root.clear();
currentMap.generateFOV(player.getPlayerX(), player.getPlayerY());
drawMap();
drawItems();
drawActors();
drawText();
drawTextBox();
TCODConsole.flush();
}
// Handle the main menu keypresses
public char HandleMainMenu()
{
// Wait for a keypress
TCODKey key = new TCODKey();
do
{
// Get the keypress
TCODConsole.flush();
key = TCODConsole.checkForKeypress((int)TCODKeyStatus.KeyPressed);
if (key.Character == 'S' || key.Character == 's' ||
key.Character == 'C' || key.Character == 'c' ||
key.Character == 'Q' || key.Character == 'q')
{
string characterPressed = key.Character.ToString().ToUpper();
return(characterPressed[0]);
}
else if (key.KeyCode == TCODKeyCode.Up || key.KeyCode == TCODKeyCode.KeypadEight)
{
if (currentMenuOption != MenuOption.Start)
{
currentMenuOption--;
return(' ');
}
else
{
currentMenuOption = MenuOption.Quit;
return(' ');
}
}
else if (key.KeyCode == TCODKeyCode.Down || key.KeyCode == TCODKeyCode.KeypadTwo)
{
if (currentMenuOption != MenuOption.Quit)
{
currentMenuOption++;
return(' ');
}
else
{
currentMenuOption = MenuOption.Start;
return(' ');
}
}
else if (key.KeyCode == TCODKeyCode.KeypadEnter || key.KeyCode == TCODKeyCode.Enter)
{
string KeyCodes = "SCQ";
return(KeyCodes[(int)currentMenuOption]);
}
PrintMainMenu();
}while (!TCODConsole.isWindowClosed());
return(' ');
}
private string getInput(string initial)
{
string s = initial;
Message.Write(s);
while (true && !TCODConsole.isWindowClosed())
{
engine.key = TCODConsole.checkForKeypress((int)TCODKeyStatus.KeyPressed);
engine.render();
TCODConsole.flush();
if (engine.key.KeyCode == TCODKeyCode.Enter)
{
break;
}
if (engine.key.KeyCode == TCODKeyCode.Backspace)
{
if (s.Length > 0)
{
s = s.Remove(s.Length - 1);
Message.unwriteLastChar();
}
}
if (engine.key.KeyCode == TCODKeyCode.Up)
{
if (s != "")
{
record[index] = s;
}
s = "up";
break;
}
if (engine.key.KeyCode == TCODKeyCode.Down)
{
if (s != "")
{
record[index] = s;
}
s = "down";
break;
}
if (!char.IsControl(engine.key.Character))
{
Message.Write(engine.key.Character.ToString());
s += engine.key.Character;
if (engine.key.Character == '|')
{
break;
}
}
}
return(s);
}
public void Update()
{
do
{
TCODConsole.flush();
_currentInput = TCODConsole.checkForKeypress((int)TCODKeyStatus.KeyPressed);
if (TCODConsole.isWindowClosed())
{
Environment.Exit(0);
}
} while (_currentInput.KeyCode == TCODKeyCode.NoKey);
}
static void Main(string[] args)
{
const int ScreenHeight = 35;
const int ScreenWidth = 80;
// Set up the main window
//Window rootWindow = new Window("Md_curses_16x16.png", ScreenWidth, ScreenHeight, "Stygia: The Hidden Depths");
Window rootWindow = new Window("font_16x16.png", ScreenWidth, ScreenHeight, "Stygia: The Hidden Depths");
// Display the title screen and wait for a keypress
rootWindow.ClearScreen();
rootWindow.DisplayTitleScreen();
rootWindow.WaitForAnyKeyPress();
// Then display the main menu
rootWindow.ClearScreen();
rootWindow.DisplayMainMenu();
// Handle main menu keypresses
bool canQuit = false;
do
{
TCODConsole.flush();
char keypress = rootWindow.HandleMainMenu();
switch (keypress)
{
case 'S':
rootWindow.ClearScreen();
rootWindow.DisplayIntro();
rootWindow.WaitForAnyKeyPress();
rootWindow.ClearScreen();
Game newgame = new Game(rootWindow, true);
newgame.Start(rootWindow);
rootWindow.DisplayMainMenu();
break;
case 'C':
rootWindow.ClearScreen();
Game oldgame = new Game(rootWindow, false);
oldgame.Start(rootWindow);
rootWindow.DisplayMainMenu();
break;
case 'Q':
rootWindow.ClearScreen();
canQuit = true;
break;
}
}while (!TCODConsole.isWindowClosed() && !canQuit);
}
/// <summary>
/// Starts the game simulation and set off the normal update life cycle
/// </summary>
/// <returns> A code corresponding to how the game exited: 0 = normal quit </returns>
public int Run()
{
if (mainConsole == null || isRunning)
{
return(APPLICATION_EXIT_ERROR);
}
isRunning = true;
internalTimer.Start();
// Main update loop
while (!TCODConsole.isWindowClosed() && isRunning)
{
long current = internalTimer.ElapsedMilliseconds;
long frameTime = current - previousUpdateTime;
previousUpdateTime = current;
frameLag += frameTime;
// Actual update / console drawing runs on an inner catchup loop that is also interuptable
// will run catchup frames or delay so that it closely matches desired FRAME_RATE, that
// is also synced with the TCODConsoles own render frame rate
while (frameLag >= MS_PER_UPDATE &&
!TCODConsole.isWindowClosed() && isRunning)
{
// TCOD must be flushed immedietly before polling the input channels
TCODConsole.flush();
lastKey = TCODConsole.checkForKeypress((int)TCODKeyStatus.KeyPressed);
mouseData = TCODMouse.getStatus();
// Handle transitions between states
if (gotoNewState)
{
EnteredNewState(nextState);
gotoNewState = false;
}
Update();
Render();
// always allow for core update interrupt
if (lastKey.KeyCode == TCODKeyCode.F4)
{
isRunning = false;
}
}
}
internalTimer.Stop();
return(APPLICATION_EXIT_NORMAL);
}
public void Draw()
{
int lightLenght = (int)((1 - _player.Light.Used) * 80);
_root.setBackgroundColor(TCODColor.black);
_root.setForegroundColor(TCODColor.white);
Map.Draw(_mapConsole);
_messages.Draw();
TCODConsole.blit(_mapConsole, 0, 0, 80, 50, _root, 0, 1);
TCODConsole.blit(_messages.Console, 0, 0, 80, 10, _root, 0, 51);
_root.hline(0, 0, 80, TCODBackgroundFlag.Set);
_root.setBackgroundColor(TCODColor.amber);
_root.setForegroundColor(TCODColor.amber);
_root.hline(0, 0, lightLenght, TCODBackgroundFlag.Set);
TCODConsole.flush();
}
private void Render()
{
TCODConsole.root.setForegroundColor(Foreground);
TCODConsole.root.setBackgroundColor(Background);
TCODConsole.root.printFrame(X, Y, Width, Height, true, TCODBackgroundFlag.Set);
TCODConsole.root.print(X + 2, Y + 2, Message);
for (int i = 0; i < Options.Length; ++i)
{
TCODConsole.root.print(X + 2, Y + 4 + i, Options[i]);
if (i == SelectedIndex)
{
TCODConsole.root.putChar(X + 1, Y + 4 + i, (char)TCODSpecialCharacter.ArrowEast);
TCODConsole.root.putChar(X + Width - 2, Y + 4 + i, (char)TCODSpecialCharacter.ArrowWest);
}
}
TCODConsole.flush();
}
public void Show()
{
var longestLine = MessageLines.Max(line => line.Length);
var x = (TCODConsole.root.getWidth() / 2) - (longestLine / 2 + 2);
var width = Math.Max(13, longestLine + 4); // Two for padding and two for the border
var y = (TCODConsole.root.getHeight() / 2) - (MessageLines.Length / 2 + 2);
var height = MessageLines.Length + 4; // Two for padding and two for the border
TCODConsole.root.setForegroundColor(Foreground);
TCODConsole.root.setBackgroundColor(Background);
TCODConsole.root.printFrame(x, y, width, height, true, TCODBackgroundFlag.Set);
for (int i = 0; i < MessageLines.Length; ++i)
{
TCODConsole.root.print(x + 2, y + 2 + i, MessageLines[i]);
}
TCODConsole.flush();
TCODConsole.waitForKeypress(true);
}
static void Main()
{
TCODConsole.initRoot(80, 50, "my game", false);
TCODSystem.setFps(25);
bool endGame = false;
while (!endGame && !TCODConsole.isWindowClosed())
{
TCODConsole.root.print(0, 0, "Hello, world");
TCODConsole.flush();
var key = TCODConsole.checkForKeypress();
if (key.KeyCode == TCODKeyCode.Escape)
{
endGame = true;
}
}
}
public void Draw()
{
TCODConsole r = TCODConsole.root;
r.clear();
// world box
r.printFrame(0, 0, 47, 47);
r.print(2, 0, "Z-DAY v0.01");
Point offset = new Point(Player.Position.X - 23, Player.Position.Y - 23);
Area.Current.Map.computeFov(Player.Position.X, Player.Position.Y, Player.ViewRadius, true, TCODFOVTypes.BasicFov);
foreach (Terrain t in Area.Current.Terrain)
{
if (Area.Current.Map.isInFov(t.Position.X, t.Position.Y))
{
t.Draw(TCODConsole.root, offset);
}
}
foreach (Decal d in Area.Current.Decals)
{
if (Area.Current.Map.isInFov(d.Position.X, d.Position.Y))
{
d.Draw(TCODConsole.root, offset);
}
}
foreach (Item i in Area.Current.Items)
{
if (Area.Current.Map.isInFov(i.Position.X, i.Position.Y))
{
i.Draw(TCODConsole.root, offset);
}
}
foreach (Character c in Area.Current.Characters)
{
if (Area.Current.Map.isInFov(c.Position.X, c.Position.Y))
{
c.Draw(TCODConsole.root, offset);
}
}
DrawHUD();
TCODConsole.flush();
}
public void run(Screen tempscreen)
{
screen = tempscreen;
kbHistory = new List <KeyHistory>();
TimeSpan startTime = DateTime.Now.TimeOfDay;
double timectrl = startTime.TotalMilliseconds;
double timespent = 0;
while (running && !TCODConsole.isWindowClosed())
{
screen.update();
screen.printDebug();
terminalManager.drawTerminals(debug);
TCODConsole.flush();
KeyHistory temp = new KeyHistory(DateTime.Now.TimeOfDay - startTime);
TCODKey key = TCODConsole.checkForKeypress((int)TCODKeyStatus.KeyPressed);
temp.RegisterKeyStatus(key, TCODKeyStatus.KeyPressed);
kbHistory.Add(temp);
screen = screen.respondToUserInput(kbHistory);
timespent = DateTime.Now.TimeOfDay.TotalMilliseconds - timectrl;
if (timespent > 250)
{
adjustFPS();
timectrl = DateTime.Now.TimeOfDay.TotalMilliseconds;
}
}
}
public bool HandleKeyPress(TCODKey key)
{
bool endTurn = false;
#region switch (key.KeyCode)
switch (key.KeyCode)
{
case TCODKeyCode.KeypadZero:
break;
case TCODKeyCode.KeypadOne:
_player.Move(-1, 1);
endTurn = true;
break;
case TCODKeyCode.KeypadTwo:
_player.Move(0, 1);
endTurn = true;
break;
case TCODKeyCode.KeypadThree:
_player.Move(1, 1);
endTurn = true;
break;
case TCODKeyCode.KeypadFour:
_player.Move(-1, 0);
endTurn = true;
break;
case TCODKeyCode.KeypadFive:
endTurn = true;
break;
case TCODKeyCode.KeypadSix:
_player.Move(1, 0);
endTurn = true;
break;
case TCODKeyCode.KeypadSeven:
_player.Move(-1, -1);
endTurn = true;
break;
case TCODKeyCode.KeypadEight:
_player.Move(0, -1);
endTurn = true;
break;
case TCODKeyCode.KeypadNine:
_player.Move(1, -1);
endTurn = true;
break;
case TCODKeyCode.KeypadAdd:
break;
case TCODKeyCode.KeypadSubtract:
break;
case TCODKeyCode.KeypadMultiply:
break;
case TCODKeyCode.KeypadDivide:
break;
case TCODKeyCode.KeypadEnter:
break;
case TCODKeyCode.KeypadDecimal:
endTurn = true;
break;
case TCODKeyCode.Left:
_player.Move(-1, 0);
endTurn = true;
break;
case TCODKeyCode.Right:
_player.Move(1, 0);
endTurn = true;
break;
case TCODKeyCode.Up:
_player.Move(0, -1);
endTurn = true;
break;
case TCODKeyCode.Down:
_player.Move(0, 1);
endTurn = true;
break;
case TCODKeyCode.Alt:
break;
case TCODKeyCode.Apps:
break;
case TCODKeyCode.Backspace:
break;
case TCODKeyCode.Capslock:
break;
case TCODKeyCode.Char:
break;
case TCODKeyCode.Control:
break;
case TCODKeyCode.Delete:
break;
case TCODKeyCode.Eight:
break;
case TCODKeyCode.End:
break;
case TCODKeyCode.Enter:
break;
case TCODKeyCode.Escape:
Exit = true;
break;
case TCODKeyCode.F1:
break;
case TCODKeyCode.F2:
break;
case TCODKeyCode.F3:
break;
case TCODKeyCode.F4:
break;
case TCODKeyCode.F5:
break;
case TCODKeyCode.F6:
break;
case TCODKeyCode.F7:
break;
case TCODKeyCode.F8:
break;
case TCODKeyCode.F9:
break;
case TCODKeyCode.F10:
break;
case TCODKeyCode.F11:
break;
case TCODKeyCode.F12:
break;
case TCODKeyCode.Five:
break;
case TCODKeyCode.Four:
break;
case TCODKeyCode.Home:
break;
case TCODKeyCode.Insert:
break;
case TCODKeyCode.Lwin:
break;
case TCODKeyCode.Nine:
break;
case TCODKeyCode.NoKey:
break;
case TCODKeyCode.Numlock:
break;
case TCODKeyCode.One:
break;
case TCODKeyCode.Pagedown:
break;
case TCODKeyCode.Pageup:
break;
case TCODKeyCode.Pause:
break;
case TCODKeyCode.Printscreen:
break;
case TCODKeyCode.Rwin:
break;
case TCODKeyCode.Scrolllock:
break;
case TCODKeyCode.Seven:
break;
case TCODKeyCode.Shift:
break;
case TCODKeyCode.Six:
break;
case TCODKeyCode.Space:
break;
case TCODKeyCode.Tab:
break;
case TCODKeyCode.Three:
break;
case TCODKeyCode.Two:
break;
case TCODKeyCode.Zero:
break;
}
#endregion
#region switch (key.Character)
switch (key.Character)
{
#region Movement
case 'h':
_player.Move(-1, 0);
endTurn = true;
break;
case 'j':
_player.Move(0, 1);
endTurn = true;
break;
case 'k':
_player.Move(0, -1);
endTurn = true;
break;
case 'l':
_player.Move(1, 0);
endTurn = true;
break;
case 'y':
_player.Move(-1, -1);
endTurn = true;
break;
case 'u':
_player.Move(1, -1);
endTurn = true;
break;
case 'b':
_player.Move(-1, 1);
endTurn = true;
break;
case 'n':
_player.Move(1, 1);
endTurn = true;
break;
case '.':
endTurn = true;
break;
#endregion
case 'd':
_player.Inventory.Draw(_root);
TCODConsole.flush();
key = TCODConsole.waitForKeypress(true);
Item i = _player.Inventory.GetAtLetter(key.Character);
_player.Inventory.RemoveAtLetter(key.Character, 1);
if (i != null)
{
i.Drop(_player.PosX, _player.PosY, Map);
}
break;
case 'g':
foreach (Item item in Map.GetItemsAt(_player.PosX, _player.PosY))
{
item.Get();
_player.Inventory.Add(item);
}
endTurn = true;
break;
case 'i':
_player.Inventory.Draw(_root);
TCODConsole.flush();
TCODConsole.waitForKeypress(true);
break;
case 'e':
_player.Inventory.Draw(_root);
TCODConsole.flush();
key = TCODConsole.waitForKeypress(true);
i = _player.Inventory.GetAtLetter(key.Character);
if (i != null)
{
_player.Equip(i);
}
endTurn = true;
break;
case 'r':
_player.Inventory.Draw(_root);
TCODConsole.flush();
key = TCODConsole.waitForKeypress(true);
i = _player.Inventory.GetAtLetter(key.Character);
if (i != null)
{
i.Use();
_player.Inventory.RemoveAllAtLetter(key.Character);
endTurn = true;
}
break;
case '>':
if (_player.PosX == Map.Stair.PosX && _player.PosY == Map.Stair.PosY)
{
_dungeon.GoToMap(_dungeon.CurrentDepth + 1, _player);
for (int n = Map.CurrentMonsterNum; n < Map.MaxMonster; n++)
{
AddMonster(Map);
}
}
break;
case '<':
if (_player.PosX == Map.StartPosX && _player.PosY == Map.StartPosY)
{
if (_dungeon.CurrentDepth != 1)
{
_dungeon.GoToMap(_dungeon.CurrentDepth - 1, _player);
}
else
{
Messages.AddMessage("If you go up, you'll exit the Dungeon. Are you sure?");
key = TCODConsole.waitForKeypress(true);
if (key.Character == 'Y')
{
Exit = true;
}
else if (key.Character != 'N')
{
Messages.AddMessage("Y or N only");
}
}
}
break;
#region Debug
case 'w':
ShowWall = !ShowWall;
break;
case 'a':
MonsterAI = !MonsterAI;
break;
case 'z':
MonsterDamage = !MonsterDamage;
break;
case 'q':
InfiniteTorch = !InfiniteTorch;
break;
#endregion
}
#endregion
return(endTurn);
}
public bool pickATile(out int x, out int y, float maxRange)
{
int pickX = Program.engine.player.x - map.offsetX, pickY = Program.engine.player.y - map.offsetY;
for (int cx = map.renderX; cx < map.renderWidth; cx++)
{
for (int cy = map.renderY; cy < map.renderHeight; cy++)
{
if (Program.engine.player.fov.isInFov(cx + map.offsetX, cy + map.offsetY) &&
(maxRange == 0 || Program.engine.player.getDistance(cx + map.offsetX, cy + map.offsetY) <= maxRange))
{
TCODColor col = TCODConsole.root.getCharBackground(cx, cy);
col = col.Multiply(1.2f);
TCODConsole.root.setCharBackground(cx, cy, col);
}
}
}
int oldX = pickX, oldY = pickY;
TCODColor oldC = TCODConsole.root.getCharBackground(pickX, pickY);
while (!TCODConsole.isWindowClosed())
{
render();
mousedata = TCODMouse.getStatus();
Program.engine.key = TCODConsole.checkForKeypress((int)TCODKeyStatus.KeyPressed);
if (Engine.useMouse)
{
if (Program.engine.player.fov.isInFov(mousedata.CellX + map.offsetX, mousedata.CellY + map.offsetY))
{
if ((maxRange == 0 || Program.engine.player.getDistance(mousedata.CellX + map.offsetX, mousedata.CellY + map.offsetY) <= maxRange))
{
pickX = mousedata.CellX;
pickY = mousedata.CellY;
if (mousedata.LeftButtonPressed)
{
x = mousedata.CellX + map.offsetX;
y = mousedata.CellY + map.offsetY;
return(true);
}
}
}
if (mousedata.RightButtonPressed)
{
x = 0;
y = 0;
return(false);
}
}
if (pickX != oldX || pickY != oldY)
{
TCODConsole.root.setCharBackground(oldX, oldY, oldC);
oldC = TCODConsole.root.getCharBackground(pickX, pickY);
TCODConsole.root.setCharBackground(pickX, pickY, TCODColor.white);
oldX = pickX;
oldY = pickY;
}
if (Program.engine.player.fov.isInFov(pickX + map.offsetX, pickY + map.offsetY))
{
if ((maxRange == 0 || Program.engine.player.getDistance(pickX + map.offsetX, pickY + map.offsetY) <= maxRange))
{
switch (Program.engine.key.KeyCode)
{
case TCODKeyCode.Enter:
{
x = pickX + map.offsetX;
y = pickY + map.offsetY;
return(true);
}
case TCODKeyCode.Up:
{
if (Program.engine.player.fov.isInFov(pickX + map.offsetX, pickY - 1 + map.offsetY))
{
if (Program.engine.player.getDistance(pickX + map.offsetX, pickY - 1 + map.offsetY) <= maxRange)
{
pickY--;
}
}
break;
}
case TCODKeyCode.Down:
if (Program.engine.player.fov.isInFov(pickX + map.offsetX, pickY + 1 + map.offsetY))
{
if (Program.engine.player.getDistance(pickX + map.offsetX, pickY + 1 + map.offsetY) <= maxRange)
{
pickY++;
}
}
break;
case TCODKeyCode.Left:
if (Program.engine.player.fov.isInFov(pickX - 1 + map.offsetX, pickY + map.offsetY))
{
if (Program.engine.player.getDistance(pickX - 1 + map.offsetX, pickY + map.offsetY) <= maxRange)
{
pickX--;
}
}
break;
case TCODKeyCode.Right:
if (Program.engine.player.fov.isInFov(pickX + 1 + map.offsetX, pickY + map.offsetY))
{
if (Program.engine.player.getDistance(pickX + 1 + map.offsetX, pickY + map.offsetY) <= maxRange)
{
pickX++;
}
}
break;
}
}
}
TCODConsole.flush();
Program.engine.lastKey = Program.engine.key;
}
x = 0;
y = 0;
return(false);
}
public static void FlushScreen()
{
TCODConsole.flush();
}
// Handle standard keypresses
public char WaitForKeyPress(KeyMode keymode)
{
// Wait for a keypress
TCODKey key = new TCODKey();
// This needs to be rewritten!
if (keymode == KeyMode.Exploration)
{
do
{
// Get the keypress
TCODConsole.flush();
key = TCODConsole.checkForKeypress((int)TCODKeyStatus.KeyPressed);
if (key.Character == 'H' || key.Character == 'h' ||
key.Character == 'J' || key.Character == 'j' ||
key.Character == 'K' || key.Character == 'k' ||
key.Character == 'L' || key.Character == 'l' ||
key.Character == 'Y' || key.Character == 'y' ||
key.Character == 'U' || key.Character == 'u' ||
key.Character == 'B' || key.Character == 'b' ||
key.Character == 'N' || key.Character == 'n' ||
key.Character == 'S' || key.Character == 's' ||
key.Character == 'G' || key.Character == 'g' ||
key.Character == 'I' || key.Character == 'i' ||
key.Character == 'D' || key.Character == 'd' ||
key.Character == 'W' || key.Character == 'w' ||
key.Character == 'T' || key.Character == 't' ||
key.Character == 'X' || key.Character == 'x' ||
key.Character == 'V' || key.Character == 'v' ||
key.Character == 'Q' || key.Character == 'q' ||
key.Character == '>' ||
key.Character == '?' ||
key.Character == '.' ||
key.KeyCode == TCODKeyCode.Up ||
key.KeyCode == TCODKeyCode.Down ||
key.KeyCode == TCODKeyCode.Left ||
key.KeyCode == TCODKeyCode.Right ||
key.KeyCode == TCODKeyCode.Escape ||
key.KeyCode == TCODKeyCode.KeypadOne ||
key.KeyCode == TCODKeyCode.KeypadTwo ||
key.KeyCode == TCODKeyCode.KeypadThree ||
key.KeyCode == TCODKeyCode.KeypadFour ||
key.KeyCode == TCODKeyCode.KeypadSix ||
key.KeyCode == TCODKeyCode.KeypadSeven ||
key.KeyCode == TCODKeyCode.KeypadEight ||
key.KeyCode == TCODKeyCode.KeypadNine
)
{
if (key.KeyCode == TCODKeyCode.Up || key.KeyCode == TCODKeyCode.KeypadEight)
{
key.Character = 'K';
}
else if (key.KeyCode == TCODKeyCode.Down || key.KeyCode == TCODKeyCode.KeypadTwo)
{
key.Character = 'J';
}
else if (key.KeyCode == TCODKeyCode.Left || key.KeyCode == TCODKeyCode.KeypadFour)
{
key.Character = 'H';
}
else if (key.KeyCode == TCODKeyCode.Right || key.KeyCode == TCODKeyCode.KeypadSix)
{
key.Character = 'L';
}
else if (key.KeyCode == TCODKeyCode.KeypadSeven)
{
key.Character = 'Y';
}
else if (key.KeyCode == TCODKeyCode.KeypadNine)
{
key.Character = 'U';
}
else if (key.KeyCode == TCODKeyCode.KeypadOne)
{
key.Character = 'B';
}
else if (key.KeyCode == TCODKeyCode.KeypadThree)
{
key.Character = 'N';
}
string characterPressed = key.Character.ToString().ToUpper();
return(characterPressed[0]);
}
}while (!TCODConsole.isWindowClosed());
return(' ');
}
else if (keymode == KeyMode.Inventory)
{
do
{
// Get the keypress
TCODConsole.flush();
key = TCODConsole.checkForKeypress((int)TCODKeyStatus.KeyPressed);
if (key.KeyCode == TCODKeyCode.Escape)
{
string characterPressed = key.Character.ToString().ToUpper();
return('#');
}
else
{
char keyPressed = Convert.ToChar(key.Character.ToString());
if (char.IsLetter(keyPressed))
{
string characterPressed = key.Character.ToString().ToUpper();
return(characterPressed[0]);
}
}
}while (!TCODConsole.isWindowClosed());
return(' ');
}
else if (keymode == KeyMode.Drop || keymode == KeyMode.Wear || keymode == KeyMode.Takeoff || keymode == KeyMode.Activate)
{
do
{
// Get the keypress
TCODConsole.flush();
key = TCODConsole.checkForKeypress((int)TCODKeyStatus.KeyPressed);
if (key.KeyCode == TCODKeyCode.Escape)
{
string characterPressed = key.Character.ToString().ToUpper();
return('#');
}
else
{
char keyPressed = Convert.ToChar(key.Character.ToString());
if (char.IsLetter(keyPressed))
{
string characterPressed = key.Character.ToString().ToUpper();
return(characterPressed[0]);
}
}
}while (!TCODConsole.isWindowClosed());
return(' ');
}
else if (keymode == KeyMode.ItemDetails)
{
do
{
// Get the keypress
TCODConsole.flush();
key = TCODConsole.checkForKeypress((int)TCODKeyStatus.KeyPressed);
if (key.KeyCode == TCODKeyCode.Escape)
{
return(' ');
}
}while (!TCODConsole.isWindowClosed());
return(' ');
}
else
{
return(' ');
}
}
public void WaitForAnyKeyPress()
{
// Wait for a keypress
TCODConsole.flush();
TCODConsole.waitForKeypress(true);
}
private static void Main(string[] args)
{
AppDomain.CurrentDomain.UnhandledException += (CurrentDomain_UnhandledException);
TCODColor fogOfWarColour = new TCODColor(80, 80, 80);
int horizontalPixels, verticalPixels;
TCODSystem.getCurrentResolution(out horizontalPixels, out verticalPixels);
//string font = "celtic_garamond_10x10_gs_tc.png";
string font = "arial12x12.png";
TCODConsole.setCustomFont(
font,
(int)(TCODFontFlags.Grayscale | TCODFontFlags.LayoutTCOD),
32,
8);
int fontWidth, fontHeight;
TCODSystem.getCharSize(out fontWidth, out fontHeight);
int screenWidth = horizontalPixels / fontWidth;
int screenHeight = verticalPixels / fontHeight;
var screenBounds = new Rectangle(0, 0, screenWidth,
screenHeight);
int infoPanelWidth = 42;
var playBounds = new Rectangle(0, 0, screenBounds.Width - infoPanelWidth, screenBounds.Height);
var playerBounds = new Rectangle(playBounds.Right, 0, infoPanelWidth, 6);
//var threatBounds = new Rectangle(playBounds.Right, playerBounds.Bottom, infoPanelWidth, 10);
var competitorBounds = new Rectangle(playBounds.Right, playerBounds.Bottom, infoPanelWidth, 27);
var eventBounds = new Rectangle(playBounds.Right, competitorBounds.Bottom, infoPanelWidth,
screenBounds.Height -
(playerBounds.Height + competitorBounds.Height));
Game game = CreateGame();
Logger.Info("Initializing RootConsole...");
TCODConsole.initRoot(screenBounds.Width, screenBounds.Height, "Last Man Standing v1.0", true, TCODRendererType.SDL);
TCODSystem.setFps(30);
var rootConsole = TCODConsole.root;
rootConsole.setForegroundColor(ColorPresets.White);
rootConsole.setAlignment(TCODAlignment.LeftAlignment);
rootConsole.setBackgroundFlag(TCODBackgroundFlag.Set);
Logger.Info("Initializing playConsole...");
TCODConsole playConsole = new TCODConsole(playBounds.Width, playBounds.Height);
//Logger.Info("Initializing threatConsole...");
//Console threatConsole = RootConsole.GetNewConsole(threatBounds.Width, threatBounds.Height);
Logger.Info("Initializing playerConsole...");
TCODConsole playerConsole = new TCODConsole(playerBounds.Width, playerBounds.Height);
Logger.Info("Initializing competitorConsole...");
TCODConsole competitorConsole = new TCODConsole(competitorBounds.Width, competitorBounds.Height);
Logger.Info("Initializing eventsConsole...");
TCODConsole eventsConsole = new TCODConsole(eventBounds.Width, eventBounds.Height);
Logger.Info("Starting Game Loop...");
do
{
TCODKey keyStroke = TCODConsole.checkForKeypress((int)TCODKeyStatus.KeyPressed);
if (game.IsActive)
{
game.ProcessTurn();
if (keyStroke.KeyCode != TCODKeyCode.NoKey)
{
((PlayerAI)game.Player.Intellect).EvaluateKeyPress(keyStroke);
}
}
RenderAllConsoles(game, rootConsole, playConsole, fogOfWarColour, playerConsole,
competitorConsole, eventsConsole, playBounds, playerBounds,
competitorBounds, eventBounds);
if (!game.IsActive)
{
rootConsole.printEx((screenBounds.Width - 30) / 2, (screenBounds.Height - 10) / 2, TCODBackgroundFlag.Set,
TCODAlignment.LeftAlignment, "Press SPACE to start a new game. Press ESC to quit.");
if (keyStroke.KeyCode == TCODKeyCode.Space)
{
rootConsole.print(1, 1, "Creating new game...");
TCODConsole.flush();
game = CreateGame();
}
}
TCODConsole.flush();
if (keyStroke.KeyCode == TCODKeyCode.Escape)
{
return;
}
} while (!TCODConsole.isWindowClosed());
}
// /////////////////////////////////////////////////////////////////////////////////
// /////////////////////////////////////////////////////////////////////////////////
private void Draw()
{
CurrentWindow.OnDraw();
TCODConsole.flush();
}
public void addRooms()
{
TCODRandom rng = TCODRandom.getInstance();
for (int i = 0; i < roomTries; i++)
{
// Program.engine.render();
// Program.engine.update();
// TCODConsole.flush();
int size = rng.getInt(ROOM_MIN_SIZE, ROOM_MAX_SIZE + roomExtraSize);
if (rng.getInt(0, 1) == 0)
{
size = rng.getInt(ROOM_MIN_SIZE, ROOM_MAX_SIZE / 2);
}
int rectangularity = rng.getInt(0, 1 + (size / 2)) * 2;
int width = size;
int height = size;
if (rng.getInt(0, 1) == 1)
{
width += rectangularity;
}
else
{
height += rectangularity;
}
int x = rng.getInt(0, ((map.width - width)));
int y = rng.getInt(0, ((map.height - height)));
if ((float)x / 2 == x / 2)
{
x += 1;
}
if ((float)y / 2 == y / 2)
{
y += 1;
}
if ((float)(height) / 2 != height / 2)
{
height += 1;
}
if ((float)(width) / 2 != width / 2)
{
width += 1;
}
Room room = new Room(x, y, width, height);
bool overlaps = false;
/*
* for (int j = 0; j < map.rooms.Count; j++)
* {
* Rectangle b = new Rectangle(room.bounds.X - 1, room.bounds.Y - 1, room.bounds.Width + 1, room.bounds.Height + 1);
* Rectangle ob = new Rectangle(map.rooms[j].bounds.X - 1, map.rooms[j].bounds.Y - 1, map.rooms[j].bounds.Width + 1, map.rooms[j].bounds.Height + 1);
* if (b.IntersectsWith(ob))
* {
* overlaps = true;
* break;
* }
* }
*/
if (!overlaps)
{
int overlapNum = 0;
for (int a = room.bounds.X - 1; a < room.bounds.X + room.bounds.Width + 2; a++)
{
for (int b = room.bounds.Y - 1; b < room.bounds.Y + room.bounds.Height + 2; b++)
{
if (!map.isWall(a, b))
{
overlapNum++;
}
}
}
if (overlapPercent * overlapNum > (((room.bounds.X) * (room.bounds.Y)) / 100))
{
overlaps = true;
}
}
if (!overlaps)
{
RoomType type = RoomType.exit;
if (currentRegion == 1)
{
type = RoomType.entrance;
}
else if (map.rooms.Last().type == RoomType.exit)
{
map.rooms.Last().type = RoomType.empty;
}
room.type = type;
startRegion();
map.rooms.Add(room);
if (debugDraw)
{
Program.engine.render();
TCODConsole.flush();
}
for (int a = room.bounds.X - 1; a < room.bounds.X + room.bounds.Width + 2; a++)
{
for (int b = room.bounds.Y - 1; b < room.bounds.Y + room.bounds.Height + 2; b++)
{
if (a < room.bounds.X || b < room.bounds.Y || a > room.bounds.X + room.bounds.Width || b > room.bounds.Y + room.bounds.Height)
{
if (map.isWall(a, b))
{
map.setWall(a, b);
}
}
else
{
carve(a, b);
}
}
}
}
}
}
public void smooth()
{
bool done = false;
int tries = 0;
int l = 0;
int percent = windingPercent ^ 2;
while (!done && !TCODConsole.isWindowClosed() && tries < percent)
{
// Program.engine.update();
if (debugDraw)
{
Program.engine.render();
TCODConsole.flush();
}
done = true;
percent = (windingPercent ^ 2) + TCODRandom.getInstance().getInt(-50, 50);
for (var y = 1; y < map.height; y += 1)
{
for (var x = 1; x < map.width; x += 1)
{
if (!map.isWall(x, y))
{
List <Point> exits = new List <Point>();
foreach (Direction dir in Enum.GetValues(typeof(Direction)))
{
if (dir != Direction.NULL)
{
Point p = dirToPoint(dir);
if (!map.isWall(x + p.X, y + p.Y))
{
exits.Add(p);
}
}
}
if (exits.Count == 2)
{
Point a = exits[0];
Point b = exits[1];
if (a.X != 0) //checks if pathway is horisontal or vertical
{
if (map.isWall(x + (a.X * 2), y) && map.isWall(x + (b.X * 2), y))
{
if (!map.isWall(x + a.X, y + 1) && !map.isWall(x + b.X, y + 1))
{
if (map.isWall(x + a.X, y - 1) && map.isWall(x + b.X, y - 1))
{
map.setWall(x + a.X, y);
map.setWall(x + b.X, y);
map.setWall(x, y);
map.dig(x, y + 1, x, y + 1);
done = false;
}
}
else
if (!map.isWall(x + a.X, y - 1) && !map.isWall(x + b.X, y - 1))
{
if (map.isWall(x + a.X, y + 1) && map.isWall(x + b.X, y + 1))
{
map.setWall(x + a.X, y);
map.setWall(x + b.X, y);
map.setWall(x, y);
map.dig(x, y - 1, x, y - 1);
done = false;
}
}
}
}
else if (a.Y != 0)
{
if (map.isWall(x, y + (a.Y * 2)) && map.isWall(x, y + (b.Y * 2)))
{
if (!map.isWall(x + 1, y + a.Y) && !map.isWall(x + 1, y + b.Y))
{
if (map.isWall(x - 1, y + a.Y) && map.isWall(x - 1, y + b.Y))
{
map.setWall(x, y + a.Y);
map.setWall(x, y + b.Y);
map.setWall(x, y);
map.dig(x + 1, y, x + 1, y);
done = false;
}
}
else
if (!map.isWall(x - 1, y + a.Y) && !map.isWall(x - 1, y + b.Y))
{
if (map.isWall(x + 1, y + a.Y) && map.isWall(x + 1, y + b.Y))
{
map.setWall(x, y + a.Y);
map.setWall(x, y + b.Y);
map.setWall(x, y);
map.dig(x - 1, y, x - 1, y);
done = false;
}
}
}
}
}
}
}
}
tries++;
l++;
if (l < (windingPercent * windingPercent) / 4)
{
Program.engine.loadingGui.loading++;
Program.engine.render();
l = 0;
}
}
done = false;
tries = 0;
while (!done && !TCODConsole.isWindowClosed() && tries < percent)
{
// Program.engine.update();
//Program.engine.render();
//TCODConsole.flush();
if (debugDraw)
{
Program.engine.render();
TCODConsole.flush();
}
done = true;
percent = (windingPercent ^ 2) + TCODRandom.getInstance().getInt(-50, 50);
for (var y = 1; y < map.height; y += 1)
{
for (var x = 1; x < map.width; x += 1)
{
if (!map.isWall(x, y))
{
List <Point> exits = new List <Point>();
foreach (Direction dir in Enum.GetValues(typeof(Direction)))
{
if (dir != Direction.NULL)
{
Point p = dirToPoint(dir);
if (!map.isWall(x + p.X, y + p.Y))
{
exits.Add(p);
}
}
}
if (exits.Count == 2)
{
Point a = exits[0];
Point b = exits[1];
if (a.X != 0) //checks if pathway is horisontal or vertical
{
if (map.isWall(x + (a.X * 3), y) && map.isWall(x + (b.X * 3), y))
{
if (!map.isWall(x + (a.X * 2), y) && !map.isWall(x + (b.X * 2), y))
{
if (!map.isWall(x + (a.X * 2), y + 1) && !map.isWall(x + (b.X * 2), y + 1))
{
if (map.isWall(x + (a.X * 2), y - 1) && map.isWall(x + (b.X * 2), y - 1))
{
map.setWall(x + a.X, y);
map.setWall(x + b.X, y);
map.setWall(x + (a.X * 2), y);
map.setWall(x + (b.X * 2), y);
map.setWall(x, y);
map.dig(x, y + 1, x, y + 1);
map.dig(x + a.X, y + 1, x + a.X, y + 1);
map.dig(x + b.X, y + 1, x + b.X, y + 1);
done = false;
}
}
else
if (!map.isWall(x + (a.X * 2), y - 1) && !map.isWall(x + (b.X * 2), y - 1))
{
if (map.isWall(x + (a.X * 2), y + 1) && map.isWall(x + (b.X * 2), y + 1))
{
map.setWall(x + a.X, y);
map.setWall(x + b.X, y);
map.setWall(x + (a.X * 2), y);
map.setWall(x + (b.X * 2), y);
map.setWall(x, y);
map.dig(x, y - 1, x, y - 1);
map.dig(x + a.X, y - 1, x + a.X, y - 1);
map.dig(x + b.X, y - 1, x + b.X, y - 1);
done = false;
}
}
}
}
else if (a.Y != 0)
{
if (map.isWall(x, y + (a.Y * 3)) && map.isWall(x, y + (b.Y * 3)))
{
if (!map.isWall(x, y + (a.Y * 2)) && !map.isWall(x, y + (b.Y * 2)))
{
if (!map.isWall(x + 1, y + (a.Y * 2)) && !map.isWall(x + 1, y + (b.Y * 2)))
{
if (map.isWall(x - 1, y + (a.Y * 2)) && map.isWall(x - 1, y + (b.Y * 2)))
{
map.setWall(x, y + a.Y);
map.setWall(x, y + b.Y);
map.setWall(x, y + (a.Y * 2));
map.setWall(x, y + (b.Y * 2));
map.setWall(x, y);
map.dig(x + 1, y + 1, x, y);
map.dig(x + 1, y + a.Y, x + 1, y + a.Y);
map.dig(x + 1, y + b.Y, x + 1, y + b.Y);
done = false;
}
}
else
if (!map.isWall(x + (a.X * 2), y + 1) && !map.isWall(x + (b.X * 2), y + 1))
{
if (map.isWall(x + (a.X * 2), y - 1) && map.isWall(x + (b.X * 2), y - 1))
{
map.setWall(x, y + a.Y);
map.setWall(x, y + b.Y);
map.setWall(x, y + (a.Y * 2));
map.setWall(x, y + (b.Y * 2));
map.setWall(x, y);
map.dig(x - 1, y - 1, x, y);
map.dig(x - 1, y + a.Y, x - 1, y + a.Y);
map.dig(x - 1, y + b.Y, x - 1, y + b.Y);
done = false;
}
}
}
}
}
}
}
}
}
}
tries++;
}
}
public void removeDeadEnds()
{
bool done = false;
int tries = 0;
int l = 0;
List <Point> ignores = new List <Point>();
while (!done && !TCODConsole.isWindowClosed() && tries < 100)
{
// Program.engine.update();
//Program.engine.render();
//TCODConsole.flush();
if (debugDraw)
{
Program.engine.render();
TCODConsole.flush();
}
done = true;
for (var y = 1; y < map.height; y += 1)
{
for (var x = 1; x < map.width; x += 1)
{
if (!map.isWall(x, y))
{
List <Point> exits = new List <Point>();
foreach (Direction dir in Enum.GetValues(typeof(Direction)))
{
if (dir != Direction.NULL)
{
Point p = dirToPoint(dir);
if (!map.isWall(x + p.X, y + p.Y) || ignores.Contains(new Point(x + p.X, y + p.Y)))
{
exits.Add(p);
}
}
}
if (exits.Count == 1)
{
if (TCODRandom.getInstance().getInt(0, 100) < 100 - deadEndLength)
{
done = false;
map.setWall(x, y);
}
else
{
ignores.Add(new Point(x, y));
}
}
}
}
}
tries++;
l++;
if (l > (100 - deadEndLength) / 5)
{
Program.engine.loadingGui.loading++;
Program.engine.render();
l = 0;
}
}
}
public static void Draw()
{
TCODConsole.flush();
}
