void OnEnable()
{
KeyListener.Clear();
KeyListener.Key = this;
enable = false;
Invoke("Active", delay);
}
void t_Tick(object sender, EventArgs e)
{
if (ExpandForm)
{
this.Size = new Size(FormSize.Width += 16, FormSize.Height += 9);
drag_panel.Size = new Size(FormSize.Width, 30);
exit_program.Location = new Point(FormSize.Width - 30, 0);
WB.Size = new Size(FormSize.Width, FormSize.Height - 30);
}
if (ContractForm)
{
if (exit_program.Location.X > contract.Location.X + 30)
{
this.Size = new Size(FormSize.Width -= 16, FormSize.Height -= 9);
drag_panel.Size = new Size(FormSize.Width, 30);
exit_program.Location = new Point(FormSize.Width - 30, 0);
WB.Size = new Size(FormSize.Width, FormSize.Height - 30);
}
}
if (WB.Document != null)
{
try
{
foreach (HtmlElement element in WB.Document.All)
{
textBox1.Text += element.InnerHtml + Environment.NewLine;
}
//textBox1.Text = WB.Document.GetElementById("player").Children[0].GetElementsByTagName("div").Count.ToString();//.GetElementsByTagName("div").Count.ToString();
//textBox1.Text = WB.Document.GetElementById("player").Children[0].GetElementsByTagName("span").Count.ToString();
}
catch { }
}
if (!FormToggle)
{
TopMost = true;
}
if (KeyListener.GetActiveKeys().Contains("|Numpad 0|"))
{
if (FormToggle)
{
//ShowForm
FormToggle = false;
WindowState = FormWindowState.Normal;
TopMost = true;
}
else
{
//HideForm
FormToggle = true;
WindowState = FormWindowState.Minimized;
TopMost = false;
}
Thread.Sleep(150);
}
}
private void RegisterKeyListener(int key, KeyListener listener)
{
if (!callbacks.ContainsKey(key))
{
this.callbacks.Add(key, listener);
}
}
public virtual void AddKeyListener(KeyListener listener)
{
if (!_keyListeners.Contains(listener))
{
_keyListeners.Add(listener);
}
}
void Update()
{
if (this.gamemode == GameMode.Multiplayer)
{
KeyListener.AttachKeyPressEvent(this.OnKeyPress);
}
}
private void ClearListeners()
{
if (_keyListener != null)
{
_keyListener.KeyUp -= _keyListener_KeyUp;
_keyListener = null;
}
}
void Awake()
{
instance = this;
foreach (KeyCode key in Enum.GetValues(typeof(KeyCode)))
{
this.watchingKeyList.Add(key);
}
}
private void Awake()
{
p1Listener = (p1.isEnemy) ? (KeyListener)gameObject.AddComponent(typeof(AIListener)) : (KeyListener)gameObject.AddComponent(typeof(PlayerListener));
p2Listener = (p2.isEnemy) ? (KeyListener)gameObject.AddComponent(typeof(AIListener)) : (KeyListener)gameObject.AddComponent(typeof(PlayerListener2));
p1.TieListener(p1Listener);
p2.TieListener(p2Listener);
p1Listener.isEnabled = p1.isEnabled;
p2Listener.isEnabled = p2.isEnabled;
}
void OnDisable()
{
enable = false;
if (KeyListener.Key == this)
{
KeyListener.Key = null;
}
KeyListener.Clear();
}
public Guy(MainWindow window, KeyListener kl, int width, int height)
{
Init();
this.window = window;
KeyListener = kl;
WindowWidth = width;
WindowHeight = height;
faceRight = true;
}
static void Main(string[] args)
{
IoC.Initialize(new SettingsIoCModule());
IoC.Instance.Resolve <ISettingsHelper>().Initialize();
IoC.Update(new BllIoCModule());
var keyListener = new KeyListener();
keyListener.Init();
}
public override void Run ()
{
//tControl.DisplayMessage("Location unknown.. Attempting connection to main cluster.. ERROR 404\n" +
// "Scanning,.. Fleet Signal confirmed; Waypoint established.", "Rob", 10.0f);
m = new Message ("Commence test of inertial dampeners;\nActivate at high velocity.\n(default key: LSHIFT)", "Rob");
Messenger.instance.AddMessage (m);
kl = new KeyListener (CustomInput.instance.DampenKey, DampenPressed);
CustomInput.instance.RegDownListener(kl);
}
public override void Run()
{
//tControl.DisplayMessage("Location unknown.. Attempting connection to main cluster.. ERROR 404\n" +
// "Scanning,.. Fleet Signal confirmed; Waypoint established.", "Rob", 10.0f);
m = new Message("Commence test of inertial dampeners;\nActivate at high velocity.\n(default key: LSHIFT)", "Rob");
Messenger.instance.AddMessage(m);
kl = new KeyListener(CustomInput.instance.DampenKey, DampenPressed);
CustomInput.instance.RegDownListener(kl);
}
private void SetupListeners()
{
ClearListeners();
_keyListener = GameObj.GetComponent <KeyListener>();
if (!Warnings.NullOrDisposed(_keyListener))
{
_keyListener.KeyUp += _keyListener_KeyUp;
}
}
protected override void OnAfterRender(bool firstRender)
{
if (!firstRender)
{
return;
}
_clickListener1 = new ClickListener(_inner1);
_clickListener1.Execute(JSRuntime);
_clickListener2 = new ClickListener(_inner2);
_clickListener2.Execute(JSRuntime);
_clickListener1.OnOuterClick += (args) =>
Console.WriteLine($"Outer1 -> Outer {args.Button} {args.X} {args.Y} {args.Shift} {args.Control}");
_clickListener1.OnClick += (args) =>
Console.WriteLine($"Outer1 -> Self {args.Button} {args.X} {args.Y} {args.Shift} {args.Control}");
_clickListener1.OnInnerClick += (args) =>
Console.WriteLine($"Outer1 -> Inner {args.Button} {args.X} {args.Y} {args.Shift} {args.Control}");
_clickListener1.OnInnerClick += (args) => { Console.WriteLine(args.TargetID); };
_clickListener2.OnOuterClick += (args) =>
Console.WriteLine($"Outer2 -> Outer {args.Button} {args.X} {args.Y} {args.Shift} {args.Control}");
_clickListener2.OnClick += (args) =>
Console.WriteLine($"Outer2 -> Self {args.Button} {args.X} {args.Y} {args.Shift} {args.Control}");
_clickListener2.OnInnerClick += (args) =>
Console.WriteLine($"Outer2 -> Inner {args.Button} {args.X} {args.Y} {args.Shift} {args.Control}");
//
KeyListener _keyListener1 = new KeyListener(_inner1);
_keyListener1.Execute(JSRuntime);
_keyListener1.OnOuterKeyUp += (args) =>
Console.WriteLine($"Outer1 -> Outer {args.Key} {args.TargetID} {args.Shift} {args.Control}");
_keyListener1.OnKeyUp += (args) =>
Console.WriteLine($"Outer1 -> OnKeyUp {args.Key} {args.TargetID} {args.Shift} {args.Control}");
_keyListener1.OnInnerKeyUp += (args) =>
Console.WriteLine($"Outer1 -> OnInnerKeyUp {args.Key} {args.TargetID} {args.Shift} {args.Control}");
//
Tooltip tooltip = new Tooltip(_inner1, "Tooltip on inner 1");
tooltip.Execute(JSRuntime);
Task.Run(() =>
{
Thread.Sleep(1000);
// Utilities.FocusElement(JSRuntime, _text1);
});
}
public void Update(GameTime gameTime)
{
_currentBlinkDelay -= (float)gameTime.ElapsedGameTime.TotalSeconds;
if (_currentBlinkDelay <= 0)
{
_isCursorVisible = !_isCursorVisible;
_currentBlinkDelay = CursorBlinkDelay;
}
KeyListener.Update(gameTime);
MouseListener.Update(gameTime);
}
void Update() {
try {
next = new KeyListener(CustomInput.instance.NextWeaponKey, this.NextWeapon, 0.2f);
prev = new KeyListener(CustomInput.instance.PrevWeaponKey, this.PrevWeapon, 0.2f);
CustomInput.instance.RegDownListener(next);
CustomInput.instance.RegDownListener(prev);
enabled = false;
} catch (UnityException e) {
Debug.LogException(e);
}
}
void Update()
{
try {
next = new KeyListener(CustomInput.instance.NextWeaponKey, this.NextWeapon, 0.2f);
prev = new KeyListener(CustomInput.instance.PrevWeaponKey, this.PrevWeapon, 0.2f);
CustomInput.instance.RegDownListener(next);
CustomInput.instance.RegDownListener(prev);
enabled = false;
} catch (UnityException e) {
Debug.LogException(e);
}
}
private KeyListener GetKeyListener()
{
var target = m_KeyListenerCache;
if (target != null)
{
return(target);
}
target = CreateKeyListener();
m_KeyListenerCache = target;
return(target);
}
public void SubscribeListener(Key key, KeyListener handler)
{
if (Listeners.ContainsKey(key))
{
Listeners[key].Add(handler);
}
else
{
var newList = new List<KeyListener>();
newList.Add(handler);
Listeners.Add(key, newList);
}
}
/// <summary>
/// Change the keybind of a key to a new key
/// </summary>
/// <param name="keyToEdit">Key of bind that is being changed</param>
/// <param name="newKey">New key to bind to</param>
public void EditBind(Keys keyToEdit, Keys newKey)
{
KeyListener listenerToEdit = GetKeyListenerObject(keyToEdit);
if (listenerToEdit != null)
{
listenerToEdit.KeyToListen = newKey;
}
else
{
Console.WriteLine("This key bind does not exist");
}
}
/// <summary>
/// Changes the callback to a keybind
/// </summary>
/// <param name="keyToEdit">Key you are editing the bind of</param>
/// <param name="callback">What will happen when the key is pressed</param>
public void EditBind(Keys keyToEdit, Action <bool, bool> callback)
{
KeyListener listenerToEdit = GetKeyListenerObject(keyToEdit);
if (listenerToEdit != null)
{
listenerToEdit.KeyPressedCallback = callback;
}
else
{
Console.WriteLine("This key bind does not exist");
}
}
/// <summary>
/// Checks to see if key bind exists for key
/// </summary>
/// <param name="keyToFind">The key to check key bind for</param>
/// <returns>true or false</returns>
public bool KeyBindExists(Keys keyToFind)
{
KeyListener keyFound = GetKeyListenerObject(keyToFind);
if (keyFound != null)
{
return(true);
}
else
{
return(false);
}
}
void FixedUpdate()
{
try {
next = new KeyListener(CustomInput.instance.SelectNextKey, this.NextEnemy, 0.2f);
prev = new KeyListener(CustomInput.instance.SelectNextKey, this.PrevEnemy, 0.2f);
spawn = new KeyListener(CustomInput.instance.EnterKey, this.SpawnEnemy, 0.2f);
CustomInput.instance.RegDownListener(next);
CustomInput.instance.RegDownListener(prev);
CustomInput.instance.RegDownListener(spawn);
enabled = false;
} catch (UnityException e) {
}
}
void FixedUpdate() {
try {
next = new KeyListener(CustomInput.instance.SelectNextKey, this.NextEnemy, 0.2f);
prev = new KeyListener(CustomInput.instance.SelectNextKey, this.PrevEnemy, 0.2f);
spawn = new KeyListener(CustomInput.instance.EnterKey, this.SpawnEnemy, 0.2f);
CustomInput.instance.RegDownListener(next);
CustomInput.instance.RegDownListener(prev);
CustomInput.instance.RegDownListener(spawn);
enabled = false;
} catch (UnityException e) {
}
}
public static void Main(string[] args)
{
gameThread = new GameThread();
Thread thread = new Thread(LaunchGameThread);
thread.Start();
KeyListener.Initialize();
while (KeyListener.ReadConsoleKey())
{
;
}
gameThread.Stop();
}
public Player(Scene scene) : base(scene, 0, 0, 0)
{
// Components
base.Use(PlayerImageData);
base.Use(PlayerPhysics);
// Player KeyBinds
KeyListener.AddKeyBind(Key.W, () => { this.Transform.Yvel += -_speed; }, () => { this.Transform.Yvel -= -_speed; });
KeyListener.AddKeyBind(Key.A, () => { this.Transform.Xvel += -_speed; }, () => { this.Transform.Xvel -= -_speed; });
KeyListener.AddKeyBind(Key.S, () => { this.Transform.Yvel += _speed; }, () => { this.Transform.Yvel -= _speed; });
KeyListener.AddKeyBind(Key.D, () => { this.Transform.Xvel += _speed; }, () => { this.Transform.Xvel -= _speed; });
KeyListener.AddKeyBind(Key.Space, () => { Shoot(); });
KeyListener.AddKeyBind(Key.Q, () => { PlayerImage2.State = this; }, () => { PlayerImage1.State = this; });
}
static void Main(string[] args)
{
Dispaly = new Display(1920, 1080);
TestWorld = new Scene();
GameObject Ground = TestWorld.AddGameObject(0, 1000, 0);
// Load Scene Image Data
RenderData SceneImageData = new RenderData();
RenderState GroundImage = SceneImageData.LoadFile("Ground.png");
// Load Player Image Data
PlayerImageData = new RenderData();
PlayerImage1 = PlayerImageData.LoadFile("Test.bmp");
PlayerImage2 = PlayerImageData.LoadFile("StateTest.png");
// Load Projectile Image Data
ProjectileImageData = new RenderData();
ProjectileImageData.LoadFile("Projectile.png");
// Create PhysicsConstraints
PlayerPhysics = new PhysicsConstraints(TestWorld);
StaticPhysics = new PhysicsConstraints(TestWorld);
ProjectilePhysics = new PhysicsConstraints(TestWorld);
PlayerPhysics.Collider = true;
StaticPhysics.Static = true;
ProjectilePhysics.Collider = true;
ProjectilePhysics.OnCollision += OnProjectileCollision;
Player1 = new Player(TestWorld);
Player1_Child = TestWorld.AddGameObject(100, 100, 0);
Player1_Child.Use(PlayerImageData);
Player1_Child.Use(Player1.Transform);
Ground.Use(SceneImageData);
Ground.Use(StaticPhysics);
KeyListener.AddKeyBind(Key.Up, () => { Camera.Yvel += -CameraSpeed; }, () => { Camera.Yvel -= -CameraSpeed; });
KeyListener.AddKeyBind(Key.Left, () => { Camera.Xvel += -CameraSpeed; }, () => { Camera.Xvel -= -CameraSpeed; });
KeyListener.AddKeyBind(Key.Down, () => { Camera.Yvel += CameraSpeed; }, () => { Camera.Yvel -= CameraSpeed; });
KeyListener.AddKeyBind(Key.Right, () => { Camera.Xvel += CameraSpeed; }, () => { Camera.Xvel -= CameraSpeed; });
Debugger.EnableDebugger = true;
Dispaly.Start();
}
/// <summary>
/// Connects a listener to the user's input device.
/// The callback will fire when the Key is pressed by the user.
/// </summary>
/// <param name="keyToListen">The key to listen for press from user</param>
/// <param name="callback">The function that will call when the key is pressed</param>
public void BindKey(Keys keyToListen, Action <bool, bool> callback)
{
//make sure key isnt already connected
KeyListener searchForKey = GetKeyListenerObject(keyToListen);
if (searchForKey == null)
{
KeyListener newBind = new KeyListener(keyToListen, callback);
Listeners.Add(newBind);
}
else
{
Console.WriteLine("This key is already bound");
}
}
public Game(ApplicationContextBase applicationContextBase)
{
_applicationContextBase = applicationContextBase;
_disposables = new List <IDisposable>();
_keyListener = new KeyListener(applicationContextBase);
_inputManager = new InputManager(this);
_tickManager = new TickManager();
_sceneManager = new Scene.SceneManager(this);
_disposables
.Append(_inputManager)
.Append(_keyListener)
.Append(_tickManager)
.Append(_sceneManager);
}
public GLChatSystem() : base()
{
// use junk method for the release callback, since we don't care about it.
listenLeft = new KeyListener(Keys.Left, OnLeftArrow, Junk);
listenRight = new KeyListener(Keys.Right, OnRightArrow, Junk);
//listenUp = new KeyListener(Keys.Up, OnUpArrow, Junk);
//listenDown = new KeyListener(Keys.Down, OnDownArrow, Junk);
InputBuffer = "";
InputDisplay = "";
InputMessageHistory = new List <string>();
CursorPosition = 0;
HistoryPos = 0;
cursorBlinkClock = 0;
}
public MenuResult Update(GameTime gameTime)
{
KeyListener.Update(gameTime);
if (KeyListener.WasKeyPressed(Keys.W) ||
KeyListener.WasKeyPressed(Keys.Up))
{
SelectedIndex--;
if (SelectedIndex < 0)
{
SelectedIndex = MenuItems.Count() - 1;
}
KeyListener.ResetKey(Keys.W);
KeyListener.ResetKey(Keys.Up);
}
else if (KeyListener.WasKeyPressed(Keys.S) ||
KeyListener.WasKeyPressed(Keys.Down))
{
SelectedIndex++;
if (SelectedIndex >= MenuItems.Count())
{
SelectedIndex = 0;
}
KeyListener.ResetKey(Keys.S);
KeyListener.ResetKey(Keys.Down);
}
else if (KeyListener.WasKeyPressed(Keys.Enter))
{
KeyListener.ResetKey(Keys.Enter);
var menuItem = MenuItems[SelectedIndex];
if (menuItem.Definition.SelectAction == MenuAction.Navigate)
{
var result = new MenuResult(menuItem.Definition.SelectAction, menuItem.Definition.MenuName);
return(result);
}
else if (menuItem.Definition.SelectAction == MenuAction.NewGame ||
menuItem.Definition.SelectAction == MenuAction.QuitGame)
{
var result = new MenuResult(menuItem.Definition.SelectAction);
return(result);
}
}
return(null);
}
public MainWindow()
{
InitializeComponent();
InitWindow();
KeyListener = new KeyListener();
guy = new Guy(this, KeyListener, WindowWidth, WindowHeight);
/*
* System.Windows.UIElement img1 = Utils.LoadImage("image/1.png");
* System.Windows.Controls.Canvas.SetLeft(img1, 180);
* System.Windows.Controls.Canvas.SetTop(img1, 180);
*
* System.Windows.UIElement img2 = Utils.LoadImage("image/2.png");
* System.Windows.Controls.Canvas.SetLeft(img2, 180 + 20);
* System.Windows.Controls.Canvas.SetTop(img2, 180);
*
* System.Windows.UIElement img3 = Utils.LoadImage("image/3.png");
* System.Windows.Controls.Canvas.SetLeft(img3, 180);
* System.Windows.Controls.Canvas.SetTop(img3, 180);
*
* System.Windows.UIElement img4 = Utils.LoadImage("image/4.png");
* System.Windows.Controls.Canvas.SetLeft(img4, 180 - 20);
* System.Windows.Controls.Canvas.SetTop(img4, 180);
*
* imgs = new System.Windows.UIElement[4];
* imgs[0] = img1;
* imgs[1] = img2;
* imgs[2] = img3;
* imgs[3] = img4;
*/
bg = Utils.LoadImage("image/chapter/2.jpg");
bgLeft = 0;
canvas = new System.Windows.Controls.Canvas();
canvas.Children.Add(bg);
this.Content = canvas;
this.KeyDown += OnKeyDown;
this.KeyUp += OnKeyUp;
this.Closing += WindowClosing;
guy.Run();
//new System.Threading.Thread(PlaySkill).Start();
new System.Threading.Thread(KeepOnMoveBG).Start();
}
// Use this for initialization
void Awake()
{
if (instance == null)
{
instance = this;
}
else if (instance != this)
{
Destroy(gameObject);
}
// winText.text = "";
player1Listener = (player1.isEnemy)? (KeyListener)gameObject.AddComponent(typeof(AIListener)): (KeyListener)gameObject.AddComponent(typeof(PlayerListener));
player2Listener = (player2.isEnemy)? (KeyListener)gameObject.AddComponent(typeof(AIListener)): (KeyListener)gameObject.AddComponent(typeof(PlayerListener));
player1.tieListener(player1Listener);
player2.tieListener(player2Listener);
}
protected override void Start () {
//base.Start ();
//cockpit.StartRadar ();
if(instance!=null) {
Destroy (gameObject, 0f);
return;
}
instance = this;
thrust = new KeyListener(CustomInput.instance.ThrustKey, this.ThrustEngines);
rotatel = new KeyListener(CustomInput.instance.RotateLKey, this.RotateLeft);
rotater = new KeyListener(CustomInput.instance.RotateRKey, this.RotateRight);
dampen = new KeyListener(CustomInput.instance.DampenKey, this.Dampen);
shoot = new KeyListener(CustomInput.instance.ShootKey, this.FireWeapons);
CustomInput.instance.RegHeldListener(thrust);
CustomInput.instance.RegHeldListener(rotatel);
CustomInput.instance.RegHeldListener(rotater);
CustomInput.instance.RegHeldListener(dampen);
CustomInput.instance.RegHeldListener(shoot);
}
public void RemoveKeyListener(KeyListener listener)
{
_keyListeners.Remove(listener);
}
public void AddKeyListener(KeyListener listener)
{
if (!_keyListeners.Contains(listener))
_keyListeners.Add(listener);
}
void Awake()
{
listener = GetComponent<CharacterManager>();
}
public void RemHeldListener(KeyListener kl) {
keyHeldListeners.Remove(kl);
}
public void RegHeldListener(KeyListener kl) {
keyHeldListeners.Add(kl);
}
public static void AddKeyListener(KeyListener keyListener)
{
keyListeners.Add(keyListener);
}
public void GetDispatchPtr(ref object dispatch_pointer)
{
dispatch_pointer = this;
COTsListener listen = new COTsListener(this);
KeyListener kybdShortcuts = new KeyListener();
}
public void RegUpListener(KeyListener kl) {
keyUpListeners.Add(kl);
}
public void RegDownListener(KeyListener kl) {
keyDownListeners.Add(kl);
}
/// <summary>
/// Adds the specified key listener to receive key events from
/// this component.
/// </summary>
public void addKeyListener(KeyListener @l)
{
}
/// <summary>
/// Removes the specified key listener so that it no longer
/// receives key events from this component.
/// </summary>
public void removeKeyListener(KeyListener @l)
{
}
public static void RemoveKeyListener(KeyListener keyListener)
{
keyListeners.Remove(keyListener);
}
void Awake()
{
listener = (KeyListener)gameObject.GetComponent<CharacterManager>();
}
public void AddKeyListener(KeyListener k)
{
if (k != null)
{
if (keys == null)
{
keys = new List<KeyListener>(10);
}
keys.Add(k);
}
useKeyListener = (keys != null && keys.Count > 0);
}
public void RemUpListener(KeyListener kl) {
keyUpListeners.Remove(kl);
}
public void RemDownListener(KeyListener kl) {
keyDownListeners.Remove(kl);
}
public void RemoveKeyListener(KeyListener k)
{
if (keys == null)
{
return;
}
if (k != null)
{
keys.Remove(k);
}
useKeyListener = (keys != null && keys.Count > 0);
}
