void Moving() { if (ExectuingCommand != null) { if (ExectuingCommand.isBeingExecuted) { ExecuteCommand(); } else { ExectuingCommand = null; } } else { if (CommandQueue.Count > 0) { ExectuingCommand = CommandQueue.Dequeue(); } else { Searching(); } } }
public void Ctor_WhenMovementCommandIsNotForwardOrBackward_ThrowsInvalidOperationException() { _movementCommand = MovementCommand.Left; Func <ForwardBackwardMovementStrategy> func = () => ForwardBackwardMovementStrategy; func.Should().Throw <InvalidOperationException>(); }
public void DoUpdate() { if (Command != MovementCommand.None) { Vector2 newCoordinates; if (MapReference.CanMoveTo(Coordinates, Command, out newCoordinates)) { if ((int)(newCoordinates - Coordinates).magnitude == 1) { Move(newCoordinates); } else { Teleport(newCoordinates); } if (IsPlayer()) { if (GhostCreationRequested) { CreateNextGhost(); GhostCreationRequested = false; } PreviousCommand.Add(Command); GhostPath.AddCommand(Command); } } Command = MovementCommand.None; } }
public void AskMoveRight(InputAction.CallbackContext ctx) { if (ctx.started && !UI_Manager.instance.bLevelPaused && Command == MovementCommand.None && GetLastCommand() != MovementCommand.Left && !IsMoving && !LoopLocked && !IsRewinding) { Command = MovementCommand.Right; } }
public bool handleDrivingKey(Keys key, bool justCheck = false) { if (!drivingModeEnabled) { return(false); // never handle if not in driving mode. } bool handled = true; try { MovementCommand command = tryConvertKeyToMovementCommand(key); if (!justCheck) { sendMovementCommand(command); } } catch (ArgumentException) { handled = false; } return(handled); }
public RemoteControlProgram(RepairDroid repairDroid, ICommandInput commandInput, IView consoleView) { _relativePosition = Coordinate.Origin; _lastPosition = _relativePosition; _movementCommand = (MovementCommand)(-1); commandInput.InputReceived += (_, v) => _movementCommand = (MovementCommand)v; repairDroid.OnReply += (_, msg) => { switch (msg) { case RepairDroidStatusCode.HitWall: consoleView.Write(GetNewLocation(_relativePosition), '#'); break; case RepairDroidStatusCode.Moved: consoleView.Write(_relativePosition, '.'); Move(); consoleView.Write(_relativePosition, 'D'); break; case RepairDroidStatusCode.MovedAndFoundOxygenSystem: Move(); FoundOxygenSystem?.Invoke(this, _relativePosition); _run = false; break; } ; }; _repairDroid = repairDroid; _commandInput = commandInput; }
private AudioSource a; //In case we want to play sound effects. void Start() { originalPosition = transform.position; originalRotation = transform.rotation; a = GetComponent <AudioSource>(); attachedBattery = GetComponent <Battery>(); useBattery = attachedBattery != null; if (type == PathType.PingPong) { MovementCommand[] newSteps = new MovementCommand[steps.Length * 2]; int pos = 0; foreach (MovementCommand step in steps) { newSteps[pos] = step; newSteps[newSteps.Length - 1 - pos] = new MovementCommand(step.type, step.interpretSpeedAsGoal, step.duration, -step.speed, -step.angularSpeed, step.freezePosition, step.freezeRotation, step.sound); pos += 1; } steps = newSteps; } Activate(); }
private void KeepAlive() { while (true) { keepAliveCommand.Execute(); if (!allowCommand()) { //Console.WriteLine("***Emergency stop enabled***"); if (emergencyLeftStopCommand == null) { emergencyLeftStopCommand = new MovementCommand(EMERGENCY_LEFT_STOP); } if (emergencyRightStopCommand == null) { emergencyRightStopCommand = new MovementCommand(EMERGENCY_RIGHT_STOP); } emergencyLeftStopCommand.Execute(); emergencyRightStopCommand.Execute(); } Thread.Sleep(_sleepPeriod); } }
public void ApplyCommandOnPlayer(PlayerBody body, MovementCommand command, float deltaTime = -1) { if(deltaTime < 0) { deltaTime = Time.deltaTime; } Transform bodyTransform = body.gameObject.transform; Rigidbody bodyRigidbody = body.gameObject.rigidbody; if(command.LateralAxis != 0) { float torqueMagnitude = body.RotAcceleration * command.LateralAxis * deltaTime; bodyRigidbody.AddTorque(bodyTransform.up.normalized * torqueMagnitude); } if(command.FrontAxis != 0) { float forceMagnitude = body.LinearAcceleration * command.FrontAxis * deltaTime; /* Vector3 comOffset = (-bodyTransform.up + bodyTransform.forward * Mathf.Sign(command.FrontAxis)) / 2; bodyRigidbody.AddForceAtPosition(bodyTransform.forward * forceMagnitude, bodyRigidbody.centerOfMass + comOffset, ForceMode.Acceleration); */ bodyRigidbody.AddForce(bodyTransform.forward.normalized*forceMagnitude); } if(command.TestButton(MovementCommand.ActionFlags.Jump)) { body.Jump(); } }
public void TestPlacingBombCommand() { var map = new GameMap(2, 1, 0); var player1 = new PlayerEntity(); player1.BombBag = 1; var block = map.GetBlockAtLocation(1, 1); block.SetEntity(player1); var transaction = new CommandTransaction(new DummyLogger()); var command = new PlaceBombCommand(); command.PerformCommand(map, player1, transaction); transaction.ValidateCommands(map); transaction.ProcessCommands(map); transaction = new CommandTransaction(new DummyLogger()); command = new PlaceBombCommand(); Assert.Throws <InvalidCommandException>(() => command.PerformCommand(map, player1, transaction), "Cannot place bomb in same location twice"); var moveCommand = new MovementCommand(MovementCommand.Direction.Right); moveCommand.PerformCommand(map, player1, transaction); transaction.ValidateCommands(map); transaction.ProcessCommands(map); transaction = new CommandTransaction(new DummyLogger()); command = new PlaceBombCommand(); Assert.Throws <InvalidCommandException>(() => command.PerformCommand(map, player1, transaction), "Player cannot place more bombs than is in the bomb bag"); }
/// <summary> /// Construct a NonPlayerCharacterMovement /// </summary> /// <param name="nDialogIndex">the index of an NPC</param> /// <param name="movementInstructionDataChunk">The full memory chunk of all movement instructions</param> /// <param name="movementOffsetDataChunk">the full memory chunk of the movement offsets</param> public NonPlayerCharacterMovement(int nDialogIndex, DataChunk movementInstructionDataChunk, DataChunk movementOffsetDataChunk) { // we totally ignore the first entry, since it's bad stuff if (nDialogIndex == 0) { return; } this._movementInstructionDataChunk = movementInstructionDataChunk; this._movementOffsetDataChunk = movementOffsetDataChunk; this._nDialogIndex = nDialogIndex; // todo: not a very efficient method of getting a UINT16 from the list -> it has to create a brand new list! _nOffset = movementOffsetDataChunk.GetChunkAsUint16List() [nDialogIndex]; // if it has the value of 0xFFFF then it indicates there are currently no instructions if (_nOffset == 0xFFFF) { return; } // calculate the offset int nOffsetIndex = (nDialogIndex) * (MAX_COMMAND_LIST_ENTRIES * MAX_MOVEMENT_COMMAND_SIZE); // get a copy because the GetAsByteList is an expensive method call List <byte> rawData = movementInstructionDataChunk.GetAsByteList(); // gets a smaller version of it - much easier to keep track of _loadedData = rawData.GetRange(nOffsetIndex, MAX_COMMAND_LIST_ENTRIES * 2); int nIndex = _nOffset; for (int i = 0; i < MAX_COMMAND_LIST_ENTRIES; i++) { byte nIterations = _loadedData[nIndex]; MovementCommandDirection direction = (MovementCommandDirection)_loadedData[nIndex + 1]; // if we have hit 0xFF then there is nothing else in the list and we can just return if (nIterations == 0xFF || nIterations == 0) { return; } if (!(direction == MovementCommandDirection.East || direction == MovementCommandDirection.West || direction == MovementCommandDirection.North || direction == MovementCommandDirection.South)) { throw new Ultima5ReduxException("a bad direction was set: " + direction.ToString()); } // we have a proper movement instruction so let's add it to the queue MovementCommand movementCommand = new MovementCommand(direction, nIterations); //this.movementQueue.Enqueue(movementCommand); AddNewMovementInstruction(movementCommand); // we actually grab from the offset, but it is circular, so we need to mod it nIndex = (nIndex + 2) % (MAX_COMMAND_LIST_ENTRIES * 2); } }
public void ConstructorShouldSetMovements(IList <Movement> expected) { var sut = new MovementCommand(expected); var actual = sut.Movements; actual.Should().BeEquivalentTo(expected); }
public void SetRecieverShouldAcceptMovements(IList <Movement> movements, [Frozen] Mock <IRover> rover) { var sut = new MovementCommand(movements); Action actual = () => sut.SetReceiver(rover.Object); actual.Should().NotThrow <System.Exception>(); }
void OnEnable() { player1 = GameObject.FindGameObjectWithTag("Player"); player2 = GameObject.FindGameObjectWithTag("PlayerClone"); currentPlayer = player1; currentPlayer.GetComponent <Player>().Indicator.SetActive(true); command = new MovementCommand(currentPlayer.GetComponent <Player>()); }
public Action(Point position, MovementCommand movementCommand) { Position = position; MovementCommand = movementCommand; OriginalMovementCommand = movementCommand; _availableMovementCommands = MovementCommand.All.Except(new[] { movementCommand }).ToList(); }
public void SetRecieverAndExecuteShouldMakeRoverMove(IList <Movement> expected, [Frozen] Mock <IRover> rover) { var sut = new MovementCommand(expected); sut.SetReceiver(rover.Object); sut.Execute(); rover.Verify(p => p.Move(expected), Times.Once); }
public void sendMovementCommand(MovementCommand command) { // Create new command packet to send. GloObject <GloDrivingCommand> gloCommand = new GloObject <GloDrivingCommand>(Glo.IDs.DrivingCommand); gloCommand.data.movementType = (UInt32)command; link.send(gloCommand); }
private void AskMoveNextPoint(int index) { TimeElapsed[index] -= MovingSpeed; if (CurrentIndex[index] >= Commands.Count - 1) { CurrentIndex[index] = Commands.Count - 1; WaitingDeath[index] = true; return; } else { CurrentIndex[index]++; } MovementCommand command = Commands[CurrentIndex[index]]; Vector3 offset = Vector3.up * Height; Vector2 newCoord; PositionMovementStart[index] = MapReference.MapCoordinatesToWorldSpace(CurrentPoint[index]) + offset; if (MapReference.CanMoveTo(CurrentPoint[index], command, out newCoord)) { if ((int)(CurrentPoint[index] - newCoord).magnitude != 1) { WaitingDeath[index] = true; AddTrailFromExisting(index, newCoord); switch (Commands[CurrentIndex[index]]) { case MovementCommand.Up: offset.z = OutOfBoundOffset; break; case MovementCommand.Down: offset.z = -OutOfBoundOffset; break; case MovementCommand.Left: offset.x = -OutOfBoundOffset; break; case MovementCommand.Right: offset.x = OutOfBoundOffset; break; } PositionMovementEnd[index] = PositionMovementStart[index] + offset; } else { CurrentPoint[index] = newCoord; PositionMovementEnd[index] = MapReference.MapCoordinatesToWorldSpace(CurrentPoint[index]) + offset; } } }
// Use this for initialization void Start() { ActivePlayer = this; pooledCommand = new MovementCommand { x = 0, y = 0, lifetime = -1.0f }; }
public async Task <IActionResult> MovePlayer(string nickname, [FromBody] MovementCommand command) { if (string.IsNullOrWhiteSpace(nickname)) { return(BadRequest("Username cannot be null or empty.")); } var playerPosition = await _movementService.MovePlayer(nickname, command.Direction); return(Ok(playerPosition)); }
public void CreateMovementCommand_GarbageString_ThrowsArgumentException() { string rawCommand = "K334/.e;fe"; Assert.Throws <System.ArgumentException>( delegate { MovementCommand command = new MovementCommand(rawCommand); } ); }
public void CreateMovementCommand_NullStringInserted_ThrowsArgumentNullException() { string rawCommand = null; Assert.Throws <System.ArgumentNullException>( delegate { MovementCommand command = new MovementCommand(rawCommand); } ); }
public void CreateMovementCommand_InvalidSideIdentifier_ThrowsArgumentException() { string rawCommand = "<XF255F255F255>"; Assert.Throws <System.ArgumentException>( delegate { MovementCommand command = new MovementCommand(rawCommand); } , "Command sent: " + rawCommand); }
public void CreateMovementCommand_InvalidMotor2Direction_ThrowsArgumentException() { string rawCommand = "<RF255X255F255>"; Assert.Throws <System.ArgumentException>( delegate { MovementCommand command = new MovementCommand(rawCommand); } , "Command sent: " + rawCommand); }
public void CreateMovementCommand_Motor3SpeedLowerThanMin_ThrowsArgumentException() { string rawCommand = "<LF255F255F-50>"; Assert.Throws <System.ArgumentException>( delegate { MovementCommand command = new MovementCommand(rawCommand); } , "Command sent: " + rawCommand); }
private void UpdateCommandVariables() { currentCommand = patterns[patternIndex].movementCommands[patternCommandIndex]; startPos = transform.position; point = currentCommand.point; isDuration = (currentCommand.movementEnd == MovementEnd.Duration); duration = currentCommand.duration; direction = currentCommand.durationDirection; worldPoint = Game.ToWorld(point); durationResultantPoint = Game.ToWorld(direction.normalized * currentCommand.durationMoveSpeed * duration); }
public MovementEntry(byte type, int data01, int data02, byte cmd, int cmdData01, int cmdData02, Vector3 position, Vector3 rotation) { Data01 = data01; Data02 = data02; Position = position; Rotation = rotation; Type = (MovementType)type; CommandData01 = cmdData01; CommandData02 = cmdData02; Command = (MovementCommand)cmd; }
public void CreateMovementCommand_Motor2SpeedHigherThanMax_ThrowsArgumentException() { string rawCommand = "<LF255F999F255>"; Assert.Throws <System.ArgumentException>( delegate { MovementCommand command = new MovementCommand(rawCommand); } , "Command sent: " + rawCommand); }
public void ApplyCommandOnPlayer(PlayerBody body, MovementCommand command, float deltaTime = -1) { if(deltaTime < 0) { deltaTime = Time.deltaTime; } if(command.HasMovement) { Debug.Log("Command have ("+command.FrontAxis+","+command.LateralAxis+")"); Transform cameraReference = body.ActiveCamera.transform; Rigidbody rigidbody = body.gameObject.rigidbody; Transform playerTransform = body.gameObject.transform; //calculate target movement Vector3 targetMovement = (command.FrontAxis * cameraReference.forward) + (command.LateralAxis * cameraReference.right); targetMovement.y = 0; //purge vertical component targetMovement.Normalize(); //normalize Vector2 commandVector = new Vector2(command.FrontAxis, command.LateralAxis); //accelerate toward target movement rigidbody.AddForce(targetMovement * commandVector.magnitude * body.LinearAcceleration * deltaTime); //gradually rotate front toward target Vector3 currentFront = playerTransform.forward; currentFront.y = 0; currentFront.Normalize(); //prevent float angle = Vector3.Angle(currentFront, targetMovement); if(angle != 0) { //check if remaining delta is smaller than what's percorrble with current angular velocity playerTransform.rotation = Quaternion.LookRotation(Vector3.RotateTowards(playerTransform.forward, targetMovement, body.RotAcceleration * deltaTime, body.LinearAcceleration * deltaTime)); /* float potential = body.RotAcceleration * deltaTime; if(angle < potential) { playerTransform.rotation = Quaternion.LookRotation(Vector3.RotateTowards(playerTransform.forward, targetMovement, 0, 0)); } else { rigidbody.AddTorque(body.transform.up * potential); } */ } } if(command.TestButton(MovementCommand.ActionFlags.Jump)) { body.Jump(); } }
public void CreateMovementCommand_InvalidMotor1Direction_ThrowsArgumentException() { string rawCommand = "<RX255F255F255>"; Assert.Throws<System.ArgumentException>( delegate { MovementCommand command = new MovementCommand(rawCommand); } , "Command sent: " + rawCommand); }
public void CreateMovementCommand_GarbageString_ThrowsArgumentException() { string rawCommand = "K334/.e;fe"; Assert.Throws<System.ArgumentException>( delegate { MovementCommand command = new MovementCommand(rawCommand); } ); }
public void Movement(string direction, Camera2D cam) { var xmovement = direction.Contains("L") ? -5 : direction.Contains("R") ? 5 : 0; var ymovement = direction.Contains("U") ? -5 : direction.Contains("D") ? 5 : 0; var command = new MovementCommand(player, xmovement, ymovement, direction, ICommand.GenerateRandID()); cam.Move(new Vector2(xmovement, ymovement)); Thread thread = new Thread(command.Run); thread.Start(); SendMessage(command); }
public void CreateMovementCommand_ValidRightFullForward_InitializesProperly() { string rawCommand = "<RF255F255F255>"; MovementCommand command = new MovementCommand(rawCommand); Assert.AreEqual(command.MotorSide, "R", "Should be \"R\""); Assert.AreEqual(command.Motor1Speed, 255, "Should be 255"); Assert.AreEqual(command.Motor2Speed, 255, "Should be 255"); Assert.AreEqual(command.Motor3Speed, 255, "Should be 255"); Assert.AreEqual(command.Motor1Direction, "F", "Should be \"F\""); Assert.AreEqual(command.Motor2Direction, "F", "Should be \"F\""); Assert.AreEqual(command.Motor3Direction, "F", "Should be \"F\""); }
internal void DispatchOnKey(Key key) { IRogueCommand command = null; if (Directions.ContainsKey(key)) { bool shouldRun = Keyboard.IsKeyDown(Key.LeftShift) || Keyboard.IsKeyDown(Key.RightShift); command = new MovementCommand(Directions[key], shouldRun); } _mainWindow.MessageTextblock.Text = string.Empty; _game.EnqueueAndProcess(command); }
public void CreateCommandFactory_TooFewSteps_StepsShouldBe1() { //arrange CommandFactory commandFactory = new CommandFactory(); //act commandFactory.AddInput("1"); commandFactory.AddInput("10 22"); commandFactory.AddInput("E -3"); MovementCommand movementCommand = commandFactory._commandSet.MovementCommands[0]; //assert Assert.AreEqual(1, movementCommand.MoveSteps); }
public MovementCommand ParseInputForCommands() { MovementCommand movCommand = new MovementCommand (); //movement axis movCommand.LateralAxis = Input.GetAxis (LEFT_RIGHT_AXIS_NAME); movCommand.FrontAxis = Input.GetAxis (BACK_FORWARD_AXIS_NAME); if(Input.GetAxis(JUMP_AXIS_NAME) > 0) { movCommand.AddButton(ActionFlags.Jump); } return movCommand; }
public void CreateMovementCommand_NullStringInserted_ThrowsArgumentNullException() { string rawCommand = null; Assert.Throws<System.ArgumentNullException>( delegate { MovementCommand command = new MovementCommand(rawCommand); } ); }
public void CreateMovementCommand_Motor3SpeedLowerThanMin_ThrowsArgumentException() { string rawCommand = "<LF255F255F-50>"; Assert.Throws<System.ArgumentException>( delegate { MovementCommand command = new MovementCommand(rawCommand); } , "Command sent: " + rawCommand); }
public void CreateMovementCommand_Motor2SpeedHigherThanMax_ThrowsArgumentException() { string rawCommand = "<LF255F999F255>"; Assert.Throws<System.ArgumentException>( delegate { MovementCommand command = new MovementCommand(rawCommand); } , "Command sent: " + rawCommand); }
public void CreateMovementCommand_InvalidSideIdentifier_ThrowsArgumentException() { string rawCommand = "<XF255F255F255>"; Assert.Throws<System.ArgumentException>( delegate { MovementCommand command = new MovementCommand(rawCommand); } , "Command sent: " + rawCommand); }