public IEnumerator loginCoroutine()
{
Debug.Log("LoginInit::loginCoroutine start login CGLoginAccount");
CGLoginAccount.Builder account = CGLoginAccount.CreateBuilder();
Debug.Log("save Game Data ");
account.Username = SaveGame.saveGame.otherAccounts[0]["username"];
account.Password = SaveGame.saveGame.otherAccounts[0]["password"];
var data = account.Build();
Bundle bundle = new Bundle();
bundle.newMessage(data.GetType());
uint fid = bundle.writePB(data);
PacketHolder packet = new PacketHolder();
yield return(StartCoroutine(bundle.sendCoroutine(KBEngineApp.app.networkInterface(), fid, packet)));
if (packet.packet.responseFlag == 0)
{
SaveGame.saveGame.charInfo = packet.packet.protoBody as GCLoginAccount;
Application.LoadLevel("XuanZeRenWu");
}
else
{
WindowMng.windowMng.ShowNotifyLog(Util.GetString("loginError"), 3);
}
Debug.Log("LoginInit::loginCoroutine finish login");
}
public Packet(byte[] input, int opcode, DateTime time, Direction direction, int number, string fileName)
: base(new MemoryStream(input, 0, input.Length), Encoding.UTF8)
{
Opcode = opcode;
Time = time;
Direction = direction;
Number = number;
Writer = null;
FileName = fileName;
Status = ParsedStatus.None;
WriteToFile = true;
if (number == 0)
{
_firstPacketTime = Time;
}
TimeSpan = Time - _firstPacketTime;
Holder = new PacketHolder()
{
BaseData = new PacketBase()
{
Number = number,
Time = Timestamp.FromDateTime(DateTime.SpecifyKind(time, DateTimeKind.Utc)),
Opcode = Opcodes.GetOpcodeName(Opcode, Direction, false)
}
};
}
private void OnMessage <RequestPacket>(PacketHeader packetHeader, byte[] packetMessage)
where RequestPacket : IServerPacket
{
//Header는 여기서 사용해야할까?
//var requestPacket = MessagePackSerializer.Deserialize<dynamic>(packetMessage, MessagePack.Resolvers.ContractlessStandardResolver.Instance);
//IServerPacket serverPacket = requestPacket as IServerPacket;
var requestPacket = MessagePackSerializer.Typeless.Deserialize(packetMessage) as IServerPacket; //size 119
//MessagePackSerializer.Deserialize<IServerPacket>(bytes);
//여기에는 send로 온.. 데이터만 들어오는데..
IClientPacket clientPacket = ProcessManager.Run(requestPacket.PacketId, requestPacket);
byte[] bytes = MessagePack.MessagePackSerializer.Typeless.Serialize(clientPacket);
PacketHeader packetHeader2 = new PacketHeader
{
ContentsVersion = packetHeader.ContentsVersion,
LogicVersion = packetHeader.LogicVersion,
PacketID = requestPacket.PacketId,
PacketSize = bytes.Length,
EncriptKey = 0,
EncriptType = 0,
};
//response
IRequestItem requestItem = new PacketHolder(PacketHeaderConverter.CreateHeaderToBytes(packetHeader2), requestPacket.PacketId, bytes);
Send(requestItem);
}
IEnumerator startRegisterCoroutine(string name, string pass)
{
Debug.Log("LoginInit::startRegisterCoroutine: ");
//var name = loginUI.nameInput.text;
//var pass = loginUI.passwordInput.text;
PacketHolder packet = new PacketHolder();
CGRegisterAccount.Builder reg = CGRegisterAccount.CreateBuilder();
reg.Username = name;
reg.Password = pass;
yield return(StartCoroutine(Bundle.sendSimple(this, reg, packet)));
if (packet.packet.responseFlag == 0)
{
SaveGame.saveGame.AddNewAccount(name, pass);
SaveGame.saveGame.SaveFile();
//Login Game Auto
yield return(StartCoroutine(loginCoroutine()));
}
else
{
//loginUI.showLog(Util.GetString("autoRegError"));
}
}
//------------ Process packet related to spawning prop ------------
private void ProcessIncomingSpawn(CSteamID remoteId, PacketHolder packetHolder)
{
var packet = packetHolder.Packet <Spawn>();
if (packet == null)
{
return;
}
switch (packet.Value.Action)
{
// When player accepted new spawn and sent back this callback
case ActionType.PropSpawn:
{
Vector3?pos = null;
if (packet.Value.Pos != null)
{
pos = new Vector3(packet.Value.Pos.Value.X, packet.Value.Pos.Value.Y, packet.Value.Pos.Value.Z);
}
SpawnProp(packet.Value.Name, pos);
// When host receives prop spawn from player
if (_globals.PlayingAsHost)
{
SpawnPropCallback(packet.Value.Name, pos, remoteId);
}
break;
}
}
}
//------------ Process packet related to only changing object rotation ------------
private void ProcessIncomingObjectRotationChange(PacketHolder packetHolder, CSteamID remoteId)
{
var packet = packetHolder.Packet <Rotation>();
if (packet == null)
{
return;
}
if (packet.Value.ObjType != ObjectType.Prop)
{
return;
}
if (!_props.TryGetValue(packet.Value.Obj, out KinematicBody updatingObj))
{
return;
}
Vector3 newObjRotation = updatingObj.Rotation;
if (packet.Value.Rot != null)
{
newObjRotation.x = packet.Value.Rot.Value.X;
newObjRotation.y = packet.Value.Rot.Value.Y;
newObjRotation.z = packet.Value.Rot.Value.Z;
}
updatingObj.Rotation = newObjRotation;
if (packet.Value.SentByHost)
{
return;
}
ObjectRotationChangeCallback(packet.Value.Obj, newObjRotation, remoteId);
}
//------------ Process packet related to only changing object position ------------
private void ProcessIncomingObjectMovementChange(PacketHolder packetHolder, CSteamID remoteId)
{
var packet = packetHolder.Packet <Movement>();
if (packet == null)
{
return;
}
if (packet.Value.ObjType != ObjectType.Prop)
{
return;
}
if (!_props.TryGetValue(packet.Value.Obj, out KinematicBody updatingObj))
{
return;
}
Transform newObjTransform = updatingObj.Transform;
if (packet.Value.Pos != null)
{
newObjTransform.origin.x = packet.Value.Pos.Value.X;
newObjTransform.origin.y = packet.Value.Pos.Value.Y;
newObjTransform.origin.z = packet.Value.Pos.Value.Z;
}
updatingObj.Transform = newObjTransform;
if (packet.Value.SentByHost)
{
return;
}
ObjectPositionChangeCallback(packet.Value.Obj, newObjTransform.origin, remoteId);
}
public bool Process(PacketHolder packet)
{
if (!hasServerTimeDiff)
{
if (packet.KindCase == PacketHolder.KindOneofCase.LoginSetTimeSpeed)
{
hasServerTimeDiff = true;
serverTimeDiff = packet.BaseData.Time.ToDateTime() - packet.LoginSetTimeSpeed.GameTime.ToDateTime();
}
}
if (!hasServerTimeDiffFromSpawnTime)
{
if (packet.KindCase == PacketHolder.KindOneofCase.UpdateObject)
{
foreach (var create in packet.UpdateObject.Created)
{
if (create.CreateType == CreateObjectType.Spawn &&
create.Guid.Type is UniversalHighGuid.Creature or UniversalHighGuid.Vehicle or UniversalHighGuid.Pet or UniversalHighGuid.GameObject &&
create.Guid.KindCase == UniversalGuid.KindOneofCase.Guid128)
{
var timeQuotient = (new DateTimeOffset(packet.BaseData.Time.ToDateTime()).ToUnixTimeSeconds() & ~((1 << 23) - 1));
var timeSpawnOffset = (long)(create.Guid.Guid128.Low & ((1 << 23) - 1));
var currentServerTime = DateTimeOffset.FromUnixTimeSeconds(timeQuotient + timeSpawnOffset);
serverTimeDiff = packet.BaseData.Time.ToDateTime() - currentServerTime;
hasServerTimeDiff = true;
hasServerTimeDiffFromSpawnTime = true;
return(false);
}
}
}
}
return(true);
}
private void ProcessPlayerMovementAndRotationChange(PacketHolder packetHolder, CSteamID remoteId)
{
var packet = packetHolder.Packet <MovementAndRotation>();
if (packet == null)
{
return;
}
if (packet.Value.ObjType != ObjectType.Player)
{
return;
}
if (!_globals.PlayerBodies.TryGetValue(packet.Value.Obj, out KinematicBody updatingPlayer))
{
if (_globals.OwnPlayerBody != null && _globals.OwnPlayerBody.Name.Equals(packet.Value.Obj))
{
updatingPlayer = _globals.OwnPlayerBody;
}
else
{
return;
}
}
Transform newPlayerTransform = updatingPlayer.Transform;
if (packet.Value.Pos != null)
{
newPlayerTransform.origin.x = packet.Value.Pos.Value.X;
newPlayerTransform.origin.y = packet.Value.Pos.Value.Y;
newPlayerTransform.origin.z = packet.Value.Pos.Value.Z;
}
updatingPlayer.Transform = newPlayerTransform;
Vector3 newPlayerRotation = updatingPlayer.Rotation;
if (packet.Value.Rot != null)
{
newPlayerRotation.x = packet.Value.Rot.Value.X;
newPlayerRotation.y = packet.Value.Rot.Value.Y;
newPlayerRotation.z = packet.Value.Rot.Value.Z;
}
updatingPlayer.Rotation = newPlayerRotation;
if (_globals.PlayingAsHost)
{
PlayerMovementAndRotationChangeCallback(packet.Value.Obj, newPlayerTransform.origin, newPlayerRotation,
remoteId);
}
}
private void ProcessPlayerMovement(PacketHolder packetHolder, CSteamID remoteId)
{
switch (packetHolder.PacketType)
{
case Packets.MovementAndRotation:
ProcessPlayerMovementAndRotationChange(packetHolder, remoteId);
break;
case Packets.Movement:
ProcessPlayerMovementChange(packetHolder, remoteId);
break;
case Packets.Rotation:
ProcessPlayerRotationChange(packetHolder, remoteId);
break;
}
}
public bool Process(PacketHolder packet)
{
if (PlayerGuid != null)
{
return(false);
}
if (packet.KindCase == PacketHolder.KindOneofCase.ClientMove)
{
PlayerGuid = packet.ClientMove.Mover;
}
else if (packet.KindCase == PacketHolder.KindOneofCase.PlayerLogin)
{
PlayerGuid = packet.PlayerLogin.PlayerGuid;
}
return(true);
}
private void ProcessIncomingPackets(object source, PacketReceiveArgs args)
{
ByteBuffer buff = new ByteBuffer(args.Packet);
PacketHolder packetHolder = PacketHolder.GetRootAsPacketHolder(buff);
switch (packetHolder.PacketType)
{
case Packets.Spawn:
ProcessSpawn(packetHolder, args.RemoteId);
break;
case Packets.MovementAndRotation:
case Packets.Movement:
case Packets.Rotation:
ProcessPlayerMovement(packetHolder, args.RemoteId);
break;
}
}
private void ProcessIncomingPlayerIds(PacketHolder packetHolder)
{
var incomingPlayerIds = packetHolder.Packet <PlayerIds>();
if (incomingPlayerIds != null)
{
if (!incomingPlayerIds.Value.SentByHost)
{
return;
}
var newIncomingPlayerIds =
Array.ConvertAll(incomingPlayerIds.Value.GetIdsArray(), item => (CSteamID)item);
_globals.UserIds.UnionWith(newIncomingPlayerIds);
GD.Print($"OK: Added lobby player id's from host, new count: {_globals.UserIds.Count}");
}
GD.Print("NOTIFY: Changing scene after getting PlayerIds packet.");
OnLobbyEnteredFinished();
}
public IRequestItem Request <RequestPacket>(RequestPacket requestPacket)
where RequestPacket : IServerPacket
{
byte[] bytes = MessagePack.MessagePackSerializer.Typeless.Serialize(requestPacket);
PacketHeader packetHeader = new PacketHeader
{
ContentsVersion = ContentsVersion,
LogicVersion = LogicVersion,
PacketID = requestPacket.PacketId,
PacketSize = bytes.Length,
EncriptKey = 0,
EncriptType = 0,
};
IRequestItem requestItem = new PacketHolder(PacketHeaderConverter.CreateHeaderToBytes(packetHeader), requestPacket.PacketId, bytes);
return(requestItem);
}
public IEnumerator regAndLog()
{
Debug.Log("LoginInit::regAndlog: start Register");
PacketHolder packet = new PacketHolder();
{
CGAutoRegisterAccount.Builder auto = CGAutoRegisterAccount.CreateBuilder();
var data = auto.Build();
Bundle bundle = new Bundle();
bundle.newMessage(typeof(CGAutoRegisterAccount));
uint fid = bundle.writePB(data);
yield return(StartCoroutine(bundle.sendCoroutine(KBEngineApp.app.networkInterface(), fid, packet)));
}
{
var newAccount = packet.packet.protoBody as GCAutoRegisterAccount;
CGRegisterAccount.Builder reg = CGRegisterAccount.CreateBuilder();
reg.Username = newAccount.Username;
reg.Password = "******";
var data = reg.BuildPartial();
Debug.Log("LoginInit::regAndLog: " + newAccount + " : " + data);
Debug.Log("LoginInit::regAndLog: username pass " + newAccount.Username + " " + data.Password);
Bundle bundle = new Bundle();
bundle.newMessage(data.GetType());
var fid = bundle.writePB(data);
yield return(StartCoroutine(bundle.sendCoroutine(KBEngineApp.app.networkInterface(), fid, packet)));
if (packet.packet.responseFlag == 0)
{
SaveGame.saveGame.AddNewAccount(newAccount.Username, data.Password);
SaveGame.saveGame.SaveFile();
}
else
{
Log.Sys(Util.GetString("autoRegError"));
}
}
yield return(StartCoroutine(loginCoroutine()));
Debug.Log("LoginInit::regAndlog: finish register");
}
public uint Process(PacketHolder packet)
{
if (packet.KindCase == PacketHolder.KindOneofCase.QueryCreatureResponse)
{
return(packet.QueryCreatureResponse.Entry);
}
if (packet.KindCase == PacketHolder.KindOneofCase.QueryGameObjectResponse)
{
return(packet.QueryGameObjectResponse.Entry);
}
if (packet.KindCase == PacketHolder.KindOneofCase.QuestGiverRequestItems)
{
return(packet.QuestGiverRequestItems.QuestGiverEntry);
}
var guid = guidExtractor.Process(packet);
return(guid?.Entry ?? 0);
}
private void ProcessIncomingPackets(byte[] packet, CSteamID remoteId)
{
ByteBuffer buff = new ByteBuffer(packet);
PacketHolder packetHolder = PacketHolder.GetRootAsPacketHolder(buff);
switch (packetHolder.PacketType)
{
case Packets.UserAction:
{
ProcessIncomingUserAction(remoteId, packetHolder);
break;
}
case Packets.PlayerIds:
{
ProcessIncomingPlayerIds(packetHolder);
break;
}
}
}
//------------ Process packet related to any object movement ------------
private void ProcessIncomingObjectAction(PacketHolder packetHolder, CSteamID remoteId)
{
switch (packetHolder.PacketType)
{
case Packets.MovementAndRotation:
{
ProcessIncomingObjectPositionAndRotationChange(packetHolder, remoteId);
break;
}
case Packets.Movement:
{
ProcessIncomingObjectMovementChange(packetHolder, remoteId);
break;
}
case Packets.Rotation:
{
ProcessIncomingObjectRotationChange(packetHolder, remoteId);
break;
}
}
}
private void ProcessIncomingUserAction(CSteamID remoteId, PacketHolder packetHolder)
{
var userAction = packetHolder.Packet <UserAction>();
if (userAction == null)
{
return;
}
GD.Print($"NOTIFY: Receiving UserAction: {userAction.Value.Action}.");
switch (userAction.Value.Action)
{
case ActionType.PlayerIds:
var sendingUsers = new HashSet <CSteamID>(_globals.UserIds);
sendingUsers.RemoveWhere(id => id.Equals(remoteId));
var packet = Utils.GetPlayerIdsBytes(true, sendingUsers);
SteamNetworking.SendP2PPacket(remoteId, packet, (uint)packet.Length,
EP2PSend.k_EP2PSendReliable);
GD.Print($"OK: Sent user list from host to: {SteamFriends.GetFriendPersonaName(remoteId)}");
break;
}
}
public virtual T?Process(PacketHolder packet)
{
switch (packet.KindCase)
{
case PacketHolder.KindOneofCase.None:
return(default);
case PacketHolder.KindOneofCase.Chat:
return(Process(packet.BaseData, packet.Chat));
case PacketHolder.KindOneofCase.QueryCreatureResponse:
return(Process(packet.BaseData, packet.QueryCreatureResponse));
case PacketHolder.KindOneofCase.Emote:
return(Process(packet.BaseData, packet.Emote));
case PacketHolder.KindOneofCase.PlaySound:
return(Process(packet.BaseData, packet.PlaySound));
case PacketHolder.KindOneofCase.PlayMusic:
return(Process(packet.BaseData, packet.PlayMusic));
case PacketHolder.KindOneofCase.PlayObjectSound:
return(Process(packet.BaseData, packet.PlayObjectSound));
case PacketHolder.KindOneofCase.GossipHello:
return(Process(packet.BaseData, packet.GossipHello));
case PacketHolder.KindOneofCase.GossipMessage:
return(Process(packet.BaseData, packet.GossipMessage));
case PacketHolder.KindOneofCase.GossipSelect:
return(Process(packet.BaseData, packet.GossipSelect));
case PacketHolder.KindOneofCase.GossipClose:
return(Process(packet.BaseData, packet.GossipClose));
case PacketHolder.KindOneofCase.SpellStart:
return(Process(packet.BaseData, packet.SpellStart));
case PacketHolder.KindOneofCase.SpellGo:
return(Process(packet.BaseData, packet.SpellGo));
case PacketHolder.KindOneofCase.AuraUpdate:
return(Process(packet.BaseData, packet.AuraUpdate));
case PacketHolder.KindOneofCase.MonsterMove:
return(Process(packet.BaseData, packet.MonsterMove));
case PacketHolder.KindOneofCase.PhaseShift:
return(Process(packet.BaseData, packet.PhaseShift));
case PacketHolder.KindOneofCase.SpellClick:
return(Process(packet.BaseData, packet.SpellClick));
case PacketHolder.KindOneofCase.PlayerLogin:
return(Process(packet.BaseData, packet.PlayerLogin));
case PacketHolder.KindOneofCase.OneShotAnimKit:
return(Process(packet.BaseData, packet.OneShotAnimKit));
case PacketHolder.KindOneofCase.SetAnimKit:
return(Process(packet.BaseData, packet.SetAnimKit));
case PacketHolder.KindOneofCase.PlaySpellVisualKit:
return(Process(packet.BaseData, packet.PlaySpellVisualKit));
case PacketHolder.KindOneofCase.QuestGiverAcceptQuest:
return(Process(packet.BaseData, packet.QuestGiverAcceptQuest));
case PacketHolder.KindOneofCase.QuestGiverCompleteQuestRequest:
return(Process(packet.BaseData, packet.QuestGiverCompleteQuestRequest));
case PacketHolder.KindOneofCase.QuestGiverQuestComplete:
return(Process(packet.BaseData, packet.QuestGiverQuestComplete));
case PacketHolder.KindOneofCase.QuestGiverRequestItems:
return(Process(packet.BaseData, packet.QuestGiverRequestItems));
case PacketHolder.KindOneofCase.NpcText:
return(Process(packet.BaseData, packet.NpcText));
case PacketHolder.KindOneofCase.NpcTextOld:
return(Process(packet.BaseData, packet.NpcTextOld));
case PacketHolder.KindOneofCase.DbReply:
return(Process(packet.BaseData, packet.DbReply));
case PacketHolder.KindOneofCase.UpdateObject:
return(Process(packet.BaseData, packet.UpdateObject));
case PacketHolder.KindOneofCase.QueryGameObjectResponse:
return(Process(packet.BaseData, packet.QueryGameObjectResponse));
case PacketHolder.KindOneofCase.ClientAreaTrigger:
return(Process(packet.BaseData, packet.ClientAreaTrigger));
case PacketHolder.KindOneofCase.QueryPlayerNameResponse:
return(Process(packet.BaseData, packet.QueryPlayerNameResponse));
case PacketHolder.KindOneofCase.QuestComplete:
return(Process(packet.BaseData, packet.QuestComplete));
case PacketHolder.KindOneofCase.QuestFailed:
return(Process(packet.BaseData, packet.QuestFailed));
case PacketHolder.KindOneofCase.QuestAddKillCredit:
return(Process(packet.BaseData, packet.QuestAddKillCredit));
case PacketHolder.KindOneofCase.ClientUseItem:
return(Process(packet.BaseData, packet.ClientUseItem));
case PacketHolder.KindOneofCase.ClientQuestGiverChooseReward:
return(Process(packet.BaseData, packet.ClientQuestGiverChooseReward));
case PacketHolder.KindOneofCase.ClientMove:
return(Process(packet.BaseData, packet.ClientMove));
case PacketHolder.KindOneofCase.ClientUseGameObject:
return(Process(packet.BaseData, packet.ClientUseGameObject));
case PacketHolder.KindOneofCase.GossipPoi:
return(Process(packet.BaseData, packet.GossipPoi));
case PacketHolder.KindOneofCase.GameObjectCustomAnim:
return(Process(packet.BaseData, packet.GameObjectCustomAnim));
default:
throw new ArgumentOutOfRangeException();
}
}
public bool Process(PacketHolder packet)
{
return(inner.Process(packet));
}
public bool PreProcess(PacketHolder packet)
{
r1.Process(packet);
return(true);
}
public bool Process(PacketHolder packet) => waypointProcessor.Process(packet);
private void ProcessSpawn(PacketHolder packetHolder, CSteamID remoteId)
{
var packet = packetHolder.Packet <Spawn>();
if (packet == null)
{
return;
}
switch (packet.Value.Action)
{
case ActionType.PlayerSpawn:
PackedScene playerScene;
KinematicBody player;
if (packet.Value.Name.Equals(_globals.OwnId.ToString()))
{
playerScene = ResourceLoader.Load <PackedScene>(_playerPath);
player = playerScene?.Instance() as KinematicBody;
if (player == null)
{
return;
}
GetParent().AddChild(player);
player.Name = packet.Value.Name;
_globals.OwnPlayerBody = player;
}
else
{
playerScene = ResourceLoader.Load <PackedScene>(_networkedPlayerPath);
player = playerScene?.Instance() as KinematicBody;
if (player == null)
{
return;
}
AddChild(player);
player.Name = packet.Value.Name;
_globals.PlayerBodies.Add(player.Name, player);
}
Transform propTransform;
if (packet.Value.Pos != null)
{
propTransform = player.Transform;
propTransform.origin.x = packet.Value.Pos.Value.X;
propTransform.origin.y = packet.Value.Pos.Value.Y;
propTransform.origin.z = packet.Value.Pos.Value.Z;
player.Transform = propTransform;
}
else
{
propTransform = player.Transform;
propTransform.origin.x = DefaultSpawnPos.x;
propTransform.origin.y = DefaultSpawnPos.y;
propTransform.origin.z = DefaultSpawnPos.z;
player.Transform = propTransform;
}
if (_globals.PlayingAsHost)
{
SpawnPlayerCallback(packet.Value.Name, propTransform.origin, remoteId);
SendAllExitingPlayersCallback(remoteId);
}
break;
}
}
public bool Process(PacketHolder packet)
{
nothingProcessor.Process(packet);
return(true);
}
public PacketViewModel(PacketHolder packet, uint entry, string?objectName)
{
Packet = packet;
Entry = entry;
ObjectName = objectName;
}
