/*
* ProcessUserCmd
* Parameters:
* 1) UserCmd cmd
* This is the usercmd that we're going to process, this code should only be called on the server instance of the object
* TODO(Jake): Allow the local player to process their own usercmd upon creation AKA Client-Sided Prediction
* https://en.wikipedia.org/wiki/Client-side_prediction
*/
public void ProcessUserCmd(UserCmd cmd)
{
if (cmd.ActionPressed(PlayerInputSynchronization.IN_FIRE))
{
//Fire!
}
if (cmd.ActionPressed(PlayerInputSynchronization.IN_ACCELERATE))
{
//Accelerate!
Debug.Log("Accelerate!");
}
bool moveLeft = cmd.ActionPressed(PlayerInputSynchronization.IN_LEFT),
moveRight = cmd.ActionPressed(PlayerInputSynchronization.IN_RIGHT);
if (moveLeft ^ moveRight)
{
if (moveLeft)
{
m_TargetController.HorizontalMoveDirection = -1;
}
else
{
m_TargetController.HorizontalMoveDirection = 1;
}
}
else
{
m_TargetController.HorizontalMoveDirection = 0;
}
if (cmd.ActionPressed(PlayerInputSynchronization.IN_RIGHT))
{
}
}
public void CopyFrom(object rightComponent)
{
var right = rightComponent as SendUserCmdComponent;
//Seq = right.Seq;
FrameInterval = right.FrameInterval;
MoveHorizontal = right.MoveHorizontal;
MoveUpDown = right.MoveUpDown;
MoveVertical = right.MoveVertical;
DeltaYaw = right.DeltaYaw;
DeltaPitch = right.DeltaPitch;
RenderTime = right.RenderTime;
ClientTime = right.ClientTime;
ChangedSeat = right.ChangedSeat;
//SnapshotId = right.SnapshotId;
BeState = right.BeState;
Buttons = right.Buttons;
SwitchNumber = right.SwitchNumber;
CurWeapon = right.CurWeapon;
UseEntityId = right.UseEntityId;
ManualPickUpEquip = right.ManualPickUpEquip;
AutoPickUpEquip = UserCmd.CopyList(AutoPickUpEquip, right.AutoPickUpEquip);
UseVehicleSeat = right.UseVehicleSeat;
UseType = right.UseType;
ChangeChannel = right.ChangeChannel;
BagIndex = right.BagIndex;
}
public static ReusableList <IUserCmd> FromProtoBuf(UserCmdMessage message)
{
ReusableList <IUserCmd> list = ReusableList <IUserCmd> .Allocate();
var count = message.UserCmdList.Count;
for (int i = 0; i < count; i++)
{
var item = message.UserCmdList[i];
UserCmd cmd = UserCmd.Allocate();
cmd.RenderTime = item.RenderTime;
cmd.FrameInterval = item.FrameInterval;
cmd.MoveHorizontal = item.MoveHorizontal;
cmd.MoveVertical = item.MoveVertical;
cmd.MoveUpDown = item.MoveUpDown;
cmd.Seq = item.Seq;
cmd.DeltaPitch = item.DeltaPitch;
cmd.DeltaYaw = item.DeltaYaw;
cmd.Buttons = item.Buttons;
cmd.BeState = item.BeState;
cmd.SwitchNumber = item.SwitchNumber;
cmd.ChangedSeat = item.ChangedSeat;
cmd.ChangeChannel = item.ChangeChannel;
cmd.SnapshotId = item.SnapshotId;
cmd.CurWeapon = item.CurWeapon;
cmd.PickUpEquip = item.PickUpEquip;
cmd.UseEntityId = item.UseVehicleId;
cmd.UseVehicleSeat = item.UseVehicleSeat;
cmd.UseType = item.UseType;
cmd.BagIndex = item.BagIndex;
list.Value.Add(cmd);
}
return(list);
}
void ServerReceiveCommand(NetworkMessage message)
{
InputSynchronizationMessage inputMessage = message.ReadMessage <InputSynchronizationMessage>();
// Get network ID from sent object.
NetworkInstanceId netId = new NetworkInstanceId(inputMessage.netId);
// Find instance of local object.
GameObject foundObj = NetworkServer.FindLocalObject(netId);
// Verify object existance.
if (foundObj == null)
{
return;
}
// Confirm ownership (only works for single player on one machine).
if (message.conn.playerControllers[0].unetView.netId == netId)
{
// Deserialize user command.
UserCmd inputCommand = UserCmd.DeSerialize(inputMessage.messageData);
// Get reference to player input.
PlayerInputSynchronization input = foundObj.GetComponent <PlayerInputSynchronization>();
// Send user command to object.
input.HandleUserCommand(inputCommand);
}
}
public GameClientPersistant()
{
pingSamples = new int[CConstVar.NUM_PING_SAMPLES];
cmdqueue = new UserCmd[CConstVar.MAX_LATENT_CMDS];
cmd = new UserCmd();
}
private void HandleInteractables(IPlayer player, UserCmd cmd)
{
var ent = cmd.HoveredEntity > 0
? Game.EntityManager.FindEntity(cmd.HoveredEntity) as IInteractable
: null;
if (_hoveredEnts.ContainsKey(player.ClientIndex) &&
_hoveredEnts[player.ClientIndex] != cmd.HoveredEntity)
{
var hoveredEnt = Game.EntityManager.FindEntity(_hoveredEnts[player.ClientIndex]);
if (hoveredEnt != null &&
hoveredEnt is IInteractable interactable)
{
interactable.MouseExit(player.ClientIndex);
}
_hoveredEnts.Remove(player.ClientIndex);
}
else if (ent != null)
{
if (_hoveredEnts.ContainsKey(player.ClientIndex) &&
_hoveredEnts[player.ClientIndex] == cmd.HoveredEntity)
{
return;
}
_hoveredEnts[player.ClientIndex] = cmd.HoveredEntity;
ent.MouseEnter(player.ClientIndex);
}
}
public static void UpdateViewAngles(PlayerState ps, UserCmd cmd)
{
if (ps.pmType == PMoveType.INTERMISSION || ps.pmType == PMoveType.SPINGTERMISSION)
{
return;
}
//TODO:state
if (ps.pmType != PMoveType.SPECTATOR && ps.states[0] <= 0)
{
return;
}
int temp;
for (int i = 0; i < 3; i++)
{
temp = cmd.angles[i] + ps.delta_angles[i];
if (i == 0)
{
if (temp > 16000)
{
ps.delta_angles[i] = 16000 - cmd.angles[i];
temp = 16000;
}
else if (temp < -16000)
{
ps.delta_angles[i] = -16000 - cmd.angles[i];
temp = -16000;
}
}
ps.viewangles[i] = temp * 360 / 65536;
}
}
public static void CopyForm(UserCmd cmd, SendUserCmdComponent right)
{
//cmd.Seq = right.Seq;
cmd.FrameInterval = right.FrameInterval;
cmd.MoveHorizontal = right.MoveHorizontal;
cmd.MoveUpDown = right.MoveUpDown;
cmd.MoveVertical = right.MoveVertical;
cmd.DeltaYaw = right.DeltaYaw;
cmd.DeltaPitch = right.DeltaPitch;
cmd.RenderTime = right.RenderTime;
cmd.ClientTime = right.ClientTime;
cmd.ChangedSeat = right.ChangedSeat;
//cmd.SnapshotId = right.SnapshotId;
cmd.BeState = right.BeState;
cmd.Buttons = right.Buttons;
cmd.SwitchNumber = right.SwitchNumber;
cmd.CurWeapon = right.CurWeapon;
cmd.UseEntityId = right.UseEntityId;
cmd.PickUpEquip = right.PickUpEquip;
cmd.UseVehicleSeat = right.UseVehicleSeat;
cmd.UseType = right.UseType;
cmd.ChangeChannel = right.ChangeChannel;
cmd.BagIndex = right.BagIndex;
}
public void WriteDeltaUserCmdKey(int key, ref UserCmd from, ref UserCmd to)
{
if (to.serverTime - from.serverTime < 256)
{
WriteBits(1, 1);
WriteBits(to.serverTime - from.serverTime, 8);
}
else
{
WriteBits(0, 1);
WriteBits(to.serverTime, 32);
}
if (from.angles[0] == to.angles[0] &&
from.angles[1] == to.angles[1] &&
from.angles[2] == to.angles[2] &&
from.forwardmove == to.forwardmove &&
from.rightmove == to.rightmove &&
from.upmove == to.upmove &&
from.buttons == to.buttons)
{
WriteBits(0, 1);
return;
}
key ^= to.serverTime;
WriteBits(1, 1);
WriteDeltaKey(key, from.angles[0], to.angles[0], 16);
WriteDeltaKey(key, from.angles[1], to.angles[1], 16);
WriteDeltaKey(key, from.angles[2], to.angles[2], 16);
WriteDeltaKey(key, from.forwardmove, to.forwardmove, 8);
WriteDeltaKey(key, from.rightmove, to.rightmove, 8);
WriteDeltaKey(key, from.upmove, to.upmove, 8);
WriteDeltaKey(key, from.buttons, to.buttons, 16);
}
/*
* ProcessUserCmd
* Parameters:
* 1) UserCmd cmd
* This is the usercmd that we're going to process, this code should only be called on the server instance of the object
* TODO(Jake): Allow the local player to process their own usercmd upon creation AKA Client-Sided Prediction
* https://en.wikipedia.org/wiki/Client-side_prediction
*/
public PlayerState ProcessUserCmd(UserCmd cmd, PlayerState playerState, float dt)
{
if (isServer)
{
// Check if we're trying to fire.
if (cmd.ActionWasReleased(PlayerInputSynchronization.IN_FIRE, Input.LastUserCommand))
{
GameObject projectile = Instantiate(
m_ProjectilePrefab,
m_TargetController.transform.position + m_ProjectileOffset,
m_ProjectilePrefab.transform.rotation);
NetworkServer.Spawn(projectile);
audiosource.PlayOneShot(sound_shoot, 0.3f);
}
else
{
//Debug.Log("NOt fired");
}
}
if (m_TargetController)
{
return(m_TargetController.StateUpdate(cmd, playerState, dt)); //Move our ship
}
return(null);
}
private void SendUserCmds()
{
var last = new UserCmd();
using (var stream = Bitstream.Create()) {
var move = new CCLCMsg_Move();
move.num_backup_commands = (uint)backup.Count;
foreach (var cmd in backup)
{
WriteUserCmd(cmd, last, stream);
last = cmd;
}
move.num_new_commands = (uint)next.Count;
foreach (var cmd in next)
{
WriteUserCmd(cmd, last, stream);
last = cmd;
}
backup.Clear();
backup.AddRange(next);
next.Clear();
move.data = stream.ToBytes();
var tick = new CNETMsg_Tick();
tick.tick = client.ServerTick;
connection.SendUnreliably(
Connection.ConvertProtoToMessage <CCLCMsg_Move>((uint)CLC_Messages.clc_Move, move),
Connection.ConvertProtoToMessage <CNETMsg_Tick>((uint)NET_Messages.net_Tick, tick));
}
}
public static void CopyForm(this SendUserCmdComponent component, IUserCmd right)
{
//component.Seq = right.Seq;
component.FrameInterval = right.FrameInterval;
component.MoveHorizontal = right.MoveHorizontal;
component.MoveUpDown = right.MoveUpDown;
component.MoveVertical = right.MoveVertical;
component.DeltaYaw = right.DeltaYaw;
component.DeltaPitch = right.DeltaPitch;
component.RenderTime = right.RenderTime;
component.ChangedSeat = right.ChangedSeat;
//component.SnapshotId = right.SnapshotId;
component.BeState = right.BeState;
component.Buttons = right.Buttons;
component.SwitchNumber = right.SwitchNumber;
component.CurWeapon = right.CurWeapon;
component.UseEntityId = right.UseEntityId;
component.ManualPickUpEquip = right.ManualPickUpEquip;
component.AutoPickUpEquip = UserCmd.CopyList(component.AutoPickUpEquip, right.AutoPickUpEquip);
component.UseVehicleSeat = right.UseVehicleSeat;
component.UseType = right.UseType;
component.ChangeChannel = right.ChangeChannel;
component.BagIndex = right.BagIndex;
}
private void FixedUpdateServer()
{
PlayerState finalState = ServerState;
UserCmd nextCmd = null;
while (m_PlayerInput.NextUserCommand(out nextCmd))
{
finalState = m_TargetPlayer.ProcessUserCmd(nextCmd, finalState, Time.fixedDeltaTime);
}
ServerStateUpdate update = new ServerStateUpdate();
update.netId = m_TargetPlayer.netId.Value;
update.Origin = finalState.Origin;
update.Velocity = finalState.Velocity;
m_TargetPlayer.MoveShip(finalState.Origin);
connectionToClient.SendByChannel(
ServerStateUpdate.MessageID,
update,
Channels.DefaultReliable
);
ServerState = finalState;
}
private void FixedUpdateClient()
{
UserCmd nextCmd = null;
while (m_PlayerInput.NextUserCommand(out nextCmd))
{
//Temporary state for client prediction
NewState = m_TargetPlayer.ProcessUserCmd(nextCmd, LastPredictedState, Time.fixedDeltaTime);
//Client frame for this duration
var frame = new Frame(Time.fixedDeltaTime);
frame.DeltaPosition = NewState.Origin - LastPredictedState.Origin; //Displacement
frame.Velocity = NewState.Velocity;
frame.input = nextCmd;
m_LagRecord.FrameHistory.Add(frame);
m_LagRecord.HistoryDuration += Time.fixedDeltaTime; //Duration of frame
LastPredictedState = NewState;
}
if (isServer)
{
m_TargetPlayer.MoveShip(LastPredictedState.Origin);
}
else
{
float latency = NetworkHandler.Instance.RoundTripTime;
var extrapolatedPosition = LastPredictedState.Origin + NewState.Velocity * latency * (1 + CONVERGENCE_MULTIPLIER);
var dt = Time.fixedDeltaTime;
var interpolationFraction = dt / (latency * (1 + CONVERGENCE_MULTIPLIER));
var clientStatePosition = LastPredictedState.Origin;
clientStatePosition += (extrapolatedPosition - clientStatePosition) * interpolationFraction;
m_TargetPlayer.MoveShip(clientStatePosition);
}
}
public void SV_ClientThink(ClientNode cl, ref UserCmd cmd){
cmd.CopyTo(cl.lastUserCmd);
// CLog.Info("last ucmd time: {0}", cl.lastUserCmd.serverTime);
if(cl.state != ClientState.ACTIVE){
return;
}
CDataModel.GameSimulate.ClientThink(Array.IndexOf(clients, cl));
}
public UserCmd CreateUserCmd()
{
UserCmd newCommand = new UserCmd(
m_LastOutgoingSeq + 1
);
return(newCommand);
}
public void RegisterSpecialCmdKeyInput(KeyReceiver keyReceiver, UserCmd userCmd)
{
keyReceiver.AddAction(UserInputKey.Switch1, (data) => userCmd.CurWeapon = (int)EWeaponSlotType.PrimeWeapon);
keyReceiver.AddAction(UserInputKey.Switch3, (data) => userCmd.CurWeapon = (int)EWeaponSlotType.PistolWeapon);
keyReceiver.AddAction(UserInputKey.Switch4, (data) => userCmd.CurWeapon = (int)EWeaponSlotType.MeleeWeapon);
keyReceiver.AddAction(UserInputKey.Switch5, (data) => userCmd.CurWeapon = (int)EWeaponSlotType.ThrowingWeapon);
// keyReceiver.AddAction(UserInputKey.Switch6, (data) => userCmd.CurWeapon = (int)EWeaponSlotType.TacticWeapon);
}
public void RegisterEnvKeyInput(KeyHandler keyHandler, UserCmd userCmd)
{
keyHandler.BindKeyAction(UserInputKey.Switch1, (data) => userCmd.CurWeapon = (int)EWeaponSlotType.PrimeWeapon);
keyHandler.BindKeyAction(UserInputKey.Switch2, (data) => userCmd.CurWeapon = (int)EWeaponSlotType.SecondaryWeapon);
keyHandler.BindKeyAction(UserInputKey.Switch3, (data) => userCmd.CurWeapon = (int)EWeaponSlotType.PistolWeapon);
keyHandler.BindKeyAction(UserInputKey.Switch4, (data) => userCmd.CurWeapon = (int)EWeaponSlotType.MeleeWeapon);
keyHandler.BindKeyAction(UserInputKey.Switch5, (data) => userCmd.CurWeapon = (int)EWeaponSlotType.ThrowingWeapon);
keyHandler.BindKeyAction(UserInputKey.Switch6, (data) => userCmd.CurWeapon = (int)EWeaponSlotType.TacticWeapon);
}
public bool ActionWasReleased(ushort field, UserCmd lastCmd = null)
{
if (lastCmd != null)
{
return(lastCmd.ActionIsPressed(field) && !this.ActionIsPressed(field));
}
return(false);
}
public void HandleUserCommand(IPlayer player, UserCmd cmd, bool isPrediction = false)
{
HandleRunCommand(player, cmd, isPrediction);
if (Game.IsHost || isPrediction)
{
HandleInteractables(player, cmd);
}
}
public void ProcessMovement(CharacterController Controller, UserCmd CommandIn)
{
State.CharacterController = Controller;
Command = CommandIn;
PlayerMove();
Debug.Log("ViewAngles: " + Command.ViewAngles + ", Forward: " + Command.ForwardMove + ", Side: " + Command.SideMove);
}
public static InputSynchronizationMessage FromUserCmd(UserCmd command)
{
var messageData = command.Serialize();
var messageLength = messageData.Length;
//Fill our message fields to be send
var newMessage = new InputSynchronizationMessage();
newMessage.messageData = messageData;
return(newMessage);
}
/*
* The client will record player input from InControl and then pipe it to the server as a UserCmd
*/
private void LocalPlayerFixedUpdate()
{
PipeUserCommand(m_UserCmd);
if (!isServer)
{
StoredCommands.Enqueue(m_UserCmd);
}
// Update user buttons.
m_LastUserCmd.Buttons = m_UserCmd.Buttons;
m_UserCmd = CreateUserCmd();
}
public UserCmd GenerateUserCmd(IUserCmdOwnAdapter player, int intverval)
{
UpdateLookAt(player, _userCmdProvider.LookAt);
if (_userCmdProvider.HasPath)
{
var vel = player.PlayerTransform.InverseTransformVector(_userCmdProvider.DesirwdVelocity);
vel.y = 0;
vel = vel.normalized;
_userCmd.MoveVertical = vel.z;
_userCmd.MoveHorizontal = vel.x;
if (_userCmd.DeltaYaw > 1)
{
_userCmd.IsSlightWalk = true;
}
else if (_userCmdProvider.DesirwdVelocity.magnitude > 2)
{
_userCmd.IsRun = true;
}
else if (_userCmdProvider.DesirwdVelocity.magnitude > 0.5)
{
}
else
{
_userCmd.IsSlightWalk = true;
}
}
_userCmd.IsCrouch = _userCmdProvider.IsCrouch;
_userCmd.IsJump = _userCmdProvider.IsJump;
_userCmd.IsProne = _userCmdProvider.IsProne;
_userCmd.IsPeekLeft = _userCmdProvider.IsPeekLeft;
_userCmd.IsPeekRight = _userCmdProvider.IsPeekRight;
_userCmd.IsF = _userCmdProvider.IsF;
_userCmd.IsLeftAttack = _userCmdProvider.IsLeftAttack;
_userCmd.IsReload = _userCmdProvider.IsReload;
//_userCmdProvider.Reset();
// _userCmdProvider.LookAt = Quaternion.Euler(0,0,
// 0);
_userCmd.FrameInterval = intverval;
_userCmd.Seq = _seq++;
var rc = UserCmd.Allocate();
_userCmd.CopyTo(rc);
_userCmd.Reset();
return(rc);
}
public void CopyTo(UserCmd cmd)
{
cmd.serverTime = serverTime;
cmd.angles[0] = angles[0];
cmd.angles[1] = angles[1];
cmd.angles[2] = angles[2];
cmd.buttons = buttons;
cmd.forwardmove = forwardmove;
cmd.rightmove = rightmove;
cmd.upmove = upmove;
cmd.skillID = skillID;
}
public UserCmd GenerateUserCmd(IUserCmdOwnAdapter player, int intverval)
{
_userCmd.Seq = _seq++;
_userCmd.FrameInterval = intverval;
_userCmd.ChangedSeat = ChangeSeat();
_userCmd.ChangeChannel = ChangeChannel();
var rc = UserCmd.Allocate();
_userCmd.CopyTo(rc);
_userCmd.Reset();
return(rc);
}
void Start()
{
if (isClient)
{
m_InputBindings = new PlayerInputBindings(); //Initialize our client-sided input bindings
m_InputBindings.InitializeBindings();
m_UserCmd = CreateUserCmd();
m_LastUserCmd = CreateUserCmd();
}
m_StoredCmds = new Queue <UserCmd>();
m_TargetPlayer = GetComponent <Player>();
}
public void HandleUserCommand(UserCmd cmd)
{
m_LastIncomingSeq = cmd.SequenceNumber;
StoredCommands.Enqueue(cmd);
if (cmd.SequenceNumber - m_LastIncomingSeq > 1)
{
//We are missing some commands lets start predicting
//Run prediction code
}
else
{
}
}
private UserCmd CreateCmd()
{
UserCmd cmd = new UserCmd();
var clientActive = CDataModel.GameState.ClActive;
Vector3 oldAngles = clientActive.viewAngles;
// AdjustAngles();
KeyMove(ref cmd);
cmd.serverTime = clientActive.serverTime;
return(cmd);
}
public UserCmd GenerateUserCmd(IUserCmdOwnAdapter player, int intverval)
{
logger.DebugFormat("GenerateUserCmd:{0}", MyGameTime.seq);
userCmd.Seq = MyGameTime.seq;
userCmd.FrameInterval = intverval;
userCmd.ChangedSeat = ChangeSeat();
userCmd.ChangeChannel = ChangeChannel();
var rc = UserCmd.Allocate();
userCmd.CopyTo(rc);
userCmd.Reset();
return(rc);
}
private UserCmd MakeUserCmd()
{
var thing = new UserCmd();
thing.Command = commandNumber++;
thing.Tick = state.ClientTick++; // TODO: This might be off by one.
thing.ViewAngles = new Vector(60, 90, 0);
thing.CrosshairTrace = new Vector(5548.375f, 3522.188f, 256);
thing.QueryEntIndex = 1390;
thing.MouseDx = 73;
thing.MouseDy = 110;
thing.OrderId = orderNumber;
thing.Order = latestOrder;
thing.CameraX = 6445;
thing.CameraY = 2670;
thing.ShopModeSomething = 15;
thing.HudStatsDropdownCategoryIndex = 15;
thing.HudStatsDropdownSortMethod = 2;
return thing;
}
private void WriteUserCmd(UserCmd cmd, UserCmd last, Bitstream stream)
{
if (cmd.Command != last.Command + 1)
{
stream.WriteBool(true);
stream.WriteUInt32(cmd.Command);
}
else
{
stream.WriteBool(false);
}
if (cmd.Tick != last.Tick + 1)
{
stream.WriteBool(true);
stream.WriteUInt32(cmd.Tick);
}
else
{
stream.WriteBool(false);
}
if (cmd.ViewAngles.X != last.ViewAngles.X)
{
stream.WriteBool(true);
stream.WriteFloat(cmd.ViewAngles.X);
}
else
{
stream.WriteBool(false);
}
if (cmd.ViewAngles.X != last.ViewAngles.X)
{
stream.WriteBool(true);
stream.WriteFloat(cmd.ViewAngles.X);
}
else
{
stream.WriteBool(false);
}
if (cmd.ViewAngles.Z != last.ViewAngles.Z)
{
stream.WriteBool(true);
stream.WriteFloat(cmd.ViewAngles.Z);
}
else
{
stream.WriteBool(false);
}
if (cmd.ForwardMove != last.ForwardMove)
{
stream.WriteBool(true);
stream.WriteFloat(cmd.ForwardMove);
}
else
{
stream.WriteBool(false);
}
if (cmd.SideMove != last.SideMove)
{
stream.WriteBool(true);
stream.WriteFloat(cmd.SideMove);
}
else
{
stream.WriteBool(false);
}
if (cmd.UpMove != last.UpMove)
{
stream.WriteBool(true);
stream.WriteFloat(cmd.UpMove);
}
else
{
stream.WriteBool(false);
}
if (cmd.Buttons != last.Buttons)
{
stream.WriteBool(true);
stream.WriteUInt32(cmd.Buttons);
}
else
{
stream.WriteBool(false);
}
if (cmd.Impulse != last.Impulse)
{
stream.WriteBool(true);
stream.WriteByte(cmd.Impulse);
}
else
{
stream.WriteBool(false);
}
if (cmd.CrosshairTrace != last.CrosshairTrace)
{
stream.WriteBool(true);
stream.WriteBitVec3Coord(cmd.CrosshairTrace);
}
else
{
stream.WriteBool(false);
}
if (cmd.CursorUnitEntIndex != last.CursorUnitEntIndex)
{
stream.WriteBool(true);
stream.WriteBits(cmd.CursorUnitEntIndex, 11);
}
else
{
stream.WriteBool(false);
}
if (cmd.QueryEntIndex != last.QueryEntIndex)
{
stream.WriteBool(true);
stream.WriteBits(cmd.QueryEntIndex, 11);
}
else
{
stream.WriteBool(false);
}
if (cmd.CursorUnitEntIndex != last.CursorUnitEntIndex)
{
stream.WriteBool(true);
stream.WriteBits(cmd.CursorUnitEntIndex, 11);
if (cmd.QueryEntIndex != last.QueryEntIndex)
{
stream.WriteBool(true);
stream.WriteBits(cmd.QueryEntIndex, 11);
}
else
{
stream.WriteBool(false);
}
}
else
{
stream.WriteBool(false);
}
if (cmd.MouseDx != last.MouseDx)
{
stream.WriteBool(true);
stream.WriteUInt16(cmd.MouseDx);
}
else
{
stream.WriteBool(false);
}
if (cmd.MouseDy != last.MouseDy)
{
stream.WriteBool(true);
stream.WriteUInt16(cmd.MouseDy);
}
else
{
stream.WriteBool(false);
}
if (cmd.Offset3c != last.Offset3c)
{
stream.WriteBool(true);
stream.WriteUInt16(cmd.Offset3c);
}
else
{
stream.WriteBool(false);
}
// 0x44 to 0x74 inclusive
if (cmd.OrderId != last.OrderId)
{
stream.WriteBool(true);
stream.WriteInt16(cmd.OrderId);
stream.WriteInt16((short) cmd.Order.Value.SelectedUnits.Length);
foreach (var entity in cmd.Order.Value.SelectedUnits)
{
stream.WriteBits(entity, 11);
}
stream.WriteInt16(cmd.Order.Value.OrderType);
stream.WriteInt16(cmd.Order.Value.EntityIndex1);
stream.WriteBitVec3Coord(cmd.Order.Value.PreparedOrderPoint);
stream.WriteBits(cmd.Order.Value.BaseNpcHandle, 11);
stream.WriteBool(cmd.Order.Value.QueueOrder);
}
else
{
stream.WriteBool(false);
}
if (cmd.CameraX != last.CameraX || cmd.CameraY != last.CameraY)
{
stream.WriteBool(true);
stream.WriteUInt16(cmd.CameraX);
stream.WriteUInt16(cmd.CameraY);
}
else
{
stream.WriteBool(false);
}
if (cmd.ClickBehavior != last.ClickBehavior)
{
stream.WriteBool(true);
stream.WriteByte(cmd.ClickBehavior);
}
else
{
stream.WriteBool(false);
}
if (cmd.SpectatorStatsSomething != last.SpectatorStatsSomething)
{
stream.WriteBool(true);
stream.WriteByte(cmd.SpectatorStatsSomething);
}
else
{
stream.WriteBool(false);
}
if (cmd.ShopModeSomething != last.ShopModeSomething)
{
stream.WriteBool(true);
stream.WriteByte(cmd.ShopModeSomething);
}
else
{
stream.WriteBool(false);
}
if (cmd.HudStatsDropdownCategoryIndex != last.HudStatsDropdownCategoryIndex)
{
stream.WriteBool(true);
stream.WriteByte(cmd.HudStatsDropdownCategoryIndex);
}
else
{
stream.WriteBool(false);
}
if (cmd.HudStatsDropdownSortMethod != last.HudStatsDropdownSortMethod)
{
stream.WriteBool(true);
stream.WriteByte(cmd.HudStatsDropdownSortMethod);
}
else
{
stream.WriteBool(false);
}
}
private void SendUserCmds()
{
var last = new UserCmd();
using (var stream = Bitstream.Create())
{
var move = new CCLCMsg_Move();
move.num_backup_commands = (uint) backup.Count;
foreach (var cmd in backup)
{
WriteUserCmd(cmd, last, stream);
last = cmd;
}
move.num_new_commands = (uint) next.Count;
foreach (var cmd in next)
{
WriteUserCmd(cmd, last, stream);
last = cmd;
}
backup.Clear();
backup.AddRange(next);
next.Clear();
move.data = stream.ToBytes();
var tick = new CNETMsg_Tick();
tick.tick = state.ServerTick;
connection.SendUnreliably(
DotaGameConnection.ConvertProtoToMessage((uint) CLC_Messages.clc_Move, move),
DotaGameConnection.ConvertProtoToMessage((uint) NET_Messages.net_Tick, tick));
}
}
