private void UpdateButton(XnaInput.ButtonState newState, GamePadButton button)
{
var buttonIndex = (int)button;
states[buttonIndex] =
states[buttonIndex].UpdateOnNativePressing(newState == XnaInput.ButtonState.Pressed);
}
public void UpdateButtonState(MouseButtons button, ButtonState state)
{
if (button == MouseButtons.None || ButtonStates[button] == state && !_alwaysNotify) return;
ButtonStates[button] = state;
_doNotify = true;
}
internal static void ApplyHandler(CursorInputHandler handler)
{
SetPosition(handler.Position);
if (handler.Left != null)
{
MouseLeft = handler.Left.Value;
}
if (handler.Right != null)
{
MouseRight = handler.Right.Value;
}
if (handler.Middle != null)
{
MouseMiddle = handler.Middle.Value;
}
if (handler.Back != null)
{
MouseBack = handler.Back.Value;
}
if (handler.Forward != null)
{
MouseForward = handler.Forward.Value;
}
}
internal static void PostProcessButtons()
{
if (Player.Playing && ConfigManager.sMouseDisableButtons)
{
ResetStatus();
}
else
{
//handle back/forward buttons on mouse.
if (GameBase.Instance.IsActive && GameBase.Mode != OsuModes.Edit && GameBase.Mode != OsuModes.Menu)
{
if (MouseBack == ButtonState.Pressed && mouseBackLast != MouseBack)
{
KeyboardHandler.DoKeyPressed(Microsoft.Xna.Framework.Input.Keys.Escape);
}
mouseBackLast = MouseBack;
if (MouseForward == ButtonState.Pressed && mouseForwardLast != MouseForward)
{
KeyboardHandler.DoKeyPressed(BindingManager.For(Bindings.Skip));
}
mouseForwardLast = MouseForward;
}
}
}
void MouseViaKeyboardControls()
{
leftButton1 |= keyboard.IsKeyDown(ConfigManager.sKeyboardBind1);
leftButton2 |= keyboard.IsKeyDown(ConfigManager.sKeyboardBind3);
rightButton1 |= keyboard.IsKeyDown(ConfigManager.sKeyboardBind2);
rightButton2 |= keyboard.IsKeyDown(ConfigManager.sKeyboardBind4);
leftButton1i |= leftButton1 && (!MouseButtonInstantRelease || !keyboardLast.IsKeyDown(ConfigManager.sKeyboardBind1));
leftButton2i |= leftButton2 && (!MouseButtonInstantRelease || !keyboardLast.IsKeyDown(ConfigManager.sKeyboardBind3));
rightButton1i |= rightButton1 && (!MouseButtonInstantRelease || !keyboardLast.IsKeyDown(ConfigManager.sKeyboardBind2));
rightButton2i |= rightButton2 && (!MouseButtonInstantRelease || !keyboardLast.IsKeyDown(ConfigManager.sKeyboardBind4));
if ((leftButton2i || leftButton1i) && !ReplayMode && GameBase.Mode == Modes.Play &&
!(Player.Paused && ChatEngine.IsVisible))
{
leftButton = ButtonState.Pressed;
//MouseHandler.mouseLeft = ButtonState.Pressed;
}
if ((rightButton1i || rightButton2i) && !ReplayMode &&
GameBase.Mode == Modes.Play && !(Player.Paused && ChatEngine.IsVisible))
{
rightButton = ButtonState.Pressed;
//MouseHandler.mouseRight = ButtonState.Pressed;
}
}
private void MapButtonValue(XNAInput.ButtonState previousXnaButton, XNAInput.ButtonState xnaButton, MappingButtons button)
{
// Mapping
bool isDown = false;
bool isPressed = false;
bool isReleased = false;
if (xnaButton == XNAInput.ButtonState.Pressed)
{
isDown = true;
if (previousXnaButton == XNAInput.ButtonState.Released)
{
isPressed = true;
}
}
else if (xnaButton == XNAInput.ButtonState.Released)
{
if (previousXnaButton == XNAInput.ButtonState.Pressed)
{
isReleased = true;
}
}
SetMappingValue(button, isDown, isPressed, isReleased);
}
internal static void ResetStatus()
{
mouseLeft = ButtonState.Released;
_left = ButtonState.Released;
mouseRight = ButtonState.Released;
_right = ButtonState.Released;
mouseMiddle = ButtonState.Released;
_middle = ButtonState.Released;
}
private void SetMouseButtonState(MouseButtons button, Microsoft.Xna.Framework.Input.ButtonState state)
{
mouse = new MouseState(mouse.X, mouse.Y, mouse.ScrollWheelValue,
(button == MouseButtons.Left) ? state : mouse.LeftButton,
(button == MouseButtons.Middle) ? state : mouse.MiddleButton,
(button == MouseButtons.Right) ? state : mouse.RightButton,
(button == MouseButtons.XButton1) ? state : mouse.XButton1,
(button == MouseButtons.XButton2) ? state : mouse.XButton2
);
SubmitMouseState();
}
private ButtonState AdaptButtonState(Microsoft.Xna.Framework.Input.ButtonState xnaButtonState)
{
switch (xnaButtonState)
{
case Microsoft.Xna.Framework.Input.ButtonState.Pressed:
return(ButtonState.PRESSED);
case Microsoft.Xna.Framework.Input.ButtonState.Released:
default:
return(ButtonState.RELEASED);
}
}
public static bool MenuIspressed()
{
Microsoft.Xna.Framework.Input.ButtonState state = Mouse.GetState().LeftButton;
int mx = Mouse.GetState().X;
int my = Mouse.GetState().Y;
if (mx >= _xpos && mx <= _xpos + _xsize && my >= _ypos && my <= _ypos + _ysize)
{
return(true);
}
return(false);
}
/// <summary>
/// Updates the active button states from internally set values. If any button has changed, then this returns true.
/// </summary>
internal static bool UpdateButtons()
{
if (mouseLeft != _left || mouseRight != _right || mouseMiddle != _middle || mouseBack != _back || mouseForward != _forward)
{
mouseLeft = _left;
mouseRight = _right;
mouseMiddle = _middle;
mouseBack = _back;
mouseForward = _forward;
return(true);
}
return(false);
}
public void ProcessButtons(ButtonState mouseButtonState, Point cursorPoint)
{
foreach (var button in Elements)
if (Utils.CursorInArea(cursorPoint, button.GetBounds()))
{
if (mouseButtonState == ButtonState.Pressed && !MouseButtonToRelease)
{
button.DoClick();
MouseButtonToRelease = true;
}
else if (mouseButtonState == ButtonState.Released)
MouseButtonToRelease = false;
button.PerformAction("mouseover", new List<object>{ true });
}
else button.PerformAction("mouseover", new List<object> { false });
}
public bool ShowCityMenu()
{
Microsoft.Xna.Framework.Input.ButtonState state = Mouse.GetState().LeftButton;
if (state == Microsoft.Xna.Framework.Input.ButtonState.Pressed)
{
int mx = Mouse.GetState().X;
int my = Mouse.GetState().Y;
//cancel is 27 pix right corner / substract
int rangex1 = _xpos + _width;
int rangey = _ypos;
if (mx <= rangex1 && mx >= rangex1 - _cancelsize && my <= rangey + _cancelsize && my >= rangey)
{
return(false);
}
}
return(true);
}
private static bool GetMouseButtonInState(MouseState state, int button, ButtonState buttonState)
{
var inState = false;
switch ((MouseButton)button)
{
case MouseButton.Left:
inState = state.LeftButton == buttonState;
break;
case MouseButton.Right:
inState = state.RightButton == buttonState;
break;
case MouseButton.Middle:
inState = state.MiddleButton == buttonState;
break;
}
return(inState);
}
protected override void Update(GameTime gameTime)
{
updateGamePadState();
// Check for enable/disable
if (currentGamePadState.Buttons.Start == ButtonState.Pressed && currentGamePadState.Buttons.Back == ButtonState.Pressed &&
currentGamePadState.Buttons.LeftShoulder == ButtonState.Pressed && currentGamePadState.Buttons.RightShoulder == ButtonState.Pressed)
{
if (previousGamePadState.Buttons.Start == ButtonState.Released || previousGamePadState.Buttons.Back == ButtonState.Released ||
previousGamePadState.Buttons.LeftShoulder == ButtonState.Released || previousGamePadState.Buttons.RightShoulder == ButtonState.Released)
{
inputDisabled = !inputDisabled;
}
}
if (!inputDisabled)
{
// Apply cursor translation
int cursorTranslateX = (int)(gameTime.ElapsedGameTime.Milliseconds * currentGamePadState.ThumbSticks.Left.X);
int cursorTranslateY = (int)(gameTime.ElapsedGameTime.Milliseconds * currentGamePadState.ThumbSticks.Left.Y * -1);
inputSim.Mouse.MoveMouseBy(cursorTranslateX, cursorTranslateY);
// Simulate LMB-click if A is pressed
if (currentGamePadState.Buttons.A == ButtonState.Pressed && previousGamePadState.Buttons.A == ButtonState.Released)
{
inputSim.Mouse.LeftButtonDown();
}
else if (currentGamePadState.Buttons.A == ButtonState.Released && previousGamePadState.Buttons.A == ButtonState.Pressed)
{
inputSim.Mouse.LeftButtonUp();
}
// Simulate RMB-click if X is pressed
if (currentGamePadState.Buttons.X == ButtonState.Pressed && previousGamePadState.Buttons.X == ButtonState.Released)
{
inputSim.Mouse.RightButtonDown();
}
else if (currentGamePadState.Buttons.X == ButtonState.Released && previousGamePadState.Buttons.X == ButtonState.Pressed)
{
inputSim.Mouse.RightButtonUp();
}
// Simulate arrow keys for the d-pad
ButtonState[] currentDirectionState = new ButtonState[4] {
currentGamePadState.DPad.Up, currentGamePadState.DPad.Down,
currentGamePadState.DPad.Left, currentGamePadState.DPad.Right
};
ButtonState[] previousDirectionState = new ButtonState[4] {
previousGamePadState.DPad.Up, previousGamePadState.DPad.Down,
previousGamePadState.DPad.Left, previousGamePadState.DPad.Right
};
for (int dir = 0; dir < 4; dir++)
{
if (currentDirectionState[dir] == ButtonState.Pressed)
{
if (previousDirectionState[dir] == ButtonState.Released)
{
inputSim.Keyboard.KeyPress(keycode[dir]);
lastRepeatTime[dir] = gameTime.TotalGameTime.TotalMilliseconds;
}
else
{
if (!repeating[dir])
{
if (gameTime.TotalGameTime.TotalMilliseconds - lastRepeatTime[dir] > 500)
{
inputSim.Keyboard.KeyPress(keycode[dir]);
lastRepeatTime[dir] = gameTime.TotalGameTime.TotalMilliseconds;
repeating[dir] = true;
}
}
else
{
if (gameTime.TotalGameTime.TotalMilliseconds - lastRepeatTime[dir] > 50)
{
inputSim.Keyboard.KeyPress(keycode[dir]);
lastRepeatTime[dir] = gameTime.TotalGameTime.TotalMilliseconds;
}
}
}
}
else
{
repeating[dir] = false;
}
}
// Simulate alt tab for the left trigger
if (currentGamePadState.Triggers.Left > 0.5 && previousGamePadState.Triggers.Left <= 0.5)
{
inputSim.Keyboard.KeyDown(VirtualKeyCode.MENU);
inputSim.Keyboard.KeyPress(VirtualKeyCode.TAB);
}
else if (currentGamePadState.Triggers.Left <= 0.5 && previousGamePadState.Triggers.Left > 0.5)
{
inputSim.Keyboard.KeyUp(VirtualKeyCode.MENU);
}
// Simulate scrolling for right thumbstick
if (currentGamePadState.ThumbSticks.Right.X != 0)
{
if (previousGamePadState.ThumbSticks.Right.X == 0 ||
gameTime.TotalGameTime.TotalMilliseconds - lastScrollTimeHorizontal > 200 - 160 * Math.Abs(currentGamePadState.ThumbSticks.Right.X))
{
inputSim.Mouse.HorizontalScroll(Math.Sign(currentGamePadState.ThumbSticks.Right.X));
lastScrollTimeHorizontal = gameTime.TotalGameTime.TotalMilliseconds;
}
}
if (currentGamePadState.ThumbSticks.Right.Y != 0)
{
if (previousGamePadState.ThumbSticks.Right.Y == 0 ||
gameTime.TotalGameTime.TotalMilliseconds - lastScrollTimeVertical > 200 - 160 * Math.Abs(currentGamePadState.ThumbSticks.Right.Y))
{
inputSim.Mouse.VerticalScroll(Math.Sign(currentGamePadState.ThumbSticks.Right.Y));
lastScrollTimeVertical = gameTime.TotalGameTime.TotalMilliseconds;
}
}
}
base.Update(gameTime);
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
protected override void Update(GameTime gameTime)
{
// Allows the game to exit
if (GamePad.GetState(PlayerIndex.One).Buttons.Back == Microsoft.Xna.Framework.Input.ButtonState.Pressed)
this.Exit();
// TODO: Add your update logic here
stage1.Update(mouseState, keyState, gameTime);
stage2.Update(mouseState, keyState, gameTime);
keyState = Keyboard.GetState();
mouseState = Mouse.GetState();
menu.Update(gameTime, this, keyState, mouseState);
keyOState = keyState;
Camerascroll.Update(gameTime, Player.staticHitbox);
// Particle modification
particleComponent.particleEmitterList[0].Position = new Vector2((float)mouseState.X, (float)mouseState.Y);
if (mouseState.LeftButton == Microsoft.Xna.Framework.Input.ButtonState.Pressed && lastButtonState != Microsoft.Xna.Framework.Input.ButtonState.Pressed)
{
particleComponent.particleEmitterList[0].Active = !particleComponent.particleEmitterList[0].Active;
}
lastButtonState = mouseState.LeftButton;
Emitter t2 = particleComponent.particleEmitterList[1];
t2.Position = new Vector2((float)random.NextDouble() * (graphics.GraphicsDevice.Viewport.Width), 0);
if (t2.EmittedNewParticle)
{
float f = MathHelper.ToRadians(t2.LastEmittedParticle.Direction + 180);
t2.LastEmittedParticle.Rotation = f;
}
base.Update(gameTime);
}
/// <summary>
/// This is called when the game should draw itself.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
protected override void Draw(GameTime gameTime)
{
_spriteBatch.Begin();
if (_intro.Showintro)
{
_intro.DrawIntro(_spriteBatch);
}
else
{
_spriteBatch.Draw(_textures[CONSTANTS.TXT_YEAR_MENU], new Vector2(0, 0), Color.White);
_spriteBatch.DrawString(_status.Font, "Year:" + _round.ToString(), new Vector2(10, 15), Color.Red);
DrawMap(gameTime);
if (_showcityMenu && _activeCity != null)
{
_cityMenu.DrawCityMenu(_spriteBatch, _activeCity);
_showcityMenu = _cityMenu.ShowCityMenu();
}
Microsoft.Xna.Framework.Input.ButtonState state = Mouse.GetState().RightButton;
if (state == Microsoft.Xna.Framework.Input.ButtonState.Pressed)
{
MapPosition pos = _mouse.GetMouseMapPosition(_status);
if (pos != null)
{
this.Window.Title = "Pressed" + pos.TID + "POS X" + pos.XPos + ".POS Y" + pos.YPos;
City cit = _cities.Find(o => o.MapPosition.XPos == pos.XPos && o.MapPosition.YPos == pos.YPos);
if (cit != null)
{
this.Window.Title = cit.Name;
_activeCity = cit;
_showcityMenu = true;
}
}
}
state = Mouse.GetState().LeftButton;
if (state == Microsoft.Xna.Framework.Input.ButtonState.Pressed)
{
if (Menu.MenuIspressed() == true && !_counterprotect)
{
//todo Protect Counting up with - mouse State Year Combination
_round++;
_counterprotect = true;
}
}
//prevent Years from Counting UP
if (state == Microsoft.Xna.Framework.Input.ButtonState.Released)
{
_counterprotect = false;
}
_mouse.DrawTheMouse(_spriteBatch, GraphicsDevice, _status);
}
_spriteBatch.End();
}
public void ActivateMouseEvent(int mx, int my, ButtonState state, MouseButtons button)
{
//foreach (IGUIMapper mapper in mappers)
// mapper.MouseEventHandler(mx, my, state, button);
}
private void CheckBox_MouseClick(object sender, Vector2 location, MouseButtons button, Microsoft.Xna.Framework.Input.ButtonState state)
{
if (button == MouseButtons.Left && state == ButtonState.Released)
{
Checked = !@checked;
}
}
//any controls other than pan and zoom
private void HandleInput()
{
if (MainForm.ApplicationIsActivated())
{
MouseState mouseState = Mouse.GetState();
//DETECT MOUSE UP AND DOWN
rMouseDown = false;
rMouseUp = false;
lMouseDown = false;
lMouseUp = false;
bool spaceDown = false;
bool delDown = false;
bool dDown = false;
#region button up/down checks;
if (kbState.IsKeyDown(Microsoft.Xna.Framework.Input.Keys.D) &&
oldKbState.IsKeyUp(Microsoft.Xna.Framework.Input.Keys.D))
{
dDown = true;
}
else
{
dDown = false;
}
if (kbState.IsKeyDown(Microsoft.Xna.Framework.Input.Keys.Space) &&
oldKbState.IsKeyUp(Microsoft.Xna.Framework.Input.Keys.Space))
{
spaceDown = true;
}
else
{
spaceDown = false;
}
if (kbState.IsKeyDown(Microsoft.Xna.Framework.Input.Keys.Delete) &&
oldKbState.IsKeyUp(Microsoft.Xna.Framework.Input.Keys.Delete))
{
delDown = true;
}
else
{
delDown = false;
}
if (lastRMouse != mouseState.RightButton)
{
if (lastRMouse == Microsoft.Xna.Framework.Input.ButtonState.Released)
{
rMouseDown = true;
}
if (lastRMouse == Microsoft.Xna.Framework.Input.ButtonState.Pressed)
{
rMouseUp = true;
}
}
if (lastLMouse != mouseState.LeftButton)
{
if (lastLMouse == Microsoft.Xna.Framework.Input.ButtonState.Released)
{
lMouseDown = true;
}
if (lastLMouse == Microsoft.Xna.Framework.Input.ButtonState.Pressed)
{
lMouseUp = true;
}
}
#endregion
#region mouse input handling
if (ClientRectangle.Contains(PointToClient(Control.MousePosition))) //if mouse position is over the control
{
if (!this.Focused && mouseState.LeftButton == Microsoft.Xna.Framework.Input.ButtonState.Pressed)
{
this.Focus(); //if not in focus, and left click is on control: give controlfocus
}
else //control is in focus
{
if (delDown)
{
parentForm.DeleteSelected();
}
if (parentForm.selectedToolTreeNode.Index == 0)//led is selected
{
#region ledMode
if (lMouseDown)
{
AddNewMasses(new Vector2(GetMousePos().X, GetMousePos().Y));
}
#endregion
}
else if (parentForm.selectedToolTreeNode.Index == 1) //select is selected
{
#region selectMode
bool offMass = false;
if (lMouseDown && selectedMass != null)
{
foreach (SimString massString in stringLists)
{
foreach (SimMass mass in massString.MassList)
{
if (!(GetMousePos().X > mass.CurrPositionX - (massTexture.Width / 2) - 5f &&
GetMousePos().X < mass.CurrPositionX + (massTexture.Width / 2) + 5f &&
GetMousePos().Y > mass.CurrPositionY - (massTexture.Height / 2) - 5f &&
GetMousePos().Y < mass.CurrPositionY + (massTexture.Height / 2) + 5f)) // deteect of mouse down over a mass
{
offMass = true;
}
}
}
if (offMass) //click was not on a mass
{
if (selectedMass.SimObjectType == SimObjectType.PASSIVETEMP)
{
selectedMass.SimObjectType = SimObjectType.ACTIVE;
}
ClearSelection();
offMass = false;
}
}
if (lMouseDown && selectedMass == null)
{
SimMass newMass = null;
SimString newString = null;
foreach (SimString massString in stringLists)
{
foreach (SimMass mass in massString.MassList)
{
if (GetMousePos().X > mass.CurrPositionX - (massTexture.Width / 2) - 5f &&
GetMousePos().X < mass.CurrPositionX + (massTexture.Width / 2) + 5f &&
GetMousePos().Y > mass.CurrPositionY - (massTexture.Height / 2) - 5f &&
GetMousePos().Y < mass.CurrPositionY + (massTexture.Height / 2) + 5f) // deteect of mouse down over a mass
{
//mouse click was on a mass
newMass = mass;
newString = massString;
}
}
}
if (newMass != null && newString != null)
{
MakeSelection(newMass, newString);
}
}
if (dDown)
{
if (selectedMass != null)
{
if (selectedMass.SimObjectType == SimObjectType.PASSIVETEMP)
{
selectedMass.SimObjectType = SimObjectType.ACTIVE;
}
}
ClearSelection();
parentForm.saveState();
}
if ((spaceDown || rMouseDown) && selectedMass != null)
{
if (selectedMass.SimObjectType == SimObjectType.PASSIVETEMP) //toggle (temp)passive/active
{
selectedMass.SimObjectType = SimObjectType.PASSIVE;
}
else
{
selectedMass.SimObjectType = SimObjectType.PASSIVETEMP;
}
parentForm.saveState();
}
if (mouseState.LeftButton == Microsoft.Xna.Framework.Input.ButtonState.Pressed)
{
if (selectedMass != null) //if left mouse held and mass is selected, mass is being moved
{
selectedMass.CurrPosition = GetMousePos();
if (selectedMass.SimObjectType == SimObjectType.ACTIVE)
{
selectedMass.SimObjectType = SimObjectType.PASSIVETEMP;
}
}
}
#endregion
}
else if (parentForm.selectedToolTreeNode.Index == 2) //rectangle select is selected
{
#region rectSelectMode
if (lMouseDown)
{
startVector = new Vector2(this.PointToClient(Control.MousePosition).X, this.PointToClient(Control.MousePosition).Y);
}
if (mouseState.LeftButton == Microsoft.Xna.Framework.Input.ButtonState.Pressed)
{
Vector2 endVector = new Vector2(this.PointToClient(Control.MousePosition).X, this.PointToClient(Control.MousePosition).Y);
int rectWidth = (int)(this.PointToClient(Control.MousePosition).X - startVector.X);
int rectHeight = (int)(this.PointToClient(Control.MousePosition).Y - startVector.Y);
Vector2 startVectorTrans = TransformPos(startVector);
Vector2 endVectorTrans = TransformPos(endVector);
Vector2 rectVector;
if (endVectorTrans.Length() > startVectorTrans.Length())
{
rectVector = endVectorTrans - startVectorTrans;
}
else
{
rectVector = startVectorTrans - endVectorTrans;
}
selectionRectangle = new Rectangle((int)startVectorTrans.X, (int)startVectorTrans.Y, (int)rectVector.X, (int)rectVector.Y);
spriteBatch.Begin();
spriteBatch.DrawRectangle(new Rectangle((int)startVector.X, (int)startVector.Y, rectWidth, rectHeight), Color.Black);
spriteBatch.End();
}
if (lMouseUp)
{
//check if any masses are inside rectangle
ObjectGroup currentGroup = new ObjectGroup();
foreach (SimString massString in stringLists)
{
foreach (SimMass mass in massString.MassList)
{
if (selectionRectangle.Contains(new Point((int)mass.CurrPositionX, (int)mass.CurrPositionY)))
{
mass.Selected = true;
foreach (SimMass sMass in massString.MassList)
{
sMass.Selected = true;
}
}
}
}
}
if (dDown)
{
foreach (SimString massString in stringLists)
{
foreach (SimMass mass in massString.MassList)
{
mass.Selected = false;
}
}
}
if (spaceDown || rMouseDown)
{
foreach (SimString massString in stringLists)
{
foreach (SimMass mass in massString.MassList)
{
if (mass.Selected)
{
if (mass.SimObjectType == SimObjectType.ACTIVE || mass.SimObjectType == SimObjectType.PASSIVETEMP)
{
mass.SimObjectType = SimObjectType.GROUPPASSIVE;
}
else if (mass.SimObjectType == SimObjectType.GROUPPASSIVE)
{
mass.SimObjectType = SimObjectType.ACTIVE;
}
}
}
}
}
#endregion
}
}
}
#endregion
oldKbState = kbState;
lastLMouse = mouseState.LeftButton;
lastRMouse = mouseState.RightButton;
spaceDown = false;
}
}
protected override void Initialize()
{
this.Dock = DockStyle.Fill;
//Init camera and dimensions
this.worldDimensions = new Rectangle(0, 0, this.Width, this.Height);
previousScroll = Mouse.GetState().ScrollWheelValue;
zoomIncrement = 0.01f;
camera = new Camera(GraphicsDevice.Viewport, (int)worldDimensions.Width * worldSizeMultiplier, (int)worldDimensions.Height * worldSizeMultiplier, 1f);
numOfMasses = 80;
ContentManager content = new ContentManager(Services);
content.RootDirectory = "Content";
massTexture = content.Load <Texture2D>("Image1");
selectedTexture = content.Load <Texture2D>("selectedRing");
spriteBatch = new SpriteBatch(GraphicsDevice);
selectedMass = null;
lastLMouse = Microsoft.Xna.Framework.Input.ButtonState.Released;
lastRMouse = Microsoft.Xna.Framework.Input.ButtonState.Released;
//area selection
startVector = new Vector2();
//group list
objectGroupList = new List <ObjectGroup>();
// Start the animation timer.
timer = new Timer();
timer.Interval = 1;
timer.Tick += Tick;
timer.Start();
//create simulation
springSim = new Simulation(this);
springSim.Stiffness = stiffness;
springSim.Damping = damping;
springSim.Length = 10f;
springSim.MassPerString = numOfMasses;
stringLists = new List <SimString>();
//add forces
gravity = new Gravity(new Vector2(0f, 9.81f));
springSim.AddGlobalForceGenerator(gravity);
air = new Medium(0.5f);
springSim.AddGlobalForceGenerator(air);
barrier = new ControlSide(new Rectangle(worldDimensions.X, worldDimensions.Y,
worldDimensions.Width * worldSizeMultiplier, worldDimensions.Height * worldSizeMultiplier));
springSim.AddGlobalForceGenerator(barrier);
//add integrator
integrator = new ForwardEulerIntegrator(this);
springSim.Integrator = integrator;
parentForm.saveState();
}
internal static void UpdateFrame()
{
if (GameBase.MenuActive)
{
return;
}
MouseHandler.UpdateWindowsMouse();
if (doubleClickTime > 0)
{
doubleClickTime = (int)Math.Max(0, doubleClickTime - GameBase.ElapsedMilliseconds);
}
//Initialises the current input/processing loop frame. In the case of 2x replays, up to two frames may be processed in a single game tick.
int loopFrame = 0;
if (ConfigManager.sMouseSpeed != 1 && GameBase.Mode != Modes.Edit)
{
//Handle mouse velocity setting.
MouseState newState = Mouse.GetState();
if (Game.IsActive && newState.X >= 0 && newState.X < GameBase.WindowWidth && newState.Y >= 0 &&
newState.Y < GameBase.WindowHeight)
{
#if newmouse
Vector2 newMouseVelocityFloat = new Vector2((float)(mouseVelocityFloat.X + (newState.X - mouseVelocityFloat.X) * ConfigManager.sMouseSpeed),
(float)(mouseVelocityFloat.Y + (newState.Y - mouseVelocityFloat.Y) * ConfigManager.sMouseSpeed));
if (mouseVelocityPoint.X != newState.X || mouseVelocityPoint.Y != newState.Y)
{
mouseVelocityFloat = newMouseVelocityFloat;
mouseVelocityPoint = new Point((int)Math.Round(mouseVelocityFloat.X),
(int)Math.Round(mouseVelocityFloat.Y));
if (GameBase.WindowRectangle.Contains(mouseVelocityPoint))
{
Mouse.SetPosition(mouseVelocityPoint.X, mouseVelocityPoint.Y);
}
}
#else
Mouse.SetPosition((int)Math.Round(mouse.X + (newState.X - mouse.X) * ConfigManager.sMouseSpeed),
(int)Math.Round(mouse.Y + (newState.Y - mouse.Y) * ConfigManager.sMouseSpeed));
#endif
/*MouseHandler.MousePoint.X += (int)((newState.X - mouse.X) * MouseHandler.mouseSpeed);
* MouseHandler.MousePoint.Y += (int)((newState.Y - mouse.Y) * MouseHandler.mouseSpeed);
*
* if (!Player.Playing && !GameBase.graphics.IsFullScreen && ( MouseHandler.MousePoint.X < 0 || MouseHandler.MousePoint.X >= GameBase.WindowWidth || MouseHandler.MousePoint.Y < 0 || MouseHandler.MousePoint.Y >= GameBase.WindowHeight))
* Mouse.SetPosition(MouseHandler.MousePoint.X, MouseHandler.MousePoint.Y);
*
* mouse = newState;*/
mouse = Mouse.GetState();
MouseHandler.MousePosition.X = mouse.X;
MouseHandler.MousePosition.Y = mouse.Y;
MouseHandler.MousePoint.X = mouse.X;
MouseHandler.MousePoint.Y = mouse.Y;
}
else
{
mouse = newState;
MouseHandler.MousePosition.X = mouse.X;
MouseHandler.MousePosition.Y = mouse.Y;
MouseHandler.MousePoint.X = mouse.X;
MouseHandler.MousePoint.Y = mouse.Y;
}
}
else
{
mouse = Mouse.GetState();
MouseHandler.MousePosition.X = mouse.X;
MouseHandler.MousePosition.Y = mouse.Y;
MouseHandler.MousePoint.X = mouse.X;
MouseHandler.MousePoint.Y = mouse.Y;
}
if (!Player.Playing || !ConfigManager.sMouseDisableButtons)
{
MouseHandler.mouseLeft = mouse.LeftButton;
if (TabletHandler.pendingTabletUpdate)
{
//Make sure we accept a tablet click even when it is release in under 16ms.
MouseHandler.mouseLeft = ButtonState.Pressed;
TabletHandler.pendingTabletUpdate = false;
}
else if (TabletHandler.tabletLeft == ButtonState.Pressed)
{
MouseHandler.mouseLeft = TabletHandler.tabletLeft;
}
MouseHandler.mouseRight = mouse.RightButton;
MouseHandler.mouseMiddle = mouse.MiddleButton;
MouseHandler.mouseBack = mouse.XButton1;
if (Game.IsActive && GameBase.Mode != Modes.Edit && GameBase.Mode != Modes.Menu)
{
if (MouseHandler.mouseBack == ButtonState.Pressed && MouseHandler.mouseBackLast != MouseHandler.mouseBack)
{
KeyboardHandler.DoKeyPressed(Keys.Escape);
}
MouseHandler.mouseBackLast = MouseHandler.mouseBack;
}
}
else
{
MouseHandler.mouseLeft = ButtonState.Released;
MouseHandler.mouseRight = ButtonState.Released;
}
bool runningSlow = false;
do
{
AudioEngine.Update();
lock (StreamingManager.LockReplayScore)
{
if (ReplayMode && ReplayScore != null && ReplayScore.replay != null)
{
int count = ReplayScore.replay.Count;
if (GameBase.Mode == Modes.Play && Player.currentScore != null &&
count > 0 &&
ReplayFrame < count - 2 &&
(ReplayToEnd || !ReplayStreaming ||
ReplayScore.replay[count - 1].time - AudioEngine.Time > 1000))
{
Buffering = false;
/* if (ReplayStreaming && !Player.IsFailed && Player.Paused)
* Buffering = false;
* else
* {*/
if (ReplayFrame < count - 2 &&
(ReplayScore.replay[ReplayFrame + 1].time <= AudioEngine.Time))
// && (Math.Abs(ReplayScore.replay[ReplayFrame + 1].time - AudioEngine.Time) < 10 || AudioEngine.Time - ReplayScore.replay[ReplayFrame + 1].time > 0))
{
ReplayFrame++;
ReplayOk = true;
}
else
{
ReplayOk = false;
}
runningSlow = AudioEngine.Time - ReplayScore.replay[ReplayFrame].time > 16 && ReplayOk;
//skip unnecessary frames
if (runningSlow)
{
while (ReplayFrame < count - 2 && !ReplayScore.replay[ReplayFrame].mouseLeft &&
!ReplayScore.replay[ReplayFrame].mouseRight &&
ReplayScore.replay[ReplayFrame + 1].time <= AudioEngine.Time &&
ReplayScore.replay[ReplayFrame].mouseLeft == leftButtonLastBool &&
ReplayScore.replay[ReplayFrame].mouseRight == rightButtonLastBool &&
ReplayScore.replay[ReplayFrame].buttonState == lastButtonState &&
!Player.IsSpinning)
{
Console.WriteLine("replay frame {0} skipped!!!!", ReplayFrame);
ReplayFrame++;
}
}
Vector2 pos;
if (MouseButtonInstantRelease)
{
leftButton1i = false;
leftButton2i = false;
rightButton1i = false;
rightButton2i = false;
leftButton = ButtonState.Released;
rightButton = ButtonState.Released;
}
if (ReplayOk &&
(ReplayScore.replay[ReplayFrame].mouseLeft ||
ReplayScore.replay[ReplayFrame].mouseRight ||
ReplayScore.replay[ReplayFrame].buttonState != lastButtonState ||
Player.IsSpinning))
{
AudioEngine.Time = ReplayScore.replay[ReplayFrame].time;
leftButton1i = (!MouseButtonInstantRelease || !leftButton1) && ReplayScore.replay[ReplayFrame].mouseLeft1;
leftButton1 = ReplayScore.replay[ReplayFrame].mouseLeft1;
leftButton2i = (!MouseButtonInstantRelease || !leftButton2) && ReplayScore.replay[ReplayFrame].mouseLeft2;
leftButton2 = ReplayScore.replay[ReplayFrame].mouseLeft2;
rightButton1i = (!MouseButtonInstantRelease || !rightButton1) && ReplayScore.replay[ReplayFrame].mouseRight1;
rightButton1 = ReplayScore.replay[ReplayFrame].mouseRight1;
rightButton2i = (!MouseButtonInstantRelease || !rightButton2) && ReplayScore.replay[ReplayFrame].mouseRight2;
rightButton2 = ReplayScore.replay[ReplayFrame].mouseRight2;
leftButton = leftButton1i || leftButton2i ? ButtonState.Pressed : ButtonState.Released;
rightButton = rightButton1i || rightButton2i ? ButtonState.Pressed : ButtonState.Released;
pos =
GameBase.GamefieldToDisplay(
new Vector2(ReplayScore.replay[ReplayFrame].mouseX,
ReplayScore.replay[ReplayFrame].mouseY));
// *WindowWidth / ReplayScore.resolution;
lastButtonState = ReplayScore.replay[ReplayFrame].buttonState;
}
else if (ReplayScore.replay[ReplayFrame].time == ReplayScore.replay[ReplayFrame + 1].time)
{
pos =
GameBase.GamefieldToDisplay(
new Vector2(ReplayScore.replay[ReplayFrame].mouseX,
ReplayScore.replay[ReplayFrame].mouseY));
}
else if (ReplayScore.replay[ReplayFrame].time >= AudioEngine.Time)
{
int p1 = Math.Max(0, ReplayFrame - 1);
int p2 = ReplayFrame;
pos =
Vector2.Lerp(
GameBase.GamefieldToDisplay(
new Vector2(ReplayScore.replay[p1].mouseX, ReplayScore.replay[p1].mouseY)),
GameBase.GamefieldToDisplay(
new Vector2(ReplayScore.replay[p2].mouseX, ReplayScore.replay[p2].mouseY)),
Math.Max(0,
(
1 - (float)(ReplayScore.replay[p2].time - AudioEngine.Time) /
(ReplayScore.replay[p2].time - ReplayScore.replay[p1].time))));
if (!MouseButtonInstantRelease)
{
leftButton = ReplayScore.replay[p2].mouseLeft
? ButtonState.Pressed
: ButtonState.Released;
rightButton = ReplayScore.replay[p2].mouseRight
? ButtonState.Pressed
: ButtonState.Released;
}
}
else
{
int p1 = ReplayFrame;
int p2 = Math.Min(count - 1, ReplayFrame + 1);
pos =
Vector2.Lerp(
GameBase.GamefieldToDisplay(
new Vector2(ReplayScore.replay[p1].mouseX, ReplayScore.replay[p1].mouseY)),
GameBase.GamefieldToDisplay(
new Vector2(ReplayScore.replay[p2].mouseX, ReplayScore.replay[p2].mouseY)),
Math.Max(0,
1 - ((float)(ReplayScore.replay[p2].time - AudioEngine.Time) /
(ReplayScore.replay[p2].time - ReplayScore.replay[p1].time))));
if (!MouseButtonInstantRelease)
{
leftButton = ReplayScore.replay[p1].mouseLeft
? ButtonState.Pressed
: ButtonState.Released;
rightButton = ReplayScore.replay[p1].mouseRight
? ButtonState.Pressed
: ButtonState.Released;
}
}
CursorPosition = pos;
CursorPoint = new Point((int)CursorPosition.X, (int)CursorPosition.Y);
Player.Playing = false;
}
else if (ReplayStreaming)
{
Player.Playing = false;
if (ReplayToEnd)
{
if (Player.Paused && !Player.Failed)
{
Buffering = false;
}
if (Player.ReplayBufferText != null && Player.Failed)
{
Player.ReplayBufferText.Text = "User Failed";
}
}
else
/*if (HitObjectManager.hitObjects != null &&
* AudioEngine.Time >= HitObjectManager.hitObjects[0].StartTime - HitObjectManager.PreEmpt)*/
{
Buffering = true;
float percent;
if (count == 0)
{
percent = 0;
}
else
{
percent =
MathHelper.Clamp(
(float)(ReplayScore.replay[count - 1].time - AudioEngine.Time) / 10, 0, 100);
}
if (Player.ReplayBufferText != null)
{
if (Player.Failed)
{
Player.ReplayBufferText.Text = "Failed";
}
else
{
Player.ReplayBufferText.Text =
string.Format("Buffering {0:0.0}%...", percent);
}
}
}
}
}
}
if (!ReplayMode)
{
//todo: move this to the outer loop?
Player.Playing = GameBase.Mode == Modes.Play &&
AudioEngine.Time >= Player.skipBoundary &&
!Player.Failed && !Player.Paused && !EventManager.BreakMode &&
Game.IsActive && !Player.currentScore.pass;
if (Player.Playing && !GameBase.graphics.IsFullScreen)
{
if (Cursor.Clip == cursorOriginalBounds)
{
Cursor.Clip = GameBase.Form.RectangleToScreen(GameBase.Form.ClientRectangle);
}
}
else if (Cursor.Clip != cursorOriginalBounds)
{
Cursor.Clip = cursorOriginalBounds;
}
CursorPosition = MouseHandler.MousePosition;
CursorPoint = MouseHandler.MousePoint;
leftButton = MouseHandler.mouseLeft;
leftButton1i = leftButton == ButtonState.Pressed && !leftButtonLastBool;
leftButton1 = leftButton == ButtonState.Pressed;
leftButton2i = leftButton == ButtonState.Pressed && !leftButtonLastBool;
leftButton2 = leftButton == ButtonState.Pressed;
rightButton = MouseHandler.mouseRight;
rightButton1i = rightButton == ButtonState.Pressed && !rightButtonLastBool;
rightButton1 = rightButton == ButtonState.Pressed;
rightButton2i = rightButton == ButtonState.Pressed && !rightButtonLastBool;
rightButton2 = rightButton == ButtonState.Pressed;
}
//Update mouse cursor position, except in editor mode where we use the windows cursor.
if (!GameBase.MenuVisible)
{
if (spriteCursor.IsVisible && GameBase.SixtyFramesPerSecondFrame)
{
pSprite trail =
new pSprite(SkinManager.Load("cursortrail"), FieldTypes.WindowScaleOnly,
(SkinManager.Current.CursorCentre ? OriginTypes.Centre : OriginTypes.TopLeft),
ClockTypes.Game, CursorPosition, spriteCursor.Depth - 0.001F,
false,
Color.White);
trail.FadeOut(150);
trail.CurrentScale = spriteCursor.CurrentScale;
if (SkinManager.Current.CursorTrailRotate)
{
trail.CurrentRotation = spriteCursor.CurrentRotation;
}
GameBase.spriteManagerOverlay.Add(trail);
}
spriteCursor.CurrentPosition = CursorPosition;
}
//Only do actions on the input if the window is active.
if (Game.IsActive || ReplayMode)
{
//Mouse wheel
MouseHandler.MouseWheelHandled = false;
if (mouse.ScrollWheelValue != scrollWheel)
{
/*if (ChatEngine.IsVisible)
* {
* if (mouse.ScrollWheelValue > scrollWheel)
* ChatEngine.MouseHandler_OnMouseWheelUp(null, null);
* else
* ChatEngine.MouseHandler_OnMouseWheelDown(null, null);
* }
* else
* {*/
if (mouse.ScrollWheelValue > scrollWheel)
{
MouseHandler.DoMouseWheelUp();
}
else
{
MouseHandler.DoMouseWheelDown();
}
/*}*/
scrollWheel = mouse.ScrollWheelValue;
}
try
{
keyboard = Keyboard.GetState();
}
catch (InvalidOperationException)
{
}
if (!ReplayMode)
{
MouseViaKeyboardControls();
}
Keys[] newKeys = (Keys[])keyboard.GetPressedKeys().Clone();
if (pressedKeys != null && !keyboard.IsKeyDown(Keys.Scroll))
{
KeyboardHandler.ControlPressed = (keyboard.IsKeyDown(Keys.LeftControl) ||
keyboard.IsKeyDown(Keys.RightControl));
KeyboardHandler.AltPressed = (keyboard.IsKeyDown(Keys.LeftAlt) ||
keyboard.IsKeyDown(Keys.RightAlt));
KeyboardHandler.ShiftPressed = (keyboard.IsKeyDown(Keys.LeftShift) ||
keyboard.IsKeyDown(Keys.RightShift));
for (int i = 0; i < newKeys.Length; i++)
{
Keys k = newKeys[i];
bool bFound = false;
for (int j = 0; j < pressedKeys.Length; j++)
{
if (k == pressedKeys[j])
{
bFound = true;
break;
}
}
if (!bFound && GameBase.FadeState != FadeStates.FadeOut)
{
repeatTickCurrent = -100;
BanchoClient.Activity();
GameBase.KeyboardHandler_OnKeyPressed(null, k);
if (ChatEngine.IsVisible)
{
string ks = k.ToString();
if (ks.Length == 2 && ks[0] == 'F' && ks[1] >= '0' && ks[1] <= '9')
{
KeyboardHandler.DoKeyPressed(k);
}
else
{
ChatEngine.GameBase_OnKeyRepeat(null, k, true);
}
}
else if (GameBase.ActiveDialog != null)
{
GameBase.ActiveDialog.HandleKey(k);
}
else if (!thisBlockKey)
{
KeyboardHandler.DoKeyPressed(k);
}
}
}
}
pressedKeys = newKeys;
repeatTickCurrent += GameBase.ElapsedMilliseconds;
if (repeatTickCurrent >= repeatTickRate)
{
repeatTickCurrent -= repeatTickRate;
if (pressedKeys != null && !keyboard.IsKeyDown(Keys.Scroll))
{
foreach (Keys k in newKeys)
{
bool bFound = false;
foreach (Keys k2 in pressedKeys)
{
if (k == k2)
{
bFound = true;
break;
}
}
if (ChatEngine.IsVisible)
{
ChatEngine.GameBase_OnKeyRepeat(null, k, false);
}
else if (GameBase.ActiveDialog == null && bFound && GameBase.FadeState == FadeStates.Idle &&
!thisBlockKey)
{
KeyboardHandler.DoOnKeyRepeat(k);
}
}
}
if (leftButton == ButtonState.Pressed &&
MouseHandler.MouseDown && GameBase.FadeState != FadeStates.FadeOut)
{
MouseHandler.DoOnClickRepeat();
}
}
MouseHandler.actualClickRegistered = (MouseHandler.mouseLeft == ButtonState.Pressed &&
mouseLeftActualPrev != ButtonState.Pressed) || (MouseHandler.mouseRight == ButtonState.Pressed &&
mouseRightActualPrev != ButtonState.Pressed);
if (leftButtonLast != leftButton || rightButtonLast != rightButton)
{
MouseHandler.LastButton2 = MouseHandler.LastButton;
MouseHandler.LastButton = MouseHandler.MouseDownButton;
MouseHandler.MouseDownButton = MouseButtons.None;
if (leftButton == ButtonState.Pressed)
{
MouseHandler.MouseDownButton |= MouseButtons.Left;
}
if (rightButton == ButtonState.Pressed)
{
MouseHandler.MouseDownButton |= MouseButtons.Right;
}
}
//We don't have a replay click, so lets check for physical mouse clicks.
//In the case that there is a replay and actual click the same frame, doOnClick will be called only once (above).
if (MouseHandler.actualClickRegistered && ReplayMode && GameBase.FadeState != FadeStates.FadeOut)
{
bool old = MouseHandler.gamePressedRegistered;
MouseHandler.gamePressedRegistered = false;
MouseHandler.DoOnClick();
MouseHandler.gamePressedRegistered = old;
}
leftCond = leftButton == ButtonState.Pressed && leftButtonLast != leftButton;
rightCond = rightButton == ButtonState.Pressed && rightButtonLast != rightButton;
middleCond = MouseHandler.mouseMiddle == ButtonState.Pressed &&
mouseMiddlePrev != MouseHandler.mouseMiddle;
MouseHandler.gameClickRegistered = false;
if (leftCond || rightCond || middleCond)
{
if (!middleCond)
{
if (SkinManager.Current.CursorExpand)
{
spriteCursor.Transformations.RemoveAll(
delegate(Transformation tr) { return(tr.Type != TransformationType.Rotation); });
Transformation t =
new Transformation(TransformationType.Scale, 1, 1.3F, GameBase.Time,
GameBase.Time + 100);
t.Easing = EasingTypes.In;
spriteCursor.Transformations.Add(t);
}
MouseHandler.clickPosition = new Vector2(mouse.X, mouse.Y);
MouseHandler.gamePressedRegistered = true;
MouseHandler.gameClickRegistered = true;
if (doubleClickTime > 0 && GameBase.FadeState != FadeStates.FadeOut)
{
MouseHandler.DoOnDoubleClick();
}
}
if (GameBase.FadeState != FadeStates.FadeOut)
{
MouseHandler.DoOnClick();
repeatTickCurrent = 0;
doubleClickTime = 250;
}
}
else if (leftButton == ButtonState.Released &&
rightButton == ButtonState.Released &&
MouseHandler.gamePressedRegistered)
{
if (SkinManager.Current.CursorExpand)
{
spriteCursor.Transformations.RemoveAll(
delegate(Transformation tr) { return(tr.Type != TransformationType.Rotation); });
Transformation t =
new Transformation(TransformationType.Scale, spriteCursor.CurrentScale, 1, GameBase.Time,
GameBase.Time + 100);
t.Easing = EasingTypes.In;
spriteCursor.Transformations.Add(t);
}
MouseHandler.gamePressedRegistered = false;
MouseHandler.DoOnClickUp();
}
if (MouseHandler.mouseLeft == ButtonState.Pressed &&
GameBase.FadeState != FadeStates.FadeOut)
{
MouseHandler.MouseDown = true;
if (mouse.X != MouseHandler.clickPosition.X ||
mouse.Y != MouseHandler.clickPosition.Y)
{
MouseHandler.DoOnDrag();
}
}
else
{
MouseHandler.MouseDown = false;
if (IsDragging)
{
MouseHandler.DoOnEndDrag();
}
}
}
else
{
leftButton = ButtonState.Released;
rightButton = ButtonState.Released;
}
GameBase.Instance.UpdateChildren();
leftButtonLast = leftButton;
rightButtonLast = rightButton;
leftButtonLastBool = leftButton == ButtonState.Pressed;
rightButtonLastBool = rightButton == ButtonState.Pressed;
mouseLeftActualPrev = MouseHandler.mouseLeft;
mouseRightActualPrev = MouseHandler.mouseRight;
mouseMiddlePrev = MouseHandler.mouseMiddle;
keyboardLast = keyboard;
thisBlockKey = false;
} while (ReplayMode && ((ReplayModeFF && loopFrame++ < 1) || (runningSlow && loopFrame++ < 4)));
}
