public void UpdateMemberRank(GuildMember Member, GuildRank NewRank)
{
Member.Rank = NewRank;
Member.Save();
//broadcast to members
using (var packet = new Packet(SH29Type.UpdateGuildMemberRank))
{
packet.WriteString(Member.Character.Character.Name, 16);
packet.WriteByte((byte)NewRank);
Broadcast(packet);
}
//broadcast to zones
using (var packet = new InterPacket(InterHeader.ZoneGuildMemberRankUpdate))
{
packet.WriteInt(ID);
packet.WriteInt(Member.Character.ID);
packet.WriteByte((byte)NewRank);
ZoneManager.Broadcast(packet);
}
}
public static void AddRewardItem(WorldConnector pConnector, InterPacket pPacket)
{
byte count;
ushort ItemID;
string Charname;
if (!pPacket.TryReadUShort(out ItemID))
{
return;
}
if (!pPacket.TryReadByte(out count))
{
return;
}
if (!pPacket.TryReadString(out Charname, 16))
{
return;
}
ZoneClient pClient = ClientManager.Instance.GetClientByName(Charname);
if (pClient == null)
{
return;
}
pClient.Character.GiveMasterRewardItem(ItemID, count);
}
public static GroupMember ReadGroupMemberFromDatabase(long pCharId)
{
//--------------------------------------------------
// Quries used in this function
//--------------------------------------------------
const string get_groupmem_query =
"SELECT `Name`, `IsGroupMaster` " +
"FROM `fiesta_world`.`characters` " +
"WHERE `CharID` = '{0}'";
//--------------------------------------------------
// Read member from database.
//--------------------------------------------------
string name = "";
bool isOnline = false;
bool isMaster = false;
using (var client = Program.DatabaseManager.GetClient())
using (var cmd = new MySqlCommand(string.Format(get_groupmem_query, pCharId), client.GetConnection()))
using (var reader = cmd.ExecuteReader())
{
while (reader.Read())
{
name = reader.GetString("Name");
if (reader.IsDBNull(reader.GetOrdinal("IsGroupMaster")))
{
isMaster = false;
}
else
{
isMaster = reader.GetBoolean("IsGroupMaster");
}
}
}
GroupMember member = new GroupMember(name, isMaster, isOnline);
if (ClientManager.Instance.HasClient(name))
{
var client = ClientManager.Instance.GetClientByCharName(name);
member.IsOnline = true;
member.Character = client.Character;
}
else
{
member.IsOnline = (bool)InterFunctionCallbackProvider.Instance.QueuePacket(id =>
{
var packet = new InterPacket(InterHeader.FunctionCharIsOnline);
packet.WriteLong(id);
packet.WriteString(name, 16);
return(packet);
}, packet =>
{
bool value = false;
packet.TryReadBool(out value);
return(value);
});
}
return(member);
}
private static void On_CharacterManager_CharacterLogout(WorldCharacter Character)
{
GuildMember member;
if (Character.Guild != null &&
Character.Guild.GetMember(Character.Character.Name, out member))
{
//send guild member logged out to other guild members
using (var packet = new Packet(SH29Type.GuildMemberLoggedOut))
{
packet.WriteString(Character.Character.Name, 16);
Character.Guild.Broadcast(packet, member);
}
//send packet to zone that guild member logged out
using (var packet = new InterPacket(InterHeader.ZoneGuildMemberLogout))
{
packet.WriteInt(Character.Guild.ID);
packet.WriteInt(Character.ID);
ZoneManager.Broadcast(packet);
}
}
}
public static void SendZoneList(ZoneConnection zc)
{
using (var packet = new InterPacket(InterHeader.Zonelist))
{
packet.Write(Program.Zones.Values.Count);
foreach (var z in Program.Zones.Values)
{
packet.Write(z.ID);
packet.Write(z.IP);
packet.Write(z.Port);
packet.WriteInt(z.Maps.Count);
foreach (var m in z.Maps)
{
packet.WriteUShort(m.ID);
packet.WriteStringLen(m.ShortName);
packet.WriteStringLen(m.FullName);
packet.WriteInt(m.RegenX);
packet.WriteInt(m.RegenY);
packet.WriteByte(m.Kingdom);
packet.WriteUShort(m.ViewRange);
}
}
zc.SendPacket(packet);
}
}
public static void SendAssigned(WorldConnection wc)
{
using (var p = new InterPacket(InterHeader.Assigned))
{
wc.SendPacket(p);
}
}
public void SendPong()
{
using (var packet = new InterPacket(InterHeader.Pong))
{
client.SendPacket(packet);
}
}
public static void SendZoneStarted(byte zoneid, string ip, ushort port, List <MapInfo> maps)
{
using (var packet = new InterPacket(InterHeader.Zoneopened))
{
packet.WriteByte(zoneid);
packet.WriteStringLen(ip);
packet.WriteUShort(port);
packet.WriteInt(maps.Count);
foreach (var m in maps)
{
packet.WriteUShort(m.ID);
packet.WriteStringLen(m.ShortName);
packet.WriteStringLen(m.FullName);
packet.WriteInt(m.RegenX);
packet.WriteInt(m.RegenY);
packet.WriteByte(m.Kingdom);
packet.WriteUShort(m.ViewRange);
}
foreach (var c in Program.Zones.Values)
{
if (c.ID != zoneid)
{
c.SendPacket(packet);
}
}
}
}
public static void On_InterClient_GuildCreated(WorldConnector pConnector, InterPacket pPacket)
{
int guildID, characterID;
if (!pPacket.TryReadInt(out guildID) ||
!pPacket.TryReadInt(out characterID))
{
return;
}
Guild guild;
if (GetGuildByID(guildID, out guild))
{
//check if character is on local zone, if so assign guild to him
ZoneCharacter character;
if (CharacterManager.GetLoggedInCharacter(characterID, out character))
{
character.Guild = guild;
character.GuildAcademy = guild.Academy;
GuildMember member;
if (guild.GetMember(characterID, out member))
{
member.Character = character;
character.GuildMember = member;
}
}
}
}
public static void HandleClientTransferZone(ZoneConnection zc, InterPacket packet)
{
byte admin, zoneid;
int accountid, CharID;
string username, charname, hostip;
ushort randid, mapid;
if (!packet.TryReadByte(out zoneid) || !packet.TryReadInt(out accountid) ||
!packet.TryReadUShort(out mapid) || !packet.TryReadString(out username) ||
!packet.TryReadString(out charname) || !packet.TryReadInt(out CharID) ||
!packet.TryReadUShort(out randid) || !packet.TryReadByte(out admin) ||
!packet.TryReadString(out hostip))
{
return;
}
if (Program.Zones.ContainsKey(zoneid))
{
ZoneConnection z;
if (Program.Zones.TryGetValue(zoneid, out z))
{
z.SendTransferClientFromZone(accountid, username, charname, CharID, randid, admin, hostip);
}
}
else
{
Log.WriteLine(LogLevel.Warn, "Uh oh, Zone {0} tried to transfer {1} to zone {1} D:", zc.ID, charname,
zoneid);
}
}
public static void ReciveCoper(ZoneConnection zc, InterPacket packet)
{
string charname;
long coper;
bool typ;
if (!packet.TryReadString(out charname, 16))
{
return;
}
if (!packet.TryReadLong(out coper))
{
return;
}
if (!packet.TryReadBool(out typ))
{
return;
}
var pClient = ClientManager.Instance.GetClientByCharname(charname);
if (typ)
{
pClient.Character.Character.ReviveCoper += coper;
}
else
{
pClient.Character.RecviveCoperMaster += coper;
pClient.Character.UpdateRecviveCoper();
}
}
public static void HandleServerAssignement(WorldConnection wc, InterPacket packet)
{
if (!packet.TryReadByte(out var wid) || !packet.TryReadString(out var name) || !packet.TryReadString(out var ip) ||
!packet.TryReadUShort(out var port))
{
Log.WriteLine(LogLevel.Error, "Could not read World ID in inter server packet.");
wc.Disconnect();
return;
}
if (WorldManager.Instance.Worlds.ContainsKey(wid))
{
Log.WriteLine(LogLevel.Error, "Already loaded this world?");
wc.Disconnect();
return;
}
wc.Name = name;
wc.ID = wid;
wc.IP = ip;
wc.Port = port;
wc.IsAWorld = true;
if (WorldManager.Instance.Worlds.TryAdd(wc.ID, wc))
{
Log.WriteLine(LogLevel.Info, "Assigned world {0}!", wc.ID);
SendAssigned(wc);
}
else
{
Log.WriteLine(LogLevel.Error, "Couldn't assign world {0}..", wc.ID);
}
}
public void Broadcast(InterPacket pPacket)
{
foreach (var zone in Program.Zones.Values)
{
zone.SendPacket(pPacket);
}
}
public void SendPacket(InterPacket packet)
{
if (this.client == null)
{
return;
}
this.client.SendPacket(packet);
}
public static void Banaccount(WorldConnection wc, InterPacket packet)
{
if (packet.TryReadInt(out var accountId))
{
Program.DatabaseManager.GetClient()
.ExecuteQuery("UPDATE Accounts Set Blocked='1' WHERE ID=" + accountId + "");
}
}
public static void TryAssiging(WorldConnector lc)
{
using (var p = new InterPacket(InterHeader.ASSIGN))
{
p.WriteStringLen(Settings.Instance.IP);
lc.SendPacket(p);
}
}
public void SendPing()
{
Pong = false;
using (var packet = new InterPacket(InterHeader.PING))
{
client.SendPacket(packet);
}
}
public static void BackTo(ZoneClient client, Packet packet)
{
using (var iacket = new InterPacket(InterHeader.ClientDisconect))
{
iacket.WriteString(client.Character.Character.Name, 16);
WorldConnector.Instance.SendPacket(iacket);
}
}
public static void UpdateMoneyWorld(long Money, string charname)
{
using (var packet = new InterPacket(InterHeader.UpdateMoney))
{
packet.WriteString(charname, 16);
packet.WriteLong(Money);
WorldConnector.Instance.SendPacket(packet);
}
}
public static void SendLevelUpToWorld(byte Level, string charname)
{
using (var packet = new InterPacket(InterHeader.CharacterLevelUP))
{
packet.WriteByte(Level);
packet.WriteString(charname, 16);
WorldConnector.Instance.SendPacket(packet);
}
}
public void ChangeMoney(long NewMoney)
{
Character.Money = NewMoney;
using (var packet = new InterPacket(InterHeader.UpdateMoneyFromWorld))
{
packet.WriteInt(Character.ID);
packet.WriteLong(NewMoney);
}
}
private Mutex QueueAndReturnMutex(InterPacket packet, long id)
{
var m = new Mutex();
m.WaitOne();
waithandlers.Add(id, m);
WorldConnector.Instance.SendPacket(packet);
return(m);
}
public static void NewPartyCreated(WorldConnector lc, InterPacket packet)
{
long id;
if (!packet.TryReadLong(out id))
{
throw new InvalidPacketException();
}
GroupManager.Instance.NewGroupCreated(id);
}
public static void SendReciveCoper(string name, long Coper, bool CoperType)
{
using (var packet = new InterPacket(InterHeader.ReciveCoper))
{
packet.WriteString(name, 16);
packet.WriteLong(Coper);
packet.WriteBool(CoperType);
WorldConnector.Instance.SendPacket(packet);
}
}
public static void NewGroupCreated(WorldConnector pConnector, InterPacket pPacket)
{
long groupId = -1;
if (!pPacket.TryReadLong(out groupId))
{
throw new InvalidPacketException();
}
GroupManager.Instance.NewGroupCreated(groupId);
}
public static void SendAddReward(ZoneConnection ZC, ushort itemID, byte count, string CharName)
{
using (var packet = new InterPacket(InterHeader.SendAddRewardItem))
{
packet.WriteUShort(itemID);
packet.WriteByte(count);
packet.WriteString(CharName, 16);
ZC.SendPacket(packet);
}
}
public static void GroupBrokeUp(WorldConnector lc, InterPacket packet)
{
long groupId;
if (!packet.TryReadLong(out groupId))
{
return;
}
GroupManager.Instance.GroupBrokeUp(groupId);
}
private void SendAddMemberInterPacket(GroupMember pMember)
{
ZoneConnection con = Program.GetZoneByMap(pMember.Character.Character.PositionInfo.Map);
using (var pack = new InterPacket(InterHeader.AddPartyMember))
{
pack.WriteLong(this.Id);
pack.WriteString(pMember.Name, 16);
con.SendPacket(pack);
}
}
public static void SendZoneStopped(byte zoneid)
{
using (var packet = new InterPacket(InterHeader.Zoneclosed))
{
packet.Write(zoneid);
foreach (var c in Program.Zones.Values)
{
c.SendPacket(packet);
}
}
}
public static void TryAssiging(LoginConnector lc)
{
using (var p = new InterPacket(InterHeader.Assign))
{
p.WriteByte(Settings.Instance.Id);
p.WriteStringLen(Settings.Instance.WorldName);
p.WriteStringLen(Settings.Instance.Ip);
p.WriteUShort(Settings.Instance.Port);
lc.SendPacket(p);
}
}
