override public void Update(eKey p_Temp)
{
Console.Clear();
switch (p_Temp)
{
case eKey.Left:
m_nChoicePosX = 45;
break;
case eKey.Right:
m_nChoicePosX = 65;
break;
case eKey.Space:
if (m_nChoicePosX == 45)
{
m_nSelectPlayer = 0;
}
else
{
m_nSelectPlayer = 1;
}
Console.Clear();
GameFPS gameFPS = new GameFPS();
GameFPS.Open();
break;
}
}
public void Run()
{
while (true)
{
Render();
var Key = Console.ReadKey();
eKey n_TileX = eKey.Max;
if (Key.Key == ConsoleKey.LeftArrow)
{
n_TileX = eKey.Left;
}
else if (Key.Key == ConsoleKey.RightArrow)
{
n_TileX = eKey.Right;
}
else if (Key.Key == ConsoleKey.Spacebar)
{
n_TileX = eKey.Space;
}
Update(n_TileX);
}
}
/// <summary>Map a continuous range of keypad keys</summary>
public void keypad(eKey kFirst, string digits)
{
for (int i = 0; i < digits.Length; i++)
{
keypad((eKey)((ushort)kFirst + i), digits[i]);
}
}
public DefaultValue(List <CSV.varient> tContents)
{
this.IDX = tContents[0];
this.id = tContents[1].ToEnum <DefaultValue.eKey>();
this.Value = tContents[2];
this.StrValue = tContents[3];
}
bool handleWindowedModeHotkey(iDiligentWindow window, eKey key, eKeyboardState ks)
{
// if( key == eKey.Esc && content.windowState == eShowWindow.Fullscreen )
if (key == eKey.Esc)
{
window.moveWindow(eShowWindow.Normal);
return(true);
}
if (key == eKey.Up && ks.HasFlag(eKeyboardState.ControlDown))
{
window.moveWindow(eShowWindow.Maximized);
return(true);
}
if (key == eKey.Down && ks.HasFlag(eKeyboardState.ControlDown))
{
window.moveWindow(eShowWindow.Minimized);
return(true);
}
if (key == eKey.Enter && ks.HasFlag(eKeyboardState.AltDown))
{
if (ks.HasFlag(eKeyboardState.ControlDown))
{
switchToTrueFullScreen(window);
}
else
{
window.moveWindow(eShowWindow.Fullscreen);
}
return(true);
}
return(false);
}
override public void Update(eKey p_Temp)
{
Console.Clear();
switch (p_Temp)
{
case eKey.Up:
m_nChoicePosY = 30;
break;
case eKey.Down:
m_nChoicePosY = 32;
break;
//Spacebar로 선택
//선택 후 m_nChoicePosY값이 30이면 다음 씬으로 넘어가고
//아닐 경우 종료
case eKey.Space:
if (m_nChoicePosY == 30)
{
Console.Clear();
PlayerScene player = new PlayerScene();
player.Run();
break;
}
else if (m_nChoicePosY == 32)
{
Environment.Exit(0);
}
break;
}
}
protected override void handleKey(eKey key, eKeyValue keyValue)
{
layout.updateState(key, keyValue);
char c = layout.keyChar(key);
handler.keyEvent(key, keyValue, c, layout.state);
}
void iKeyboardHandler.keyEvent(eKey key, eKeyValue what, ushort unicodeChar, eKeyboardState ks)
{
// Console.WriteLine( "iKeyboardHandler.keyEvent: {0} {1} {2:x} {3}", key, what, unicodeChar, ks );
if (what != eKeyValue.Pressed)
{
return;
}
if (context.renderContext is iDiligentWindow window)
{
if (handleWindowedModeHotkey(window, key, ks))
{
return;
}
}
if (key == eKey.P)
{
screenshot();
return;
}
if (context.scene is iKeyPressedHandler hh)
{
hh.keyPressed(key, ks);
}
}
/// <summary>Use a custom expression. The expression must take no parameters, and return char.</summary>
public void custom(eKey key, Expression keyChar)
{
Expression body = Expression.Return(returnTarget, keyChar);
SwitchCase sc = Expression.SwitchCase(body, Expression.Constant(key, typeof(eKey)));
map.Add(key, sc);
}
public void keyPressed(eKey key, eKeyboardState keyboardState)
{
switch (key)
{
case eKey.Space:
playPause();
return;
case eKey.Home:
mediaEngine.currentTime = TimeSpan.Zero;
return;
case eKey.PageUp:
seek(keyboardState.HasFlag(eKeyboardState.ControlDown) ? -veryLargeSeek : -largeSeek);
return;
case eKey.PageDown:
seek(keyboardState.HasFlag(eKeyboardState.ControlDown) ? veryLargeSeek : largeSeek);
return;
case eKey.Left:
seek(-smallSeek);
return;
case eKey.Right:
seek(smallSeek);
return;
}
}
public void Update(eKey p_Temp)
{
Console.Clear();
switch (p_Temp)
{
case eKey.Up:
y = 30;
break;
case eKey.Down:
y = 32;
break;
case eKey.Space:
if (y == 30)
{
Console.Clear();
OpenScene openScene = new OpenScene();
OpenScene.Open();
i--;
}
else if (y == 32)
{
Environment.Exit(0);
}
break;
}
}
private int m_nChoicePosY = 30; //선택 화살표의 y값
public void Run()
{
while (true)
{
Render();
var Key = Console.ReadKey();
eKey n_TileY = eKey.Max;
if (Key.Key == ConsoleKey.UpArrow)
{
n_TileY = eKey.Up;
}
else if (Key.Key == ConsoleKey.DownArrow)
{
n_TileY = eKey.Down;
}
else if (Key.Key == ConsoleKey.Spacebar)
{
n_TileY = eKey.Space;
}
Update(n_TileY);
}
}
/// <summary>Map a key that doesn’t depend on the state, such as enter</summary>
public void key(eKey k, char c, bool ignoreControlAlt = false)
{
if (ignoreControlAlt)
{
custom(k, Expression.Constant(c));
return;
}
custom(k, Expression.Condition(eControlOrAltIsDown, eNullChar, Expression.Constant(c)));
}
public Speeches(List <CSV.varient> tContents)
{
this.id = tContents[0].ToEnum <Speeches.eKey>();
this.StrValue = tContents[1];
this.Search = tContents[2];
this.StrHelp = tContents[3];
this.StrMotion = tContents[4];
this.json = tContents[5];
}
/// <summary>Map a continuous range of keys which change with either shift or caps lock</summary>
public void letters(eKey kFirst, string normal, string upperCase)
{
if (normal.Length != upperCase.Length)
{
throw new ArgumentException();
}
for (int i = 0; i < normal.Length; i++)
{
letter((eKey)((ushort)kFirst + i), normal[i], upperCase[i]);
}
}
/// <summary>Map a continuous range of keys which depend on shift but ignore caps lock, such as 1</summary>
public void symbols(eKey kFirst, string normal, string shiftDown)
{
if (normal.Length != shiftDown.Length)
{
throw new ArgumentException();
}
for (int i = 0; i < normal.Length; i++)
{
symbol((eKey)((ushort)kFirst + i), normal[i], shiftDown[i]);
}
}
/// <summary>Map a key so it produces different characters based on whether Ctrl+Shift are both down</summary>
public void customCtrlShift(eKey k, char normal, char ctrlShift)
{
Expression cControlShift = Expression.Constant((int)(eKeyboardState.ControlDown | eKeyboardState.ShiftDown));
Expression eControlShiftDown = Expression.Equal(cControlShift, Expression.And(eStateInt, cControlShift));
custom(k,
Expression.Condition
(
eControlShiftDown,
Expression.Constant(ctrlShift),
Expression.Constant(normal)
));
}
static int GetIndex(eKey a_eKey)
{
int nReturn = -1;
for (int i = 0; i < arValue.Length; ++i)
{
if (arValue[i] == a_eKey)
{
nReturn = i;
break;
}
}
return(nReturn);
}
/// <summary>Map a key so it produces different characters when Ctrl or Ctrl+Shift are down</summary>
public void customCtrlAlt(eKey k, char normal, char ctrl, char ctrlAlt)
{
custom(k,
Expression.Condition
(
eControlAltDown,
Expression.Constant(ctrlAlt),
Expression.Condition
(
eControlDown,
Expression.Constant(ctrl),
Expression.Constant(normal)
)
));
}
protected override void handleKey(eKey key, eKeyValue keyValue)
{
layout.updateState(key, keyValue);
char c = layout.keyChar(key);
if (0 != c)
{
Console.WriteLine("KeyChar: {0} {1} {2} {3}", charString(c), key, keyValue, time);
}
else
{
Console.WriteLine("Key: {0} {1} {2}", key, keyValue, time);
}
}
void iKeyboardHandler.keyEvent(eKey key, eKeyValue what, ushort unicodeChar, eKeyboardState ks)
{
if (0 == unicodeChar)
{
Console.WriteLine("keyEvent: {0} {1} {2}", key, what, ks);
}
else if (key == 0)
{
Console.WriteLine("keyEvent: {0} {1} {2}", printKey((char)unicodeChar), what, ks);
}
else
{
Console.WriteLine("keyEvent: {0} ({1}) {2} {3}", printKey((char)unicodeChar), key, what, ks);
}
}
/// <summary>Map a key that depends on shift but ignores caps lock, such as 1</summary>
public void symbol(eKey k, char normal, char shiftDown)
{
custom(k,
Expression.Condition
(
eControlOrAltIsDown,
eNullChar,
Expression.Condition
(
eShift,
Expression.Constant(shiftDown),
Expression.Constant(normal)
)
)
);
}
/// <summary>Map a key that changes with either shift or caps lock, such as Q</summary>
public void letter(eKey k, char normal, char upperCase)
{
custom(k,
Expression.Condition
(
eControlOrAltIsDown,
eNullChar,
Expression.Condition
(
eShiftXorCapsLock,
Expression.Constant(upperCase),
Expression.Constant(normal)
)
)
);
}
void iKeyPressedHandler.keyPressed(eKey key, eKeyboardState keyboardState)
{
switch (key)
{
case eKey.R:
if (toggleFloat(ref radiansPerSecond, rotationSpeed))
{
context.animation.startDelta(this);
}
else
{
context.animation.cancelDelta(this);
}
break;
case eKey.B:
toggleFloat(ref boxesOpacity, 0.75f);
context.queueRenderFrame();
break;
case eKey.C:
if (context.drawDevice is iVrmacDrawDevice vdd)
{
customClipping = !customClipping;
if (customClipping)
{
vdd.clippingRectangleOverride = customClippingRect;
}
else
{
vdd.clippingRectangleOverride = null;
}
context.queueRenderFrame();
}
break;
case eKey.Home:
viewboxController.reset();
rotationAngle = default;
context.queueRenderFrame();
break;
}
}
void iKeyboardLayout.updateState(eKey key, eKeyValue val)
{
switch (key)
{
case eKey.LeftShift:
case eKey.RightShift:
updateState(eKeyboardState.ShiftDown, val);
return;
case eKey.LeftCtrl:
case eKey.RightCtrl:
updateState(eKeyboardState.ControlDown, val);
return;
case eKey.LeftAlt:
case eKey.RightAlt:
updateState(eKeyboardState.AltDown, val);
return;
}
}
void iKeyPressedHandler.keyPressed(eKey key, eKeyboardState keyboardState)
{
switch (key)
{
case eKey.Space:
motion?.toggleAnimation();
break;
case eKey.Enter:
motion?.toggleForce();
break;
case eKey.PageUp:
motion?.increaseForce();
break;
case eKey.PageDown:
motion?.decreaseForce();
break;
}
}
public void Run()
{
while (i == 1)
{
Info();
var Key = Console.ReadKey();
eKey p_Temp = eKey.Max;
if (Key.Key == ConsoleKey.UpArrow)
{
p_Temp = eKey.Up;
}
else if (Key.Key == ConsoleKey.DownArrow)
{
p_Temp = eKey.Down;
}
else if (Key.Key == ConsoleKey.Spacebar)
{
p_Temp = eKey.Space;
}
Update(p_Temp);
}
}
public Secure(List <CSV.varient> tContents)
{
this.id = tContents[0].ToEnum <Secure.eKey>();
this.Text = tContents[1];
}
public void bindKey(eKey key, Key value)
{
throw new NotImplementedException();
}
public void bindKey(eKey key, Key value)
{
throw new NotImplementedException();
}
protected override void handleKey(eKey key, eKeyValue keyValue)
{
Console.WriteLine("Key: {0} {1} {2}", key, keyValue, time);
}
