private Events?Handle(CSVCMsg_PacketEntities message)
{
using (var stream = Bitstream.CreateWith(message.entity_data))
{
entityUpdater.Update(
stream,
(uint)message.baseline,
message.update_baseline,
(uint)message.updated_entries,
message.is_delta);
}
if (message.update_baseline)
{
var ack = new CCLCMsg_BaselineAck
{
baseline_nr = state.Baseline,
baseline_tick = (int)state.ServerTick
};
var ackMsg = DotaGameConnection.ConvertProtoToMessage(
(uint)CLC_Messages.clc_BaselineAck,
ack);
connection.SendReliably(ackMsg);
return(null);
}
return(null);
}
public DotaGame(DotaGameState state, DotaGameConnection connection)
{
this.state = state;
this.connection = connection;
entityUpdater = new EntityUpdater(state);
stringTableUpdater = new StringTableUpdater();
}
public void EnterConnected()
{
connection.OpenChannel();
state.Reset();
var scv = new CNETMsg_SetConVar();
scv.convars = state.ExposeCVars();
var scvMessage = DotaGameConnection.ConvertProtoToMessage(
(uint)NET_Messages.net_SetConVar,
scv);
var ss = new CNETMsg_SignonState();
ss.num_server_players = 0;
ss.spawn_count = 0xFFFFFFFF;
ss.signon_state = (uint)SIGNONSTATE.SIGNONSTATE_CONNECTED;
var ssMessage = DotaGameConnection.ConvertProtoToMessage(
(uint)NET_Messages.net_SignonState,
ss);
connection.SendReliably(scvMessage, ssMessage);
}
public void EnterNew()
{
var ci = new CCLCMsg_ClientInfo();
ci.server_count = state.ServerCount;
var ciMessage = DotaGameConnection.ConvertProtoToMessage(
(uint)CLC_Messages.clc_ClientInfo,
ci);
var ss = new CNETMsg_SignonState();
ss.signon_state = (uint)SIGNONSTATE.SIGNONSTATE_NEW;
ss.spawn_count = state.ServerCount;
ss.num_server_players = 0;
var ssMessage = DotaGameConnection.ConvertProtoToMessage(
(uint)NET_Messages.net_SignonState,
ss);
var scv = new CNETMsg_SetConVar();
scv.convars = new CMsg_CVars();
var cvar = new CMsg_CVars.CVar();
cvar.name = "steamworks_sessionid_client";
cvar.value = details.SteamworksSessionId.ToString();
state.CVars["steamworks_sessionid_client"] = details.SteamworksSessionId.ToString();
scv.convars.cvars.Add(cvar);
var scvMessage = DotaGameConnection.ConvertProtoToMessage(
(uint)NET_Messages.net_SetConVar,
scv);
connection.SendReliably(ciMessage, ssMessage, scvMessage);
}
public void EnterPrespawn()
{
var ss = new CNETMsg_SignonState();
ss.signon_state = (uint)SIGNONSTATE.SIGNONSTATE_PRESPAWN;
ss.spawn_count = state.ServerCount;
ss.num_server_players = 0;
var ssMessage = DotaGameConnection.ConvertProtoToMessage(
(uint)NET_Messages.net_SignonState,
ss);
// Send mask for game events?
// 0c 23
// 0d 8b820592
// 0d 0140e890
// 0d f6ffff7f
// 0d ff9bfc6e
// 0d 0310e87c
// 0d cbfffff8
// 0d effc0700
var le = new CCLCMsg_ListenEvents();
for (uint i = 0; i < 267; i += 32)
{
le.event_mask.Add(0xffffffff);
}
le.event_mask.Add(0x0000000a);
var leMessage = DotaGameConnection.ConvertProtoToMessage(
(uint)CLC_Messages.clc_ListenEvents,
le);
connection.SendReliably(ssMessage, leMessage);
}
public void Submit(string consoleCommand)
{
var cmd = new CNETMsg_StringCmd();
cmd.command = consoleCommand;
connection.SendReliably(DotaGameConnection.ConvertProtoToMessage((uint)NET_Messages.net_StringCmd, cmd));
}
public DotaGame(DotaGameState state, DotaGameConnection connection)
{
this.state = state;
this.connection = connection;
entityUpdater = new EntityUpdater(state);
stringTableUpdater = new StringTableUpdater();
}
public Events? Handle(DotaGameConnection.Message message)
{
using (var stream = Bitstream.CreateWith(message.Data))
{
if (message.Type == (uint) NET_Messages.net_NOP)
{
return null;
}
if (message.Type == (uint) NET_Messages.net_Disconnect)
{
return Handle(Serializer.Deserialize<CNETMsg_Disconnect>(stream));
}
if (message.Type == (uint) NET_Messages.net_Tick)
{
return Handle(Serializer.Deserialize<CNETMsg_Tick>(stream));
}
if (message.Type == (uint) NET_Messages.net_SetConVar)
{
return Handle(Serializer.Deserialize<CNETMsg_SetConVar>(stream));
}
if (message.Type == (uint) NET_Messages.net_SignonState)
{
return Handle(Serializer.Deserialize<CNETMsg_SignonState>(stream));
}
if (message.Type == (uint) SVC_Messages.svc_ServerInfo)
{
return Handle(Serializer.Deserialize<CSVCMsg_ServerInfo>(stream));
}
if (message.Type == (uint) SVC_Messages.svc_SendTable)
{
return Handle(Serializer.Deserialize<CSVCMsg_SendTable>(stream));
}
if (message.Type == (uint) SVC_Messages.svc_ClassInfo)
{
return Handle(Serializer.Deserialize<CSVCMsg_ClassInfo>(stream));
}
if (message.Type == (uint) SVC_Messages.svc_PacketEntities)
{
return Handle(Serializer.Deserialize<CSVCMsg_PacketEntities>(stream));
}
if (message.Type == (uint) SVC_Messages.svc_CreateStringTable)
{
return Handle(Serializer.Deserialize<CSVCMsg_CreateStringTable>(stream));
}
if (message.Type == (uint) SVC_Messages.svc_UpdateStringTable)
{
return Handle(Serializer.Deserialize<CSVCMsg_UpdateStringTable>(stream));
}
if (message.Type == (uint) SVC_Messages.svc_Print)
{
return Handle(Serializer.Deserialize<CSVCMsg_Print>(stream));
}
if (message.Type == (uint) SVC_Messages.svc_GameEventList)
{
return Handle(Serializer.Deserialize<CSVCMsg_GameEventList>(stream));
}
return null;
}
}
/// <summary>
/// Initialize the signon handler.
/// </summary>
/// <param name="state"></param>
/// <param name="connection"></param>
public DotaSignon(DotaGameState state, DotaGameConnection connection, DOTAConnectDetails details)
{
this.state = state;
this.details = details;
this.connection = connection;
entityUpdater = new EntityUpdater(state);
sendTableFlattener = new SendTableFlattener();
stringTableUpdater = new StringTableUpdater();
}
/// <summary>
/// Initialize the signon handler.
/// </summary>
/// <param name="state"></param>
/// <param name="connection"></param>
public DotaSignon(DotaGameState state, DotaGameConnection connection, DOTAConnectDetails details)
{
this.state = state;
this.details = details;
this.connection = connection;
entityUpdater = new EntityUpdater(state);
sendTableFlattener = new SendTableFlattener();
stringTableUpdater = new StringTableUpdater();
}
public DotaHandshake(
DOTAConnectDetails details,
DotaGameState state,
DotaGameConnection connection)
{
this.details = details;
this.connection = connection;
this.state = state;
client_challenge = (uint) new Random().Next();
}
public DotaHandshake(
DOTAConnectDetails details,
DotaGameState state,
DotaGameConnection connection)
{
this.details = details;
this.connection = connection;
this.state = state;
client_challenge = (uint)new Random().Next();
}
public UserCmdGenerator(DotaGameState state, DotaGameConnection connection)
{
this.state = state;
this.connection = connection;
backup = new List <UserCmd>();
next = new List <UserCmd>();
commandNumber = 0;
orderNumber = 0;
}
public UserCmdGenerator(DotaGameState state, DotaGameConnection connection)
{
this.state = state;
this.connection = connection;
backup = new List<UserCmd>();
next = new List<UserCmd>();
commandNumber = 0;
orderNumber = 0;
}
public void Write(DotaGameConnection.Packet packet)
{
if (State == SubchannelState.Queued)
{
packet.Stream.WriteBool(true);
WriteQueued(packet);
}
else
{
packet.Stream.WriteBool(false);
}
}
public void EnterSpawn()
{
var ss = new CNETMsg_SignonState();
ss.signon_state = (uint)SIGNONSTATE.SIGNONSTATE_SPAWN;
ss.spawn_count = state.ServerCount;
ss.num_server_players = 0;
var ssMessage = DotaGameConnection.ConvertProtoToMessage(
(uint)NET_Messages.net_SignonState,
ss);
connection.SendReliably(ssMessage);
}
public void EnterGame()
{
var ack = new CCLCMsg_BaselineAck();
ack.baseline_nr = state.Baseline;
ack.baseline_tick = (int)state.ServerTick;
var ackMsg = DotaGameConnection.ConvertProtoToMessage(
(uint)CLC_Messages.clc_BaselineAck,
ack);
var ss = new CNETMsg_SignonState();
ss.num_server_players = 0;
ss.signon_state = (uint)SIGNONSTATE.SIGNONSTATE_FULL;
ss.spawn_count = state.ServerCount;
var ssMessage = DotaGameConnection.ConvertProtoToMessage(
(uint)NET_Messages.net_SignonState,
ss);
var le = new CCLCMsg_ListenEvents();
for (uint i = 0; i < 267; i += 32)
{
le.event_mask.Add(0xffffffff);
}
le.event_mask.Add(0x000003ff);
var leMessage = DotaGameConnection.ConvertProtoToMessage(
(uint)CLC_Messages.clc_ListenEvents,
le);
connection.SendReliably(ackMsg, ssMessage, leMessage);
var clientMsgs = new List <DotaGameConnection.Message>();
for (var i = 0; i < 10; ++i)
{
var msg = new CCLCMsg_ClientMessage();
msg.data = new byte[] { 0x0D, 0xCD, 0xCC, 0xCC, 0x3F };
msg.msg_type = 2;
var msgMessage = DotaGameConnection.ConvertProtoToMessage(
(uint)CLC_Messages.clc_ClientMessage,
msg);
clientMsgs.Add(msgMessage);
}
connection.SendUnreliably(clientMsgs.ToArray());
}
public Events? Handle(DotaGameConnection.Message message)
{
using (var stream = Bitstream.CreateWith(message.Data))
{
if (message.Type == (uint) NET_Messages.net_NOP)
{
return null;
}
if (message.Type == (uint) NET_Messages.net_Disconnect)
{
return Handle(Serializer.Deserialize<CNETMsg_Disconnect>(stream));
}
if (message.Type == (uint) NET_Messages.net_StringCmd)
{
return Handle(Serializer.Deserialize<CNETMsg_StringCmd>(stream));
}
if (message.Type == (uint) NET_Messages.net_Tick)
{
return Handle(Serializer.Deserialize<CNETMsg_Tick>(stream));
}
if (message.Type == (uint) SVC_Messages.svc_PacketEntities)
{
return Handle(Serializer.Deserialize<CSVCMsg_PacketEntities>(stream));
}
if (message.Type == (uint) SVC_Messages.svc_UpdateStringTable)
{
return Handle(Serializer.Deserialize<CSVCMsg_UpdateStringTable>(stream));
}
if (message.Type == (uint) SVC_Messages.svc_UserMessage)
{
return Handle(Serializer.Deserialize<CSVCMsg_UserMessage>(stream));
}
if (message.Type == (uint) SVC_Messages.svc_GameEvent)
{
return Handle(Serializer.Deserialize<CSVCMsg_GameEvent>(stream));
}
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 = state.ServerTick;
connection.SendUnreliably(
DotaGameConnection.ConvertProtoToMessage((uint)CLC_Messages.clc_Move, move),
DotaGameConnection.ConvertProtoToMessage((uint)NET_Messages.net_Tick, tick));
}
}
public Events? Handle(DotaGameConnection.Message message)
{
throw new NotImplementedException();
}
private void WriteQueuedChunk(DotaGameConnection.Packet packet)
{
var chunkOffset = (offset + DotaGameConnection.BYTES_PER_CHUNK - 1)/DotaGameConnection.BYTES_PER_CHUNK;
var chunkCount = (count + DotaGameConnection.BYTES_PER_CHUNK - 1)/DotaGameConnection.BYTES_PER_CHUNK;
packet.Stream.WriteBits((uint) chunkOffset, 18);
packet.Stream.WriteBits((uint) chunkCount, 3);
if (offset == 0)
{
packet.Stream.WriteBool(false);
packet.Stream.WriteBool(false);
packet.Stream.WriteBits((uint) data.Length, 26);
}
packet.Stream.Write(data, offset, count);
}
private void WriteQueuedSingle(DotaGameConnection.Packet packet)
{
packet.Stream.WriteBool(false);
packet.Stream.WriteBits((uint) count, 18);
packet.Stream.Write(data, offset, count);
}
private void WriteQueued(DotaGameConnection.Packet packet)
{
if (offset != 0 || count != data.Length)
{
packet.Stream.WriteBool(true);
WriteQueuedChunk(packet);
}
else
{
packet.Stream.WriteBool(false);
WriteQueuedSingle(packet);
}
SentIn = packet.Seq;
State = SubchannelState.Blocked;
}
