public void TestWalkMove()
{
// login, create character, start game
FakeNetworkClient client = HandlerTestHelper.InitializeTestEnvironment();
WalkPacket walkPacket = new WalkPacket()
{
Speed = 11, XCoordinate = 89, YCoordinate = 126
};
// send walkpacket to client
client.ReceivePacket(walkPacket);
string mvPacket = HandlerTestHelper.WaitForPacket(client, "mv");
MovePacket movePacket = PacketFactory.Deserialize <MovePacket>(mvPacket);
Assert.AreEqual(walkPacket.XCoordinate, movePacket.MapX);
Assert.AreEqual(walkPacket.YCoordinate, movePacket.MapY);
Assert.AreEqual(walkPacket.Speed, movePacket.Speed);
HandlerTestHelper.ShutdownTestingEnvironment();
Assert.Pass();
}
public void TestSerializeToEndCantBeNull()
{
var serializedPacket = PacketFactory.Deserialize("/ ");
Assert.AreEqual(serializedPacket, null);
}
public void DeserializeOptionalListPacket()
{
var packet = (MShopPacket)PacketFactory.Deserialize("m_shop 1", typeof(MShopPacket));
Assert.IsTrue(packet.Type == CreateShopPacketType.Close);
}
public void DeserializeSpecial()
{
var packet = (UseItemPacket)PacketFactory.Deserialize("u_i 2 3 4 5 6", typeof(UseItemPacket));
Assert.IsTrue(packet.Mode == 6);
}
public void PacketEndingWithNullableMakeItOptional()
{
var packet = PacketFactory.Deserialize("$CreateItem 1012 1", typeof(CreateItemPacket));
Assert.IsNotNull(packet);
}
public void InvalidSlot_Does_Not_Create_Character()
{
const string name = "TestCharacter";
Assert.IsNull(PacketFactory.Deserialize($"Char_NEW {name} 4 0 0 0", typeof(CharNewPacket)));
}
public void VerifyLogin(string packet)
{
User user = PacketFactory.Deserialize <User>(packet);
//fermé
bool flag = true;
if (flag)
{
//TODO: implement check for maintenances
bool maintenanceCheck = true;
if (maintenanceCheck)
{
AccountDTO loadedAccount = DAOFactory.AccountDAO.LoadByName(user.Name);
if (loadedAccount != null && loadedAccount.Password.Equals(user.PasswordDecrypted))
{
DAOFactory.AccountDAO.WriteConnectionLog(loadedAccount.AccountId, _session.Client.RemoteEndPoint.ToString(), null, "Connection", "LoginServer");
if (!ServiceFactory.Instance.CommunicationService.AccountIsConnected(loadedAccount.Name))
{
//0 banned 1 register 2 user 3 GM
AuthorityType type = loadedAccount.AuthorityEnum;
switch (type)
{
case AuthorityType.Banned:
{
_session.Client.SendPacket(String.Format("fail {O}", Language.Instance.GetMessageFromKey("BANNED").ToString()));
}
break;
default:
{
int newSessionId = SessionFactory.Instance.GenerateSessionId();
DAOFactory.AccountDAO.UpdateLastSessionAndIp(user.Name, (int)newSessionId, _session.Client.RemoteEndPoint.ToString());
Logger.Log.DebugFormat(Language.Instance.GetMessageFromKey("CONNECTION"), user.Name, newSessionId);
//inform communication service about new player from login server
try
{
ServiceFactory.Instance.CommunicationService.RegisterAccountLogin(user.Name, newSessionId);
}
catch (Exception ex)
{
Logger.Log.Error(ex.Message);
}
_session.Client.SendPacket(BuildServersPacket((int)newSessionId));
}
break;
}
}
else
{
_session.Client.SendPacket(String.Format("fail {0}", Language.Instance.GetMessageFromKey("ALREADY_CONNECTED").ToString()));
}
}
else
{
_session.Client.SendPacket(String.Format("fail {0}", Language.Instance.GetMessageFromKey("IDERROR").ToString()));
}
}
else
{
_session.Client.SendPacket(String.Format("fail {O}", Language.Instance.GetMessageFromKey("CLOSE").ToString()));
}
}
else
{
_session.Client.SendPacket(String.Format("fail {O}", Language.Instance.GetMessageFromKey("WAITING").ToString()));
}
}
public static FakeNetworkClient InitializeTestEnvironment()
{
System.Globalization.CultureInfo.DefaultThreadCurrentUICulture = System.Globalization.CultureInfo.GetCultureInfo("en-US");
// initialize Logger
Logger.InitializeLogger(LogManager.GetLogger(typeof(BasicPacketHandlerTest)));
// create server entities (this values would have been imported)
CreateServerItems();
CreateServerMaps();
CreateServerSkills();
// initialize servermanager
ServerManager.Instance.Initialize();
// initialize WCF
ServiceFactory.Instance.Initialize();
// register mappings for items
DAOFactory.ItemInstanceDAO.RegisterMapping(typeof(SpecialistInstance));
DAOFactory.ItemInstanceDAO.RegisterMapping(typeof(WearableInstance));
DAOFactory.ItemInstanceDAO.RegisterMapping(typeof(UsableInstance));
DAOFactory.ItemInstanceDAO.InitializeMapper(typeof(ItemInstance));
// initialize PacketSerialization
PacketFactory.Initialize <WalkPacket>();
// initialize new manager
_sessionManager = new NetworkManager <TestEncryption>("127.0.0.1", 1234, typeof(CharacterScreenPacketHandler), typeof(TestEncryption), true);
FakeNetworkClient client = new FakeNetworkClient();
_sessionManager.AddSession(client);
AccountDTO account = new AccountDTO()
{
AccountId = 1,
Authority = AuthorityType.Admin,
LastSession = 12345,
Name = "test",
Password = "******"
};
DAOFactory.AccountDAO.InsertOrUpdate(ref account);
// register for account login
ServiceFactory.Instance.CommunicationService.RegisterAccountLogin("test", 12345);
// OpenNosEntryPoint -> LoadCharacterList
client.ReceivePacket("12345");
client.ReceivePacket("test");
client.ReceivePacket("test");
string clistStart = WaitForPacket(client);
string clistEnd = WaitForPacket(client);
// creation of character
client.ReceivePacket("Char_NEW Test 2 1 0 9");
List <string> clistAfterCreate = WaitForPackets(client, 3);
CListPacket cListPacket = PacketFactory.Deserialize <CListPacket>(clistAfterCreate[1]);
// select character
client.ReceivePacket($"select {cListPacket.Slot}");
string okPacket = WaitForPacket(client);
// start game
client.ReceivePacket("game_start");
List <string> gameStartPacketsFirstPart = WaitForPackets(client, "p_clear");
List <string> gameStartPacketsSecondPart = WaitForPackets(client, "p_clear");
//wait 100 milliseconds to be sure initialization has been finished
Task.Delay(100);
return(client);
}
private void TriggerHandler(string packetHeader, string packet, bool force)
{
if (ServerManager.Instance.InShutdown)
{
return;
}
if (!IsDisposing)
{
if (!HandlerMethods.TryGetValue(packetHeader, out HandlerMethodReference methodReference))
{
Logger.Log.WarnFormat(Language.Instance.GetMessageFromKey("HANDLER_NOT_FOUND"), packetHeader);
return;
}
if (methodReference.HandlerMethodAttribute != null && !force && methodReference.HandlerMethodAttribute.Amount > 1 && !_waitForPacketsAmount.HasValue)
{
// we need to wait for more
_waitForPacketsAmount = methodReference.HandlerMethodAttribute.Amount;
_waitForPacketList.Add(packet != string.Empty ? packet : $"1 {packetHeader} ");
return;
}
try
{
if (!HasSelectedCharacter && methodReference.ParentHandler.GetType().Name != "CharacterScreenPacketHandler" &&
methodReference.ParentHandler.GetType().Name != "LoginPacketHandler")
{
return;
}
// call actual handler method
if (methodReference.PacketDefinitionParameterType != null)
{
//check for the correct authority
if (IsAuthenticated && (byte)methodReference.Authority > (byte)Account.Authority)
{
return;
}
object deserializedPacket = PacketFactory.Deserialize(packet, methodReference.PacketDefinitionParameterType, IsAuthenticated);
if (deserializedPacket != null || methodReference.PassNonParseablePacket)
{
methodReference.HandlerMethod(methodReference.ParentHandler, deserializedPacket);
}
else
{
Logger.Log.WarnFormat(Language.Instance.GetMessageFromKey("CORRUPT_PACKET"), packetHeader, packet);
}
}
else
{
methodReference.HandlerMethod(methodReference.ParentHandler, packet);
}
}
catch (DivideByZeroException ex)
{
// disconnect if something unexpected happens
Logger.Log.Error("Handler Error SessionId: " + SessionId, ex);
Disconnect();
}
}
else
{
Logger.Log.WarnFormat(Language.Instance.GetMessageFromKey("CLIENTSESSION_DISPOSING"), packetHeader);
}
}
public void Broadcast(ClientSession client, PacketBase packet, ReceiverType receiver = ReceiverType.All, string characterName = "", long characterId = -1, int delay = 0)
{
Broadcast(client, PacketFactory.Deserialize(packet), receiver, characterName, characterId, delay);
}
/// <summary>
/// Send a packet to the Server as the Fake client receives it and triggers a Handler method.
/// </summary>
/// <param name="packet">Packet created thru PacketFactory.</param>
public void ReceivePacket(PacketBase packet)
{
ReceivePacket(PacketFactory.Deserialize(packet));
}
