public override void ProcessKeyboard(SadConsole.Console consoleObject, SadConsole.Input.Keyboard info, out bool handled)
{
// Upcast this because we know we're only using it with a Console type.
var console = (ScrollingConsole)consoleObject;
if (info.IsKeyDown(Keys.Left))
{
console.ViewPort = new Rectangle(console.ViewPort.Left - 1, console.ViewPort.Top, 80, 23);
}
if (info.IsKeyDown(Keys.Right))
{
console.ViewPort = new Rectangle(console.ViewPort.Left + 1, console.ViewPort.Top, 80, 23);
}
if (info.IsKeyDown(Keys.Up))
{
console.ViewPort = new Rectangle(console.ViewPort.Left, console.ViewPort.Top - 1, 80, 23);
}
if (info.IsKeyDown(Keys.Down))
{
console.ViewPort = new Rectangle(console.ViewPort.Left, console.ViewPort.Top + 1, 80, 23);
}
handled = true;
}
public override void ProcessKeyboard(IScreenObject consoleObject, SadConsole.Input.Keyboard info, out bool handled)
{
// Upcast this because we know we're only using it with a Console type.
var console = (Console)consoleObject;
if (info.IsKeyDown(Keys.Left))
{
console.ViewPosition = console.ViewPosition.Translate((-1, 0));
}
if (info.IsKeyDown(Keys.Right))
{
console.ViewPosition = console.ViewPosition.Translate((1, 0));
}
if (info.IsKeyDown(Keys.Up))
{
console.ViewPosition = console.ViewPosition.Translate((0, -1));
}
if (info.IsKeyDown(Keys.Down))
{
console.ViewPosition = console.ViewPosition.Translate((0, +1));
}
handled = true;
}
public override void ProcessKeyboard(SadConsole.Console console, SadConsole.Input.Keyboard info, out bool handled)
{
foreach (AsciiKey key in info.KeysPressed)
{
if (key.Character != '\0')
{
input += key.Character.ToString();
console.Cursor.Print(key.Character.ToString());
}
if (key.Key == Keys.Back)
{
if (input.Length > 0)
{
input = input.Remove(input.Length - 1, 1);
console.Cursor.LeftWrap(1).Print(" ").LeftWrap(1);
}
}
if (key.Key == Keys.Enter)
{
ProcessInput(input);
input = "";
}
}
handled = true;
}
public override bool ProcessKeyboard(Keyboard keyboard)
{
if (keyboard.IsKeyPressed(Keys.Insert))
{
brush.Symbol = 0;
return(true);
}
if (keyboard.IsKeyPressed(Keys.Delete))
{
brush.Symbol = null;
return(true);
}
if (brush.Symbol.HasValue)
{
if (keyboard.IsKeyPressed(Keys.PageUp))
{
var nextSymbol = brush.Symbol.Value + 1;
brush.Symbol = Math.Min(Font.MaxGlyphIndex, nextSymbol);
}
if (keyboard.IsKeyPressed(Keys.PageDown))
{
var prevSymbol = brush.Symbol.Value - 1;
brush.Symbol = Math.Max(0, prevSymbol);
}
}
return(base.ProcessKeyboard(keyboard));
}
/// <summary>
/// Called by the engine to process the keyboard. If the <see cref="KeyboardHandler"/> has been set, that will be called instead of this method.
/// </summary>
/// <param name="info">Keyboard information.</param>
/// <returns>True when the keyboard had data and this console did something with it.</returns>
public virtual bool ProcessKeyboard(Input.Keyboard info)
{
var handlerResult = KeyboardHandler?.Invoke(this, info) ?? false;
if (!handlerResult && this.UseKeyboard)
{
return(Cursor.ProcessKeyboard(info));
}
return(handlerResult);
}
/// <summary>
/// Processes the keyboard looking for the ESC key press to close the console, if required. Otherwise the base ControlsConsole will process the keyboard.
/// </summary>
/// <param name="info">Keyboard state.</param>
public override bool ProcessKeyboard(Input.Keyboard info)
{
if (CloseOnESC && info.IsKeyReleased(Keys.Escape))
{
this.Hide();
return(true);
}
else
{
return(base.ProcessKeyboard(info));
}
}
public override bool ProcessKeyboard(SadConsole.Input.Keyboard info)
{
if (info.IsKeyPressed(Keys.Escape))
{
Parent.IsFocused = true;
Parent.Children.Remove(this);
}
else
{
ListControls(info);
}
return(true);
}
public override bool ProcessKeyboard(SadConsole.Input.Keyboard info)
{
if (info.IsKeyDown(Keys.Left))
{
View = View.WithPosition(new Point(View.Position.X - 1, View.Position.Y));
}
if (info.IsKeyDown(Keys.Right))
{
View = View.WithPosition(new Point(View.Position.X + 1, View.Position.Y));
}
if (info.IsKeyDown(Keys.Up))
{
View = View.WithPosition(new Point(View.Position.X, View.Position.Y - 1));
}
if (info.IsKeyDown(Keys.Down))
{
View = View.WithPosition(new Point(View.Position.X, View.Position.Y + 1));
}
if (info.IsKeyReleased(Keys.Space))
{
NextAnsi();
LoadAnsi();
}
if (info.IsKeyReleased(Keys.L))
{
if (writer == null || lineCounter == lines.Length)
{
NextAnsi();
lineCounter = 0;
this.Clear();
lines = doc.AnsiString.Split('\n');
writer = new SadConsole.Ansi.AnsiWriter(doc, this);
}
writer.AnsiReadLine(lines[lineCounter], true);
lineCounter++;
if (lineCounter > lines.Length)
{
writer = null;
}
}
return(true);
}
public override bool ProcessKeyboard(SadConsole.Input.Keyboard info)
{
if (info.IsKeyDown(Keys.Left))
{
ViewPort = new Rectangle(ViewPort.Left - 1, ViewPort.Top, 80, 23);
}
if (info.IsKeyDown(Keys.Right))
{
ViewPort = new Rectangle(ViewPort.Left + 1, ViewPort.Top, 80, 23);
}
if (info.IsKeyDown(Keys.Up))
{
ViewPort = new Rectangle(ViewPort.Left, ViewPort.Top - 1, 80, 23);
}
if (info.IsKeyDown(Keys.Down))
{
ViewPort = new Rectangle(ViewPort.Left, ViewPort.Top + 1, 80, 23);
}
if (info.IsKeyReleased(Keys.Space))
{
NextAnsi();
LoadAnsi();
}
if (info.IsKeyReleased(Keys.L))
{
if (writer == null || lineCounter == lines.Length)
{
NextAnsi();
lineCounter = 0;
Clear();
lines = doc.AnsiString.Split('\n');
writer = new SadConsole.Ansi.AnsiWriter(doc, this);
}
writer.AnsiReadLine(lines[lineCounter], true);
lineCounter++;
if (lineCounter > lines.Length)
{
writer = null;
}
}
return(true);
}
/// <summary>
/// Processes the keyboard for the console.
/// </summary>
/// <param name="info">Keyboard information sent by the engine.</param>
public override bool ProcessKeyboard(Input.Keyboard info)
{
if (!UseGlobalKeyboardInput)
{
KeyboardState.Update(Global.GameTimeUpdate);
info = KeyboardState;
}
var handlerResult = KeyboardHandler == null ? false : KeyboardHandler(this, info);
if (!handlerResult && this.UseKeyboard)
{
bool canTab = true;
if (FocusedControl != null)
{
canTab = FocusedControl.TabStop;
}
if (canTab)
{
if (
((info.IsKeyDown(Keys.LeftShift) ||
info.IsKeyDown(Keys.RightShift)) ||
info.IsKeyReleased(Keys.LeftShift) ||
info.IsKeyReleased(Keys.RightShift))
&&
info.IsKeyReleased(Keys.Tab))
{
// TODO: Handle tab by changing focused control unless existing control doesn't support tab
TabPreviousControl();
return(true);
}
else if (info.IsKeyReleased(Keys.Tab))
{
// TODO: Handle tab by changing focused control unless existing control doesn't support tab
TabNextControl();
return(false);
}
}
if (FocusedControl != null && FocusedControl.IsEnabled && FocusedControl.UseKeyboard)
{
return(FocusedControl.ProcessKeyboard(info));
}
}
return(false);
}
public override bool ProcessKeyboard(SadConsole.Input.Keyboard info)
{
foreach (var component in ComponentsKeyboard.ToArray())
{
component.ProcessKeyboard(this, info, out bool isHandled);
if (isHandled)
{
return(true);
}
}
return(false);
}
public bool HandleMove(SadConsole.Input.Keyboard info)
{
foreach (Keys key in MovementDirectionMapping.Keys)
{
if (info.IsKeyPressed(key))
{
Direction moveDirection = MovementDirectionMapping[key];
Point coorToMove = new Point(moveDirection.DeltaX, moveDirection.DeltaY);
bool sucess = CommandManager.MoveActorBy((Actor)GameLoop.World.CurrentMap.ControlledEntitiy, coorToMove);
return(sucess);
}
}
return(false);
}
public override bool ProcessKeyboard(SadConsole.Input.Keyboard info)
{
if (info.IsKeyReleased(Keys.Space))
{
showMouse = !showMouse;
}
if (info.IsKeyReleased(Keys.Enter))
{
UsePrintProcessor = !UsePrintProcessor;
}
if (info.IsKeyReleased(Keys.C))
{
DoClear = !DoClear;
}
return(true);
}
public override bool ProcessKeyboard(SadConsole.Input.Keyboard info)
{
if (info.IsKeyReleased(Keys.C))
{
backIndex++;
if (backIndex == backgroundcycle.Length)
{
backIndex = 0;
}
var theme = Theme;
theme.FillStyle.Background = backgroundcycle[backIndex];
Theme = theme;
}
return(base.ProcessKeyboard(info));
}
public override bool ProcessKeyboard(SadConsole.Input.Keyboard info)
{
if (info.IsKeyPressed(Keys.Escape))
{
if (targetSelector != null)
{
targetSelector = null;
//UpdateItemSelector();
}
else
{
Close();
}
return(true);
}
else
{
return(((Console)targetSelector ?? itemSelector).ProcessKeyboard(info));
}
}
public override bool ProcessKeyboard(SadConsole.Input.Keyboard info)
{
if (info.IsKeyReleased(Keys.C))
{
backIndex++;
if (backIndex == backgroundcycle.Length)
{
backIndex = 0;
}
var theme = Theme.Clone();
theme.Colors.ControlBack = backgroundcycle[backIndex];
theme.Colors.RebuildAppearances();
Theme = theme;
}
return(base.ProcessKeyboard(info));
}
/// <summary>
/// Focuses the previous or next selection button depending on if the UP or DOWN arrow keys were pressed.
/// </summary>
/// <param name="info">The keyboard state.</param>
public override bool ProcessKeyboard(SadConsole.Input.Keyboard info)
{
if (info.IsKeyReleased(Keys.Up))
{
SelectPrevious();
PreviousSelection.IsFocused = true;
return(true);
}
else if (info.IsKeyReleased(Keys.Down))
{
SelectNext();
NextSelection.IsFocused = true;
return(true);
}
else if (info.IsKeyReleased(Keys.Enter))
{
InvokeClick();
}
return(base.ProcessKeyboard(info));
}
public override bool ProcessKeyboard(SadInput.Keyboard info)
{
// TODO use some StateMachine instead.
if (info.IsKeyDown(Keys.Right))
{
Animation = Animations["WalkRight"];
}
else if (info.IsKeyDown(Keys.Left))
{
Animation = Animations["WalkLeft"];
}
else
{
Animation = Animations["Idle"];
}
Animation.Start();
return(base.ProcessKeyboard(info));
}
public override bool ProcessKeyboard(SadConsole.Input.Keyboard info)
{
return(false);
}
public void ListControls(SadConsole.Input.Keyboard info)
{
if (info.IsKeyPressed(Keys.Up))
{
if (CanScrollUp)
{
startIndex--;
}
}
else if (info.IsKeyPressed(Keys.Down))
{
if (CanScrollDown)
{
startIndex++;
}
}
else if (info.IsKeyPressed(Keys.Left))
{
if (CanPageUp)
{
startIndex -= 26;
}
else
{
startIndex = 0;
}
}
else if (info.IsKeyPressed(Keys.Right))
{
if (CanPageDown)
{
startIndex += 26;
}
else
{
startIndex = Math.Max(0, Choices.Count - 26);
}
}
else
{
//If this key represents an item, then we select it
foreach (var k in info.KeysPressed)
{
var key = k.Key;
if (Keys.A <= key && key <= Keys.Z)
{
//A represents the first displayed item (i.e. the one at startIndex). Z represents the last displayed item (startIndex + 25)
int index = (key - Keys.A) + startIndex;
if (index < Choices.Count)
{
//Select the item
ListChoice <T> selected = Choices.ToList()[index];
if (select.Invoke(selected.Value))
{
Choices.Remove(selected);
//If we're at the bottom of the menu and we're removing an item here, move the list view up so that we don't have empty slots
if (Choices.Count > 25 && !CanPageDown)
{
startIndex = Choices.Count - 26;
}
}
}
break;
}
}
}
}
public virtual bool ProcessKeyboard(Input.Keyboard state)
{
return(false);
}
public override bool ProcessKeyboard(SadConsole.Input.Keyboard info)
{
int delta = 1; //Distance moved by camera
if (info.IsKeyDown(Keys.RightControl))
{
delta *= 8;
}
/*
* if (info.IsKeyDown(Keys.RightControl)) {
* examineMenu.ListControls(info);
* } else
*/
if (info.IsKeyPressed(Keys.Up))
{
if (info.IsKeyDown(Keys.RightShift))
{
world.camera += new XYZ(0, 0, delta);
}
else
{
world.camera += new XYZ(0, delta);
}
UpdateExamine();
}
else if (info.IsKeyPressed(Keys.Down))
{
if (info.IsKeyDown(Keys.RightShift))
{
world.camera += new XYZ(0, 0, -delta);
}
else
{
world.camera += new XYZ(0, -delta);
}
UpdateExamine();
}
else if (info.IsKeyPressed(Keys.Left))
{
world.camera += new XYZ(-delta, 0);
UpdateExamine();
}
else if (info.IsKeyPressed(Keys.Right))
{
world.camera += new XYZ(delta, 0);
UpdateExamine();
}
else if (info.IsKeyPressed(Keys.Escape))
{
world.camera = world.player.Position;
Parent.IsFocused = true;
Parent.Children.Remove(this);
}
else if (info.IsKeyPressed(Keys.Enter))
{
selectAt(world.camera);
}
else
{
examineMenu.ListControls(info);
}
return(true);
}
public override bool ProcessKeyboard(SadConsole.Input.Keyboard info)
{
// Forward the keyboard data to the entity to handle the movement code.
// We could detect if the users hit ESC and popup a menu or something.
// By not setting the entity as the active object, twe let this
// "game level" (the console we're hosting the entity on) determine if
// the keyboard data should be sent to the entity.
// Process logic for moving the entity.
bool keyHit = false;
Point oldPosition = player.Position;
Point newPosition = (0, 0);
// Toggles entity random movements
if (info.IsKeyPressed(Keys.Q))
{
moveEntities = !moveEntities;
}
// Process UP/DOWN movements
if (info.IsKeyPressed(Keys.Up))
{
newPosition = player.Position + (0, -1);
keyHit = true;
}
else if (info.IsKeyPressed(Keys.Down))
{
newPosition = player.Position + (0, 1);
keyHit = true;
}
// Process LEFT/RIGHT movements
if (info.IsKeyPressed(Keys.Left))
{
newPosition = player.Position + (-1, 0);
keyHit = true;
}
else if (info.IsKeyPressed(Keys.Right))
{
newPosition = player.Position + (1, 0);
keyHit = true;
}
// If a movement key was pressed
if (keyHit)
{
// Check if the new position is valid
if (Surface.Area.Contains(player.Position))
{
// Entity moved. Let's draw a trail of where they moved from.
Surface.SetGlyph(player.Position.X, player.Position.Y, 250);
player.Position = newPosition;
return(true);
}
}
// You could have multiple entities in the game for example, and change
// which entity gets keyboard commands.
return(false);
}
public override void ProcessKeyboard(SadConsole.Console consoleObject, SadConsole.Input.Keyboard info, out bool handled)
{
// Upcast this because we know we're only using it with a Console type.
var console = (ScrollingConsole)consoleObject;
// Check each key pressed.
foreach (var key in info.KeysPressed)
{
// If the character associated with the key pressed is a printable character, print it
if (key.Character != '\0')
{
console.Cursor.Print(key.Character.ToString());
}
// Special character - BACKSPACE
else if (key.Key == Keys.Back)
{
// Get the prompt that the console has.
string prompt = ((CustomConsoles.DOSConsole)console).Prompt;
// If the console has scrolled since the user started typing, adjust the starting row of the virtual cursor by that much.
if (console.TimesShiftedUp != 0)
{
CursorLastY -= console.TimesShiftedUp;
console.TimesShiftedUp = 0;
}
// Do not let them backspace into the prompt
if (console.Cursor.Position.Y != CursorLastY || console.Cursor.Position.X > prompt.Length)
{
console.Cursor.LeftWrap(1).Print(" ").LeftWrap(1);
}
}
// Special character - ENTER
else if (key.Key == Keys.Enter)
{
// If the console has scrolled since the user started typing, adjust the starting row of the virtual cursor by that much.
if (console.TimesShiftedUp != 0)
{
CursorLastY -= console.TimesShiftedUp;
console.TimesShiftedUp = 0;
}
// Get the prompt to exclude it in determining the total length of the string the user has typed.
string prompt = ((CustomConsoles.DOSConsole)console).Prompt;
int startingIndex = console.GetIndexFromPoint(new Point(prompt.Length, CursorLastY));
string data = ((ScrollingConsole)console).GetString(startingIndex, console.GetIndexFromPoint(console.Cursor.Position) - startingIndex);
// Move the cursor to the next line before we send the string data to the processor
console.Cursor.CarriageReturn().LineFeed();
// Send the string data
EnterPressedAction(data);
// After they have processed the string, we will create a new line and display the prompt.
console.Cursor.CarriageReturn().LineFeed();
console.Cursor.DisableWordBreak = true;
console.Cursor.Print(((CustomConsoles.DOSConsole)console).Prompt);
console.Cursor.DisableWordBreak = false;
CursorLastY = console.Cursor.Position.Y;
// Preparing the next lines could have scrolled the console, reset the counter
console.TimesShiftedUp = 0;
}
}
handled = true;
}
public bool HandleKeyboard(IConsole console, SadConsole.Input.Keyboard info)
{
var realConsole = (SadConsole.Console)console;
// Check each key pressed.
foreach (var key in info.KeysPressed)
{
// If the character associated with the key pressed is a printable character, print it
if (key.Character != '\0')
{
int startingIndex = realConsole.GetIndexFromPoint(Room.MapWidth + 2, Room.MapHeight + 4);
String data = realConsole.GetString(startingIndex, realConsole.GetIndexFromPoint(console.Cursor.Position) - startingIndex);
if (data.Length < 14)
{
console.Cursor.Print(key.Character.ToString().ToUpper());
}
}
// Special character - BACKSPACE
else if (key.Key == Keys.Back)
{
// If the console has scrolled since the user started typing, adjust the starting row of the virtual cursor by that much.
if (realConsole.TimesShiftedUp != 0)
{
realConsole.TimesShiftedUp = 0;
}
// Do not let them backspace into the prompt
if (console.Cursor.Position.Y != Room.MapHeight + 4 || console.Cursor.Position.X > Room.MapWidth + 2)
{
console.Cursor.LeftWrap(1).Print(" ").LeftWrap(1);
}
}
// Special character - ENTER
else if (key.Key == Keys.Enter)
{
// If the console has scrolled since the user started typing, adjust the starting row of the virtual cursor by that much.
if (realConsole.TimesShiftedUp != 0)
{
CursorLastY -= realConsole.TimesShiftedUp;
realConsole.TimesShiftedUp = 0;
}
// Get the prompt to exclude it in determining the total length of the string the user has typed.
int startingIndex = realConsole.GetIndexFromPoint(Room.MapWidth + 2, Room.MapHeight + 4);
String data = realConsole.GetString(startingIndex, realConsole.GetIndexFromPoint(console.Cursor.Position) - startingIndex);
// Move the cursor to the next line before we send the string data to the processor
// Send the string data
EnterPressedAction(data);
// After they have processed the string, we will create a new line and display the prompt.
CursorLastY = console.Cursor.Position.Y;
// Preparing the next lines could have scrolled the console, reset the counter
realConsole.TimesShiftedUp = 0;
}
}
return(true);
}
/// <summary>
/// Called by the engine to process the keyboard. If the <see cref="KeyboardHandler"/> has been set, that will be called instead of this method.
/// </summary>
/// <param name="info">Keyboard information.</param>
/// <returns>True when the keyboard had data and this console did something with it.</returns>
public virtual bool ProcessKeyboard(Input.Keyboard info)
{
var handlerResult = KeyboardHandler == null ? false : KeyboardHandler(this, info);
if (!handlerResult && this.UseKeyboard)
{
bool didSomething = false;
foreach (var key in info.KeysPressed)
{
if (key.Character == '\0')
{
switch (key.Key)
{
case Keys.Space:
this.virtualCursor.Print(key.Character.ToString());
didSomething = true;
break;
case Keys.Enter:
this.virtualCursor.CarriageReturn().LineFeed();
didSomething = true;
break;
case Keys.Pause:
case Keys.Escape:
case Keys.F1:
case Keys.F2:
case Keys.F3:
case Keys.F4:
case Keys.F5:
case Keys.F6:
case Keys.F7:
case Keys.F8:
case Keys.F9:
case Keys.F10:
case Keys.F11:
case Keys.F12:
case Keys.LeftShift:
case Keys.RightShift:
case Keys.LeftAlt:
case Keys.RightAlt:
case Keys.LeftControl:
case Keys.RightControl:
case Keys.LeftWindows:
case Keys.RightWindows:
case Keys.F13:
case Keys.F14:
case Keys.F15:
case Keys.F16:
case Keys.F17:
case Keys.F18:
case Keys.F19:
case Keys.F20:
case Keys.F21:
case Keys.F22:
case Keys.F23:
case Keys.F24:
//this._virtualCursor.Print(key.Character.ToString());
break;
case Keys.Up:
this.virtualCursor.Up(1);
didSomething = true;
break;
case Keys.Left:
this.virtualCursor.Left(1);
didSomething = true;
break;
case Keys.Right:
this.virtualCursor.Right(1);
didSomething = true;
break;
case Keys.Down:
this.virtualCursor.Down(1);
didSomething = true;
break;
case Keys.None:
break;
case Keys.Back:
this.virtualCursor.Left(1).Print(" ").Left(1);
didSomething = true;
break;
default:
this.virtualCursor.Print(key.Character.ToString());
didSomething = true;
break;
}
}
else
{
this.virtualCursor.Print(key.Character.ToString());
didSomething = true;
}
}
return(didSomething);
}
return(handlerResult);
}
public override bool ProcessKeyboard(SadConsole.Input.Keyboard info)
{
return(base.ProcessKeyboard(info));
}
public override bool ProcessKeyboard(SadConsole.Input.Keyboard info)
{
// Forward the keyboard data to the entity to handle the movement code.
// We could detect if the users hit ESC and popup a menu or something.
// By not setting the entity as the active object, twe let this
// "game level" (the console we're hosting the entity on) determine if
// the keyboard data should be sent to the entity.
// Process logic for moving the entity.
bool keyHit = false;
Point oldPosition = player.Position;
if (info.IsKeyPressed(Keys.W))
{
//player.Animation.Surface.AddDecorator(0, 2, new[] { new CellDecorator(Color.Green, 67, Mirror.None) });
keyHit = true;
}
if (info.IsKeyPressed(Keys.Q))
{
moveEntities = !moveEntities;
keyHit = true;
}
if (info.IsKeyPressed(Keys.Up))
{
player.Position = new Point(player.Position.X, player.Position.Y - 1);
keyHit = true;
}
else if (info.IsKeyPressed(Keys.Down))
{
player.Position = new Point(player.Position.X, player.Position.Y + 1);
keyHit = true;
}
if (info.IsKeyPressed(Keys.Left))
{
player.Position = new Point(player.Position.X - 1, player.Position.Y);
keyHit = true;
}
else if (info.IsKeyPressed(Keys.Right))
{
player.Position = new Point(player.Position.X + 1, player.Position.Y);
keyHit = true;
}
if (keyHit)
{
// Check if the new position is valid
if (Surface.Area.Contains(player.Position))
{
// Entity moved. Let's draw a trail of where they moved from.
Surface.SetGlyph(playerPreviousPosition.X, playerPreviousPosition.Y, 250);
playerPreviousPosition = player.Position;
return(true);
}
else // New position was not in the area of the console, move back
{
player.Position = oldPosition;
}
}
// You could have multiple entities in the game for example, and change
// which entity gets keyboard commands.
return(false);
}
public override void ProcessKeyboard(SadConsole.Console console, Keyboard info, out bool handled)
{
handled = true;
bool shift = info.IsKeyDown(Keys.LeftShift) || info.IsKeyDown(Keys.RightShift); // could move this to line 36 if (info.IsKeyPressed(Keys.X)){ if this is an issue
if (Program.world != null)
{
// movement keys can use else ifs since they are contradictory
if (info.IsKeyPressed(Keys.Left))
{
Program.world.MoveCursor(-1, 0);
}
else if (info.IsKeyPressed(Keys.Right))
{
Program.world.MoveCursor(1, 0);
}
if (info.IsKeyPressed(Keys.Up))
{
Program.world.MoveCursor(0, -1);
}
else if (info.IsKeyPressed(Keys.Down))
{
Program.world.MoveCursor(0, 1);
}
// when released, update the map
if (info.IsKeyReleased(Keys.Left) ||
info.IsKeyReleased(Keys.Right) ||
info.IsKeyReleased(Keys.Up) ||
info.IsKeyReleased(Keys.Down)
)
{
new Task(() => { Program.world.RedrawTooltip(); }).Start();
}
// ditto for zoom keys
if (info.IsKeyPressed(Keys.OemPlus))
{
Program.world.Zoom(1);
}
else if (info.IsKeyPressed(Keys.OemMinus))
{
Program.world.Zoom(-1);
}
// other keys can be pressed simultaneously
if (info.IsKeyPressed(Keys.E))
{
Program.world.selection.Embark();
Program.Log("Embarked! (Not yet implemented...)");
}
if (info.IsKeyPressed(Keys.R)) // debug
{
Program.Log(People.NamingSystem.systems
[Program.rng.Next(0, People.NamingSystem.systems.Count)]
.RandomFromGender(MochaRandom.Bool()));
}
if (info.IsKeyPressed(Keys.S)) // save map
{
new Task(() => { Export.Celestia.ExportBitmap(); }).Start();
}
if (info.IsKeyPressed(Keys.X))
{
Mapping.CycleChar(shift ? -1 : 1);
Program.world.Print();
}
if (info.IsKeyPressed(Keys.Z))
{
Mapping.CycleColor(shift ? -1 : 1);
Program.world.Print();
}
}
if (info.IsKeyPressed(Keys.Escape))
{
Program.Exit();
}
}
public virtual bool ProcessKeyboard(Keyboard info)
{
return(false);
}
