public override void KeyPressed(TCODKey keyData) { if (keyData.KeyCode == TCODKeyCode.Up) { CharacterList.SelectedIndex -= 1; } else if (keyData.KeyCode == TCODKeyCode.Down) { CharacterList.SelectedIndex += 1; } else if (keyData.KeyCode == TCODKeyCode.Escape) { Game.ChangeScene(PreviousScene); } else if (keyData.KeyCode == TCODKeyCode.Tab) { if (!keyData.Shift) { Game.ChangeScene(new PersonnelWoundsScene(Game, PreviousScene, Characters, CharacterList.SelectedIndex)); } else { Game.ChangeScene(new PersonnelBioticsScene(Game, PreviousScene, Characters, CharacterList.SelectedIndex)); } } }
public override void KeyPressed(TCODKey keyData) { switch(char.ToUpper(keyData.Character)) { case 'N': Game.ChangeScene(new NewGameScene(Game)); break; case 'L': new BlockingMessageModal(Game.Settings.UiForeground, Game.Settings.UiBackground, "This feature is not yet implemented.").Show(); Game.ChangeScene(new MapGenTestScene(Game)); break; case 'O': new BlockingMessageModal(Game.Settings.UiForeground, Game.Settings.UiBackground, "This feature is not yet implemented.").Show(); break; case 'C': Game.ChangeScene(new CreditsScene(Game)); break; case 'Q': var confirmQuit = new BlockingConfirmationModal() { Foreground = Game.Settings.UiForeground, Background = Game.Settings.UiBackground, Message = "Are you sure you want to quit?" }.Show(); if(confirmQuit) { Game.ChangeScene(null); } break; } }
public string Show() { LongestLine = Math.Max(Message.Length, Options.Max(line => line.Length)); X = (TCODConsole.root.getWidth() / 2) - (Message.Length / 2 + 2); Width = Math.Max(13, LongestLine + 4); // Two for padding and two for the border Y = (TCODConsole.root.getHeight() / 2) - 3; Height = Options.Length + 6; // 2 for border, 2 for padding, 2 for title w/ padding TCODKey key = null; Render(); do { key = TCODConsole.waitForKeypress(true); if (key.KeyCode == TCODKeyCode.Up) { SelectedIndex -= 1; if (SelectedIndex < 0) { SelectedIndex = Options.Length - 1; } } else if (key.KeyCode == TCODKeyCode.Down) { SelectedIndex += 1; if (SelectedIndex >= Options.Length) { SelectedIndex = 0; } } Render(); } while(key.KeyCode != TCODKeyCode.Enter && key.KeyCode != TCODKeyCode.Escape); return(key.KeyCode == TCODKeyCode.Enter ? Options[SelectedIndex] : null); }
public override void KeyPressed(TCODKey keyData) { if (keyData.KeyCode == TCODKeyCode.Escape) { Game.ChangeScene(new MainMenuScene(Game)); } }
public override void Update(TCODKey k, TCODMouseData m) { foreach (Button b in Buttons) { b.Update(m); } }
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'); }
public void Update() { bool endturn; do { TCODKey key = TCODConsole.waitForKeypress(true); endturn = HandleKeyPress(key); Draw(); } while (!endturn && !Exit); if (!Exit) { Map.Update(); Draw(); if (Map.IntensityAt(_player.PosX, _player.PosY) == 0) { if (_turnInDark == 3) { Exit = true; } else { _turnInDark++; } } } }
public override void KeyPressed(TCODKey keyData) { if (keyData.KeyCode == TCODKeyCode.Space) { Map.Generate(Game.Settings.ScreenWidth, Game.Settings.ScreenHeight); } }
public void Update(TCODKey k, TCODMouseData m) { this.Current.Update(k, m); //Should exit? this.Run = this.Run && !TCODConsole.isWindowClosed(); this.Run = this.Run && !(k.KeyCode == TCODKeyCode.Escape); }
public void SetActionSecondary(T action, TCODKey key) { if (!_inputs.ContainsKey(action)) { _inputs[action] = new Pair <TCODKey, TCODKey>(); } _inputs[action].Second = key; }
public void SetActionPrimary(T action, TCODKey key) { if (!_inputs.ContainsKey(action)) { _inputs[action] = new Pair <TCODKey, TCODKey>(); } _inputs[action].First = key; }
public void initialize(bool restarting) { Console.WriteLine("Initializing..."); gameStatus = GameStatus.LOADING; TCODConsole.initRoot(screenWidth, screenHeight, "Janus Roguelike", false); TCODMouse.showCursor(true); menuGui = new GUI.MenuGui(screenWidth, screenHeight); levels = new Dictionary <int, Level>(); gui = new GUI.Gui(); loadingGui = new GUI.LoadingGui(); messageGui = new GUI.MessageGui(); defeatGui = new GUI.DefeatGui(); debugCommands.initialize(this); levels.Add(FIRST_LEVEL, new Level()); levelnr = FIRST_LEVEL; //currentLevel = new Level(); if (FIRST_LEVEL == int.MaxValue) { currentLevel.initialize(restarting, FIRST_LEVEL, typeof(Generators.TestLevelGenerator)); } else { currentLevel.initialize(restarting, FIRST_LEVEL); } changeLevel(FIRST_LEVEL); player = new Player(); player.getDestructible().ressurect(); player.x = map.startx; //assign player position player.y = map.starty; player.fov.update(); if (actorHandler.getActor(0) != null) { actorHandler.actors.Remove(actorHandler.getActor(0)); } actorHandler.addActor(player); Saver.load(); Console.WriteLine("Initializing Complete"); render(); lastKey = new TCODKey(); gameStatus = GameStatus.STARTUP; }
public override void KeyPressed(TCODKey keyData) { if(keyData.KeyCode == TCODKeyCode.Up) { TaskList.SelectedIndex -= 1; } else if(keyData.KeyCode == TCODKeyCode.Down) { TaskList.SelectedIndex += 1; } else if(keyData.KeyCode == TCODKeyCode.Escape) { Game.ChangeScene(PreviousScene); } }
// 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(' '); }
public void Update() { do { TCODConsole.flush(); _currentInput = TCODConsole.checkForKeypress((int)TCODKeyStatus.KeyPressed); if (TCODConsole.isWindowClosed()) { Environment.Exit(0); } } while (_currentInput.KeyCode == TCODKeyCode.NoKey); }
public void RegisterKeyStatus(TCODKey key, TCODKeyStatus status) { if (key.KeyCode == TCODKeyCode.Char) { int it = Enum.GetValues(typeof(TCODKeyCode)).Length + (int)key.Character; ksMap[it] = new KeyStatus(key.Character, key.KeyCode, status); } else { ksMap[(int)key.KeyCode] = new KeyStatus(key.Character, key.KeyCode, status); } }
public void update(bool validate) { this.validate = validate; if (validate == true) { currentLevel.actorHandler.update(true); } mousedata = TCODMouse.getStatus(); key = TCODConsole.checkForKeypress((int)TCODKeyStatus.KeyPressed); debugCommands.update(); if (gameStatus == GameStatus.LOADING) { loadingGui.update(); } else if (gameStatus == GameStatus.DEFEAT) { if (key.Pressed) { Console.WriteLine("Restarting game..."); initialize(true); } } else if (gameStatus == GameStatus.MENU) { menuGui.focused = true; menuGui.update(); if (key.KeyCode == (TCODKeyCode.Escape)) { menuGui.focused = false; gameStatus = GameStatus.IDLE; } } else { gameStatus = GameStatus.IDLE; player.update(); gui.update(); messageGui.update(); if (gameStatus == GameStatus.NEW_TURN) { currentLevel.update(); //Message.flush(); } Message.update(); } lastKey = key; }
/// <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); }
private bool Check(TCODKey key, bool noChars) { if (_currentInput.KeyCode != key.KeyCode) { return(false); } if (key.KeyCode == TCODKeyCode.Char) { return(_currentInput.Character == key.Character && !noChars); } return(true); }
public override void KeyPressed(TCODKey keyData) { if (keyData.KeyCode == TCODKeyCode.Up) { TaskList.SelectedIndex -= 1; } else if (keyData.KeyCode == TCODKeyCode.Down) { TaskList.SelectedIndex += 1; } else if (keyData.KeyCode == TCODKeyCode.Escape) { Game.ChangeScene(PreviousScene); } }
public override void KeyPressed(TCODKey keyData) { if(keyData.KeyCode == TCODKeyCode.Up) { CharacterList.SelectedIndex -= 1; } else if(keyData.KeyCode == TCODKeyCode.Down) { CharacterList.SelectedIndex += 1; } else if(keyData.KeyCode == TCODKeyCode.Escape) { Game.ChangeScene(PreviousScene); } else if(keyData.KeyCode == TCODKeyCode.Tab) { if(!keyData.Shift) { Game.ChangeScene(new PersonnelBioticsScene(Game, PreviousScene, Characters, CharacterList.SelectedIndex)); } else { Game.ChangeScene(new PersonnelSkillsScene(Game, PreviousScene, Characters, CharacterList.SelectedIndex)); } } }
public static bool IsKeypad(TCODKey key) { bool result = false; result |= key.KeyCode == TCODKeyCode.KeypadOne; result |= key.KeyCode == TCODKeyCode.KeypadTwo; result |= key.KeyCode == TCODKeyCode.KeypadThree; result |= key.KeyCode == TCODKeyCode.KeypadFour; result |= key.KeyCode == TCODKeyCode.KeypadFive; result |= key.KeyCode == TCODKeyCode.KeypadSix; result |= key.KeyCode == TCODKeyCode.KeypadSeven; result |= key.KeyCode == TCODKeyCode.KeypadEight; result |= key.KeyCode == TCODKeyCode.KeypadNine; return(result); }
private void PollKeyboard() { TCODKey key = TCODConsole.checkForKeypress((int)TCODKeyStatus.KeyPressed | (int)TCODKeyStatus.KeyReleased); if (key.KeyCode != TCODKeyCode.NoKey) { if (key.Pressed) { _attachedComponent.OnKeyPressed(new KeyboardData(key)); } else { _attachedComponent.OnKeyReleased(new KeyboardData(key)); } } }
private void AddKeyPressToBuffer(TCODKey keyPress) { switch (keyPress.KeyCode) { case TCODKeyCode.Up: case TCODKeyCode.Left: case TCODKeyCode.Right: case TCODKeyCode.Down: case TCODKeyCode.Enter: case TCODKeyCode.KeypadOne: case TCODKeyCode.KeypadTwo: case TCODKeyCode.KeypadThree: case TCODKeyCode.KeypadFour: case TCODKeyCode.KeypadFive: case TCODKeyCode.KeypadSix: case TCODKeyCode.KeypadSeven: case TCODKeyCode.KeypadEight: case TCODKeyCode.KeypadNine: keyBuffer.Enqueue(keyPress); break; case TCODKeyCode.Char: //switch (keyPress.Character) //{ // case 101: // case 113: // case 119: // case 100: // case 97: // case 115: // case 99: // case 120: // case 122: // keyBuffer.Enqueue(keyPress); // break; // default: // break; //} break; default: break; } }
public override void KeyPressed(TCODKey keyData) { if (keyData.KeyCode == TCODKeyCode.Enter) { if (new BlockingConfirmationModal() { Foreground = Game.Settings.UiForeground, Background = Game.Settings.UiBackground, Message = "Are you sure you want to start with these characters?" }.Show()) { Game.ChangeScene(new HomeBaseScene(Game)); } } else if (char.ToUpper(keyData.Character) == 'R') { GenerateCharacters(); } }
/// <summary> /// Update the button based on the input mouse state /// </summary> public void Update(TCODMouseData mState, TCODKey kState) { if (mState.CellX >= origin.X && mState.CellX < origin.X + size.X && mState.CellY >= origin.Y && mState.CellY < origin.Y + size.Y) { if (mState.LeftButtonPressed) { isInFocus = true; } } else if (mState.LeftButtonPressed) { isInFocus = false; } if (isInFocus) { char ch = kState.Character; // append the character, unless it would be longer than the size of the box if ((ch >= 'A' && ch <= 'z' || ch == ' ') && text.Length + 1 < size.X) { text += ch; } // do backspace to remove char if (kState.KeyCode == TCODKeyCode.Backspace && text.Length >= 1) { text = text.Remove(text.Length - 1, 1); } } if (kState.KeyCode == TCODKeyCode.Enter) { isInFocus = false; enterHandler(); } }
public override void KeyPressed(TCODKey keyData) { switch (char.ToUpper(keyData.Character)) { case 'N': Game.ChangeScene(new NewGameScene(Game)); break; case 'L': new BlockingMessageModal(Game.Settings.UiForeground, Game.Settings.UiBackground, "This feature is not yet implemented.").Show(); Game.ChangeScene(new MapGenTestScene(Game)); break; case 'O': new BlockingMessageModal(Game.Settings.UiForeground, Game.Settings.UiBackground, "This feature is not yet implemented.").Show(); break; case 'C': Game.ChangeScene(new CreditsScene(Game)); break; case 'Q': var confirmQuit = new BlockingConfirmationModal() { Foreground = Game.Settings.UiForeground, Background = Game.Settings.UiBackground, Message = "Are you sure you want to quit?" }.Show(); if (confirmQuit) { Game.ChangeScene(null); } break; } }
// ///////////////////////////////////////////////////////////////////////////////// // ///////////////////////////////////////////////////////////////////////////////// /// <summary> /// Constructs a KeyboardData from specified TCODKey object /// </summary> /// <param name="tcodKeys"></param> public KeyboardData(TCODKey tcodKeys) { if (tcodKeys == null) { throw new ArgumentNullException("tcodKeys"); } this.character = tcodKeys.Character; this.keyCode = tcodKeys.KeyCode; this.isKeyPress = tcodKeys.Pressed; int f = 0; if (tcodKeys.LeftAlt) { f |= (int)ControlKeys.LeftAlt; } if (tcodKeys.RightAlt) { f |= (int)ControlKeys.RightAlt; } if (tcodKeys.LeftControl) { f |= (int)ControlKeys.LeftControl; } if (tcodKeys.RightControl) { f |= (int)ControlKeys.RightControl; } if (tcodKeys.Shift) { f |= (int)ControlKeys.Shift; } this.controlKeys = (ControlKeys)f; }
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; } } }
void render_image(bool first, TCODKey key) { sampleConsole.clear(); if (img == null) { img = new TCODImage("skull.png"); circle = new TCODImage("circle.png"); } if (first) TCODSystem.setFps(30); /* limited to 30 fps */ sampleConsole.setBackgroundColor(TCODColor.black); sampleConsole.clear(); float x = SAMPLE_SCREEN_WIDTH / 2 + (float)Math.Cos(TCODSystem.getElapsedSeconds()) * 10.0f; float y = (float)(SAMPLE_SCREEN_HEIGHT / 2); float scalex = 0.2f + 1.8f * (1.0f + (float)Math.Cos(TCODSystem.getElapsedSeconds() / 2)) / 2.0f; float scaley = scalex; float angle = TCODSystem.getElapsedSeconds(); uint elapsed = TCODSystem.getElapsedMilli() / 2000; if (elapsed > lastSwitch) { lastSwitch = elapsed; swap = !swap; } if (swap) { /* split the color channels of circle.png */ /* the red channel */ sampleConsole.setBackgroundColor(TCODColor.red); sampleConsole.rect(0, 3, 15, 15, false, TCODBackgroundFlag.Set); circle.blitRect(sampleConsole, 0, 3, -1, -1, TCODBackgroundFlag.Multiply); /* the green channel */ sampleConsole.setBackgroundColor(green); sampleConsole.rect(15, 3, 15, 15, false, TCODBackgroundFlag.Set); circle.blitRect(sampleConsole, 15, 3, -1, -1, TCODBackgroundFlag.Multiply); /* the blue channel */ sampleConsole.setBackgroundColor(blue); sampleConsole.rect(30, 3, 15, 15, false, TCODBackgroundFlag.Set); circle.blitRect(sampleConsole, 30, 3, -1, -1, TCODBackgroundFlag.Multiply); } else { /* render circle.png with normal blitting */ circle.blitRect(sampleConsole, 0, 3, -1, -1, TCODBackgroundFlag.Set); circle.blitRect(sampleConsole, 15, 3, -1, -1, TCODBackgroundFlag.Set); circle.blitRect(sampleConsole, 30, 3, -1, -1, TCODBackgroundFlag.Set); } img.blit(sampleConsole, x, y, TCODCBackgroundHelpers.CreateAddAlphaBackground((float).6), scalex, scaley, angle); }
public bool Event_Tick(TCODKey k, TCODMouseData m) { if (this == GameLoop.Game.Player) { //Player move Directions dir; if (Screens.World.PlayerDirections.TryGetValue(k.Character, out dir)) { Walk(dir); } else { return false; } } else { this.Sleep = 10; } return true; }
void render_bsp(bool first, TCODKey key) { int x, y; if (generate || refresh) { // dungeon generation if (bsp == null) { // create the bsp bsp = new TCODBsp(0, 0, SAMPLE_SCREEN_WIDTH, SAMPLE_SCREEN_HEIGHT); } else { // restore the nodes size bsp.resize(0, 0, SAMPLE_SCREEN_WIDTH, SAMPLE_SCREEN_HEIGHT); } for (int x1 = 0; x1 < SAMPLE_SCREEN_WIDTH; x1++) for (int y1 = 0; y1 < SAMPLE_SCREEN_HEIGHT; y1++) bsp_map[x1, y1] = '#'; if (generate) { // build a new random bsp tree bsp.removeSons(); bsp.splitRecursive(null, bspDepth, minRoomSize + (roomWalls ? 1 : 0), minRoomSize + (roomWalls ? 1 : 0), 1.5f, 1.5f); } // create the dungeon from the bsp bsp.traverseInvertedLevelOrder(new TraverseNode()); generate = false; refresh = false; } sampleConsole.clear(); sampleConsole.setForegroundColor(TCODColor.white); sampleConsole.printEx(1, 1, TCODBackgroundFlag.None, TCODAlignment.LeftAlignment, "ENTER : rebuild bsp\nSPACE : rebuild dungeon\n+-: bsp depth " + bspDepth + "\n*/: room size " + minRoomSize + "\n1 : random room size " + (randomRoom ? "ON" : "OFF")); if (randomRoom) sampleConsole.printEx(1, 6, TCODBackgroundFlag.None, TCODAlignment.LeftAlignment, "2 : room walls " + (roomWalls ? "ON" : "OFF")); // render the level for (y = 0; y < SAMPLE_SCREEN_HEIGHT; y++) { for (x = 0; x < SAMPLE_SCREEN_WIDTH; x++) { bool wall = (bsp_map[x,y] == '#'); sampleConsole.setCharBackground(x, y, (wall ? darkWall : darkGround), TCODBackgroundFlag.Set); } } if (key.KeyCode == TCODKeyCode.Enter || key.KeyCode == TCODKeyCode.KeypadEnter) { generate = true; } else if (key.Character == ' ') { refresh = true; } else if (key.Character == '+') { bspDepth++; generate = true; } else if (key.Character == '-' && bspDepth > 1) { bspDepth--; generate = true; } else if (key.Character == '*') { minRoomSize++; generate = true; } else if (key.Character == '/' && minRoomSize > 2) { minRoomSize--; generate = true; } else if (key.Character == '1' || key.KeyCode == TCODKeyCode.One || key.KeyCode == TCODKeyCode.KeypadOne) { randomRoom = !randomRoom; if (!randomRoom) roomWalls = true; refresh = true; } else if (key.Character == '2' || key.KeyCode == TCODKeyCode.Two || key.KeyCode == TCODKeyCode.KeypadTwo) { roomWalls = !roomWalls; refresh = true; } }
public override void Update(TCODKey k, TCODMouseData m) { //GameLogic stuff here GameLoop.Game.world.Update(k, m); }
public void KeyPress(TCODKey key) { Game game = Game.GetSingleton(); if (key.KeyCode == TCODKeyCode.Char) { if (key.Character != '`') { if (consoleActive == true) { AddToInput(key.Character); } } else { consoleActive = !consoleActive; game.lua["native.console"] = consoleActive; } } else if (key.KeyCode == TCODKeyCode.Space) { if (consoleActive == true) { AddToInput(' '); } } else if (key.KeyCode == TCODKeyCode.Backspace) { if (consoleActive == true) { if (ConsoleInput.Length > 0) { string stemp = ConsoleInput.Substring(0, Position - 1); if (Position < ConsoleInput.Length) { ConsoleInput = stemp + ConsoleInput.Substring(Position, ConsoleInput.Length - Position); } else { ConsoleInput = stemp; } Position--; } } } else if (key.KeyCode == TCODKeyCode.Delete) { if (consoleActive == true) { if (ConsoleInput.Length > 0 && Position < ConsoleInput.Length) { ConsoleInput = ConsoleInput.Remove(Position, 1); } } } else if (key.KeyCode == TCODKeyCode.Enter & key.Shift == false) { if (consoleActive == true) { try { if (TotalInput == "") { WriteLine('>' + ConsoleInput, TCODColor.lightGrey); game.lua.DoString(ConsoleInput); } else { TotalInput += ConsoleInput + Environment.NewLine; WriteLine("<->" + ConsoleInput, TCODColor.lightestPurple); game.lua.DoString(TotalInput); TotalInput = ""; } } catch (Exception ex) { WriteLine(ex.Message, TCODColor.red); } if (lastLines.Count > 0) { if (lastLines[lastLines.Count - 1] != ConsoleInput) { lastLines.Add(ConsoleInput); } } else { lastLines.Add(ConsoleInput); } CurrentLine = lastLines.Count; ConsoleInput = ""; Position = 0; } } else if (key.KeyCode == TCODKeyCode.Down) { if (CurrentLine < lastLines.Count - 1) { CurrentLine++; ConsoleInput = lastLines[CurrentLine]; Position = ConsoleInput.Length; } } else if (key.KeyCode == TCODKeyCode.Up) { if (CurrentLine > 0) { CurrentLine--; ConsoleInput = lastLines[CurrentLine]; Position = ConsoleInput.Length; } } else if (key.KeyCode == TCODKeyCode.Left) { if (Position > 0) { Position--; } } else if (key.KeyCode == TCODKeyCode.Right) { if (Position < ConsoleInput.Length) { Position++; } } else if (key.KeyCode == TCODKeyCode.Home) { Position = 0; } else if (key.KeyCode == TCODKeyCode.End) { Position = ConsoleInput.Length; } else { if (consoleActive) { if (key.Shift) { switch (key.KeyCode) { case TCODKeyCode.One: AddToInput('!'); break; case TCODKeyCode.Two: AddToInput('@'); break; case TCODKeyCode.Three: AddToInput('#'); break; case TCODKeyCode.Four: AddToInput('$'); break; case TCODKeyCode.Six: AddToInput('^'); break; case TCODKeyCode.Seven: AddToInput('&'); break; case TCODKeyCode.Eight: AddToInput('*'); break; case TCODKeyCode.Nine: AddToInput('('); break; case TCODKeyCode.Zero: AddToInput(')'); break; default: break; } } else { switch (key.KeyCode) { case TCODKeyCode.One: AddToInput('1'); break; case TCODKeyCode.Two: AddToInput('2'); break; case TCODKeyCode.Three: AddToInput('3'); break; case TCODKeyCode.Four: AddToInput('4'); break; case TCODKeyCode.Five: AddToInput('5'); break; case TCODKeyCode.Six: AddToInput('6'); break; case TCODKeyCode.Seven: AddToInput('7'); break; case TCODKeyCode.Eight: AddToInput('8'); break; case TCODKeyCode.Nine: AddToInput('9'); break; case TCODKeyCode.Zero: AddToInput('0'); break; default: break; } } } } if (key.Shift && key.KeyCode == TCODKeyCode.Enter) { if (consoleActive && ConsoleInput.Length > 0) { TotalInput += ConsoleInput + Environment.NewLine; WriteLine("<->" + ConsoleInput, TCODColor.lightestPurple); ConsoleInput = ""; Position = 0; } } }
void render_name(bool first, TCODKey key) { if (names.Count == 0) { foreach (string filename in System.IO.Directory.GetFiles("Names")) { TCODNameGenerator.parse(filename); } sets = TCODNameGenerator.getSets().ToList(); nbSets = sets.Count; } if (first) TCODSystem.setFps(30); while (names.Count >= 15) { string nameToRemove = names[0]; names.RemoveAt(0); } sampleConsole.clear(); sampleConsole.setForegroundColor(TCODColor.white); sampleConsole.printEx(1, 1, TCODBackgroundFlag.None, TCODAlignment.LeftAlignment, string.Format("{0}\n\n+ : next generator\n- : prev generator", sets[curSet])); for (int i = 0; i < names.Count; ++i) { string name = names[i]; if (name.Length < SAMPLE_SCREEN_WIDTH) sampleConsole.printEx(SAMPLE_SCREEN_WIDTH - 2, 2 + i, TCODBackgroundFlag.None, TCODAlignment.RightAlignment, name); } delay += TCODSystem.getLastFrameLength(); if (delay >= .5f) { delay -= .5f; names.Add(TCODNameGenerator.generate(sets[curSet])); } if (key.Character == '+') { curSet++; if (curSet == nbSets) curSet = 0; names.Add("======"); } if (key.Character == '-') { curSet--; if (curSet < 0) curSet = nbSets-1; names.Add("======"); } }
public void Update(TCODKey k, TCODMouseData m) { List<Position> unload = new List<Position>(); SortedList<long, Entitys.Entity> entitys = new SortedList<long,Entitys.Entity>(); long sleep_lowest = 1; bool tick_unlocked = true; //Update loaded chunks foreach (KeyValuePair<Position, Chunk> kv in LoadedChunks) { kv.Value.Update(); //If timed out add to unload list if (kv.Value.Idle > Chunk.Timeout) { unload.Add(kv.Key); } } //Unload chunks foreach (Position p in unload) { LoadedChunks[p].SaveToFile(); LoadedChunks.Remove(p); } //Tick next entity foreach (KeyValuePair<Position, Chunk> kv in LoadedChunks) { foreach (Entitys.Entity e in kv.Value.Entitys) { entitys.Add(e.Sleep, e); } } if (entitys.Count > 0) { sleep_lowest = entitys.Values[0].Sleep; tick_unlocked = entitys.Values[0].Event_Tick(k, m); } if (tick_unlocked) { foreach (KeyValuePair<long, Entitys.Entity> kv in entitys) { kv.Value.Sleep -= sleep_lowest; } Turns_Total += sleep_lowest; } }
public virtual void KeyPressed(TCODKey keyData) { }
private void HandleCharacterInTextbox(TCODKey key) { if (m_cursorPosition == -1) { if (m_fileInput.Length < TextEntryLength) { bool validCharacter = !(((char)key.Character).ToString().IndexOfAny(System.IO.Path.GetInvalidFileNameChars()) != -1); if (validCharacter) m_fileInput = m_fileInput + (char)key.Character; } } }
public int Run(string[] args) { fillSampleList(); int curSample = 0; // index of the current sample bool first = true; // first time we render a sample TCODKey key = new TCODKey(); string font = "celtic_garamond_10x10_gs_tc.png"; int numberCharsHorz = 32; int numberCharsVert = 8; int fullscreenWidth = 0; int fullscreenHeight = 0; bool fullscreen = false; bool credits = false; TCODFontFlags flags = TCODFontFlags.Grayscale | TCODFontFlags.LayoutTCOD; TCODFontFlags newFlags = 0; for (int i = 1; i < args.Length; i++) { if (args[i] == "-font" && ArgsRemaining(args, i, 1)) { i++; font = args[i]; } else if (args[i] == "-font-char-numberRows" && ArgsRemaining(args, i, 2)) { i++; numberCharsHorz = System.Convert.ToInt32(args[i]); i++; numberCharsVert = System.Convert.ToInt32(args[i]); } else if (args[i] == "-fullscreen-resolution" && ArgsRemaining(args, i, 2)) { i++; fullscreenWidth = System.Convert.ToInt32(args[i]); i++; fullscreenHeight = System.Convert.ToInt32(args[i]); } else if (args[i] == "-fullscreen") { fullscreen = true; } else if (args[i] == "-font-in-row") { flags = 0; newFlags |= TCODFontFlags.LayoutAsciiInRow; } else if (args[i] == "-font-greyscale") { flags = 0; newFlags |= TCODFontFlags.Grayscale; } else if (args[i] == "-font-tcod") { flags = 0; newFlags |= TCODFontFlags.LayoutTCOD; } else if (args[i] == "-help") { System.Console.Out.WriteLine("options : \n"); System.Console.Out.WriteLine("-font <filename> : use a custom font\n"); System.Console.Out.WriteLine("-font-char-size <char_width> <char_height> : size of the custom font's characters\n"); System.Console.Out.WriteLine("-font-in-row : the font layout is in row instead of columns\n"); System.Console.Out.WriteLine("-font-tcod : the font uses TCOD layout instead of ASCII\n"); System.Console.Out.WriteLine("-font-greyscale : antialiased font using greyscale bitmap\n"); System.Console.Out.WriteLine("-fullscreen : start in fullscreen\n"); System.Console.Out.WriteLine("-fullscreen-resolution <screen_width> <screen_height> : force fullscreen resolution\n"); return 0; } } if (flags == 0) flags = newFlags; if (fullscreenWidth > 0) TCODSystem.forceFullscreenResolution(fullscreenWidth, fullscreenHeight); TCODConsole.setCustomFont(font, (int)flags, numberCharsHorz, numberCharsVert); TCODConsole.initRoot(80, 50, "tcodlib C# sample", fullscreen, TCODRendererType.SDL); rootConsole = TCODConsole.root; sampleConsole = new TCODConsole(SAMPLE_SCREEN_WIDTH, SAMPLE_SCREEN_HEIGHT); setupStaticData(); rootConsole.setBackgroundFlag(TCODBackgroundFlag.Set); rootConsole.setAlignment(TCODAlignment.LeftAlignment); do { rootConsole.clear(); if (!credits) credits = TCODConsole.renderCredits(60, 42, false); for (int i = 0; i < sampleList.Length; i++) { if (i == curSample) { // set colors for currently selected sample rootConsole.setForegroundColor(TCODColor.white); rootConsole.setBackgroundColor(TCODColor.blue); } else { // set colors for other samples rootConsole.setForegroundColor(TCODColor.grey); rootConsole.setBackgroundColor(TCODColor.black); } rootConsole.print(2, 45 - sampleList.Length + i, sampleList[i].name); } rootConsole.setForegroundColor(TCODColor.grey); rootConsole.setBackgroundColor(TCODColor.black); rootConsole.printEx(79, 46, TCODBackgroundFlag.Set, TCODAlignment.RightAlignment, "last frame : " + ((int)(TCODSystem.getLastFrameLength() * 1000)).ToString() + " ms ( " + TCODSystem.getFps() + "fps)"); rootConsole.printEx(79, 47, TCODBackgroundFlag.Set, TCODAlignment.RightAlignment, "elapsed : " + TCODSystem.getElapsedMilli() + "ms " + (TCODSystem.getElapsedSeconds().ToString("0.00")) + "s"); rootConsole.putChar(2, 47, (char)TCODSpecialCharacter.ArrowNorth); rootConsole.putChar(3, 47, (char)TCODSpecialCharacter.ArrowSouth); rootConsole.print(4, 47, " : select a sample"); rootConsole.print(2, 48, "ALT-ENTER : switch to " + (TCODConsole.isFullscreen() ? "windowed mode " : "fullscreen mode")); sampleList[curSample].render(first, key); first = false; TCODConsole.blit(sampleConsole, 0, 0, SAMPLE_SCREEN_WIDTH, SAMPLE_SCREEN_HEIGHT, rootConsole, SAMPLE_SCREEN_X, SAMPLE_SCREEN_Y); TCODConsole.flush(); key = TCODConsole.checkForKeypress((int)TCODKeyStatus.KeyPressed); if (key.KeyCode == TCODKeyCode.Down) { // down arrow : next sample curSample = (curSample + 1) % sampleList.Length; first = true; } else if (key.KeyCode == TCODKeyCode.Up) { // up arrow : previous sample curSample--; if (curSample < 0) curSample = sampleList.Length - 1; first = true; } else if (key.KeyCode == TCODKeyCode.Enter && (key.LeftAlt || key.RightAlt)) { // ALT-ENTER : switch fullscreen TCODConsole.setFullscreen(!TCODConsole.isFullscreen()); } else if (key.KeyCode == TCODKeyCode.F1) { System.Console.Out.WriteLine("key.pressed" + " " + key.LeftAlt + " " + key.LeftControl + " " + key.RightAlt + " " + key.RightControl + " " + key.Shift); } } while (!TCODConsole.isWindowClosed()); return 0; }
private static bool IsKeyCodeOfCharacter(TCODKey k) { return k.KeyCode == TCODKeyCode.Char || k.KeyCode == TCODKeyCode.Zero || k.KeyCode == TCODKeyCode.One || k.KeyCode == TCODKeyCode.Two || k.KeyCode == TCODKeyCode.Three || k.KeyCode == TCODKeyCode.Four || k.KeyCode == TCODKeyCode.Five || k.KeyCode == TCODKeyCode.Six || k.KeyCode == TCODKeyCode.Seven || k.KeyCode == TCODKeyCode.Eight || k.KeyCode == TCODKeyCode.Nine; }
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; }
// Name: doAction // Description: If this is an AI controlled monster, invoke the AI. If // it is a player controlled monster, allow the player to // make his action public void doAction() { if ( !isFlagSet(AttributeFlags.isPlayer) ) { } else { // This is temp code for keyboard input on the player's turn. // It most certainly does not belong here in its entirety, and // should probably be delegated to a dedicated class // ALSO THIS IMPLEMENTATION IS DISGUSTING JUST SAYING key = TCODConsole.waitForKeypress(true); if (key.KeyCode == TCODKeyCode.Down) { yCoord = isWalkable( monsterLayer.dungeonLevel.dungeonLayer.getTile( xCoord, (short)(yCoord + 1) ) ) ? (short)(yCoord + 1) : yCoord; } else if (key.KeyCode == TCODKeyCode.Up) { yCoord = isWalkable( monsterLayer.dungeonLevel.dungeonLayer.getTile( xCoord, (short)(yCoord - 1))) ? (short)(yCoord - 1) : yCoord; } else if (key.KeyCode == TCODKeyCode.Right) { xCoord = isWalkable( monsterLayer.dungeonLevel.dungeonLayer.getTile( (short)(xCoord + 1), yCoord)) ? (short)(xCoord + 1) : xCoord; } else if (key.KeyCode == TCODKeyCode.Left) { xCoord = isWalkable( monsterLayer.dungeonLevel.dungeonLayer.getTile( (short)(xCoord - 1), yCoord )) ? (short)(xCoord - 1) : xCoord; } } }
public bool HandleInput(TCODKey key) { #region "Player Input" //tar_y = player.Y; //tar_x = player.X; //tar_z = player.Z; tar_x = 0; tar_y = 0; tar_z = 0; switch (key.KeyCode) { //MOVEMENT case TCODKeyCode.KeypadEight: tar_y = - 1; return true; case TCODKeyCode.KeypadSix: tar_x = 1; return true; case TCODKeyCode.KeypadTwo: tar_y = 1; return true; case TCODKeyCode.KeypadFour: tar_x = - 1; return true; case TCODKeyCode.KeypadNine: tar_y = - 1; tar_x = + 1; return true; case TCODKeyCode.KeypadThree: tar_y = + 1; tar_x = + 1; return true; case TCODKeyCode.KeypadOne: tar_y = + 1; tar_x = - 1; return true; case TCODKeyCode.KeypadSeven: tar_y = - 1; tar_x = - 1; return true; case TCODKeyCode.KeypadFive: return true; //SELECTION case TCODKeyCode.KeypadAdd: menu_selection++; return true; case TCODKeyCode.KeypadSubtract: menu_selection--; return true; case TCODKeyCode.KeypadEnter: lock_cursor = true; return true; } switch (key.Character) { case '<': tar_z = player.Z - 1; return true; case '>': tar_z = player.Z + 1; return true; case 't': player_pickup = true; return true; case 'e': if (mdm == MainDisplayMode.Inventory) { player_equip = true; return true; } return false; case 'u': if (mdm == MainDisplayMode.Inventory) { player_unequip = true; return true; } return false; case 'a': if (mdm == MainDisplayMode.Game) { player_attack_ranged = true; } return true; } #endregion if (key.Character == 'i') { mdm = MainDisplayMode.Inventory; menu_selection = 0; return true; } if (key.Character == 'c') { Item i = (Item)Select(SelectionMode.Item); //Creature c = (Creature)Select(SelectionMode.Creature); return false; } if (key.Character == 'q') { mdm = MainDisplayMode.Game; CancelDialog(); } if (key.KeyCode == TCODKeyCode.F1) { tar_x = 1300; tar_y = 1300; tar_z = map.DropObject(1300, 1300, 49); return true; } if (key.KeyCode == TCODKeyCode.F2) { tar_x = 1300; tar_y = 1300; tar_z = map.DropObject(1300, 1300, 31); return true; } if (key.KeyCode == TCODKeyCode.F4) { map.AddItem((Item)player.Body.SeverRandomBodyPart()); } if (key.KeyCode == TCODKeyCode.F5) { //DisplayDialog("This is a test message.Dabei wird in Deutschland die Maßeinheit cm zugrunde gelegt, während in Amerika und England die Maßeinheit inch (1 inch = 2,54 cm) für die Hemdgrößen von Herren verwendet wird. Zusätzlich wird die Ärmellänge im Handel gegebenenfalls mit Kurzarm oder Langarm angegeben, jedoch kann dabei die genaue Länge je nach Hersteller unterschiedlich ausfallen. Meist haben dann bei den Herrenhemden zwei aufeinander folgende Hemdgrößen (z.B. 39/40) den gleichen Schnitt des Oberkörpers."); SortedDictionary<char, string> test = new SortedDictionary<char, string>(); test.Add('a', "Test item A"); test.Add('b', "Test item B"); test.Add('c', "Test item C"); Out.SendDebugMessage("Response: " + DisplayInputDialog("Choose one test item. Press q to abort.", test)); } if (key.KeyCode == TCODKeyCode.F6) { DisplayDialog(player.Body.MakeDescription()); } if (key.KeyCode == TCODKeyCode.F9) { DisplayDialog(map.ComposeLookAt(player.X, player.Y, player.Z)); } if (key.Character == 'l') { map.TEST_CIE = map.TEST_CIE ? false : true; } if (key.KeyCode == TCODKeyCode.F11) { List<LightSource> templ = new List<LightSource>(); foreach (Item i in map.ItemList.GetValues()) { if (i.GetType() == typeof(LightSource)) { LightSource l = (LightSource)i; //l.SetPosition(l.X, l.Y, l.Z); //l.SetLevel((byte)(l.LightRadius - 1)); l.SetRecalculate(true); templ.Add(l); } } foreach (LightSource ls in templ) { map.ItemList.Remove(ls.GUID); map.ItemList.Add(ls); } } if (key.KeyCode == TCODKeyCode.F12) { GC.Collect(); return true; } if (key.KeyCode == TCODKeyCode.Escape) { endGame = true; return true; } if (key.KeyCode != TCODKeyCode.NoKey) { TCODConsole.root.print(0, 0, key.Character.ToString()); TCODConsole.root.print(0, 1, key.KeyCode.ToString()); return false; } return false; }
public void EvaluateKeyPress(TCODKey keyStroke) { AddKeyPressToBuffer(keyStroke); ProcessKeyPressBuffer(); }
void render_offscreen(bool first, TCODKey key) { if (!off_init) { off_init = true; off_secondary.printFrame(0, 0, SAMPLE_SCREEN_WIDTH / 2, SAMPLE_SCREEN_HEIGHT / 2, false, TCODBackgroundFlag.Set, "Offscreen console"); off_secondary.printRectEx(SAMPLE_SCREEN_WIDTH / 4, 2, SAMPLE_SCREEN_WIDTH / 2 - 2, SAMPLE_SCREEN_HEIGHT / 2, TCODBackgroundFlag.None, TCODAlignment.CenterAlignment, "You can render to an offscreen console and blit in on another one, simulating alpha transparency."); } if (first) { TCODSystem.setFps(30); // fps limited to 30 // get a "screenshot" of the current sample screen TCODConsole.blit(sampleConsole, 0, 0, SAMPLE_SCREEN_WIDTH, SAMPLE_SCREEN_HEIGHT, off_screenshot, 0, 0); } off_counter++; if (off_counter % 20 == 0) { // move the secondary screen every 2 seconds off_x += off_xdir; off_y += off_ydir; if (off_x == (SAMPLE_SCREEN_WIDTH / 2) + 5) off_xdir = -1; else if (off_x == -5) off_xdir = 1; if (off_y == (SAMPLE_SCREEN_HEIGHT / 2) + 5) off_ydir = -1; else if (off_y == -5) off_ydir = 1; } // restore the initial screen TCODConsole.blit(off_screenshot, 0, 0, SAMPLE_SCREEN_WIDTH, SAMPLE_SCREEN_HEIGHT, sampleConsole, 0, 0); // blit the overlapping screen TCODConsole.blit(off_secondary, 0, 0, SAMPLE_SCREEN_WIDTH / 2, SAMPLE_SCREEN_HEIGHT / 2, sampleConsole, off_x, off_y, 1.0f, .75f); }
public virtual void KeyReleased(TCODKey keyData) { }
public override void KeyPressed(TCODKey keyData) { currentDelay = 0.0f; }
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()); }
void render_mouse(bool first, TCODKey key) { if (first) { sampleConsole.setBackgroundColor(TCODColor.grey); sampleConsole.setForegroundColor(TCODColor.yellow); TCODMouse.moveMouse(320, 200); TCODMouse.showCursor(true); } sampleConsole.clear(); TCODMouseData mouse = TCODMouse.getStatus(); if (mouse.LeftButtonPressed) mouse_lbut = !mouse_lbut; if (mouse.RightButtonPressed) mouse_rbut = !mouse_rbut; if (mouse.MiddleButtonPressed) mouse_mbut = !mouse_mbut; string s1 = "Mouse position : " + mouse.PixelX.ToString("000") + " x " + mouse.PixelY.ToString("000") + "\n"; string s2 = "Mouse cell : " + mouse.CellX.ToString("000") + " x " + mouse.CellY.ToString("000") + "\n"; string s3 = "Mouse movement : " + mouse.PixelVelocityX.ToString("000") + " x " + mouse.PixelVelocityY.ToString("000") + "\n"; string s4 = "Left button : " + (mouse.LeftButton ? " ON" : "OFF") + " (toggle " + (mouse_lbut ? " ON" : "OFF") + ")\n"; string s5 = "Right button : " + (mouse.RightButton ? " ON" : "OFF") + " (toggle " + (mouse_rbut ? " ON" : "OFF") + ")\n"; string s6 = "Middle button : " + (mouse.MiddleButton ? " ON" : "OFF") + " (toggle " + (mouse_mbut ? " ON" : "OFF") + ")\n"; sampleConsole.print(1, 1, s1 + s2 + s3 + s4 + s5 + s6); sampleConsole.print(1, 10, "1 : Hide cursor\n2 : Show cursor"); if (key.Character == '1') TCODMouse.showCursor(false); else if (key.Character == '2') TCODMouse.showCursor(true); }
void render_fov(bool first, TCODKey key) { if (map == null) { // initialize the map for the fov toolkit map = new TCODMap(SAMPLE_SCREEN_WIDTH, SAMPLE_SCREEN_HEIGHT); for (int y = 0; y < SAMPLE_SCREEN_HEIGHT; y++) { for (int x = 0; x < SAMPLE_SCREEN_WIDTH; x++) { if (smap[y][x] == ' ') map.setProperties(x, y, true, true);// ground else if (smap[y][x] == '=') map.setProperties(x, y, true, false); // window } } // 1d noise used for the torch flickering map_noise = new TCODNoise(1); } if (first) { TCODSystem.setFps(30); // fps limited to 30 // we draw the foreground only the first time. // during the player movement, only the @ is redrawn. // the rest impacts only the background color // draw the help text & player @ sampleConsole.clear(); sampleConsole.setForegroundColor(TCODColor.white); string prompt = "IJKL : move around\nT : torch fx " + (torch ? "off" : "on ") + " : light walls " + (light_walls ? "off" : "on ") + "\n+-: algo " + algo_names[(int)algonum]; sampleConsole.print(1, 1, prompt); sampleConsole.setForegroundColor(TCODColor.black); sampleConsole.putChar(px, py, '@'); // draw windows for (int y = 0; y < SAMPLE_SCREEN_HEIGHT; y++) { for (int x = 0; x < SAMPLE_SCREEN_WIDTH; x++) { if (smap[y][x] == '=') { sampleConsole.putChar(x, y, '='); } } } } if (recomputeFov) { // calculate the field of view from the player position recomputeFov = false; map.computeFov(px, py, torch ? (int)TORCH_RADIUS : 0, light_walls, algonum); } // torch position & intensity variation float dx = 0.0f, dy = 0.0f, di = 0.0f; if (torch) { // slightly change the perlin noise parameter torchx += 0.2f; // randomize the light position between -1.5 and 1.5 float[] tdx = { torchx + 20.0f }; dx = map_noise.getPerlinNoise(tdx) * 1.5f; tdx[0] += 30.0f; dy = map_noise.getPerlinNoise(tdx) * 1.5f; // randomize the light intensity between -0.2 and 0.2 float[] torchxArray = { torchx }; di = 0.2f * map_noise.getPerlinNoise(torchxArray); } // draw the dungeon for (int y = 0; y < SAMPLE_SCREEN_HEIGHT; y++) { for (int x = 0; x < SAMPLE_SCREEN_WIDTH; x++) { bool visible = map.isInFov(x, y); bool wall = (smap[y][x] == '#'); if (!visible) { sampleConsole.setCharBackground(x, y, (wall ? darkWall : darkGround), TCODBackgroundFlag.Set); } else { if (!torch) { sampleConsole.setCharBackground(x, y, wall ? lightWall : lightGround, TCODBackgroundFlag.Set); } else { // torch flickering fx TCODColor baseColor = wall ? darkWall : darkGround; TCODColor light = wall ? lightWall : lightGround; // cell distance to torch (squared) float r = (float)((x - px + dx) * (x - px + dx) + (y - py + dy) * (y - py + dy)); if (r < SQUARED_TORCH_RADIUS) { // l = 1.0 at player position, 0.0 at a radius of 10 cells float l = (SQUARED_TORCH_RADIUS - r) / SQUARED_TORCH_RADIUS + di; // clamp between 0 and 1 if (l < 0.0f) l = 0.0f; else if (l > 1.0f) l = 1.0f; // interpolate the color baseColor = new TCODColor((byte)(baseColor.Red + (light.Red - baseColor.Red) * l), (byte)(baseColor.Green + (light.Green - baseColor.Green) * l), (byte)(baseColor.Blue + (light.Blue - baseColor.Blue) * l)); } sampleConsole.setCharBackground(x, y, baseColor, TCODBackgroundFlag.Set); } } } } if (key.Character == 'I' || key.Character == 'i') { // player move north if (smap[py - 1][px] == ' ') { sampleConsole.putChar(px, py, ' ', TCODBackgroundFlag.None); py--; sampleConsole.putChar(px, py, '@', TCODBackgroundFlag.None); recomputeFov = true; } } else if (key.Character == 'K' || key.Character == 'k') { // player move south if (smap[py + 1][px] == ' ') { sampleConsole.putChar(px, py, ' ', TCODBackgroundFlag.None); py++; sampleConsole.putChar(px, py, '@', TCODBackgroundFlag.None); recomputeFov = true; } } else if (key.Character == 'J' || key.Character == 'j') { // player move west if (smap[py][px - 1] == ' ') { sampleConsole.putChar(px, py, ' ', TCODBackgroundFlag.None); px--; sampleConsole.putChar(px, py, '@', TCODBackgroundFlag.None); recomputeFov = true; } } else if (key.Character == 'L' || key.Character == 'l') { // player move east if (smap[py][px + 1] == ' ') { sampleConsole.putChar(px, py, ' ', TCODBackgroundFlag.None); px++; sampleConsole.putChar(px, py, '@', TCODBackgroundFlag.None); recomputeFov = true; } } else if (key.Character == 'T' || key.Character == 't') { // enable/disable the torch fx torch = !torch; sampleConsole.setForegroundColor(TCODColor.white); string prompt = "IJKL : move around\nT : torch fx " + (torch ? "off" : "on ") + " : light walls " + (light_walls ? "off" : "on ") + "\n+-: algo " + algo_names[(int)algonum]; sampleConsole.print(1, 1, prompt); sampleConsole.setForegroundColor(TCODColor.black); } else if (key.Character == 'W' || key.Character == 'W') { light_walls = !light_walls; sampleConsole.setForegroundColor(TCODColor.white); string prompt = "IJKL : move around\nT : torch fx " + (torch ? "off" : "on ") + " : light walls " + (light_walls ? "off" : "on ") + "\n+-: algo " + algo_names[(int)algonum]; sampleConsole.print(1, 1, prompt); sampleConsole.setForegroundColor(TCODColor.black); recomputeFov = true; } else if (key.Character == '+' || key.Character == '-') { algonum += key.Character == '+' ? 1 : -1; if (algonum >= TCODFOVTypes.RestrictiveFov) algonum = TCODFOVTypes.RestrictiveFov; else if (algonum < 0) algonum = TCODFOVTypes.BasicFov; sampleConsole.setForegroundColor(TCODColor.white); string prompt = "IJKL : move around\nT : torch fx " + (torch ? "off" : "on ") + " : light walls " + (light_walls ? "off" : "on ") + "\n+-: algo " + algo_names[(int)algonum]; sampleConsole.print(1, 1, prompt); sampleConsole.setForegroundColor(TCODColor.black); recomputeFov = true; } }
// ///////////////////////////////////////////////////////////////////////////////// // ///////////////////////////////////////////////////////////////////////////////// /// <summary> /// Constructs a KeyboardData from specified TCODKey object /// </summary> /// <param name="tcodKeys"></param> public KeyboardData(TCODKey tcodKeys) { if (tcodKeys == null) { throw new ArgumentNullException("tcodKeys"); } this.character = tcodKeys.Character; this.keyCode = tcodKeys.KeyCode; this.isKeyPress = tcodKeys.Pressed; int f = 0; if (tcodKeys.LeftAlt) f |= (int)ControlKeys.LeftAlt; if (tcodKeys.RightAlt) f |= (int)ControlKeys.RightAlt; if (tcodKeys.LeftControl) f |= (int)ControlKeys.LeftControl; if (tcodKeys.RightControl) f |= (int)ControlKeys.RightControl; if (tcodKeys.Shift) f |= (int)ControlKeys.Shift; this.controlKeys = (ControlKeys)f; }
void render_noise(bool first, TCODKey key) { if (first) { TCODSystem.setFps(30); /* limited to 30 fps */ } sampleConsole.clear(); /* texture animation */ noise_dx += 0.01f; noise_dy += 0.01f; /* render the 2d noise function */ for (int y = 0; y < SAMPLE_SCREEN_HEIGHT; y++) { for (int x = 0; x < SAMPLE_SCREEN_WIDTH; x++) { float[] f = new float[2]; float value = 0.0f; byte c; TCODColor col = new TCODColor(); f[0] = noise_zoom * x / SAMPLE_SCREEN_WIDTH + noise_dx; f[1] = noise_zoom * y / SAMPLE_SCREEN_HEIGHT + noise_dy; switch (noise_func) { case noiseFunctions.Perlin: value = noise.getPerlinNoise(f); break; case noiseFunctions.PerlinFBM: value = noise.getPerlinBrownianMotion(f, noise_octaves); break; case noiseFunctions.PerlinTurbulence: value = noise.getPerlinTurbulence(f, noise_octaves); break; case noiseFunctions.Simplex: value = noise.getSimplexNoise(f); break; case noiseFunctions.SimplexFBM: value = noise.getSimplexBrownianMotion(f, noise_octaves); break; case noiseFunctions.SimplexTurbulence: value = noise.getSimplexTurbulence(f, noise_octaves); break; case noiseFunctions.Wavelet: value = noise.getWaveletNoise(f); break; case noiseFunctions.WaveletFBM: value = noise.getWaveletBrownianMotion(f, noise_octaves); break; case noiseFunctions.WaveletTurbulence: value = noise.getWaveletTurbulence(f, noise_octaves); break; } c = (byte)((value + 1.0f) / 2.0f * 255); /* use a bluish color */ col = new TCODColor((byte)(c / 2), (byte)(c / 2), c); sampleConsole.setCharBackground(x, y, col, TCODBackgroundFlag.Set); } } /* draw a transparent rectangle */ sampleConsole.setBackgroundColor(TCODColor.grey); sampleConsole.rect(2, 2, (noise_func <= noiseFunctions.Wavelet ? 16 : 24), (noise_func <= noiseFunctions.Wavelet ? 4 : 7), false, TCODBackgroundFlag.Multiply); /* draw the text */ for (noiseFunctions curfunc = noiseFunctions.Perlin; curfunc <= noiseFunctions.WaveletTurbulence; curfunc++) { if (curfunc == noise_func) { sampleConsole.setForegroundColor(TCODColor.white); sampleConsole.setBackgroundColor(TCODColor.blue); sampleConsole.print(2, 2 + (int)(curfunc), noise_funcName[(int)curfunc]); } else { sampleConsole.setForegroundColor(TCODColor.grey); sampleConsole.print(2, 2 + (int)(curfunc), noise_funcName[(int)curfunc]); } } /* draw parameters */ sampleConsole.setForegroundColor(TCODColor.white); sampleConsole.print(2, 11, "Y/H : zome (" + noise_zoom.ToString("0.0") + ")"); if (noise_func > noiseFunctions.Wavelet) { sampleConsole.print(2, 12, "E/D : hurst (" + noise_hurst.ToString("0.0") + ")"); sampleConsole.print(2, 13, "R/F : lacunarity (" + noise_lacunarity.ToString("0.0") + ")"); sampleConsole.print(2, 14, "T/G : octaves (" + noise_octaves.ToString("0.0") + ")"); } /* handle keypress */ if (key.KeyCode == TCODKeyCode.NoKey) return; if (key.Character >= '1' && key.Character <= '9') { noise_func = (noiseFunctions)(key.Character - '1'); } else if (key.Character == 'E' || key.Character == 'e') { /* increase hurst */ noise_hurst += 0.1f; noise.Dispose(); noise = new TCODNoise(2, noise_hurst, noise_lacunarity); } else if (key.Character == 'D' || key.Character == 'd') { /* decrease hurst */ noise_hurst -= 0.1f; noise.Dispose(); noise = new TCODNoise(2, noise_hurst, noise_lacunarity); } else if (key.Character == 'R' || key.Character == 'r') { /* increase lacunarity */ noise_lacunarity += 0.5f; noise.Dispose(); noise = new TCODNoise(2, noise_hurst, noise_lacunarity); } else if (key.Character == 'F' || key.Character == 'f') { /* decrease lacunarity */ noise_lacunarity -= 0.5f; noise.Dispose(); noise = new TCODNoise(2, noise_hurst, noise_lacunarity); } else if (key.Character == 'T' || key.Character == 't') { /* increase octaves */ noise_octaves += 0.5f; } else if (key.Character == 'G' || key.Character == 'g') { /* decrease octaves */ noise_octaves -= 0.5f; } else if (key.Character == 'Y' || key.Character == 'y') { /* increase zoom */ noise_zoom += 0.2f; } else if (key.Character == 'H' || key.Character == 'h') { /* decrease zoom */ noise_zoom -= 0.2f; } }
void render_lines(bool first, TCODKey key) { sampleConsole.clear(); if (key.KeyCode == TCODKeyCode.Enter || key.KeyCode == TCODKeyCode.KeypadEnter) { // switch to the next blending mode if (libtcod.libtcod.TCODBackgroundAlphaMask(line_bkFlag) == TCODBackgroundFlag.Alpha) line_bkFlag = TCODBackgroundFlag.None; else line_bkFlag++; } if (libtcod.libtcod.TCODBackgroundAlphaMask(line_bkFlag) == TCODBackgroundFlag.Alpha) { // for the alpha mode, update alpha every frame double alpha = (1.0f + Math.Cos(TCODSystem.getElapsedSeconds() * 2)) / 2.0f; line_bkFlag = TCODCBackgroundHelpers.CreateAlphaBackground((float)alpha); } else if (libtcod.libtcod.TCODBackgroundAlphaMask(line_bkFlag) == TCODBackgroundFlag.AddAlpha) { // for the add alpha mode, update alpha every frame double alpha = (1.0f + Math.Cos(TCODSystem.getElapsedSeconds() * 2)) / 2.0f; line_bkFlag = TCODCBackgroundHelpers.CreateAddAlphaBackground((float)alpha); } if (!line_init) { // initialize the colored background for (int x = 0; x < SAMPLE_SCREEN_WIDTH; x++) { for (int y = 0; y < SAMPLE_SCREEN_HEIGHT; y++) { TCODColor col = new TCODColor((byte)(x * 255 / (SAMPLE_SCREEN_WIDTH - 1)), (byte)((x + y) * 255 / (SAMPLE_SCREEN_WIDTH - 1 + SAMPLE_SCREEN_HEIGHT - 1)), (byte)(y * 255 / (SAMPLE_SCREEN_HEIGHT - 1))); line_bk.setCharBackground(x, y, col, TCODBackgroundFlag.Set); } } line_init = true; } if (first) { TCODSystem.setFps(30); // fps limited to 30 sampleConsole.setForegroundColor(TCODColor.white); } // blit the background TCODConsole.blit(line_bk, 0, 0, SAMPLE_SCREEN_WIDTH, SAMPLE_SCREEN_HEIGHT, sampleConsole, 0, 0); // render the gradient int recty = (int)((SAMPLE_SCREEN_HEIGHT - 2) * ((1.0f + Math.Cos(TCODSystem.getElapsedSeconds())) / 2.0f)); for (int x = 0; x < SAMPLE_SCREEN_WIDTH; x++) { TCODColor col = new TCODColor((byte)(x * 255 / SAMPLE_SCREEN_WIDTH), (byte)(x * 255 / SAMPLE_SCREEN_WIDTH), (byte)(x * 255 / SAMPLE_SCREEN_WIDTH)); sampleConsole.setCharBackground(x, recty, col, line_bkFlag); sampleConsole.setCharBackground(x, recty + 1, col, line_bkFlag); sampleConsole.setCharBackground(x, recty + 2, col, line_bkFlag); } // calculate the segment ends float angle = TCODSystem.getElapsedSeconds() * 2.0f; float cosAngle = (float)Math.Cos(angle); float sinAngle = (float)Math.Sin(angle); int xo = (int)(SAMPLE_SCREEN_WIDTH / 2 * (1 + cosAngle)); int yo = (int)(SAMPLE_SCREEN_HEIGHT / 2 + sinAngle * SAMPLE_SCREEN_WIDTH / 2); int xd = (int)(SAMPLE_SCREEN_WIDTH / 2 * (1 - cosAngle)); int yd = (int)(SAMPLE_SCREEN_HEIGHT / 2 - sinAngle * SAMPLE_SCREEN_WIDTH / 2); // render the line int xx = xo, yy = yo; TCODLine.init(xx, yy, xd, yd); do { if (xx >= 0 && yy >= 0 && xx < SAMPLE_SCREEN_WIDTH && yy < SAMPLE_SCREEN_HEIGHT) { sampleConsole.setCharBackground(xx, yy, TCODColor.blue, line_bkFlag); } } while (!TCODLine.step(ref xx, ref yy)); // print the current flag sampleConsole.print(2, 2, libtcod.libtcod.TCODBackgroundAlphaMask(line_bkFlag).ToString() + " (ENTER to change)"); }
public override void KeyPressed(TCODKey keyData) { if(keyData.KeyCode == TCODKeyCode.Space) { Map.Generate(Game.Settings.ScreenWidth, Game.Settings.ScreenHeight); } }
void render_path(bool first, TCODKey key) { if (map == null) { // initialize the map map = new TCODMap(SAMPLE_SCREEN_WIDTH, SAMPLE_SCREEN_HEIGHT); for (int y = 0; y < SAMPLE_SCREEN_HEIGHT; y++) { for (int x = 0; x < SAMPLE_SCREEN_WIDTH; x++) { if (smap[y][x] == ' ') map.setProperties(x, y, true, true);// ground else if (smap[y][x] == '=') map.setProperties(x, y, true, false); // window } } } if (first) { TCODSystem.setFps(30); // fps limited to 30 // we draw the foreground only the first time. // during the player movement, only the @ is redrawn. // the rest impacts only the background color // draw the help text & player @ sampleConsole.clear(); sampleConsole.setForegroundColor(TCODColor.white); sampleConsole.print(1, 1, "IJKL / mouse :\nmove destination\nTAB : A*/dijkstra"); sampleConsole.print(1, 4, "Using : A*"); sampleConsole.setForegroundColor(TCODColor.black); sampleConsole.putChar(px, py, '@'); // draw windows for (int y = 0; y < SAMPLE_SCREEN_HEIGHT; y++) { for (int x = 0; x < SAMPLE_SCREEN_WIDTH; x++) { if (smap[y][x] == '=') { sampleConsole.putChar(x, y, '='); } } } recalculatePath = true; } if (recalculatePath) { if (usingAstar) { if (AStrPath == null) AStrPath = new TCODPath(map, 1.41f); AStrPath.compute(px, py, dx, dy); } else { if (DijkstraPath == null) DijkstraPath = new TCODDijkstra(map, 1.41f); dijkstraDist = 0.0f; /* compute the distance grid */ DijkstraPath.compute(px, py); /* get the maximum distance (needed for ground shading only) */ for (int y = 0; y < SAMPLE_SCREEN_HEIGHT; y++) { for (int x = 0; x < SAMPLE_SCREEN_WIDTH; x++) { float d = DijkstraPath.getDistance(x, y); if (d > dijkstraDist) dijkstraDist = d; } } // compute the path DijkstraPath.setPath(dx, dy); } recalculatePath = false; busy = .2f; } // draw the dungeon for (int y = 0; y < SAMPLE_SCREEN_HEIGHT; y++) { for (int x = 0; x < SAMPLE_SCREEN_WIDTH; x++) { bool wall = smap[y][x] == '#'; sampleConsole.setCharBackground(x, y, (wall ? darkWall : darkGround), TCODBackgroundFlag.Set); } } // draw the path if (usingAstar) { for (int i = 0; i < AStrPath.size(); i++) { int x, y; AStrPath.get(i, out x, out y); sampleConsole.setCharBackground(x, y, lightGround, TCODBackgroundFlag.Set); } } else { for (int y = 0; y < SAMPLE_SCREEN_HEIGHT; y++) { for (int x = 0; x < SAMPLE_SCREEN_WIDTH; x++) { bool wall = smap[y][x] == '#'; if (!wall) { float d = DijkstraPath.getDistance(x, y); sampleConsole.setCharBackground(x, y, TCODColor.Interpolate(lightGround, darkGround, (float)0.9 * d / dijkstraDist), TCODBackgroundFlag.Set); } } } for (int i = 0; i < DijkstraPath.size(); i++) { int x, y; DijkstraPath.get(i, out x, out y); sampleConsole.setCharBackground(x, y, lightGround, TCODBackgroundFlag.Set); } } // move the creature busy -= TCODSystem.getLastFrameLength(); if (busy <= 0.0f) { busy += 0.2f; if (usingAstar) { if (!AStrPath.isEmpty()) { sampleConsole.putChar(px, py, ' ', TCODBackgroundFlag.None); AStrPath.walk(ref px, ref py, true); sampleConsole.putChar(px, py, '@', TCODBackgroundFlag.None); } } else { if (!DijkstraPath.isEmpty()) { sampleConsole.putChar(px, py, ' ', TCODBackgroundFlag.None); DijkstraPath.walk(ref px, ref py); sampleConsole.putChar(px, py, '@', TCODBackgroundFlag.None); recalculatePath = true; } } } if ((key.Character == 'I' || key.Character == 'i') && dy > 0) { // destination move north sampleConsole.putChar(dx, dy, oldChar, TCODBackgroundFlag.None); dy--; oldChar = sampleConsole.getChar(dx, dy); sampleConsole.putChar(dx, dy, '+', TCODBackgroundFlag.None); if (smap[dy][dx] == ' ') { recalculatePath = true; } } else if ((key.Character == 'K' || key.Character == 'k') && dy < SAMPLE_SCREEN_HEIGHT - 1) { // destination move south sampleConsole.putChar(dx, dy, oldChar, TCODBackgroundFlag.None); dy++; oldChar = sampleConsole.getChar(dx, dy); sampleConsole.putChar(dx, dy, '+', TCODBackgroundFlag.None); if (smap[dy][dx] == ' ') { recalculatePath = true; } } else if ((key.Character == 'J' || key.Character == 'j') && dx > 0) { // destination move west sampleConsole.putChar(dx, dy, oldChar, TCODBackgroundFlag.None); dx--; oldChar = sampleConsole.getChar(dx, dy); sampleConsole.putChar(dx, dy, '+', TCODBackgroundFlag.None); if (smap[dy][dx] == ' ') { recalculatePath = true; } } else if ((key.Character == 'L' || key.Character == 'l') && dx < SAMPLE_SCREEN_WIDTH - 1) { // destination move east sampleConsole.putChar(dx, dy, oldChar, TCODBackgroundFlag.None); dx++; oldChar = sampleConsole.getChar(dx, dy); sampleConsole.putChar(dx, dy, '+', TCODBackgroundFlag.None); if (smap[dy][dx] == ' ') { recalculatePath = true; } } else if (key.KeyCode == TCODKeyCode.Tab) { usingAstar = !usingAstar; sampleConsole.setForegroundColor(TCODColor.white); if (usingAstar) sampleConsole.print(1, 4, "Using : A* "); else sampleConsole.print(1, 4, "Using : Dijkstra"); sampleConsole.setForegroundColor(TCODColor.black); recalculatePath = true; } TCODMouseData mouse = TCODMouse.getStatus(); int mx = mouse.CellX - SAMPLE_SCREEN_X; int my = mouse.CellY - SAMPLE_SCREEN_Y; if (mx >= 0 && mx < SAMPLE_SCREEN_WIDTH && my >= 0 && my < SAMPLE_SCREEN_HEIGHT && (dx != mx || dy != my)) { sampleConsole.putChar(dx, dy, oldChar, TCODBackgroundFlag.None); dx = mx; dy = my; oldChar = sampleConsole.getChar(dx, dy); sampleConsole.putChar(dx, dy, '+', TCODBackgroundFlag.None); if (smap[dy][dx] == ' ') { recalculatePath = true; } } }
private void Set(Actions action, TCODKey primary) { Set(action, primary, primary); }
void render_colors(bool first, TCODKey key) { int TOPLEFT = 0; int TOPRIGHT = 1; int BOTTOMLEFT = 2; int BOTTOMRIGHT = 3; TCODColor textColor = new TCODColor(); /* ==== slighty modify the corner colors ==== */ if (first) { TCODSystem.setFps(0); sampleConsole.clear(); } /* ==== slighty modify the corner colors ==== */ for (int c = 0; c < 4; c++) { /* move each corner color */ int component = random.getInt(0, 2); switch (component) { case 0: render_cols[c] = new TCODColor((byte)(render_cols[c].Red + (byte)(5 * render_dirr[c])), render_cols[c].Green, render_cols[c].Blue); if (render_cols[c].Red == 255) render_dirr[c] = -1; else if (render_cols[c].Red == 0) render_dirr[c] = 1; break; case 1: render_cols[c] = new TCODColor(render_cols[c].Red, (byte)(render_cols[c].Green + (byte)(5 * render_dirg[c])), render_cols[c].Blue); if (render_cols[c].Green == 255) render_dirg[c] = -1; else if (render_cols[c].Green == 0) render_dirg[c] = 1; break; case 2: render_cols[c] = new TCODColor(render_cols[c].Red, render_cols[c].Green, (byte)(render_cols[c].Blue + (byte)(5 * render_dirb[c]))); if (render_cols[c].Blue == 255) render_dirb[c] = -1; else if (render_cols[c].Blue == 0) render_dirb[c] = 1; break; } } /* ==== scan the whole screen, interpolating corner colors ==== */ for (int x = 0; x < SAMPLE_SCREEN_WIDTH; x++) { float xcoef = (float)(x) / (SAMPLE_SCREEN_WIDTH - 1); /* get the current column top and bottom colors */ TCODColor top = TCODColor.Interpolate(render_cols[TOPLEFT], render_cols[TOPRIGHT], xcoef); TCODColor bottom = TCODColor.Interpolate(render_cols[BOTTOMLEFT], render_cols[BOTTOMRIGHT], xcoef); for (int y = 0; y < SAMPLE_SCREEN_HEIGHT; y++) { float ycoef = (float)(y) / (SAMPLE_SCREEN_HEIGHT - 1); /* get the current cell color */ TCODColor curColor = TCODColor.Interpolate(top, bottom, ycoef); sampleConsole.setCharBackground(x, y, curColor, TCODBackgroundFlag.Set); } } /* ==== print the text ==== */ /* get the background color at the text position */ textColor = sampleConsole.getCharBackground(SAMPLE_SCREEN_WIDTH / 2, 5); /* and invert it */ textColor = new TCODColor((byte)(255 - textColor.Red), (byte)(255 - textColor.Green), (byte)(255 - textColor.Blue)); sampleConsole.setForegroundColor(textColor); /* put random text (for performance tests) */ for (int x = 0; x < SAMPLE_SCREEN_WIDTH; x++) { for (int y = 0; y < SAMPLE_SCREEN_HEIGHT; y++) { TCODColor col = sampleConsole.getCharForeground(x, y); col = TCODColor.Interpolate(col, TCODColor.black, 0.5f); int c = random.getInt(System.Convert.ToByte('a'), System.Convert.ToByte('z')); sampleConsole.setForegroundColor(col); sampleConsole.putChar(x, y, (char)c, TCODBackgroundFlag.None); } } /* the background behind the text is slightly darkened using the BKGND_MULTIPLY flag */ sampleConsole.setBackgroundColor(TCODColor.grey); sampleConsole.printRectEx(SAMPLE_SCREEN_WIDTH / 2, 5, SAMPLE_SCREEN_WIDTH - 2, SAMPLE_SCREEN_HEIGHT - 1, TCODBackgroundFlag.Multiply, TCODAlignment.CenterAlignment, "The Doryen library uses 24 bits colors, for both background and foreground."); }
protected ConsoleKey GetConsoleKey(TCODKey key) { ConsoleKey consoleKey = default(ConsoleKey); bool found = true; switch (key.KeyCode) { case TCODKeyCode.Space: consoleKey = ConsoleKey.Spacebar; break; case TCODKeyCode.Right: consoleKey = ConsoleKey.RightArrow; break; case TCODKeyCode.Left: consoleKey = ConsoleKey.LeftArrow; break; case TCODKeyCode.Up: consoleKey = ConsoleKey.UpArrow; break; case TCODKeyCode.Down: consoleKey = ConsoleKey.DownArrow; break; default: found = false; break; } if (found) { return consoleKey; } else { string keyCodeString; if (key.KeyCode == TCODKeyCode.Char) { keyCodeString = string.Format("{0}", key.Character); Enum.TryParse(keyCodeString, true, out consoleKey); return consoleKey; } else { keyCodeString = string.Format("{0}", key.KeyCode); Enum.TryParse(keyCodeString, true, out consoleKey); return consoleKey; } } }
private void Set(Actions action, TCODKey primary, TCODKey secondary) { SetActionPrimary(action, primary); SetActionSecondary(action, secondary); }