public bool HandleMessage(INetMessage message)
{
Console.WriteLine($"SetUnitPositionHandler. PeerId: {message.Client.NetPeer.Id}");
if (message.Client.CurrentSessionId == null)
{
return(true);
}
var session = SessionCache.Instance.GetSessionById(message.Client.CurrentSessionId);
if (session == null || session.IsStarted)
{
return(true);
}
int unitId = message.Reader.GetInt();
PositionData positionData = MessageSerializerService.DeserializeObjectOfType <PositionData>(message.Reader.GetString());
if (session.Units.ContainsKey(unitId))
{
session.Units[unitId].UnitData.PositionData = positionData;
}
return(true);
}
protected override void OnHandleMessage(NetDataReader reader)
{
int unitCount = reader.GetInt();
for (int i = 0; i < unitCount; i++)
{
UnitData unitData = MessageSerializerService.DeserializeObjectOfType <UnitData>(reader.GetString());
UnitController newUnit = ((GameObject)Instantiate(Resources.Load("Objects/Player"),
new Vector3(unitData.PositionData.X, unitData.PositionData.Y, unitData.PositionData.Z),
Quaternion.identity)).GetComponent <UnitController>();
NetObject netObject = newUnit.gameObject.GetComponent <NetObject>();
netObject.Id = unitData.UnitId;
newUnit.Health = unitData.Health;
newUnit.MoveSpeed = unitData.MoveSpeed;
newUnit.MinDamage = unitData.MinDamage;
newUnit.MaxDamage = unitData.MaxDamage;
newUnit.AttackRadius = unitData.AttackRadius;
ClientNetEventListener.Instance.NetObjects.Add(unitData.UnitId, netObject);
BattleManager.Instance.EnemyUnits.Add(i, newUnit);
}
BattleManager.Instance.StartSession();
}
public bool HandleMessage(INetMessage message)
{
int unitId = message.Reader.GetInt();
var serializePositionData = message.Reader.GetString();
PositionData positionData =
MessageSerializerService.DeserializeObjectOfType <PositionData>(serializePositionData);
var session = SessionCache.Instance.GetSessionById(message.Client.CurrentSessionId);
if (session == null || !session.IsStarted)
{
return(true);
}
if (session.Units.ContainsKey(unitId))
{
NetDataWriter _dataWriter = new NetDataWriter();
_dataWriter.Reset();
_dataWriter.Put((byte)NetOperationCode.SendUnit);
_dataWriter.Put(unitId);
_dataWriter.Put(serializePositionData);
foreach (var p in session.Players)
{
session.SendToAll(_dataWriter, DeliveryMethod.Sequenced);
}
}
return(true);
}
protected override void OnHandleMessage(Dictionary <byte, object> parameters, string debugMessage, int returnCode)
{
var selectedCharacter =
MessageSerializerService.DeserializeObjectOfType <GameCommon.SerializedObjects.Character>(
parameters[(byte)MessageParameterCode.Object]);
if (selectedCharacter != null)
{
GameData.Instance.selectedCharacter = selectedCharacter;
var characterName = selectedCharacter.Name;
var posX = selectedCharacter.Loc_X;
var posZ = selectedCharacter.Loc_Z;
var posY = Terrain.activeTerrain.terrainData.GetHeight((int)posX, (int)posZ);
Vector3 characterPosition = new Vector3(posX, posY, posZ);
characterPosition.y = Terrain.activeTerrain.SampleHeight(characterPosition);
var characterPrefab = Resources.Load("Hammer Warrior") as GameObject;
var obj = Instantiate(characterPrefab, characterPosition, Quaternion.identity);
if (obj != null)
{
var player = obj.AddComponent <Player>();
player.CharacterName = characterName;
GameData.Instance.players.Add(player);
}
Debug.Log("WorldEnterHandler charName:" + characterName);
}
}
public bool HandleMessage(INetMessage message)
{
Console.WriteLine($"JoinSessionHandler. PeerId: {message.Client.NetPeer.Id}");
byte[] sessionId = new byte[12];
message.Reader.GetBytes(sessionId, 12);
NetDataWriter writer = new NetDataWriter();
writer.Put((byte)NetOperationCode.JoinSession);
if (message.Client.CurrentSessionId != null || !SessionCache.Instance.JoinSession(sessionId, message.Client))
{
writer.Put((byte)NetErrorCode.SessionConnectedFailed);
}
else
{
writer.Put((byte)NetErrorCode.Success);
writer.Put(message.Client.Units.Count);
foreach (var u in message.Client.Units)
{
writer.Put(MessageSerializerService.SerializeObjectOfType(u.Value.UnitData));
}
}
message.Client.NetPeer.Send(writer, DeliveryMethod.ReliableOrdered);
return(true);
}
/// <summary>
/// Handle message.
/// </summary>
/// <param name="reader">Reader of parameters</param>
protected override void OnHandleMessage(NetDataReader reader)
{
var id = reader.GetInt();
PositionData positionData = MessageSerializerService.DeserializeObjectOfType <PositionData>(reader.GetString());
Vector3 newPosition = new Vector3(positionData.X, positionData.Y, positionData.Z);
ClientNetEventListener.Instance.OnMoveEvent(id, newPosition);
}
public void SendRegisterRequest()
{
if (Login.text.Length < 6 || Password.text.Length < 6)
{
Info.text = "Login and password can't be less than 6 symbols";
return;
}
else if (Login.text.Length > 16 || Password.text.Length > 16)
{
Info.text = "Login and password can't be more than 16 symbols";
return;
}
if (Password.text != ConfirmPassword.text)
{
Info.text = "Passwords don't match";
return;
}
if (CharacterName.text.Length < 6)
{
Info.text = "Name of your character can't be less than 6 symbols.";
return;
}
else if (CharacterName.text.Length > 16)
{
Info.text = "Name of your character can't be more than 16 symbols";
return;
}
var serializeCharacterData = MessageSerializerService
.SerializeObjectOfType <RegisterCharacterData>(new RegisterCharacterData
{
CharacterName = CharacterName.text,
Sex = Sex,
CharacterType = CharacterType,
Class = Class,
SubClass = SubClass
});
OperationRequest request = new OperationRequest()
{
OperationCode = (byte)MessageOperationCode.LoginOperationCode,
Parameters = new Dictionary <byte, object>
{
{ PhotonEngine.Instance.SubCodeParameterCode, (int)MessageSubCode.RegisterSubCode },
{ (byte)MessageParameterCode.Login, Login.text },
{ (byte)MessageParameterCode.Password, Password.text },
{ (byte)MessageParameterCode.Email, Email.text },
{ (byte)MessageParameterCode.CharacterRegisterData, serializeCharacterData.ToString() }
}
};
PhotonEngine.Instance.SendRequest(request);
}
public void SetPosition(int unitId, Vector3 newPosition)
{
PositionData positionData = new PositionData(newPosition.x, newPosition.y, newPosition.z);
NetDataWriter writer = new NetDataWriter();
writer.Put((byte)NetOperationCode.SetUnitPosition);
writer.Put(unitId);
writer.Put(MessageSerializerService.SerializeObjectOfType(positionData));
ClientNetEventListener.Instance.SendOperation(writer, DeliveryMethod.ReliableOrdered);
}
public void SendNewDestination(Vector3 newDestination)
{
PositionData positionData = new PositionData(newDestination.x, newDestination.y, newDestination.z);
NetDataWriter dataWriter = new NetDataWriter();
dataWriter.Reset();
dataWriter.Put((byte)NetOperationCode.SendUnit);
dataWriter.Put(Id);
dataWriter.Put(MessageSerializerService.SerializeObjectOfType(positionData));
ClientNetEventListener.Instance.SendOperation(dataWriter, DeliveryMethod.Sequenced);
}
protected override void OnHandleMessage(Dictionary <byte, object> parameters, string debugMessage,
int returnCode)
{
if (returnCode == (short)ReturnCode.Ok)
{
var region =
MessageSerializerService.DeserializeObjectOfType <GameCommon.SerializedObjects.Region>(
parameters[(byte)MessageParameterCode.Object]);
GameData.Instance.region = region;
LoadingScene.imageComp.fillAmount += 0.25f;
Debug.LogFormat("Region of character is selected successfully. Your region is {0}", region.Name);
}
}
protected override void OnHandleMessage(Dictionary <byte, object> parameters, string debugMessage, int returnCode)
{
if (returnCode == (short)ReturnCode.Ok)
{
var listChar =
MessageSerializerService.DeserializeObjectOfType <IEnumerable <GameCommon.SerializedObjects.Character> >(parameters[(byte)MessageParameterCode.Object]);
var characters = listChar.ToList();
GameData.Instance.characters = characters.ToList();
controller.LoadCharacterListInScene(characters.ToList());
}
else
{
Debug.LogFormat("{0}", debugMessage);
}
}
private void OnOperationRequest(object sender, MessageReceivedEventArgs e)
{
Console.WriteLine("Handling operation request");
using (var message = e.GetMessage()) {
using (var reader = message.GetReader()) {
var parameters =
MessageSerializerService.DeserializeObjectOfType <Dictionary <byte, object> >(reader.ReadString());
handlerList.HandleMessage(
new Request((byte)e.Tag,
parameters.ContainsKey(Server.SubCodeParameterCode)
? (int?)Convert.ToInt32(parameters[Server.SubCodeParameterCode])
: null, parameters), this);
}
}
}
protected override void OnHandleMessage(Dictionary <byte, object> parameters, string debugMessage, int returnCode)
{
if (returnCode == (short)ReturnCode.Ok)
{
var selectedCharacter =
MessageSerializerService.DeserializeObjectOfType <GameCommon.SerializedObjects.Character>(
parameters[(byte)MessageParameterCode.Object]);
Debug.LogFormat("Character selected successfully. Your character is {0}", selectedCharacter.Name);
GameData.Instance.selectedCharacter = selectedCharacter;
SceneManager.LoadScene(3); // go back to select character scene
}
else
{
Debug.LogFormat("{0}", debugMessage);
}
}
private IEnumerator SendMyPosition()
{
yield return(new WaitForSeconds(0.1f));
PositionData positionData = new PositionData(transform.position.x, transform.position.y, transform.position.z);
NetDataWriter dataWriter = new NetDataWriter();
dataWriter.Reset();
dataWriter.Put((byte)NetOperationCode.MoveUnit);
dataWriter.Put(Id);
dataWriter.Put(MessageSerializerService.SerializeObjectOfType(positionData));
ClientNetEventListener.Instance.SendOperation(dataWriter, DeliveryMethod.Sequenced);
StartCoroutine("SendMyPosition");
}
protected void OnOperationRequest(object sender, MessageReceivedEventArgs e)
{
var peer = ConnectionCollection.GetPeers <IClientPeer>().FirstOrDefault(c => c.Client == e.Client);
subServerHandlerList.Peer = peer;
Console.WriteLine("Handling operation request");
using (var message = e.GetMessage()) {
using (var reader = message.GetReader()) {
var parameters =
MessageSerializerService.DeserializeObjectOfType <Dictionary <byte, object> >(reader.ReadString());
subServerHandlerList.HandleMessage(new Request((byte)e.Tag,
parameters.ContainsKey(SubCodeParameterCode)
? (int?)Convert.ToInt32(parameters[SubCodeParameterCode])
: null, parameters), this);
}
}
}
public bool HandleMessage(IMessage message, IServerPeer peer)
{
// How to prevent hacking? - Proxy server removed all "special" codes from the client, and uses its own when forwarding data
var charList = new CharacterMapper().LoadByUserId((int)message.Parameters[(byte)MessageParameterCode.UserId])
.Select(characterDO => new Character {
CharacterId = characterDO.Id,
Name = characterDO.Name
});
// We have a list of characters, Added into a Serializable object
var returnResponse = new Response(Code, SubCode, new Dictionary <byte, object>()
{
{ (byte)MessageParameterCode.PeerId, message.Parameters[(byte)MessageParameterCode.PeerId] },
{ (byte)MessageParameterCode.Object, MessageSerializerService.SerializeObjectOfType(charList) },
{ (byte)MessageParameterCode.SubCodeParameterCode, SubCode }
});
peer.SendMessage(returnResponse);
return(true);
}
public bool HandleMessage(INetMessage message)
{
int unitId = message.Reader.GetInt();
var serializePositionData = message.Reader.GetString();
PositionData positionData =
MessageSerializerService.DeserializeObjectOfType <PositionData>(serializePositionData);
var session = SessionCache.Instance.GetSessionById(message.Client.CurrentSessionId);
if (session == null || !session.IsStarted)
{
return(true);
}
if (session.Units.ContainsKey(unitId))
{
session.Units[unitId].UnitData.PositionData = positionData;
}
return(true);
}
public void SendMessage(IMessage message)
{
if (!message.Parameters.Keys.Contains(Server.SubCodeParameterCode))
{
message.Parameters.Add(Server.SubCodeParameterCode, message.SubCode);
}
switch (message)
{
case Event _:
using (var writer = DarkRiftWriter.Create()) {
var parameters = new Dictionary <byte, object>()
{
{ (byte)MessageParameterCode.SubCodeParameterCode, message.SubCode }
};
var serializedParams = MessageSerializerService.SerializeObjectOfType(parameters);
writer.Write((string)serializedParams);
using (var msg = Message.Create(message.Code, writer)) {
Client.SendMessage(msg, SendMode.Reliable);
}
}
break;
case Response response:
using (var writer = DarkRiftWriter.Create()) {
var serializedParams = MessageSerializerService.SerializeObjectOfType(response.Parameters);
writer.Write((string)serializedParams);
writer.Write(response.DebugMessage);
writer.Write(response.ReturnCode);
using (var msg = Message.Create(message.Code, writer)) {
Client.SendMessage(msg, SendMode.Reliable);
}
}
break;
}
}
public void StartSession(object src, ElapsedEventArgs args)
{
if (IsStarted)
{
return;
}
if (Players.Count != 2)
{
SessionCache.Instance.DeleteSession(Id);
return;
}
NetDataWriter writer = new NetDataWriter();
writer.Put((byte)NetOperationCode.StartSession);
writer.Put(Players.ElementAt(1).Value.Units.Count);
foreach (var u in Players.ElementAt(1).Value.Units)
{
writer.Put(MessageSerializerService.SerializeObjectOfType(u.Value.UnitData));
}
Players.ElementAt(0).Value.NetPeer.Send(writer, DeliveryMethod.ReliableOrdered);
writer.Reset();
writer.Put((byte)NetOperationCode.StartSession);
writer.Put(Players.ElementAt(0).Value.Units.Count);
foreach (var u in Players.ElementAt(0).Value.Units)
{
writer.Put(MessageSerializerService.SerializeObjectOfType(u.Value.UnitData));
}
Players.ElementAt(1).Value.NetPeer.Send(writer, DeliveryMethod.ReliableOrdered);
IsStarted = true;
}
/// <summary>
/// Handle message.
/// </summary>
/// <param name="reader">Reader of parameters</param>
protected override void OnHandleMessage(NetDataReader reader)
{
NetErrorCode errorCode = (NetErrorCode)reader.GetByte();
if (errorCode == NetErrorCode.SessionConnectedFailed)
{
Debug.Log("Session connected failed");
return;
}
int unitCount = reader.GetInt();
for (int i = 0; i < unitCount; i++)
{
UnitData unitData = MessageSerializerService.DeserializeObjectOfType <UnitData>(reader.GetString());
UnitController newUnit = ((GameObject)Instantiate(Resources.Load("Objects/Player"),
new Vector3(unitData.PositionData.X, unitData.PositionData.Y, unitData.PositionData.Z),
Quaternion.identity)).GetComponent <UnitController>();
NetObject netObject = newUnit.gameObject.GetComponent <NetObject>();
netObject.Id = unitData.UnitId;
netObject.IsMine = true;
newUnit.Health = unitData.Health;
newUnit.MoveSpeed = unitData.MoveSpeed;
newUnit.MinDamage = unitData.MinDamage;
newUnit.MaxDamage = unitData.MaxDamage;
newUnit.AttackRadius = unitData.AttackRadius;
ClientNetEventListener.Instance.NetObjects.Add(unitData.UnitId, netObject);
BattleManager.Instance.PlayerUnits.Add(i, newUnit);
}
BattleManager.Instance.JoinSessionSuccess();
}
public bool HandleMessage(IMessage message, IServerPeer peer)
{
var serverPeer = peer as PhotonServerPeer;
var operation = new RegisterOperation(serverPeer.protocol, message);
if (!operation.IsValid)
{
peer.SendMessage(new Response(Code, SubCode, new Dictionary <byte, object>()
{
{ (byte)MessageParameterCode.SubCodeParameterCode, SubCode },
{ (byte)MessageParameterCode.PeerIdParameterCode, message.Parameters[(byte)MessageParameterCode.PeerIdParameterCode] },
}, operation.GetErrorMessage(), (int)ReturnCode.OperationInvalid));
return(true);
}
if (operation.Login.Length < 6 || operation.Password.Length < 6)
{
peer.SendMessage(new Response(Code, SubCode, new Dictionary <byte, object>()
{
{ (byte)MessageParameterCode.SubCodeParameterCode, SubCode },
{ (byte)MessageParameterCode.PeerIdParameterCode, message.Parameters[(byte)MessageParameterCode.PeerIdParameterCode] },
}, "Login and password can't be less than 6 symbols.", (int)ReturnCode.OperationInvalid));
return(true);
}
else if (operation.Login.Length > 16 || operation.Password.Length > 16)
{
peer.SendMessage(new Response(Code, SubCode, new Dictionary <byte, object>()
{
{ (byte)MessageParameterCode.SubCodeParameterCode, SubCode },
{ (byte)MessageParameterCode.PeerIdParameterCode, message.Parameters[(byte)MessageParameterCode.PeerIdParameterCode] },
}, "Login and password can't be more than 16 symbols.", (int)ReturnCode.OperationInvalid));
return(true);
}
var checkMail = new EmailAddressAttribute();
if (!checkMail.IsValid(operation.Email))
{
peer.SendMessage(new Response(Code, SubCode, new Dictionary <byte, object>()
{
{ (byte)MessageParameterCode.SubCodeParameterCode, SubCode },
{ (byte)MessageParameterCode.PeerIdParameterCode, message.Parameters[(byte)MessageParameterCode.PeerIdParameterCode] },
}, "Email address incorrect.", (int)ReturnCode.OperationInvalid));
return(true);
}
var characterData = MessageSerializerService.DeserializeObjectOfType <RegisterCharacterData>(
operation.CharacterRegisterData);
characterData.CharacterType = 1; // delete this if we add more types
if (characterData.CharacterName.Length < 6)
{
peer.SendMessage(new Response(Code, SubCode, new Dictionary <byte, object>()
{
{ (byte)MessageParameterCode.SubCodeParameterCode, SubCode },
{ (byte)MessageParameterCode.PeerIdParameterCode, message.Parameters[(byte)MessageParameterCode.PeerIdParameterCode] },
}, "Name of your character can't be less than 6 symbols.", (int)ReturnCode.OperationInvalid));
return(true);
}
else if (characterData.CharacterName.Length > 16)
{
peer.SendMessage(new Response(Code, SubCode, new Dictionary <byte, object>()
{
{ (byte)MessageParameterCode.SubCodeParameterCode, SubCode },
{ (byte)MessageParameterCode.PeerIdParameterCode, message.Parameters[(byte)MessageParameterCode.PeerIdParameterCode] },
}, "Name of your can't be more than 16 symbols.", (int)ReturnCode.OperationInvalid));
return(true);
}
else if (characterData.Sex != "Male" && characterData.Sex != "Female")
{
return(true);
}
else if (characterData.CharacterType != 1) // add more types
{
return(true);
}
else if (characterData.Class != "Warrior" && characterData.Class != "Rogue" && characterData.Class != "Mage")
{
return(true);
}
else if (characterData.SubClass != "Warlock" && characterData.SubClass != "Cleric")
{
return(true);
}
try
{
using (var session = NHibernateHelper.OpenSession())
{
using (var transaction = session.BeginTransaction())
{
var accounts = session.QueryOver <AccountModel>().Where(a => a.Login == operation.Login).List();
var accountsByEmail = session.QueryOver <AccountModel>().Where(a => a.Email == operation.Email).List();
var characters = session.QueryOver <CharacterModel>().Where(c => c.Name == characterData.CharacterName).List();
if (accounts.Count > 0)
{
transaction.Commit();
peer.SendMessage(new Response(Code, SubCode, new Dictionary <byte, object>()
{
{ (byte)MessageParameterCode.SubCodeParameterCode, SubCode },
{ (byte)MessageParameterCode.PeerIdParameterCode, message.Parameters[(byte)MessageParameterCode.PeerIdParameterCode] },
}, "Login already taken.", (int)ReturnCode.AlreadyExist));
return(true);
}
else if (accountsByEmail.Count > 0)
{
transaction.Commit();
peer.SendMessage(new Response(Code, SubCode, new Dictionary <byte, object>()
{
{ (byte)MessageParameterCode.SubCodeParameterCode, SubCode },
{ (byte)MessageParameterCode.PeerIdParameterCode, message.Parameters[(byte)MessageParameterCode.PeerIdParameterCode] },
}, "Email already taken.", (int)ReturnCode.AlreadyExist));
return(true);
}
else if (characters.Count > 0)
{
transaction.Commit();
peer.SendMessage(new Response(Code, SubCode, new Dictionary <byte, object>()
{
{ (byte)MessageParameterCode.SubCodeParameterCode, SubCode },
{ (byte)MessageParameterCode.PeerIdParameterCode, message.Parameters[(byte)MessageParameterCode.PeerIdParameterCode] },
}, "Name already taken.", (int)ReturnCode.AlreadyExist));
return(true);
}
string salt = Guid.NewGuid().ToString().Replace("-", "");
AccountModel newAccount = new AccountModel()
{
Login = operation.Login,
Password = BitConverter.ToString(SHA512.Create().ComputeHash(
Encoding.UTF8.GetBytes(salt + operation.Password))).Replace("-", ""),
Salt = salt,
Email = operation.Email,
AdminLevel = 0,
BanLevel = 0,
Created = DateTime.Now,
Updated = DateTime.Now
};
session.Save(newAccount);
transaction.Commit();
Log.DebugFormat("Create new Account. Login - {0}.", operation.Login);
}
using (var transaction = session.BeginTransaction())
{
var accounts = session.QueryOver <AccountModel>().Where(a => a.Login == operation.Login).SingleOrDefault();
CharacterModel newCharacter = new CharacterModel()
{
AccountId = accounts,
Name = characterData.CharacterName,
Sex = characterData.Sex,
CharacterType = characterData.CharacterType,
Class = characterData.Class,
SubClass = characterData.SubClass,
Level = 1,
Exp = 0,
Strength = 1,
Intellect = 1,
RangLevel = 0,
Gold = 10000,
Donate = 0,
SkillPoint = 1000,
StatPoint = 0,
InventorySize = 32,
GuildId = 0,
Created = DateTime.Now,
Updated = DateTime.Now
};
session.Save(newCharacter);
transaction.Commit();
Log.DebugFormat("Create new Character. Name - {0}.", characterData.CharacterName);
}
peer.SendMessage(new Response(Code, SubCode, new Dictionary <byte, object>()
{
{ (byte)MessageParameterCode.SubCodeParameterCode, SubCode },
{ (byte)MessageParameterCode.PeerIdParameterCode, message.Parameters[(byte)MessageParameterCode.PeerIdParameterCode] },
}, "Register success.", (int)ReturnCode.OK));
}
return(true);
}
catch (Exception ex)
{
Log.ErrorFormat("Error register handler: {0}", ex);
peer.SendMessage(new Response(Code, SubCode, new Dictionary <byte, object>()
{
{ (byte)MessageParameterCode.SubCodeParameterCode, SubCode },
{ (byte)MessageParameterCode.PeerIdParameterCode, message.Parameters[(byte)MessageParameterCode.PeerIdParameterCode] },
}, ex.ToString(), (int)ReturnCode.OperationDenied));
return(true);
}
}
