public void GetAll_ReturnsEmptyList_ClientList()
{
List <ClientClass> newList = new List <ClientClass>();
List <ClientClass> result = ClientClass.GetAll();
CollectionAssert.AreEqual(newList, result);
}
public async Task <IActionResult> Edit(int id, [Bind("ID,ClientContactPerson,ClientContactNumber,ClientCompanyName,ClientRateSheetID,LastUpdateDate")] ClientClass clientClass)
{
if (id != clientClass.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(clientClass);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ClientClassExists(clientClass.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(clientClass));
}
private static void ReturnCar(ClientClass client)
{
Console.Clear();
List <RentClass> rentsOfClient = RentService.GetRentsOfClient(client);
if (rentsOfClient.Count == 0)
{
Console.Clear();
Console.WriteLine("You have no rents");
return;
}
foreach (var i in RentService.GetRentsOfClient(client))
{
Console.WriteLine("\nCar id: " + i.CurrentCar.CarId);
Console.WriteLine("Car type: " + i.CurrentCar.Bodywork.Type);
Console.WriteLine("Car color: " + i.CurrentCar.Bodywork.Color);
}
Console.Write("\nChoose car's id you want to return: ");
if (UserInputInt(out int chosenCarId))
{
Console.Clear();
CarClass tempCar = AutoParkService.SearchCarById(chosenCarId);
if (tempCar != null && tempCar.CurrentClient == client)
{
RentService.RemoveRent(RentService.GetRentByCarId(chosenCarId));
Console.WriteLine($"Car with id '{chosenCarId}' was successfully returned");
return;
}
}
Console.Clear();
Console.WriteLine("Id not found!");
}
public void On_CMSG_GUILD_SET_PUBLIC_NOTE(PacketClass packet, ClientClass client)
{
if (packet.Data.Length - 1 < 6)
{
return;
}
packet.GetInt16();
var playerName = packet.GetString();
if (packet.Data.Length - 1 < 6 + playerName.Length + 1)
{
return;
}
var note = packet.GetString();
_clusterServiceLocator.WorldCluster.Log.WriteLine(LogType.DEBUG, "[{0}:{1}] CMSG_GUILD_SET_PUBLIC_NOTE [{2}]", client.IP, client.Port, playerName);
if (!client.Character.IsInGuild)
{
_clusterServiceLocator.WcGuild.SendGuildResult(client, GuildCommand.GUILD_CREATE_S, GuildError.GUILD_PLAYER_NOT_IN_GUILD);
return;
}
if (!client.Character.IsGuildRightSet(GuildRankRights.GR_RIGHT_EPNOTE))
{
_clusterServiceLocator.WcGuild.SendGuildResult(client, GuildCommand.GUILD_CREATE_S, GuildError.GUILD_PERMISSIONS);
return;
}
_clusterServiceLocator.WorldCluster.GetCharacterDatabase().Update(string.Format("UPDATE characters SET char_guildPNote = \"{1}\" WHERE char_name = \"{0}\";", playerName, note.Replace("\"", "_").Replace("'", "_")));
_clusterServiceLocator.WcGuild.SendGuildRoster(client.Character);
}
public void On_CMSG_GMTICKET_GETTICKET(PacketClass packet, ClientClass client)
{
_clusterServiceLocator.WorldCluster.Log.WriteLine(LogType.DEBUG, "[{0}:{1}] CMSG_GMTICKET_GETTICKET", client.IP, client.Port);
PacketClass smsgGmticketGetticket = new(Opcodes.SMSG_GMTICKET_GETTICKET);
DataTable mySqlResult = new();
_clusterServiceLocator.WorldCluster.GetCharacterDatabase().Query(string.Format("SELECT * FROM characters_tickets WHERE char_guid = {0};", client.Character.Guid), ref mySqlResult);
if (mySqlResult.Rows.Count > 0)
{
smsgGmticketGetticket.AddInt32((int)GmTicketGetResult.GMTICKET_AVAILABLE);
smsgGmticketGetticket.AddString(Conversions.ToString(mySqlResult.Rows[0]["ticket_text"]));
}
else
{
smsgGmticketGetticket.AddInt32((int)GmTicketGetResult.GMTICKET_NOTICKET);
}
client.Send(smsgGmticketGetticket);
smsgGmticketGetticket.Dispose();
PacketClass smsgQueryTimeResponse = new(Opcodes.SMSG_QUERY_TIME_RESPONSE);
smsgQueryTimeResponse.AddInt32(_clusterServiceLocator.NativeMethods.timeGetTime("")); // GetTimestamp(Now))
client.Send(smsgQueryTimeResponse);
smsgQueryTimeResponse.Dispose();
}
public void On_MSG_RANDOM_ROLL(PacketClass packet, ClientClass client)
{
if (packet.Data.Length - 1 < 13)
{
return;
}
packet.GetInt16();
var minRoll = packet.GetInt32();
var maxRoll = packet.GetInt32();
_clusterServiceLocator.WorldCluster.Log.WriteLine(LogType.DEBUG, "[{0}:{1}] MSG_RANDOM_ROLL [min={2} max={3}]", client.IP, client.Port, minRoll, maxRoll);
var response = new PacketClass(Opcodes.MSG_RANDOM_ROLL);
response.AddInt32(minRoll);
response.AddInt32(maxRoll);
response.AddInt32(_clusterServiceLocator.WorldCluster.Rnd.Next(minRoll, maxRoll));
response.AddUInt64(client.Character.Guid);
if (client.Character.IsInGroup)
{
client.Character.Group.Broadcast(response);
}
else
{
client.SendMultiplyPackets(response);
}
response.Dispose();
}
public void On_CMSG_GROUP_SET_LEADER(PacketClass packet, ClientClass client)
{
if (packet.Data.Length - 1 < 6)
{
return;
}
packet.GetInt16();
var name = packet.GetString();
_clusterServiceLocator.WorldCluster.Log.WriteLine(LogType.DEBUG, "[{0}:{1}] CMSG_GROUP_SET_LEADER [Name={2}]", client.IP, client.Port, name);
var guid = _clusterServiceLocator.WcHandlerCharacter.GetCharacterGuidByName(name);
if (guid == 0m)
{
SendPartyResult(client, "", PartyCommand.PARTY_OP_INVITE, PartyCommandResult.INVITE_NOT_FOUND);
}
else if (_clusterServiceLocator.WorldCluster.CharacteRs.ContainsKey(guid) == false)
{
SendPartyResult(client, "", PartyCommand.PARTY_OP_INVITE, PartyCommandResult.INVITE_NOT_FOUND);
}
else if (!client.Character.IsGroupLeader)
{
SendPartyResult(client, client.Character.Name, PartyCommand.PARTY_OP_INVITE, PartyCommandResult.INVITE_NOT_LEADER);
}
else
{
var tmp = _clusterServiceLocator.WorldCluster.CharacteRs;
var argobjCharacter = tmp[guid];
client.Character.Group.SetLeader(argobjCharacter);
tmp[guid] = argobjCharacter;
}
}
public void On_CMSG_GROUP_UNINVITE_GUID(PacketClass packet, ClientClass client)
{
if (packet.Data.Length - 1 < 13)
{
return;
}
packet.GetInt16();
var guid = packet.GetUInt64();
_clusterServiceLocator.WorldCluster.Log.WriteLine(LogType.DEBUG, "[{0}:{1}] CMSG_GROUP_UNINVITE_GUID [0x{2:X}]", client.IP, client.Port, guid);
// TODO: InBattlegrounds: INVITE_RESTRICTED
if (guid == 0m)
{
SendPartyResult(client, "", PartyCommand.PARTY_OP_LEAVE, PartyCommandResult.INVITE_NOT_FOUND);
}
else if (_clusterServiceLocator.WorldCluster.CharacteRs.ContainsKey(guid) == false)
{
SendPartyResult(client, "", PartyCommand.PARTY_OP_LEAVE, PartyCommandResult.INVITE_NOT_FOUND);
}
else if (!client.Character.IsGroupLeader)
{
SendPartyResult(client, "", PartyCommand.PARTY_OP_LEAVE, PartyCommandResult.INVITE_NOT_LEADER);
}
else
{
var tmp = _clusterServiceLocator.WorldCluster.CharacteRs;
var argobjCharacter = tmp[guid];
client.Character.Group.Leave(argobjCharacter);
tmp[guid] = argobjCharacter;
}
}
public void On_CMSG_REQUEST_RAID_INFO(PacketClass packet, ClientClass client)
{
_clusterServiceLocator.WorldCluster.Log.WriteLine(LogType.DEBUG, "[{0}:{1}] CMSG_REQUEST_RAID_INFO", client.IP, client.Port);
var q = new DataTable();
if (client.Character is object)
{
_clusterServiceLocator.WorldCluster.GetCharacterDatabase().Query(string.Format("SELECT * FROM characters_instances WHERE char_guid = {0};", client.Character.Guid), ref q);
}
var response = new PacketClass(Opcodes.SMSG_RAID_INSTANCE_INFO);
response.AddInt32(q.Rows.Count); // Instances Counts
var i = 0;
foreach (DataRow r in q.Rows)
{
response.AddUInt32(Conversions.ToUInteger(r["map"])); // MapID
response.AddUInt32((uint)(Conversions.ToInteger(r["expire"]) - _clusterServiceLocator.Functions.GetTimestamp(DateAndTime.Now))); // TimeLeft
response.AddUInt32(Conversions.ToUInteger(r["instance"])); // InstanceID
response.AddUInt32((uint)i); // Counter
i += 1;
}
client.Send(response);
response.Dispose();
}
public void On_MSG_RAID_READY_CHECK(PacketClass packet, ClientClass client)
{
_clusterServiceLocator.WorldCluster.Log.WriteLine(LogType.DEBUG, "[{0}:{1}] MSG_RAID_READY_CHECK", client.IP, client.Port);
if (client.Character.IsGroupLeader)
{
client.Character.Group.BroadcastToOther(packet, client.Character);
}
else
{
if (packet.Data.Length - 1 < 6)
{
return;
}
packet.GetInt16();
var result = packet.GetInt8();
if (result == 0)
{
// DONE: Not ready
client.Character.Group.GetLeader().Client.Send(packet);
}
else
{
// DONE: Ready
var response = new PacketClass(Opcodes.MSG_RAID_READY_CHECK);
response.AddUInt64(client.Character.Guid);
client.Character.Group.GetLeader().Client.Send(response);
response.Dispose();
}
}
}
static void startAsync(int graphSize)
{
Simulator sim = new Simulator();
Graph graf = sim.simulateGraph(graphSize, 1);
Threats threat = sim.simulateThreats(graf);
ClientClass clnt = new ClientClass();
clnt.sendGraph(graf);
var path = clnt.receivePath();
Console.WriteLine("PATH :");
foreach (int i in path)
{
Console.Write("{0}\t", i.ToString());
}
Console.WriteLine("Trying to send");
while (true)
{
// await Task.Delay(1000);
clnt.sendGraph(graf, threat);
Console.WriteLine("dbg : sent");
Console.ReadKey();
path = clnt.receivePath();
Console.WriteLine("PATH :");
foreach (int i in path)
{
Console.Write("{0}\t", i.ToString());
}
Console.WriteLine();
threat = sim.changeThreats(graf, threat);
Console.WriteLine("Waiting ... ");
Console.ReadKey();
//await Task.Delay(5000);
}
}
public void On_CMSG_CHANNEL_UNBAN(PacketClass packet, ClientClass client)
{
if (packet.Data.Length - 1 < 6)
{
return;
}
packet.GetInt16();
var channelName = packet.GetString();
if (packet.Data.Length - 1 < 6 + channelName.Length + 1)
{
return;
}
var playerName = _clusterServiceLocator.Functions.CapitalizeName(packet.GetString());
_clusterServiceLocator.WorldCluster.Log.WriteLine(LogType.DEBUG, "[{0}:{1}] CMSG_CHANNEL_UNBAN [{2}, {3}]", client.IP, client.Port, channelName, playerName);
// ChannelName = ChannelName.ToUpper
if (_clusterServiceLocator.WsHandlerChannels.ChatChanneLs.ContainsKey(channelName))
{
_clusterServiceLocator.WsHandlerChannels.ChatChanneLs[channelName].UnBan(client.Character, playerName);
}
}
public void On_CMSG_ADD_IGNORE(PacketClass packet, ClientClass client)
{
if (packet.Data.Length - 1 < 6)
{
return;
}
packet.GetInt16();
PacketClass response = new(Opcodes.SMSG_FRIEND_STATUS);
var name = packet.GetString();
var guid = 0UL;
_clusterServiceLocator.WorldCluster.Log.WriteLine(LogType.DEBUG, "[{0}:{1}] CMSG_ADD_IGNORE [{2}]", client.IP, client.Port, name);
// DONE: Get GUID from DB
DataTable q = new();
_clusterServiceLocator.WorldCluster.GetCharacterDatabase().Query(string.Format("SELECT char_guid FROM characters WHERE char_name = \"{0}\";", name), ref q);
if (q.Rows.Count > 0)
{
guid = (ulong)q.Rows[0].As <long>("char_guid");
q.Clear();
_clusterServiceLocator.WorldCluster.GetCharacterDatabase().Query(string.Format("SELECT flags FROM character_social WHERE flags = {0}", Conversions.ToByte(SocialFlag.SOCIAL_FLAG_IGNORED)), ref q);
var numberOfFriends = q.Rows.Count;
q.Clear();
_clusterServiceLocator.WorldCluster.GetCharacterDatabase().Query(string.Format("SELECT * FROM character_social WHERE guid = {0} AND friend = {1} AND flags = {2};", client.Character.Guid, guid, Conversions.ToByte(SocialFlag.SOCIAL_FLAG_IGNORED)), ref q);
if (guid == client.Character.Guid)
{
response.AddInt8((byte)FriendResult.FRIEND_IGNORE_SELF);
response.AddUInt64(guid);
}
else if (q.Rows.Count > 0)
{
response.AddInt8((byte)FriendResult.FRIEND_IGNORE_ALREADY);
response.AddUInt64(guid);
}
else if (numberOfFriends >= (int)SocialList.MAX_IGNORES_ON_LIST)
{
response.AddInt8((byte)FriendResult.FRIEND_IGNORE_ALREADY);
response.AddUInt64(guid);
}
else
{
response.AddInt8((byte)FriendResult.FRIEND_IGNORE_ADDED);
response.AddUInt64(guid);
_clusterServiceLocator.WorldCluster.GetCharacterDatabase().Update(string.Format("INSERT INTO character_social (guid, friend, flags) VALUES ({0}, {1}, {2});", client.Character.Guid, guid, Conversions.ToByte(SocialFlag.SOCIAL_FLAG_IGNORED)));
client.Character.IgnoreList.Add(guid);
}
}
else
{
response.AddInt8((byte)FriendResult.FRIEND_IGNORE_NOT_FOUND);
response.AddUInt64(guid);
}
client.Send(response);
response.Dispose();
q.Dispose();
_clusterServiceLocator.WorldCluster.Log.WriteLine(LogType.DEBUG, "[{0}:{1}] SMSG_FRIEND_STATUS", client.IP, client.Port);
}
public void On_CMSG_CHANNEL_SET_OWNER(PacketClass packet, ClientClass client)
{
packet.GetInt16();
var channelName = packet.GetString();
var channelNewOwner = packet.GetString();
_clusterServiceLocator.WorldCluster.Log.WriteLine(LogType.DEBUG, "[{0}:{1}] CMSG_CHANNEL_SET_OWNER [{2}, {3}]", client.IP, client.Port, channelName, channelNewOwner);
// ChannelName = ChannelName.ToUpper
if (_clusterServiceLocator.WsHandlerChannels.ChatChanneLs.ContainsKey(channelName))
{
if (_clusterServiceLocator.WsHandlerChannels.ChatChanneLs[channelName].CanSetOwner(client.Character, channelNewOwner))
{
foreach (var guid in _clusterServiceLocator.WsHandlerChannels.ChatChanneLs[channelName].Joined.ToArray())
{
if ((_clusterServiceLocator.WorldCluster.CharacteRs[guid].Name.ToUpper() ?? "") == (channelNewOwner.ToUpper() ?? ""))
{
var tmp = _clusterServiceLocator.WorldCluster.CharacteRs;
var argCharacter = tmp[guid];
_clusterServiceLocator.WsHandlerChannels.ChatChanneLs[channelName].SetOwner(argCharacter);
tmp[guid] = argCharacter;
break;
}
}
}
}
}
public void SendIgnoreList(ClientClass client, WcHandlerCharacter.CharacterObject character)
{
// DONE: Query DB
DataTable q = new();
_clusterServiceLocator.WorldCluster.GetCharacterDatabase().Query(string.Format("SELECT * FROM character_social WHERE guid = {0} AND (flags & {1}) > 0;", character.Guid, Conversions.ToInteger(SocialFlag.SOCIAL_FLAG_IGNORED)), ref q);
// DONE: Make the packet
PacketClass smsgIgnoreList = new(Opcodes.SMSG_IGNORE_LIST);
if (q.Rows.Count > 0)
{
smsgIgnoreList.AddInt8((byte)q.Rows.Count);
foreach (DataRow row in q.Rows)
{
smsgIgnoreList.AddUInt64(row.As <ulong>("friend")); // Player GUID
}
}
else
{
smsgIgnoreList.AddInt8(0);
}
client.Send(smsgIgnoreList);
smsgIgnoreList.Dispose();
_clusterServiceLocator.WorldCluster.Log.WriteLine(LogType.DEBUG, "[{0}:{1}] SMSG_IGNORE_LIST", client.IP, client.Port);
}
private void button3_Click(object sender, EventArgs e)
{
ClientClass selectedClient = (ClientClass)listBox1.SelectedItem;
if (selectedClient.Status == 0)
{
selectedClient.Status = 2;
MessageBox.Show($"'{selectedClient.FirstName}' with id '{selectedClient.ClientId}' was successfully banned", "Autopark", new MessageBoxButtons(), MessageBoxIcon.Asterisk);
}
else if (selectedClient.Status == 1)
{
MessageBox.Show("Unable to ban administrator", "Error", new MessageBoxButtons(), MessageBoxIcon.Error);
return;
}
else if (selectedClient.Status == 2)
{
selectedClient.Status = 0;
MessageBox.Show($"'{selectedClient.FirstName}' with id '{selectedClient.ClientId}' was successfully unbanned", "Autopark", new MessageBoxButtons(), MessageBoxIcon.Asterisk);
}
try
{
SQLClients.GetInstance().Update(selectedClient);
}
catch (Exception excp) { Console.WriteLine(excp.Message); }
listBox1_SelectedIndexChanged(sender, new EventArgs());
}
public RentClass(int rentId, ClientClass currentClient, CarClass currentCar, DateTime issueDate, DateTime returnDate)
{
if (rentId == -1)
{
RentService.LastId++;
RentId = RentService.LastId;
}
else
{
RentId = rentId;
RentService.LastId = RentId;
}
CurrentClient = currentClient ?? throw new ArgumentNullException("currentClient can't be null!");
CurrentCar = currentCar ?? throw new ArgumentNullException("currentCar can't be null");
if (issueDate != null)
{
IssueDate = issueDate;
}
else
{
throw new ArgumentNullException("issueDate can't be null");
}
if (returnDate != null)
{
ReturnDate = returnDate;
}
else
{
throw new ArgumentNullException("returnDate can't be null");
}
CurrentCar.CarStatus = true;
}
public void On_MSG_MOVE_START_FORWARD(PacketClass packet, ClientClass client)
{
try
{
client.Character.GetWorld.ClientPacket(client.Index, packet.Data);
_clusterServiceLocator.WorldCluster.Log.WriteLine(LogType.DEBUG, "[{0}:{1}] MSG_MOVE_START_FOWARD [{2}]", client.IP, client.Port, client.Character.Map);
}
catch
{
_clusterServiceLocator.WcNetwork.WorldServer.Disconnect("NULL", new List <uint> {
client.Character.Map
});
_clusterServiceLocator.WorldCluster.Log.WriteLine(LogType.WARNING, "[{0}:{1}] MSG_MOVE_START_FOWARD error occured [{2}]", client.IP, client.Port, client.Character.Map);
return;
}
// DONE: Save location on cluster
client.Character.PositionX = packet.GetFloat(); // (15)
client.Character.PositionY = packet.GetFloat();
client.Character.PositionZ = packet.GetFloat();
// DONE: Sync your location to other party / raid members
if (client.Character.IsInGroup)
{
var statsPacket = new PacketClass(Opcodes.UMSG_UPDATE_GROUP_MEMBERS)
{
Data = client.Character.GetWorld.GroupMemberStats(client.Character.Guid, (int)Functions.PartyMemberStatsFlag.GROUP_UPDATE_FLAG_POSITION + (int)Functions.PartyMemberStatsFlag.GROUP_UPDATE_FLAG_ZONE)
};
client.Character.Group.BroadcastToOutOfRange(statsPacket, client.Character);
statsPacket.Dispose();
}
}
public void On_MSG_START_BACKWARD(PacketClass packet, ClientClass client)
{
try
{
client.Character.GetWorld.ClientPacket(client.Index, packet.Data);
_clusterServiceLocator.WorldCluster.Log.WriteLine(LogType.DEBUG, "[{0}:{1}] MSG_START_BACKWARD [{2}]", client.IP, client.Port, client.Character.Map);
}
catch
{
// _WC_Network.WorldServer.Disconnect("NULL", New List(Of UInteger)() From {client.Character.Map}) 'There's an error coming from here, uncomment for full runtime error log details!
_clusterServiceLocator.WorldCluster.Log.WriteLine(LogType.WARNING, "[{0}:{1}] MSG_START_BACKWARD error occured [{2}]", client.IP, client.Port, client.Character.Map);
return;
}
// DONE: Save location on cluster
client.Character.PositionX = packet.GetFloat(); // (15)
client.Character.PositionY = packet.GetFloat();
client.Character.PositionZ = packet.GetFloat();
// DONE: Sync your location to other party / raid members
if (client.Character.IsInGroup)
{
PacketClass statsPacket = new(Opcodes.UMSG_UPDATE_GROUP_MEMBERS) { Data = client.Character.GetWorld.GroupMemberStats(client.Character.Guid, (int)Functions.PartyMemberStatsFlag.GROUP_UPDATE_FLAG_POSITION + (int)Functions.PartyMemberStatsFlag.GROUP_UPDATE_FLAG_ZONE) };
client.Character.Group.BroadcastToOutOfRange(statsPacket, client.Character);
statsPacket.Dispose();
}
}
public void On_CMSG_GUILD_LEAVE(PacketClass packet, ClientClass client)
{
// packet.GetInt16()
_clusterServiceLocator.WorldCluster.Log.WriteLine(LogType.DEBUG, "[{0}:{1}] CMSG_GUILD_LEAVE", client.IP, client.Port);
// DONE: Checks
if (!client.Character.IsInGuild)
{
_clusterServiceLocator.WcGuild.SendGuildResult(client, GuildCommand.GUILD_CREATE_S, GuildError.GUILD_PLAYER_NOT_IN_GUILD);
return;
}
if (client.Character.IsGuildLeader)
{
_clusterServiceLocator.WcGuild.SendGuildResult(client, GuildCommand.GUILD_QUIT_S, GuildError.GUILD_LEADER_LEAVE);
return;
}
_clusterServiceLocator.WcGuild.RemoveCharacterFromGuild(client.Character);
_clusterServiceLocator.WcGuild.SendGuildResult(client, GuildCommand.GUILD_QUIT_S, GuildError.GUILD_PLAYER_NO_MORE_IN_GUILD, client.Character.Name);
var response = new PacketClass(Opcodes.SMSG_GUILD_EVENT);
response.AddInt8((byte)GuildEvent.LEFT);
response.AddInt8(1);
response.AddString(client.Character.Name);
var argnotTo = 0UL;
_clusterServiceLocator.WcGuild.BroadcastToGuild(response, client.Character.Guild, notTo: argnotTo);
response.Dispose();
}
public void On_CMSG_REQUEST_PARTY_MEMBER_STATS(PacketClass packet, ClientClass client)
{
if (packet.Data.Length - 1 < 13)
{
return;
}
packet.GetInt16();
var guid = packet.GetUInt64();
_clusterServiceLocator.WorldCluster.Log.WriteLine(LogType.DEBUG, "[{0}:{1}] CMSG_REQUEST_PARTY_MEMBER_STATS [{2:X}]", client.IP, client.Port, guid);
if (!_clusterServiceLocator.WorldCluster.CharacteRs.ContainsKey(guid))
{
// Character is offline
var response = _clusterServiceLocator.Functions.BuildPartyMemberStatsOffline(guid);
client.Send(response);
response.Dispose();
}
else if (_clusterServiceLocator.WorldCluster.CharacteRs[guid].IsInWorld == false)
{
// Character is offline (not in world)
var response = _clusterServiceLocator.Functions.BuildPartyMemberStatsOffline(guid);
client.Send(response);
response.Dispose();
}
else
{
// Request information from WorldServer
var response = new PacketClass(0)
{
Data = _clusterServiceLocator.WorldCluster.CharacteRs[guid].GetWorld.GroupMemberStats(guid, 0)
};
client.Send(response);
response.Dispose();
}
}
public void On_CMSG_GMTICKET_CREATE(PacketClass packet, ClientClass client)
{
packet.GetInt16();
var ticketMap = packet.GetUInt32();
var ticketX = packet.GetFloat();
var ticketY = packet.GetFloat();
var ticketZ = packet.GetFloat();
var ticketText = _clusterServiceLocator.Functions.EscapeString(packet.GetString());
DataTable mySqlResult = new();
_clusterServiceLocator.WorldCluster.GetCharacterDatabase().Query(string.Format("SELECT * FROM characters_tickets WHERE char_guid = {0};", client.Character.Guid), ref mySqlResult);
PacketClass smsgGmticketCreate = new(Opcodes.SMSG_GMTICKET_CREATE);
if (mySqlResult.Rows.Count > 0)
{
_clusterServiceLocator.WorldCluster.Log.WriteLine(LogType.DEBUG, "[{0}:{1}] CMSG_GMTICKET_CREATE", client.IP, client.Port);
smsgGmticketCreate.AddInt32((int)GmTicketCreateResult.GMTICKET_ALREADY_HAVE);
}
else
{
_clusterServiceLocator.WorldCluster.Log.WriteLine(LogType.DEBUG, "[{0}:{1}] CMSG_GMTICKET_CREATE [{2}]", client.IP, client.Port, ticketText);
_clusterServiceLocator.WorldCluster.GetCharacterDatabase().Update(string.Format("INSERT INTO characters_tickets (char_guid, ticket_text, ticket_x, ticket_y, ticket_z, ticket_map) VALUES ({0} , \"{1}\", {2}, {3}, {4}, {5});", client.Character.Guid, ticketText, Strings.Trim(Conversion.Str(ticketX)), Strings.Trim(Conversion.Str(ticketY)), Strings.Trim(Conversion.Str(ticketZ)), ticketMap));
smsgGmticketCreate.AddInt32((int)GmTicketCreateResult.GMTICKET_CREATE_OK);
}
client.Send(smsgGmticketCreate);
smsgGmticketCreate.Dispose();
}
public void On_CMSG_GUILD_ROSTER(PacketClass packet, ClientClass client)
{
// packet.GetInt16()
_clusterServiceLocator.WorldCluster.Log.WriteLine(LogType.DEBUG, "[{0}:{1}] CMSG_GUILD_ROSTER", client.IP, client.Port);
_clusterServiceLocator.WcGuild.SendGuildRoster(client.Character);
}
public void On_CMSG_GUILD_DEL_RANK(PacketClass packet, ClientClass client)
{
packet.GetInt16();
_clusterServiceLocator.WorldCluster.Log.WriteLine(LogType.DEBUG, "[{0}:{1}] CMSG_GUILD_DEL_RANK", client.IP, client.Port);
if (!client.Character.IsInGuild)
{
_clusterServiceLocator.WcGuild.SendGuildResult(client, GuildCommand.GUILD_CREATE_S, GuildError.GUILD_PLAYER_NOT_IN_GUILD);
return;
}
if (!client.Character.IsGuildLeader)
{
_clusterServiceLocator.WcGuild.SendGuildResult(client, GuildCommand.GUILD_CREATE_S, GuildError.GUILD_PERMISSIONS);
return;
}
// TODO: Check if someone in the guild is the rank we're removing?
// TODO: Can we really remove all ranks?
for (var i = 9; i >= 0; i -= 1)
{
if (!string.IsNullOrEmpty(client.Character.Guild.Ranks[i]))
{
_clusterServiceLocator.WorldCluster.GetCharacterDatabase().Update(string.Format("UPDATE guilds SET guild_rank{1} = '{2}', guild_rank{1}_Rights = '{3}' WHERE guild_id = {0};", client.Character.Guild.Id, i, "", 0));
_clusterServiceLocator.WcGuild.SendGuildQuery(client, client.Character.Guild.Id);
_clusterServiceLocator.WcGuild.SendGuildRoster(client.Character);
return;
}
}
_clusterServiceLocator.WcGuild.SendGuildResult(client, GuildCommand.GUILD_CREATE_S, GuildError.GUILD_INTERNAL);
}
public void On_CMSG_GUILD_RANK(PacketClass packet, ClientClass client)
{
if (packet.Data.Length - 1 < 14)
{
return;
}
packet.GetInt16();
var rankId = packet.GetInt32();
var rankRights = packet.GetUInt32();
var rankName = packet.GetString().Replace("\"", "_").Replace("'", "_");
_clusterServiceLocator.WorldCluster.Log.WriteLine(LogType.DEBUG, "[{0}:{1}] CMSG_GUILD_RANK [{2}:{3}:{4}]", client.IP, client.Port, rankId, rankRights, rankName);
if (rankId < 0 || rankId > 9)
{
return;
}
if (!client.Character.IsInGuild)
{
_clusterServiceLocator.WcGuild.SendGuildResult(client, GuildCommand.GUILD_CREATE_S, GuildError.GUILD_PLAYER_NOT_IN_GUILD);
return;
}
if (!client.Character.IsGuildLeader)
{
_clusterServiceLocator.WcGuild.SendGuildResult(client, GuildCommand.GUILD_CREATE_S, GuildError.GUILD_PERMISSIONS);
return;
}
client.Character.Guild.Ranks[rankId] = rankName;
client.Character.Guild.RankRights[rankId] = rankRights;
_clusterServiceLocator.WorldCluster.GetCharacterDatabase().Update(string.Format("UPDATE guilds SET guild_rank{1} = \"{2}\", guild_rank{1}_Rights = {3} WHERE guild_id = {0};", client.Character.Guild.Id, rankId, rankName, rankRights));
_clusterServiceLocator.WcGuild.SendGuildQuery(client, client.Character.Guild.Id);
_clusterServiceLocator.WcGuild.SendGuildRoster(client.Character);
}
public void On_CMSG_INSPECT(PacketClass packet, ClientClass client)
{
packet.GetInt16();
var guid = packet.GetUInt64();
_clusterServiceLocator.WorldCluster.Log.WriteLine(LogType.DEBUG, "[{0}:{1}] CMSG_INSPECT [GUID={2:X}]", client.IP, client.Port, guid);
}
public void LogPacket(byte[] data, bool server, [Optional, DefaultParameterValue(null)] ClientClass client)
{
int j;
var buffer = "";
try
{
var opcode = (Opcodes)BitConverter.ToInt16(data, 2);
if (IgnorePacket(opcode))
{
return;
}
var startAt = 6;
if (server)
{
startAt = 4;
}
var typeStr = "IN";
if (server)
{
typeStr = "OUT";
}
if (client is null)
{
buffer += string.Format("{4} Packet: (0x{0:X4}) {1} PacketSize = {2}{3}", opcode, opcode, data.Length - startAt, Constants.vbCrLf, typeStr);
}
else
{
buffer += string.Format("[{0}:{1}] {6} Packet: (0x{2:X4}) {3} PacketSize = {4}{5}", client.IP, client.Port, opcode, opcode, data.Length - startAt, Constants.vbCrLf, typeStr);
}
buffer += "|------------------------------------------------|----------------|" + Constants.vbCrLf;
buffer += "|00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F |0123456789ABCDEF|" + Constants.vbCrLf;
buffer += "|------------------------------------------------|----------------|" + Constants.vbCrLf;
var loopTo = data.Length - 1;
for (j = startAt; j <= loopTo; j += 16)
{
if (j + 16 > data.Length)
{
buffer += "|" + BitConverter.ToString(data, j, data.Length - j).Replace("-", " ");
buffer += new string(' ', (j + 16 - data.Length) * 3);
buffer += " |" + FormatPacketStr(Encoding.ASCII.GetString(data, j, data.Length - j));
buffer += new string(' ', j + 16 - data.Length);
}
else
{
buffer += "|" + BitConverter.ToString(data, j, 16).Replace("-", " ");
buffer += " |" + FormatPacketStr(Encoding.ASCII.GetString(data, j, 16));
}
buffer += "|" + Constants.vbCrLf;
}
buffer += "-------------------------------------------------------------------" + Constants.vbCrLf + Constants.vbCrLf;
File.AppendAllText("packets.log", buffer);
}
catch (Exception)
{
}
}
public CarClass(int carId, BodyworkClass bodywork, EngineClass engine, ClientClass currentClient, int kilometrage, int cost, int carStatus)
{
Bodywork = bodywork ?? throw new ArgumentNullException("Bodywork can't be null!");
Engine = engine ?? throw new ArgumentNullException("Engine can't be null!");
CurrentClient = currentClient;
if (kilometrage < 0)
{
throw new Exception("Kilometrage can't be less than zero!");
}
Kilometrage = kilometrage;
if (cost < 0)
{
throw new Exception("Cost can't be less than zero!");
}
Cost = cost;
if (carId < 0)
{
throw new Exception("carId can't be less than zero!");
}
//if (CarIdAll.Contains(carId))
// throw new Exception("carId is not unique!");
CarId = carId;
CarIdAll.Add(carId);
if (carStatus != 0 && carStatus != 1)
{
throw new Exception("carStatus can't be represented as bool!");
}
CarStatus = Convert.ToBoolean(carStatus);
}
public void SendGuildQuery(ClientClass client, uint guildId)
{
if (guildId == 0L)
{
return;
}
// WARNING: This opcode is used also in character enum, so there must not be used any references to CharacterObject, only ClientClass
// DONE: Load the guild if it doesn't exist in the memory
if (GuilDs.ContainsKey(guildId) == false)
{
var tmpGuild = new Guild(guildId);
GuilDs.Add(guildId, tmpGuild);
}
var response = new PacketClass(Opcodes.SMSG_GUILD_QUERY_RESPONSE);
response.AddUInt32(guildId);
response.AddString(GuilDs[guildId].Name);
for (var i = 0; i <= 9; i++)
{
response.AddString(GuilDs[guildId].Ranks[i]);
}
response.AddInt32(GuilDs[guildId].EmblemStyle);
response.AddInt32(GuilDs[guildId].EmblemColor);
response.AddInt32(GuilDs[guildId].BorderStyle);
response.AddInt32(GuilDs[guildId].BorderColor);
response.AddInt32(GuilDs[guildId].BackgroundColor);
response.AddInt32(0);
client.Send(response);
response.Dispose();
}
public void On_CMSG_UPDATE_ACCOUNT_DATA(PacketClass packet, ClientClass client)
{
try
{
if (packet.Data.Length - 1 < 13)
{
return;
}
packet.GetInt16();
var dataId = packet.GetUInt32();
var uncompressedSize = packet.GetUInt32();
_clusterServiceLocator.WorldCluster.Log.WriteLine(LogType.DEBUG, "[{0}:{1}] CMSG_UPDATE_ACCOUNT_DATA [ID={2} Size={3}]", client.IP, client.Port, dataId, uncompressedSize);
if (dataId > 7L)
{
return;
}
// TODO: How does Mangos Zero Handle the Account Data For the Character?
// Dim AccData As New DataTable
// _WorldCluster.AccountDatabase.Query(String.Format("SELECT account_id FROM accounts WHERE username = ""{0}"";", client.Account), AccData)
// If AccData.Rows.Count = 0 Then
// _WorldCluster.Log.WriteLine(LogType.WARNING, "[{0}:{1}] CMSG_UPDATE_ACCOUNT_DATA [Account ID not found]", client.IP, client.Port)
// Exit Sub
// End If
// Dim AccID As Integer = CType(AccData.Rows(0).Item("account_id"), Integer)
// AccData.Clear()
// DONE: Clear the entry
// If UncompressedSize = 0 Then
// _WorldCluster.AccountDatabase.Update(String.Format("UPDATE `account_data` SET `account_data{0}`='' WHERE `account_id`={1}", DataID, AccID))
// Exit Sub
// End If
// DONE: Can not handle more than 65534 bytes
// If UncompressedSize >= 65534 Then
// _WorldCluster.Log.WriteLine(LogType.WARNING, "[{0}:{1}] CMSG_UPDATE_ACCOUNT_DATA [Invalid uncompressed size]", client.IP, client.Port)
// Exit Sub
// End If
var receivedPacketSize = packet.Data.Length - packet.Offset;
}
// Dim dataStr As String
// DONE: Check if it's compressed, if so, decompress it
// If UncompressedSize > ReceivedPacketSize Then
// Dim compressedBuffer(ReceivedPacketSize - 1) As Byte
// Array.Copy(packet.Data, packet.Offset, compressedBuffer, 0, compressedBuffer.Length)
//
// dataStr = ToHex(DeCompress(compressedBuffer))
// Else
// dataStr = ToHex(packet.Data, packet.Offset)
// End If
// _WorldCluster.AccountDatabase.Update(String.Format("UPDATE `account_data` SET `account_data{0}`={2} WHERE `account_id`={1};", DataID, AccID, dataStr))
catch (Exception e)
{
_clusterServiceLocator.WorldCluster.Log.WriteLine(LogType.FAILED, "Error while updating account data.{0}", Constants.vbCrLf + e);
}
}
public GameForm(ClientClass client, string name)
{
DoubleBuffered = true;
this.name = name.Remove(0,9).Replace(System.Environment.NewLine, "");
this.client = client;
StartGame();
this.LabelPlayerNumber.Text += "2";
}
private void buttonConnect_Click(object sender, EventArgs e)
{
client = new TcpClient(textBoxIP.Text,int.Parse(textBoxPort.Text));
ClientClass tcpclient = new ClientClass(client);
Form z = new NewGame(false,naam,tcpclient,this, textBoxIP.Text, textBoxPort.Text);
z.Show();
this.Hide();
}
public NewGame(bool isHost, string name, ClientClass client,Form oldForm, string ip, string port)
{
Player2 = name;
this.Name = "Load game";
this.oldForm = oldForm;
this.isHost = isHost;
this.client = client;
this.ip = ip;
this.port = port;
InitializeComponent();
this.button_Start.Hide();
this.label_Player2.Text += Player2;
label_PlayerOne.Text += Player1;
//Packet_NameMessage temp1 = (Packet_NameMessage)client.received;
//label_PlayerOne.Text += temp1.message;
}
public ClientUI()
{
InitializeComponent();
//initialize Map
map = new string[Constant.MAP_SIZE, Constant.MAP_SIZE];
for (int i = 0; i < Constant.MAP_SIZE; i++)
{
for (int j = 0; j < Constant.MAP_SIZE; j++)
map[i, j] = Constant.EMPTY;
}
mapDetails = new string[Constant.MAP_SIZE, Constant.MAP_SIZE];
mapLabels = new Label[Constant.MAP_SIZE, Constant.MAP_SIZE];
for (int i = 0; i < Constant.MAP_SIZE; i++)
{
for (int j = 0; j < Constant.MAP_SIZE; j++)
mapLabels[i, j] = (Label)tableLayoutPanel2.GetControlFromPosition(i,j);
}
//initialize details table
tableDetails = new string[5,5];
tableLabels = new Label[5,5];
for (int i = 0; i < 5; i++)
{
for (int j = 0; j < 5; j++)
tableLabels[i, j] = (Label)tableLayoutPanel1.GetControlFromPosition(i+1, j+1);
}
//instantiate message passer
parser = new MsgParser();
//instantiate network client
networkClient = new ClientClass(parser);
//Adding a timer
timer = new Timer();
timer.Interval = 100;
//adding listeners
timer.Tick += updateMap;
timer.Tick += updateLabels;
timer.Tick += updateCommConsole;
timer.Start();
}
public OpponentForm(ClientClass client, GameForm form)
{
this.form = form;
this.client = client;
StartGame();
}
