private void OnMovement(InputValue value)
{
Vector2 rawInpVec = value.Get <Vector2>();
//Debug.Log("OnMovement" + rawInpVec);
MovementEvent?.Invoke(rawInpVec);
}
[ClientRpc] void RpcEndMovement(int i)
{
MovementEvent movementEvent = movementEvents [i];
movementEvent.done = true;
UpdateColor();
}
public void HandleMissive(MovementEvent missive)
{
if (!Footstep.isPlaying)
{
footstepSound(missive.position);
}
}
public MovableImpl(ILoggerFactory loggerFactory, MovementEvent movementEvent, IEventRecorder eventRecorder)
{
_movementEvent = movementEvent;
_eventRecorder = eventRecorder;
_logger = loggerFactory.CreateLogger <MovableImpl>();
_stringBuilder = new StringBuilder();
}
private void DeselectCurrentPosition(MovementEvent state)
{
var gameHasStarted = (state != null);
if (gameHasStarted)
{
results[state.MovementData.CurrentPosition.ToString()].Deselect();
}
}
private void ProcessMovement()
{
var destination = MouseHelper.GetPositionUnderMouse();
var movementEvent = new MovementEvent(destination);
movementEventRepository.SetValue(movementEvent);
SetDirection();
}
void EndMovement(int i)
{
MovementEvent movementEvent = movementEvents [i];
print("Arrive at " + VTEUtil.GetTime() + " after " + (VTEUtil.GetTime() - movementEvent.time));
print("Completing movement " + i.ToString() + " : " + movementEvent.ToString());
movementEvent.done = true;
gameObject.SendMessage("OnArrivedAtPlanet", movementEvent.tgtPlanet);
RpcEndMovement(i);
}
public static MovementEvent read(BinaryReader binaryReader)
{
MovementEvent newObj = new MovementEvent();
newObj.object_id = binaryReader.ReadUInt32();
newObj.instance_timestamp = binaryReader.ReadUInt16();
newObj.movement_data = MovementData.read(binaryReader);
return(newObj);
}
void FixedUpdate()
{
frameMovement.sprint = _movement.sprintTime;
Vector3 tempForce = _movement.ApplyForces(frameMovement.forceNextFrame);
MovementEvent?.Invoke(frameMovement);
frameMovement = new FrameMovement();
frameMovement.position = transform.position;
frameMovement.forceNextFrame = tempForce;
}
public MovementInfo(MovementEvent onFall, MovementEvent onJump)
{
this.mOnFall = onFall;
this.mOnJump = onJump;
this.IsAllowedToMove = true;
this.mIsFalling = false;
this.mIsJumping = false;
this.IsPushedByArcaneLevitator = false;
this.IsMovementForced = false;
this.mMoveDirection = new Vector3();
this.ClearInfo();
}
public MovementInfo(MovementEvent onFall, MovementEvent onJump)
{
this.mOnFall = onFall;
this.mOnJump = onJump;
this.IsAllowedToMove = true;
this.mIsFalling = false;
this.mIsJumping = false;
this.IsPushedByArcaneLevitator = false;
this.IsMovementForced = false;
this.mMoveDirection = new Vector3();
this.ClearInfo();
}
void OnMovementEvent(MovementEvent e)
{
mouseDrag = false;
if (e.Direction == "left")
{
moveLeft = !e.EndClick;
}
else
{
moveRight = !e.EndClick;
}
}
public void AddMovementEvent(FVector2 destination, float travelTime, int interpType = 0, float delay = 0.0f, bool guaranteeArrival = false )
{
SetupPhysics();
MovementEvent move = new MovementEvent();
move.destination = destination;
move.travelTime = travelTime;
move.interpType = interpType;
move.delay = delay;
move.guaranteeArrival = guaranteeArrival;
movementEventList.AddLast(move);
if(!movementActive) {
StartMovementEvent();
}
}
public void AddMovementEvent(FVector2 destination, float travelTime, int interpType = 0, float delay = 0.0f, bool guaranteeArrival = false)
{
SetupPhysics();
MovementEvent move = new MovementEvent();
move.destination = destination;
move.travelTime = travelTime;
move.interpType = interpType;
move.delay = delay;
move.guaranteeArrival = guaranteeArrival;
movementEventList.AddLast(move);
if (!movementActive)
{
StartMovementEvent();
}
}
public override void OnEvent(MovementEvent _movementEvent)
{
base.OnEvent(_movementEvent);
if (_movementEvent.character.Equals(character))
{
if (_movementEvent.type == MovementEventType.Stop)
{
StopEnemy(true);
}
else if (_movementEvent.type == MovementEventType.Move)
{
StopEnemy(false);
}
}
return;
}
public float GetApparentTime()
{
float time = 0;
for (int i = GetCurrentMovementEventIdx(); i >= 0; --i)
{
MovementEvent movementEvent = movementEvents [i];
time = VTEUtil.GetApparentTime(movementEvent.startPos, movementEvent.tgtPos, movementEvent.time, unitsPerSec, VTEUtil.GetLocalPlayerComponent <Moveable> ().GetActualPosition());
if (time >= 0)
{
break;
} // else {
// print ("Going back " + (1 + GetCurrentMovementEventIdx () - i).ToString ());
// }
}
return(time);
}
Vector3?GetPositionAt(float time)
{
if (time <= 0)
{
return(null);
}
InitMovementEvents();
MovementEvent lastDeparture = movementEvents.FindLast(movementEvent => movementEvent.time <= time);
if (lastDeparture == null)
{
return(null);
}
float timeRequired = Vector3.Distance(lastDeparture.startPos, lastDeparture.tgtPos) / unitsPerSec;
float fractionCompleted = (time - lastDeparture.time) / timeRequired;
// print (lastDeparture);
// print("Apparent Time" + time.ToString() + " Actual time " + VTEUtil.GetTime() );
// print ("Fraction completed = " + fractionCompleted);
return(Vector3.Lerp(lastDeparture.startPos, lastDeparture.tgtPos, fractionCompleted));
}
private IEnumerator MovementEventHelper(MovementEvent move)
{
//print ("currentPosition: " + body.Position);
//print ("should be moving");
if (move.delay > 0.0f)
{
yield return(new WaitForSeconds(move.delay));
}
FVector2 speed = GetConstantSpeed(body.Position, move.destination, move.travelTime);
body.LinearVelocity = speed;
//Wait for movement to finish
yield return(new WaitForSeconds(move.travelTime));
//We're done, stop the object
body.LinearVelocity = FVector2.Zero;
if (move.guaranteeArrival)
{
body.Position = move.destination;
}
}
/// <summary>
/// Create a battle animation, given a certain move.
/// </summary>
/// <param name="move">The move to create an animation for.</param>
/// <returns></returns>
public Timeline createBattleAnimation(BattleMove move)
{
//TODO: Creating and handling a move's animation should be more robust and maintainable. This is a bit of a hack.
//Create the animation timeline.
Timeline animation = new Timeline(move);
//Check the name of the move and create a fitting animation.
switch (move.Name)
{
case "Ember":
{
//Add events to the timeline.
ModifyEnergyEvent energy = new ModifyEnergyEvent(animation, 0, null, move.User, -move.EnergyConsume);
ModifyControlEvent state = new ModifyControlEvent(animation, 0, energy, move, move.User, false);
ModifyCancelableEvent cancel = new ModifyCancelableEvent(animation, 0, energy, move, false);
ProjectileEvent projectile = new ProjectileEvent(animation, 0, null, move.User.Position, new Destination(move.Target));
ModifyHealthEvent damage = new ModifyHealthEvent(animation, 0, projectile, move.Target, -move.GetDamage());
ImpactEvent impact = new ImpactEvent(animation, 0, projectile, move);
//Add the events to the timeline.
animation.AddEvent(energy);
animation.AddEvent(state);
animation.AddEvent(cancel);
animation.AddEvent(projectile);
animation.AddEvent(damage);
animation.AddEvent(impact);
break;
}
case "Scratch":
{
//Add events to the timeline.
ModifyControlEvent stateStart = new ModifyControlEvent(animation, 0, null, move, move.User, true);
MovementEvent moveTo = new MovementEvent(animation, 0, null, move.User, new Destination(move.Target), MovementType.Run);
ModifyCancelableEvent cancel = new ModifyCancelableEvent(animation, 0, moveTo, move, false);
ModifyHealthEvent damage = new ModifyHealthEvent(animation, 0, moveTo, move.Target, -move.GetDamage());
ModifyEnergyEvent energy = new ModifyEnergyEvent(animation, 0, damage, move.User, -move.EnergyConsume);
ModifyControlEvent stateEnd = new ModifyControlEvent(animation, 0, energy, move, move.User, false);
ImpactEvent impact = new ImpactEvent(animation, 0, moveTo, move);
//Add the events to the timeline.
animation.AddEvent(stateStart);
animation.AddEvent(moveTo);
animation.AddEvent(cancel);
animation.AddEvent(damage);
animation.AddEvent(energy);
animation.AddEvent(stateEnd);
animation.AddEvent(impact);
break;
}
default: { goto case "Scratch"; }
}
//Return the animation.
return animation;
}
private void RaiseMovementEvent(int entity, Direction dir)
{
MovementEvent?.Invoke(entity, dir);
}
public override void OnPointerDown(PointerEventData eventData)
{
base.OnPointerDown(eventData);
_currentMovementEvent = MovementEvent.Moving;
Debug.Log("PewPewJoystick is Moving");
}
public override void OnPointerUp(PointerEventData eventData)
{
base.OnPointerUp(eventData);
_currentMovementEvent = MovementEvent.Stopped;
Debug.Log("PewPewJoystick is Stopped");
}
public abstract void HandleMovementEvent(MovementEvent move);
/// <summary>
/// Processes the message
/// </summary>
/// <param name="connectionBase">The connection base</param>
/// <param name="message">The playerio message</param>
/// <param name="handled">Whether the message was already handled</param>
public void Process(ConnectionBase connectionBase, Message message, bool handled)
{
int userId = message.GetInt(0);
double x = message.GetDouble(1);
double y = message.GetDouble(2);
double speedX = message.GetDouble(3);
double speedY = message.GetDouble(4);
int modifierX = message.GetInt(5);
int modifierY = message.GetInt(6);
int horizontal = message.GetInt(7);
int vertical = message.GetInt(8);
bool spacedown = message.GetBoolean(10);
WorldConnection worldCon = (WorldConnection)connectionBase;
WorldPlayer player = worldCon.Players.GetPlayer(userId);
if (!handled && player != null)
{
Input playerInput = 0;
if (horizontal != player.Horizontal)
{
if (horizontal < 0)
{
playerInput |= Input.HoldLeft;
}
else if (horizontal > 0)
{
playerInput |= Input.HoldRight;
}
else if (horizontal == 0)
{
if ((player.LastInput & Input.HoldLeft) != 0)
{
playerInput |= Input.ReleaseLeft;
}
else if ((player.LastInput & Input.HoldRight) != 0)
{
playerInput |= Input.ReleaseRight;
}
}
}
if (vertical != player.Vertical)
{
if (vertical < 0)
{
playerInput |= Input.HoldUp;
}
else if (vertical > 0)
{
playerInput |= Input.HoldDown;
}
else if (vertical == 0)
{
if ((player.LastInput & Input.HoldUp) != 0)
{
playerInput |= Input.ReleaseUp;
}
else if ((player.LastInput & Input.HoldDown) != 0)
{
playerInput |= Input.ReleaseDown;
}
}
}
player.X = x;
player.Y = y;
player.SpeedX = speedX;
player.SpeedY = speedY;
player.ModifierX = modifierX;
player.ModifierY = modifierY;
player.Horizontal = horizontal;
player.Vertical = vertical;
player.SpaceDown = spacedown;
player.LastInput = playerInput;
worldCon.Physics.ServerUpdate(player);
}
MovementEvent movementEvent = new MovementEvent()
{
Raw = message,
Player = player,
Input = (player == null) ? Input.Nothing : player.LastInput
};
connectionBase.RaiseServerEvent <MovementEvent>(movementEvent);
}
public void UpdateFromRecordedMovement(FrameMovement frameMovement)
{
_head.rotation = frameMovement.look;
if (grabFrameBuffer > 0 || frameMovement.grab)
{
if (_grabber.Grab())
{
grabFrameBuffer = 0;
}
else
{
--grabFrameBuffer;
}
}
if (frameMovement.release)
{
if (_grabber.Release())
{
grabFrameBuffer = 0;
}
}
SetAnimatorValues(frameMovement.hMov, frameMovement.vMov);
/*
* if (frameMovement.jump) _movement.Jump();
* _movement.sprintTime = frameMovement.sprint;
* _movement.ApplyForces(frameMovement.forceNextFrame);
*
* if (Vector3.Distance(transform.position, frameMovement.position) < 0.1f)
* {
* transform.position = frameMovement.position;
* }
* else
* {
* Debug.Log(name + " desynced!");
* }
*/
if (synced && frameMovement.jump && !_feet.isGrounded && _movement.jumping)
{
//synced = false;
Debug.Log(name + " desynced!");
}
if (synced)
{
_movement.Move(frameMovement.position);
}
else
{
if (frameMovement.jump)
{
_movement.Jump();
}
_movement.sprintTime = frameMovement.sprint;
_movement.ApplyForces(frameMovement.forceNextFrame);
}
MovementEvent?.Invoke(frameMovement);
}
public override bool acceptMessageData(BinaryReader messageDataReader, TreeView outputTreeView)
{
bool handled = true;
PacketOpcode opcode = Util.readOpcode(messageDataReader);
switch (opcode)
{
// TODO: PacketOpcode.Evt_Movement__PositionAndMovement_ID
case PacketOpcode.Evt_Movement__Jump_ID: {
Jump message = Jump.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
case PacketOpcode.Evt_Movement__MoveToState_ID: {
MoveToState message = MoveToState.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
case PacketOpcode.Evt_Movement__DoMovementCommand_ID: {
DoMovementCommand message = DoMovementCommand.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
// TODO: PacketOpcode.Evt_Movement__TurnEvent_ID
// TODO: PacketOpcode.Evt_Movement__TurnToEvent_ID
case PacketOpcode.Evt_Movement__StopMovementCommand_ID: {
StopMovementCommand message = StopMovementCommand.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
case PacketOpcode.Evt_Movement__UpdatePosition_ID: {
UpdatePosition message = UpdatePosition.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
case PacketOpcode.Evt_Movement__MovementEvent_ID: {
MovementEvent message = MovementEvent.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
case PacketOpcode.Evt_Movement__AutonomyLevel_ID: {
AutonomyLevel message = AutonomyLevel.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
case PacketOpcode.Evt_Movement__AutonomousPosition_ID: {
AutonomousPosition message = AutonomousPosition.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
case PacketOpcode.Evt_Movement__Jump_NonAutonomous_ID: {
Jump_NonAutonomous message = Jump_NonAutonomous.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
default: {
handled = false;
break;
}
}
return(handled);
}
public static MovementEvent read(BinaryReader binaryReader)
{
MovementEvent newObj = new MovementEvent();
newObj.object_id = binaryReader.ReadUInt32();
newObj.instance_timestamp = binaryReader.ReadUInt16();
newObj.server_control_timestamp = binaryReader.ReadUInt16();
newObj.movement_timestamp = binaryReader.ReadUInt16();
newObj.autonomous = binaryReader.ReadByte();
Util.readToAlign(binaryReader);
newObj.movementType__guessedname = (MovementTypes.Type)binaryReader.ReadUInt16();
newObj.style = (MotionStyle)command_ids[binaryReader.ReadUInt16()];
switch (newObj.movementType__guessedname)
{
// TODO: This now needs to mimic the rest of MovementManager::unpack_movement here
case MovementTypes.Type.Invalid: {
newObj.motionState__guessedname = InterpretedMotionState.read(binaryReader);
if (((ushort)newObj.movementType__guessedname & 0x100) != 0) // TODO: Double check that this is the correct mask here
{
newObj.stickToObject = binaryReader.ReadUInt32();
}
break;
}
case MovementTypes.Type.MoveToObject: {
newObj.moveToObject = binaryReader.ReadUInt32();
newObj.moveToPos = Position.readOrigin(binaryReader);
newObj.movementParams__guessedname = MovementParameters.read(newObj.movementType__guessedname, binaryReader);
newObj.my_run_rate = binaryReader.ReadSingle();
break;
}
case MovementTypes.Type.MoveToPosition: {
newObj.moveToPos = Position.readOrigin(binaryReader);
newObj.movementParams__guessedname = MovementParameters.read(newObj.movementType__guessedname, binaryReader);
newObj.my_run_rate = binaryReader.ReadSingle();
break;
}
case MovementTypes.Type.TurnToObject: {
newObj.turnToObject = binaryReader.ReadUInt32();
newObj.turnToHeading = binaryReader.ReadSingle();
newObj.movementParams__guessedname = MovementParameters.read(newObj.movementType__guessedname, binaryReader);
break;
}
case MovementTypes.Type.TurnToHeading: {
newObj.movementParams__guessedname = MovementParameters.read(newObj.movementType__guessedname, binaryReader);
break;
}
default: {
break;
}
}
return(newObj);
}
private IEnumerator MovementEventHelper(MovementEvent move)
{
//print ("currentPosition: " + body.Position);
//print ("should be moving");
if(move.delay > 0.0f) {
yield return new WaitForSeconds(move.delay);
}
FVector2 speed = GetConstantSpeed(body.Position, move.destination, move.travelTime);
body.LinearVelocity = speed;
//Wait for movement to finish
yield return new WaitForSeconds(move.travelTime);
//We're done, stop the object
body.LinearVelocity = FVector2.Zero;
if(move.guaranteeArrival) {
body.Position = move.destination;
}
}
/// <summary>
/// Sends movement event with ControlledEntity
/// </summary>
/// <param name="dir">Direction of movement</param>
private void MoveEntity(Direction dir)
{
MovementEvent?.Invoke(ControlledEntity, dir);
}
