public override void Create()
{
base.Create();
cControl = new XboxController(SlimDX.XInput.UserIndex.One);
pControl = new XboxController(SlimDX.XInput.UserIndex.Two);
GameObject cursor = new Cursor(cControl);
GameObject player = new Player(pControl);
GameObject cannon1 = new Cannon();
cannon1.Position.X = 365;
cannon1.Position.Y = -265;
GameObject cannon2 = new Cannon();
cannon2.Position.X = 365;
cannon2.Position.Y = 265;
GameObject cannon3 = new Cannon();
cannon3.Position.X = -365;
cannon3.Position.Y = 265;
GameObject cannon4 = new Cannon();
cannon4.Position.X = -365;
cannon4.Position.Y = -265;
ObjectManager.AddGameObject(cursor);
ObjectManager.AddGameObject(player);
ObjectManager.AddGameObject(cannon1);
ObjectManager.AddGameObject(cannon2);
ObjectManager.AddGameObject(cannon3);
ObjectManager.AddGameObject(cannon4);
}
public PlayerInfo(XboxController ID, PlayerColors playerColors)
{
IsAlive = true;
PlayerID = ID;
CurrentColor = playerColors;
Scores = new List <ScoreInformation>();
}
// Update is called once per frame
void Update()
{
XboxButton activate = XboxButton.LeftBumper;
XboxController controller = XboxController.First;
switch (m_playerNumber)
{
case 1:
activate = XboxButton.LeftBumper;
controller = XboxController.First;
break;
case 2:
activate = XboxButton.RightBumper;
controller = XboxController.First;
break;
case 3:
activate = XboxButton.LeftBumper;
controller = XboxController.Second;
break;
case 4:
activate = XboxButton.RightBumper;
controller = XboxController.Second;
break;
}
if (XCI.GetButtonDown(activate, controller))
{
m_shipHealth.Health += m_healAmount;
}
}
// Use this for initialization
void Start()
{
_Pool = new GameObject[1000];
Timer = _RateOfFire;
_Pool = _BulletPool.GetComponent <BulletPool>().GetBullet();
Player = transform.parent.gameObject.GetComponent <PlayerMovement>().GetController;
}
private readonly Stopwatch _dpadStopwatch = new Stopwatch(); //Basically a "debounce"
internal Hexapi(IkController ikController,
XboxController xboxController,
Navigator navigator,
SparkFunSerial16X2Lcd display,
Gps.Gps gps,
IoTClient ioTClient)
{
_ik = ikController;
_xboxController = xboxController;
_gps = gps;
_navigator = navigator;
_display = display;
_ioTClient = ioTClient;
_functionStopwatch.Start();
_dpadStopwatch.Start();
SetGaitOptions();
XboxController.LeftDirectionChanged += XboxController_LeftDirectionChanged;
XboxController.RightDirectionChanged += XboxController_RightDirectionChanged;
XboxController.DpadDirectionChanged += XboxController_DpadDirectionChanged;
XboxController.LeftTriggerChanged += XboxController_LeftTriggerChanged;
XboxController.RightTriggerChanged += XboxController_RightTriggerChanged;
XboxController.FunctionButtonChanged += XboxController_FunctionButtonChanged;
XboxController.BumperButtonChanged += XboxController_BumperButtonChanged;
XboxController.DisconnectedEvent += XboxController_DisconnectedEvent;;
}
void Awake()
{
allContollers = XboxController.All;
currentIndex = 0;
buttonPositions = new List <GameObject>();
currentScene = SceneManager.GetActiveScene();
if (currentScene.buildIndex == 0)
{
for (int outerIndex = 0; outerIndex < menuButtonCollection.Length; outerIndex++)
{
if (menuButtonCollection[outerIndex].activeInHierarchy)
{
for (int innerIndex = 0; innerIndex < menuButtonCollection[outerIndex].transform.GetChild(1).childCount; innerIndex++)
{
buttonPositions.Add(menuButtonCollection[outerIndex].transform.GetChild(1).GetChild(innerIndex).gameObject);
}
}
}
}
else if (currentScene.buildIndex == 1)
{
for (int innerIndex = 0; innerIndex < menuButtonCollection[2].transform.GetChild(1).childCount; innerIndex++)
{
buttonPositions.Add(menuButtonCollection[2].transform.GetChild(1).GetChild(innerIndex).gameObject);
}
}
}
// Init
private void Awake()
{
rb = GetComponent <Rigidbody2D>();
sr = GetComponent <SpriteRenderer>();
controller = player_data.controllers[(int)Owner];
earth_Reticle = GetComponent <earth_reticle>();
if (Owner != player.Earth)
{
earth_Reticle.enabled = false;
}
// Init visuals
//Color fadedCol = player_data.colors[(int)Owner];
//fadedCol.a = sr.color.a;
//sr.color = fadedCol;
arrow_cap.color = player_data.colors[(int)Owner];
line_to_active_region.startColor = player_data.colors[(int)Owner];
line_to_active_region.endColor = player_data.colors[(int)Owner];
line_to_active_region.enabled = false;
arrow_cap.enabled = false;
// Init raycast contact filter
region_mask = LayerMask.GetMask(new string[] { "Regions" });
contactFilter.NoFilter();
contactFilter.useLayerMask = true;
contactFilter.layerMask = region_mask;
}
public void LoadPlayers() //! SpawnPlayers, Spawn Players,
{
XboxController[] JoinedXboxControllers = new XboxController[playerSelectedCharacter.Count];
int nextIndex = 0;
for (int i = 0; i < 4; i++)
{
if (playerSelectedCharacter.ContainsKey(XboxController.First + i))
{
JoinedXboxControllers[nextIndex] = XboxController.First + i;
nextIndex++;
}
}
if (!m_bMovedToMainScene)
{
for (int i = 0; i < 4 - JoinedPlayers; ++i)
{
Vector3 spawnPosition = ControllerManager.Instance.spawnPoints[i].position; //Get the spawn position
//Make the gameojbect and keep a reference scoped to the single loop
GameObject go = Instantiate(playerSelectedCharacter[JoinedXboxControllers[i]], spawnPosition, Quaternion.identity, null);
//Set anything required for the player to work.
go.transform.position = spawnPosition;
go.GetComponent <ControllerSetter>().SetController(JoinedXboxControllers[i]);
go.GetComponent <ControllerSetter>().m_playerNumber = (int)JoinedXboxControllers[i] - 1;
go.GetComponent <PlayerStatus>().spawnIndex = i;
//Find the Array for players
//Make a reference in game manager
GameManagerc.Instance.AddPlayer(go.GetComponent <PlayerStatus>());
DontDestroyOnLoad(go); //turn it on
go.SetActive(true);
CameraControl.mInstance.AddTarget(go.transform); //make a reference in camera control
m_bMovedToMainScene = true;
}
}
}
public virtual void Update(XboxController controller)
{
// movement
Vector3 moveDirection = new Vector3(XCI.GetAxisRaw(XboxAxis.LeftStickX, controller), 0, XCI.GetAxisRaw(XboxAxis.LeftStickY, controller));
_characterController.Move(moveDirection);
// throw
if (XCI.GetButton(XboxButton.RightBumper, controller) && _straightCoolDownTimer <= 0 && Time.time >= _straightThrowAvailableTime)
{
_straightCoolDownTimer = _settings.StraightCoolDown;
_tossAvailableTime = Time.time + _settings.ThrowDeadzoneDuration;
_characterController.Throw();
}
if (_settings.StraightCoolDown > 0)
{
_straightCoolDownTimer -= Time.deltaTime;
}
// toss
if (XCI.GetButton(XboxButton.LeftBumper, controller) && _arcCoolDownTimer <= 0 && Time.time >= _tossAvailableTime)
{
_arcCoolDownTimer = _settings.ArcCoolDown;
_straightThrowAvailableTime = Time.time + _settings.ThrowDeadzoneDuration;
_characterController.Toss();
}
if (_settings.ArcCoolDown > 0)
{
_arcCoolDownTimer -= Time.deltaTime;
}
}
//Setup
private void Start()
{
//Listen to all controllers
controller = XboxController.All;
//Fill in the menuButtons Array
//PopulateMenuButtons();
//Fill in the menuButtons Array
Button[] tempButtonChildren = GetComponentsInChildren <Button>();
//menuButtons = new List<GameObject>[tempButtonChildren.Length];
int countOfChildren = 0;
//Add each active button to the list
foreach (Button childButton in tempButtonChildren)
{
menuButtons.Add(childButton.gameObject);
countOfChildren++;
}
//Store the colours
buttonActiveTint = menuButtons[0].GetComponent <Button>().colors.highlightedColor;
buttonInactiveTint = menuButtons[0].GetComponent <Button>().colors.normalColor;
//activate first menu item
menuButtons[0].GetComponent <Image>().color = buttonActiveTint;
}
private void HandleInput(ref PlayerInput playerInput, XboxController controller)
{
//Vector3 cameraPos = BaseGame.CameraPos;
if (Input.KeyboardUpPressed || controller.RightTrigger > 0)
{
//_playerForwardDelta = ForwardScalar * _elapsedGameTime;
playerInput.Forward = 0.5f;
}
else if (Input.KeyboardDownPressed || controller.LeftTrigger > 0)
{
//_playerForwardDelta = -ForwardScalar * _elapsedGameTime;
playerInput.Forward = -0.5f;
}
if (Input.KeyboardLeftPressed || controller.IsDPadLeftPressed)
{
//_playerRotationDelta = -RotationScalar * _elapsedGameTime;
playerInput.Rotation = 0.5f;
}
else if (Input.KeyboardRightPressed || controller.IsDPadRightPressed)
{
//_playerRotationDelta = RotationScalar * _elapsedGameTime;
playerInput.Rotation = -0.5f;
}
if (Input.KeyboardF1JustPressed)
{
game.ToggleDebugDrawing();
}
}
public AxisToButton(XboxController controllerId, XboxAxis axis, ReadAxis readAxis, float deadZone)
{
m_ControllerId = controllerId;
m_Axis = axis;
m_Readaxis = readAxis;
m_DeadZone = deadZone;
}
// Set up controllers
private void Awake()
{
if (inputManager != this)
{
Destroy(this);
return;
}
// only temporary, need to make going from keyboard to controller more formal and streamlined!!!!!!!!!!
// controllers[0] = new MouseKeyboard(0);
keyboardEnabled = false;
// for (int i = 1; i < 4; ++i)
for (int i = 0; i < 4; ++i)
{
controllers[i] = new XboxController(i);
}
// ChangeControllerType(0, Controller.Type.MouseKeyboard);
#if UNITY_ANDROID || UNITY_IOS
Debug.Log("Mobile Device Detected");
ChangeControllerType(0, Controller.Type.TouchScreen);
ChangeControllerType(1, Controller.Type.TouchScreen);
#endif
#if UNITY_EDITOR_WIN || UNITY_STANDALONE_WIN
UpdateXInputStateThread = new Thread(UpdateXInputStateThreadLoop);
UpdateXInputStateThread.Start();
#endif
}
public VirtualButton(XboxController controller, KeyCode key, XboxButton button, AxisToButton axis)
{
m_ControllerId = controller;
m_Key = key;
m_Button = button;
m_Axis = axis;
}
/// <summary>
/// Updates every frame.
/// </summary>
private void Update()
{
// Written, 18.12.2018
XboxController xc = MoControlsGO.xboxController;
if (xc.isConnected)
{
if (xc.getButtonDown(keyName))
{
startTime = Time.time;
timer = startTime;
}
if (xc.getButtonPressed(keyName) && held == false)
{
timer += Time.deltaTime;
if (timer > (startTime + holdTime))
{
held = true;
action?.Invoke();
}
}
if (xc.getButtonUp(keyName))
{
held = false;
}
}
}
// Use this for initialization
void Start()
{
if (PlayerPrefs.GetInt("P2_Controller_Scheme") == 0)
{
usingXbox = false;
}
else
{
usingXbox = true;
if (PlayerPrefs.GetInt("P1_Controller_Scheme") == 0)
{
player2Controller = XboxController.First;
}
else
{
player2Controller = XboxController.Second;
}
}
player2Camera = gameObject.GetComponentInChildren <Camera> ();
mouseLook.Init(this.transform, player2Camera.transform);
moves = GameConstants.MOVES_BEFORE_COOLDOWN;
coolDown = GameConstants.COOLDOWN_VALUE;
elapsedTime = 0;
movesLeftText = movesLeftGO.GetComponent <Text> ();
updateMovesText();
}
public Screen()
{
InitializeComponent();
bmp = new WriteableBitmap(BitmapWidth, BitmapHeight, 96, 96, PixelFormats.Gray8, null);
var whitescreen = new byte[BitmapWidth * BitmapHeight];
for (int i = 0; i < whitescreen.Length; i++)
{
whitescreen[i] = 0xff;
}
bmp.WritePixels(new Int32Rect(0, 0, BitmapWidth, BitmapHeight), whitescreen, BitmapWidth, 0);
Display.Source = bmp;
RenderOptions.SetBitmapScalingMode(Display, BitmapScalingMode.NearestNeighbor);
FPSDisplayEnable.Checked += (x, y) => FPS.Visibility = Visibility.Visible;
FPSDisplayEnable.Unchecked += (x, y) => FPS.Visibility = Visibility.Collapsed;
XboxController.UpdateFrequency = 5;
XboxController.StartPolling();
var Controller1 = new XboxControllerWithInterruptHandler(XboxController.RetrieveController(0));
var Controller2 = new XboxControllerWithInterruptHandler(XboxController.RetrieveController(1));
var Controller3 = new XboxControllerWithInterruptHandler(XboxController.RetrieveController(2));
var Controller4 = new XboxControllerWithInterruptHandler(XboxController.RetrieveController(3));
Dictionary <Key, JoypadKey> mappedKeys = new()
{
{ Key.X, JoypadKey.A },
{ Key.LeftShift, JoypadKey.Select },
private void HandleWeapons()
{
if (canRangeAttack && Input.GetAxisRaw(XboxController.GetButtonName(shootButton) + playerNumber) > 0.0f)
{
Shoot();
}
}
// Use this for initialization
private InputManager()
{
//Hard-setting Keybinds for players 1 and 2 here for now. Eventually implement options.
PlayerKeybindArray [0].UpKey = KeyCode.W;
PlayerKeybindArray [0].DownKey = KeyCode.S;
PlayerKeybindArray [0].LeftKey = KeyCode.A;
PlayerKeybindArray [0].RightKey = KeyCode.D;
PlayerKeybindArray [0].LTurnKey = KeyCode.Q;
PlayerKeybindArray [0].RTurnKey = KeyCode.E;
PlayerKeybindArray [0].GraborThrowKey = KeyCode.F;
PlayerKeybindArray[0].AbilityKey = KeyCode.R;
PlayerKeybindArray [1].UpKey = KeyCode.I;
PlayerKeybindArray [1].DownKey = KeyCode.K;
PlayerKeybindArray [1].LeftKey = KeyCode.J;
PlayerKeybindArray [1].RightKey = KeyCode.L;
PlayerKeybindArray [1].LTurnKey = KeyCode.U;
PlayerKeybindArray [1].RTurnKey = KeyCode.O;
PlayerKeybindArray [1].GraborThrowKey = KeyCode.Semicolon;
PlayerKeybindArray[1].AbilityKey = KeyCode.P;
PlayerKeybindArray [0].SelectKey = KeyCode.Return; //Only exists once to prevent game from "double-pausing"
PlayerKeybindArray [0].ExitKey = KeyCode.Escape;
for (int i = 0; i < ControllerArray.Length; i++)
{
ControllerArray[i] = new XboxController(i);
}
}
public void Run()
{
Console.WriteLine("== ARDUINO INTERFACE ==");
var controller = new XboxController();
Console.Write("Use default settings? (y/n) :");
TankInterface tank;
if (Console.ReadLine().ToUpper().Equals("Y"))
{
tank = new TankInterface("COM3", 115200);
}
else
{
Console.Write("PORT: ");
var port = Console.ReadLine();
Console.Write("BAUDRATE: ");
var baudrate = int.Parse(Console.ReadLine());
tank = new TankInterface(port, baudrate);
}
tank.AttachController(controller);
}
static void Main(string[] args)
{
RenderWindow app = new RenderWindow(new VideoMode(800, 600), "OMG, it works!");
app.Closed += new EventHandler(OnClose);
Color windowColor = new Color(77, 255, 130);
CircleShape shape = new CircleShape(10);
shape.FillColor = new Color(Color.Red);
RectangleShape square = new RectangleShape();
square.FillColor = new Color(Color.Red);
square.Position = new Vector2f(app.Size.X / 2, app.Size.Y / 2);
square.OutlineColor = new Color(0, 0, 0, 255);
square.Size = new Vector2f(50, 50);
// Start the game loop
while (app.IsOpen())
{
// Process events
app.DispatchEvents();
// Clear screen
app.Clear(windowColor);
app.Draw(shape);
app.Draw(square);
Console.WriteLine(XboxController.RefreshButtonPressed());
Console.WriteLine(XboxController.RefreshAxisPressed());
if (JoyState.HasFlag(ControllerState.DPAD_UP_PRESSED))
{
square.Position = new Vector2f(square.Position.X, square.Position.Y - 1);
}
if (JoyState.HasFlag(ControllerState.DPAD_DOWN_PRESSED))
{
square.Position = new Vector2f(square.Position.X, square.Position.Y + 1);
}
if (JoyState.HasFlag(ControllerState.DPAD_LEFT_PRESSED))
{
square.Position = new Vector2f(square.Position.X - 1, square.Position.Y);
}
if (JoyState.HasFlag(ControllerState.DPAD_RIGHT_PRESSED))
{
square.Position = new Vector2f(square.Position.X + 1, square.Position.Y);
}
// Update the window
app.Display();
}
}
static Manager()
{
controller = new InputController("Teslagrad.tas");
xbox = XboxController.RetrieveController(0);
XboxController.UpdateFrequency = 30;
XboxController.StartPolling();
}
/// <summary>
/// Update
/// </summary>
protected override void Update(GameTime gameTime)
{
// Update game engine
base.Update(gameTime);
var controller = XboxController.RetrieveController(0);
controller.UpdateState();
if (controller.IsBackPressed || Keyboard.GetState().IsKeyDown(Keys.Escape))
{
Exit();
}
var elapsedGameTime = (float)gameTime.ElapsedGameTime.TotalSeconds;
var input = new PlayerInput();
HandleInput(ref input, controller);
game.Input(input);
game.Update(elapsedGameTime);
frame = game.getPosition();
CameraPos = new Vector3(frame.Position.X, -frame.Position.Y, CameraPos.Z);
ViewMatrix = Matrix.CreateLookAt(CameraPos, new Vector3(CameraPos.X, CameraPos.Y, 0), Vector3.Up);
Window.Title = "GTA2.NET - " + WindowTitle + Fps.ToString(CultureInfo.InvariantCulture) + " fps X: " + CameraPos.X.ToString() + "Y: " + CameraPos.Y.ToString() + "Z: " + CameraPos.Z;
}
private void HandlePickup()
{
if (Input.GetButtonDown(XboxController.GetButtonName(pickupButton) + playerNumber) && !isCarrying)
{
GameObject item = pickUpVolume.PickupItem();
if (item != null)
{
pickedUpItem = item;
pickedUpItem.transform.parent = itemLocation.transform;
pickedUpItem.transform.localPosition = Vector3.zero;
pickedUpItem.GetComponent <PickUpItem>().HoldItem(true);
isCarrying = true;
}
else
{
pickedUpItem = null;
isCarrying = false;
}
}
else if (Input.GetButtonDown(XboxController.GetButtonName(pickupButton) + playerNumber) && isCarrying)
{
pickedUpItem.transform.parent = null;
pickedUpItem.GetComponent <PickUpItem>().HoldItem(false);
pickedUpItem = null;
isCarrying = false;
}
}
private void AddController(XboxController controller)
{
int id = ((int)controller) - 1;
// If there's a container empty, then add a player into it. (Not sure if we should do this, or just match the ID to the connected controller).
GameObject containerGO = this.GetContainerByID(id).gameObject;
if (containerGO)
{
// Getting the container and checking if it already has a player
PlayerContainer container = containerGO.GetComponent <PlayerContainer>();
if (container.HasPlayer)
{
return;
}
// Setting up the container:
container.ID = id;
container.Controller = controller;
container.HasPlayer = true;
container.ToggleMech();
++assignedPlayers;
}
else
{
Debug.Log("Can't find container.");
}
}
static void RespondToJoystickEvents(RectangleShape player)
{
buttonText.DisplayedString = XboxController.RefreshButtonPressed();
axisText.DisplayedString = XboxController.RefreshAxisPressed();
if (JoyState.HasFlag(ControllerState.DPAD_UP_PRESSED))
{
player.Position = new Vector2f(player.Position.X, player.Position.Y - 1);
}
if (JoyState.HasFlag(ControllerState.DPAD_DOWN_PRESSED))
{
player.Position = new Vector2f(player.Position.X, player.Position.Y + 1);
}
if (JoyState.HasFlag(ControllerState.DPAD_LEFT_PRESSED))
{
player.Position = new Vector2f(player.Position.X - 1, player.Position.Y);
}
if (JoyState.HasFlag(ControllerState.DPAD_RIGHT_PRESSED))
{
player.Position = new Vector2f(player.Position.X + 1, player.Position.Y);
}
if (JoyState.HasFlag(ControllerState.B_PRESSED))
{
player.Position = RespawnCentreScreen();
}
}
// @brief Update is called once per frame
// Handles adding players to the game and starting the game
private void Update()
{
if (m_isLoading)
{
return;
}
// Add players to the game
AddPlayer();
// If there are no players in the list, the game cannot start
if (Menus.GetActivatedPlayerAmount() <= 0)
{
return;
}
else
{
// Loop through each controller and check for an input to start the game
for (int i = 0; i < Menus.GetActivatedPlayerAmount(); i++)
{
// Only allow players who have joined the game to start it
StaticVariables holder = Menus.GetPlayerInformation(i);
XboxController controller = holder.Controller;
// Only let the player change hat and ready up if they have not already readied up
if (!holder.IsReady)
{
HatSelection();
ReadyUp();
}
else
{
// Check for the players input
if (XCI.GetButtonDown(XboxButton.Start, controller))
{
m_PlayerAddMenu.SetActive(false);
m_loadingMenu.SetActive(true);
for (int j = 0; j < m_listOfUI.Count; j++)
{
Destroy(m_listOfUI[j]);
Destroy(m_readyPlayers[j]);
}
gameObject.GetComponent<PlayerAdd>().enabled = false;
}
}
}
}
for (int i = 0; i < Menus.GetActivatedPlayerAmount(); i++)
{
StaticVariables holder = Menus.GetPlayerInformation(i);
ControllerVibrato(holder);
}
}
private static void HandleXboxInputPanTilt(MainWindow mainWindow, PanTiltController panTilt, FiringController firingController,
XboxController handHeldController)
{
try
{
var convertedXboxInputX = ConvertXInputCoordinateToVelocity(handHeldController.LeftThumbStick.X);
var convertedXboxInputY = ConvertXInputCoordinateToVelocity(handHeldController.LeftThumbStick.Y);
Console.WriteLine("X Value Converted - " + convertedXboxInputX);
//Pan Up & Pan Down for Manual Tracking
if (convertedXboxInputY <= PAN_TILT_SPEED_LIMIT && !s_PanTiltTooFarDown && mainWindow.TrackingMode == TrackingMode.MANUAL)
{
s_PanTiltTooFarUp = false;
mainWindow.CannonYVelocity = convertedXboxInputY;
panTilt.PanY(mainWindow.CannonYVelocity);
}
if (convertedXboxInputY >= -1 * PAN_TILT_SPEED_LIMIT && !s_PanTiltTooFarUp && mainWindow.TrackingMode == TrackingMode.MANUAL)
{
mainWindow.CannonYVelocity = convertedXboxInputY;
//set too far to false. if its stil too far the next key event handler will set to true
s_PanTiltTooFarDown = false;
panTilt.PanY(mainWindow.CannonYVelocity);
}
if (convertedXboxInputY <= PAN_TILT_SPEED_LIMIT && !s_PanTiltTooFarDown && mainWindow.TrackingMode == TrackingMode.AUDIBLE)
{
s_PanTiltTooFarUp = false;
mainWindow.CannonYVelocity = convertedXboxInputY;
panTilt.PanY(mainWindow.CannonYVelocity);
}
if (convertedXboxInputY >= -1 * PAN_TILT_SPEED_LIMIT && !s_PanTiltTooFarUp && mainWindow.TrackingMode == TrackingMode.AUDIBLE)
{
mainWindow.CannonYVelocity = convertedXboxInputY;
//set too far to false. if its stil too far the next key event handler will set to true
s_PanTiltTooFarDown = false;
panTilt.PanY(mainWindow.CannonYVelocity);
}
if (mainWindow.CannonXVelocity >= -1 * PAN_TILT_SPEED_LIMIT && !s_PanTiltTooFarRight && mainWindow.TrackingMode == TrackingMode.MANUAL)
{
mainWindow.CannonXVelocity = convertedXboxInputX;
//set too far to false. if its stil too far the next key event handler will set to true
s_PanTiltTooFarLeft = false;
panTilt.PanX(mainWindow.CannonXVelocity);
}
if (mainWindow.CannonXVelocity <= PAN_TILT_SPEED_LIMIT && !s_PanTiltTooFarLeft && mainWindow.TrackingMode == TrackingMode.MANUAL)
{
mainWindow.CannonXVelocity = convertedXboxInputX;
//set too far to false. if its stil too far the next key event handler will set to true
s_PanTiltTooFarRight = false;
panTilt.PanX(mainWindow.CannonXVelocity);
}
}
//anything goes wrong, stop pantilt and crash the app
catch (Exception ex)
{
panTilt.Disengage();
throw ex;
}
}
// Update is called once per frame
void Update()
{
if (PlayerManager.Gamestate == gamestate.sea_levels_rose)
{
return;
}
// Take in player input for switching policies
for (int i = 0; i < 2; i++)
{
int Player = (i == 0) ? (int)player.A : (int)player.B;
int currentPolicy = (int)policies[Player];
policy newPolicy = (policy)currentPolicy;
XboxController controller = player_data.controllers[Player];
if (RCI.GetButtonDown(XboxButton.DPadDown, controller))
{
newPolicy = (policy)Mathf.Clamp(currentPolicy - 1, 1, policiesCount - 1);
}
else if (RCI.GetButtonDown(XboxButton.DPadUp, controller))
{
newPolicy = (policy)Mathf.Clamp(currentPolicy + 1, 1, policiesCount - 1);
}
ChangePolicyBonusDisplay(i, currentPolicy, newPolicy);
if (newPolicy != policies[Player])
{
policies[Player] = newPolicy;
//city.updatePoliciesAll(Player, (policy)newPolicy);
// Play corresponding sound effect
if (newPolicy == policy.industry)
{
mixer.playSFX("ind policy");
}
else if (newPolicy == policy.neutral)
{
mixer.playSFX("population growth");
}
else if (newPolicy == policy.eco)
{
mixer.playSFX("eco policy");
}
}
}
// Update policy displays
for (int pol = 0; pol < policiesCount; pol++)
{
if (p1PolicyDisplays[pol] != null)
{
setPolicySR(p1PolicyDisplays[pol], policies[1] == (policy)pol);
}
if (p2PolicyDisplays[pol] != null)
{
setPolicySR(p2PolicyDisplays[pol], policies[2] == (policy)pol);
}
}
}
static void Main(string[] args)
{
GameApp = new RenderWindow(new VideoMode(ScreenWidth, ScreenHeight), "Display Sprites");
GameApp.Closed += new EventHandler(OnClose);
Color windowColor = new Color(0, 192, 255);
SetupFont();
SetupPlayerSprite();
SetupBombSprite();
SetupAppleSprite();
SetupGameText();
// quick alias
var app = GameApp;
// Start the game loop
while (app.IsOpen())
{
// Process events
app.DispatchEvents();
// Clear screen
app.Clear(windowColor);
BombSprite.Position = GameUtils.RandomlyMovePosition(BombSprite.Position, app.Size);
buttonText.DisplayedString = XboxController.RefreshButtonPressed();
axisText.DisplayedString = XboxController.RefreshAxisPressed();
PlayerSprite.Position = RespondToJoystickEvents(PlayerSprite.Position);
if (IsPlayerOverFood(PlayerSprite.GetGlobalBounds(), AppleSprite.GetGlobalBounds()) == true)
{
// Respawn food and increase health!
AppleSprite.Position = RespawnRandomLocation();
foodCountText.DisplayedString = string.Format("Food: {0}", ++foodCount);
}
if (IsPlayerOverEnemy(PlayerSprite.GetGlobalBounds(), BombSprite.GetGlobalBounds()) == true)
{
PlayerSprite.Position = RespawnTopLeftScreen();
killCountext.DisplayedString = string.Format("Killed: {0}", ++killCount);
}
app.Draw(headerText);
app.Draw(buttonText);
app.Draw(axisText);
app.Draw(foodCountText);
app.Draw(killCountext);
app.Draw(PlayerSprite);
app.Draw(BombSprite);
app.Draw(AppleSprite);
// Update the window
app.Display();
}
}
public XInputController(int deviceIndex)
{
_deviceIndex = deviceIndex;
_controller = XboxController.RetrieveController(deviceIndex);
_running = true;
_monitorThread = new Thread(MonitorThread);
_monitorThread.Start();
}
public void XboxControllerUpdateTest()
{
XboxController controller = new XboxController(TrackingState.NotApplicable, Utilities.Handedness.None);
controller.SetupDefaultInteractions(Utilities.Handedness.None);
TestGenericJoystickControllerUpdate(controller);
}
private static void Initialize()
{
for (int i = 0; i < NUMBER_OF_CONTROLLERS; ++i)
{
m_XboxControllers[i] = new XboxController();
m_XboxControllers[i].ControllerIndex = (PlayerIndex)i;
m_IsInitialized = true;
}
UpdateState();
}
public static Player Create(XboxController i)
{
Player player = (GameObject.Instantiate(Game.Instance.Settings.PlayerPrefabs[(int)i - 1].gameObject) as GameObject).GetComponent<Player>();
player.rigidbody.isKinematic = true;
MeshRenderer [] renderers = player.GetComponentsInChildren<MeshRenderer>();
foreach (MeshRenderer r in renderers) {
if (r.tag != "PasDeCouleur")
r.material.color = Game.Instance.Settings.PlayerColors [(int)i - 1];
}
player.controller = i;
return player;
}
public override void Update()
{
base.Update();
pControl = pControl == null ? new XboxController(SlimDX.XInput.UserIndex.Two) : pControl;
if (!GameOver && (ObjectManager.GetAllObjectsByName("CANNON").Count == 0 ||
ObjectManager.GetObjectByName("PLAYER") == null))
{
TextManager.AddText("RESTART", "Press START to restart", FontTypes.Arial32);
TextObject text = TextManager.GetTextObjectByName("RESTART");
text.Position.X = -Game.WindowWidth / 2;
text.Position.Y = Game.WindowHeight / 2;
GameOver = true;
}
if (GameOver)
{
pControl.Update();
if (cControl.IsTriggered(XboxKeys.START) || pControl.IsTriggered(XboxKeys.START))
GameStateManager.GoToState(new Level());
}
}
private static float XInputApplyDeadzone(float rawAxisValue, XboxAxis axis, XboxController controller)
{
float finalValue = rawAxisValue;
float deadzone = 0.0f;
// Find the deadzone
switch(axis)
{
case XboxAxis.LeftStickX:
deadzone = XciHandler.Instance.Deadzones.LeftStickX[(int) controller];
break;
case XboxAxis.LeftStickY:
deadzone = XciHandler.Instance.Deadzones.LeftStickY[(int) controller];
break;
case XboxAxis.RightStickX:
deadzone = XciHandler.Instance.Deadzones.RightStickX[(int) controller];
break;
case XboxAxis.RightStickY:
deadzone = XciHandler.Instance.Deadzones.RightStickY[(int) controller];
break;
case XboxAxis.LeftTrigger:
deadzone = XciHandler.Instance.Deadzones.LeftTrigger[(int) controller];
break;
case XboxAxis.RightTrigger:
deadzone = XciHandler.Instance.Deadzones.RightTrigger[(int) controller];
break;
}
// Clear axis value if less than the deadzone
if(Mathf.Abs(rawAxisValue) < deadzone)
{
finalValue = 0.0f;
}
// Remap the axis value from interval [0,1] to [deadzone,1]
else
{
finalValue = (Mathf.Abs(rawAxisValue) * (1 - deadzone)) + deadzone;
finalValue = finalValue * Mathf.Sign(rawAxisValue);
}
return finalValue;
}
/// <summary>
/// Returns the float number of the specified axis from a specified controller without Unity's smoothing filter.
/// </summary>
/// <param name='axis'>
/// An identifier for the specified Xbox axis to be tested.
/// </param>
/// <param name='controller'>
/// An identifier for the specific controller on which to test the axis.
/// </param>
public static float GetAxisRaw(XboxAxis axis, XboxController controller)
{
if (controller == XboxController.All)
return GetAxisRaw(axis);
int controllerNumber = (int)controller;
float r = 0.0f;
if(OnWindowsNative())
{
if(!XInputStillInCurrFrame())
{
XInputUpdateAllStates();
}
GamePadState ctrlrState = XInputGetPaticularState(controllerNumber);
if(axis == XboxAxis.LeftTrigger || axis == XboxAxis.RightTrigger)
{
r = XInputGetAxisState(ctrlrState.Triggers, axis);
}
else
{
r = XInputGetAxisState(ctrlrState.ThumbSticks, axis);
}
}
else
{
string axisCode = DetermineAxisCode(axis, controllerNumber);
r = Input.GetAxisRaw(axisCode);
r = AdjustAxisValues(r, axis, controllerNumber);
}
return r;
}
// From @ProjectEnder
/// <summary>
/// Returns <c>true</c> at the frame the specified button is Pressed by a specified controller.
/// Does NOT work on Linux with Wired Controllers.
/// </summary>
/// <param name='button'>
/// Identifier for the Xbox button to be tested.
/// </param>
/// <param name='controller'>
/// An identifier for the specific controller on which to test the button.
/// </param>
public static bool GetDPadDown(XboxDPad padDirection, XboxController controller)
{
if (controller == XboxController.All)
return GetDPadDown(padDirection);
int controllerNumber = (int)controller;
bool r = false;
if(OnWindowsNative())
{
if(Time.frameCount < 2)
{
return false;
}
if(!XInputStillInCurrFrame())
{
XInputUpdateAllStates();
}
GamePadState ctrlrState = XInputGetPaticularState(controllerNumber);
GamePadState ctrlrStatePrev = XInputGetPaticularStatePrev(controllerNumber);
if( ( XInputGetDPadState(ctrlrState.DPad, padDirection) == ButtonState.Pressed ) &&
( XInputGetDPadState(ctrlrStatePrev.DPad, padDirection) == ButtonState.Released ) )
{
return true;
}
}
else
{
string inputCode = "";
if(OnMac())
{
inputCode = DetermineDPadMac(padDirection, controllerNumber);
r = Input.GetKeyDown(inputCode);
}
else if(OnLinux() && IsControllerWireless(controllerNumber))
{
inputCode = DetermineDPadWirelessLinux(padDirection, controllerNumber);
r = Input.GetKeyDown(inputCode);
}
else
{
//Place Holder for Wired Linux
r = false;
}
}
return r;
}
/// <summary>
/// Returns <c>true</c> if the specified D-Pad direction is pressed down by a specified controller.
/// </summary>
/// <param name='padDirection'>
/// An identifier for the specified D-Pad direction to be tested.
/// </param>
/// <param name='controller'>
/// An identifier for the specific controller on which to test the D-Pad.
/// </param>
public static bool GetDPad(XboxDPad padDirection, XboxController controller)
{
if (controller == XboxController.All)
return GetDPad(padDirection);
int controllerNumber = (int)controller;
bool r = false;
if(OnWindowsNative())
{
if(!XInputStillInCurrFrame())
{
XInputUpdateAllStates();
}
GamePadState ctrlrState = XInputGetPaticularState(controllerNumber);
if( XInputGetDPadState(ctrlrState.DPad, padDirection) == ButtonState.Pressed )
{
return true;
}
}
else
{
string inputCode = "";
if(OnMac())
{
inputCode = DetermineDPadMac(padDirection, controllerNumber);
r = Input.GetKey(inputCode);
}
else if(OnLinux() && IsControllerWireless(controllerNumber))
{
inputCode = DetermineDPadWirelessLinux(padDirection, controllerNumber);
r = Input.GetKey(inputCode);
}
else // Windows Web Player and Linux Wired Controller
{
inputCode = DetermineDPad(padDirection, controllerNumber);
switch(padDirection)
{
case XboxDPad.Up: r = Input.GetAxis(inputCode) > 0; break;
case XboxDPad.Down: r = Input.GetAxis(inputCode) < 0; break;
case XboxDPad.Left: r = Input.GetAxis(inputCode) < 0; break;
case XboxDPad.Right: r = Input.GetAxis(inputCode) > 0; break;
default: r = false; break;
}
}
}
return r;
}
/// <summary>
/// Returns <c>true</c> at the frame the specified button is released by a specified controller.
/// </summary>
/// <param name='button'>
/// Identifier for the Xbox button to be tested.
/// </param>
/// <param name='controller'>
/// An identifier for the specific controller on which to test the button.
/// </param>
public static bool GetButtonUp(XboxButton button, XboxController controller)
{
if (button.IsDPad())
return GetDPadUp(button.ToDPad(), controller);
if (controller == XboxController.All)
return GetButtonUp(button);
int controllerNumber = (int)controller;
if(OnWindowsNative())
{
if(Time.frameCount < 2)
{
return false;
}
if(!XInputStillInCurrFrame())
{
XInputUpdateAllStates();
}
GamePadState ctrlrState = XInputGetPaticularState(controllerNumber);
GamePadState ctrlrStatePrev = XInputGetPaticularStatePrev(controllerNumber);
if( ( XInputGetButtonState(ctrlrState.Buttons, button) == ButtonState.Released ) &&
( XInputGetButtonState(ctrlrStatePrev.Buttons, button) == ButtonState.Pressed ) )
{
return true;
}
}
else
{
string btnCode = DetermineButtonCode(button, controllerNumber);
if(Input.GetKeyUp(btnCode))
{
return true;
}
}
return false;
}
public void Start()
{
_selectedController = XboxController.RetrieveController( 0 );
XboxController.StartPolling();
}
public XboxInput(XboxController controller)
{
this.controller = controller;
}
