public static void RemoveOnDisconnect(party p, Systems c)
{
//Remove client and member if it contains our removing character
if (p.Members.Contains(c.Character.Information.UniqueID))
{
p.Members.Remove(c.Character.Information.UniqueID);
p.MembersClient.Remove(c.client);
}
//Send packet to each player
foreach (int member in p.Members)
{
Systems playerdetail = GetPlayer(member);
if (p.Members.Count > 1)
{
playerdetail.client.Send(Packet.Party_Data(1, 0));
}
else
{
//Send removal of party
playerdetail.client.Send(Packet.Party_Data(3, playerdetail.Character.Information.UniqueID));
//Remove party state
playerdetail.Character.Network.Party = null;
}
}
}
void CleanUp(Systems c)
{
c.Character.Network.Guild.MembersClient.Remove(c.client);
c.Character.Network.Guild.Members.Remove(c.Character.Information.CharacterID);
c.Character.Network.Guild.Name = null;
c.Character.Network.Guild.Level = 0;
c.Character.Network.Guild.PointsTotal = 0;
c.Character.Network.Guild.NewsTitle = null;
c.Character.Network.Guild.NewsMessage = null;
c.Character.Network.Guild.StorageSlots = 0;
c.Character.Network.Guild.Wargold = 0;
c.Character.Network.Guild.StorageGold = 0;
c.Character.Network.Guild.GuildOwner = 0;
c.Character.Network.Guild.Guildid = 0;
c.Character.Network.Guild.GrantName = null;
c.Character.Network.Guild.FWrank = 0;
c.Character.Network.Guild.DonateGP = 0;
c.Character.Network.Guild.LastDonate = 0;
c.Character.Network.Guild.joinRight = false;
c.Character.Network.Guild.withdrawRight = false;
c.Character.Network.Guild.unionRight = false;
c.Character.Network.Guild.guildstorageRight = false;
c.Character.Network.Guild.noticeeditRight = false;
c.Character.Network.Guild.MembersClient = null;
c.Character.Network.Guild.MembersClient = null;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Player Disconnect
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public void KickPlayer(Systems Target)
{
try
{
Target.client.Send((Packet.ChatPacket(7, Target.Character.Information.UniqueID, "You Have been kicked!", "")));
if (Player != null)
{
MsSQL.UpdateData("UPDATE users SET online='" + 0 + "' WHERE id='" + Target.Player.AccountName + "'");
MsSQL.UpdateData("UPDATE character SET online=" + 0 + "' WHERE id='" + Target.Character.Information.UniqueID + "'");
Target.Player.Dispose();
Target.Player = null;
}
if (Target.Character != null)
{
if (Target.Character.Transport.Right) Target.Character.Transport.Horse.DeSpawnMe();
if (Target.Character.Grabpet.Active) Target.Character.Grabpet.Details.DeSpawnMe();
if (Target.Character.Network.Exchange.Window) Target.Exchange_Close();
if (Target.Character.State.Sitting) Target.StopSitDownTimer();
Target.StopAttackTimer();
Target.BuffAllClose();
Target.DeSpawnMe();
Target.StopMPRegen();
Target.StopHPRegen();
Target.SavePlayerPosition();
Target.SavePlayerInfo();
Target.Character.InGame = false;
client.Disconnect(Target.client.clientSocket);
Target.client.Close();
}
}
catch (Exception ex)
{
Systems.Debugger.Write(ex);
}
}
public void MonsterDrop()
{
try
{
if (this.GetDie || this.Die)
{
if (this.Type != 16)
{
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Set Target Information
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Systems sys = (Systems)this.GetTarget();
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// If There's no target return
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
if (sys == null)
{
return;
}
sbyte Leveldiff = (sbyte)(sys.Character.Information.Level - Data.ObjectBase[ID].Level);
int Amountinfo = 0;
if (Math.Abs(Leveldiff) < 10 || Math.Abs(Leveldiff) == 0)
{
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Gold Drop
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#region Gold
int Golddrop = rnd.Next(Data.LevelGold[Data.ObjectBase[ID].Level].min, Data.LevelGold[Data.ObjectBase[ID].Level].max);
Amountinfo = 0;
if (this.Type == 4 && (rnd.Next(0, 200) < 200 * Systems.Rate.Gold))
{
Amountinfo = Convert.ToByte(rnd.Next(1, 3));
}
if (this.Type == 3 && (rnd.Next(0, 200) < 200 * Systems.Rate.Gold))
{
Amountinfo = Convert.ToByte(rnd.Next(4, 6));
}
if (this.Type == 1 && (rnd.Next(0, 200) < 200 * Systems.Rate.Gold))
{
Amountinfo = Convert.ToByte(rnd.Next(1, 3));
}
if (this.Type == 0 && (rnd.Next(0, 200) < 100 * Systems.Rate.Gold))
{
Amountinfo = 1;
}
for (byte a = 1; a <= Amountinfo;)
{
world_item Gold_Drop = new world_item();
Gold_Drop.amount = Golddrop * Systems.Rate.Gold;
Gold_Drop.Model = 1;
if (Gold_Drop.amount < 1000)
{
Gold_Drop.Model = 1;
}
else if (Gold_Drop.amount > 1000 && Gold_Drop.amount < 10000)
{
Gold_Drop.Model = 2;
}
else if (Gold_Drop.amount > 10000)
{
Gold_Drop.Model = 3;
}
Gold_Drop.Ids = new Global.ID(Global.ID.IDS.World);
Gold_Drop.UniqueID = Gold_Drop.Ids.GetUniqueID;
Gold_Drop.x = this.x + rnd.Next(0, 7);
Gold_Drop.z = this.z;
Gold_Drop.y = this.y + rnd.Next(0, 7);
Gold_Drop.xSec = this.xSec;
Gold_Drop.ySec = this.ySec;
Gold_Drop.Type = 1;
Gold_Drop.downType = true;
Gold_Drop.fromType = 5;
Systems.aRound(ref Gold_Drop.x, ref Gold_Drop.y, 0);
Systems.WorldItem.Add(Gold_Drop);
Gold_Drop.Send(Packet.ObjectSpawn(Gold_Drop), true);
a++;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Send Info To Grabpet
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
if (((Systems)this.GetTarget()).Character.Grabpet.Active)
{
((Systems)this.GetTarget()).Pet_PickupItem(Gold_Drop);
}
}
#endregion
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Drop Database
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#region Drop Databases
foreach (KeyValuePair <string, DarkEmu_GameServer.Global.drop_database> p in Data.DropBase)
{
Amountinfo = p.Value.GetAmount(Data.ObjectBase[ID].Type, p.Key);
if (Amountinfo > 0)
{
for (byte c = 1; c <= Amountinfo; c++)
{
world_item Dropped_Item = new world_item();
Dropped_Item.Model = p.Value.GetDrop(Data.ObjectBase[this.ID].Level, this.ID, p.Key, sys.Character.Information.Race);
if (Dropped_Item.Model == -1)
{
continue;
}
Dropped_Item.Ids = new Global.ID(Global.ID.IDS.World);
Dropped_Item.UniqueID = Dropped_Item.Ids.GetUniqueID;
Dropped_Item.PlusValue = Function.Items.RandomPlusValue();
Dropped_Item.MagAtt = Function.Items.RandomStatValue();
Dropped_Item.x = this.x + rnd.Next(0, 11);
Dropped_Item.z = this.z;
Dropped_Item.y = this.y + rnd.Next(0, 11);
Dropped_Item.xSec = this.xSec;
Dropped_Item.ySec = this.ySec;
Dropped_Item.Type = p.Value.GetSpawnType(p.Key);
Dropped_Item.fromType = 5;
Dropped_Item.downType = true;
Dropped_Item.fromOwner = this.UniqueID;
Dropped_Item.amount = p.Value.GetQuantity(this.Type, p.Key);
Dropped_Item.Owner = ((Systems)this.GetTarget()).Character.Account.ID;
Systems.WorldItem.Add(Dropped_Item);
Dropped_Item.Send(Packet.ObjectSpawn(Dropped_Item), true);
}
}
}
}
#endregion
}
}
}
catch (Exception ex)
{
Console.WriteLine("Drop system error: {0}", ex);
}
}
public void ChangeCrit_cr(Systems Target, int slot, bool delete,bool UpdatePacket)
{
if (!delete)
{
}
}
public static byte[] Party_DataMember(party p)
{
//Create new packet writer
PacketWriter Writer = new PacketWriter();
//Add opcode
Writer.Create(Systems.SERVER_PARTYMEMBER_DATA);
//Write static byte
Writer.Byte(0xFF);
//Write party id
Writer.DWord(p.ptid);
//Write leader id
Writer.DWord(p.LeaderID);
//Write byte party type
Writer.Byte(p.Type);
//Write total amount of members in party
Writer.Byte(p.Members.Count);
//Repeat for each member in party -1
for (byte b = 0; b <= p.Members.Count - 1; b++)
{
//Get player detail information
Systems PartyMemberInfo = Systems.GetPlayer(p.Members[b]);
//Calculate hp and mp
int partyPercentMP = (int)Math.Round((decimal)(PartyMemberInfo.Character.Stat.SecondMP * 10) / PartyMemberInfo.Character.Stat.Mp) << 4;
int partyPercentHP = (int)Math.Round((decimal)(PartyMemberInfo.Character.Stat.SecondHp * 10) / PartyMemberInfo.Character.Stat.Hp);
//Set percent
int partyPercent = partyPercentHP | partyPercentMP;
//Write static byte
Writer.Byte(0xff);
//Write unique member id
Writer.DWord(PartyMemberInfo.Character.Information.UniqueID);
//Write character name
Writer.Text(PartyMemberInfo.Character.Information.Name);
//Write character model
Writer.DWord(PartyMemberInfo.Character.Information.Model);
//Write character level
Writer.Byte(PartyMemberInfo.Character.Information.Level);
//Write stat hp mp information
Writer.Byte((byte)partyPercent);
//Write x and y sector
Writer.Byte(PartyMemberInfo.Character.Position.xSec);
Writer.Byte(PartyMemberInfo.Character.Position.ySec);
//Write x z y
Writer.Word(Formule.packetx(PartyMemberInfo.Character.Position.x, PartyMemberInfo.Character.Position.xSec));
Writer.Word(PartyMemberInfo.Character.Position.z);
Writer.Word(Formule.packety(PartyMemberInfo.Character.Position.y, PartyMemberInfo.Character.Position.ySec));
//Write double word 1
Writer.Word(1);
Writer.Word(1);
//If player has a guild
if (PartyMemberInfo.Character.Network.Guild.Name != null)
{
//Write guild name
Writer.Text(PartyMemberInfo.Character.Network.Guild.Name);
}
//If player has no guild
else
{
//Write word 0 value
Writer.Word(0);
}
//Write static byte
Writer.Byte(0);
//Write dword
Writer.DWord(0);
Writer.DWord(0);
}
//Return all bytes for sending
return(Writer.GetBytes());
}
private void SpawnUnique(List <string> parameters)
{
obj o = new obj();
switch ((Uniques)Int32.Parse(parameters[0]))
{
case Uniques.TigerGirl: // INSERT SPAWN CODE HERE
o = getMob(1954, parameters);
Systems.Objects.Add(o);
o.SpawnMe();
Systems.SendAll(Packet.Unique_Data(5, (int)o.ID, null));
break;
case Uniques.Urichi:
o = getMob(1982, parameters);
Systems.Objects.Add(o);
o.SpawnMe();
Systems.SendAll(Packet.Unique_Data(5, (int)o.ID, null));
break;
case Uniques.Isyutaru:
o = getMob(2002, parameters);
Systems.Objects.Add(o);
o.SpawnMe();
Systems.SendAll(Packet.Unique_Data(5, (int)o.ID, null));
break;
case Uniques.LordYarkan:
o = getMob(3810, parameters);
Systems.Objects.Add(o);
o.SpawnMe();
Systems.SendAll(Packet.Unique_Data(5, (int)o.ID, null));
break;
case Uniques.DemonShaitan:
o = getMob(3875, parameters);
Systems.Objects.Add(o);
o.SpawnMe();
Systems.SendAll(Packet.Unique_Data(5, (int)o.ID, null));
break;
case Uniques.Cerberus:
o = getMob(5871, parameters);
Systems.Objects.Add(o);
o.SpawnMe();
Systems.SendAll(Packet.Unique_Data(5, (int)o.ID, null));
break;
case Uniques.CapIvy:
o = getMob(14778, parameters);
Systems.Objects.Add(o);
o.SpawnMe();
Systems.SendAll(Packet.Unique_Data(5, (int)o.ID, null));
break;
case Uniques.Medusa:
o = getMob(14839, parameters);
Systems.Objects.Add(o);
o.SpawnMe();
Systems.SendAll(Packet.Unique_Data(5, (int)o.ID, null));
break;
case Uniques.Roc:
o = getMob(3877, parameters);
Systems.Objects.Add(o);
o.SpawnMe();
Systems.SendAll(Packet.Unique_Data(5, (int)o.ID, null));
break;
case Uniques.Neith:
o = getMob(32768, parameters);
Systems.Objects.Add(o);
o.SpawnMe();
Systems.SendAll(Packet.Unique_Data(5, (int)o.ID, null));
break;
case Uniques.Isis:
o = getMob(32770, parameters);
Systems.Objects.Add(o);
o.SpawnMe();
Systems.SendAll(Packet.Unique_Data(5, (int)o.ID, null));
break;
case Uniques.Sphinx:
o = getMob(32752, parameters);
Systems.Objects.Add(o);
o.SpawnMe();
Systems.SendAll(Packet.Unique_Data(5, (int)o.ID, null));
break;
}
}
public void ChangeTargetHp_cmcr(Systems Target, int slot, bool delete, bool UpdatePacket)
{
try
{
if (!delete)
{
if (Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties1["cmcr"] != 0)
{
int amount = Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties1["cmcr"];
Target.Character.Action.Buff.UpdatedStats[slot].Mp = amount;
Target.Character.Stat.Mp -= Target.Character.Action.Buff.UpdatedStats[slot].Mp;
Target.Character.Stat.SecondMP -= Target.Character.Action.Buff.UpdatedStats[slot].Mp;
}
}
else
{
if (Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties1["cmcr"] != 0)
{
Target.Character.Stat.Mp += Target.Character.Action.Buff.UpdatedStats[slot].Mp;
Target.Character.Stat.SecondMP += Target.Character.Action.Buff.UpdatedStats[slot].Mp;
Target.Character.Action.Buff.UpdatedStats[slot].Mp = 0;
}
}
if (UpdatePacket) Target.client.Send(Packet.PlayerStat(Target.Character));
}
catch (Exception ex)
{
Systems.Debugger.Write(ex);
}
}
/////////////////////////////////////////////////////////////////////////////////
// DE-Spawn system (Spawn our char to others).
/////////////////////////////////////////////////////////////////////////////////
void ObjectDePlayerSpawn(Systems s)
{
try
{
if (s.Character.Spawned(this.Character.Information.UniqueID) && !s.Character.deSpawning)
{
if (s.Character.Information.UniqueID != 0)
{
s.ObjectDeSpawnCheck();
}
}
}
catch (Exception ex)
{
Console.WriteLine("Systems despawn error {0}", ex);
Systems.Debugger.Write(ex);
}
}
void KickFromGuild()
{
//Wrap our function inside a catcher
try
{
//Open a new packet reader
PacketReader Reader = new PacketReader(PacketInformation.buffer);
//Read short value lenght of name below
short CharacterNameLen = Reader.Int16();
//Read string charactername
string CharacterName = Reader.String(CharacterNameLen);
//Close packet reader
Reader.Close();
//Get player information
Systems TargetCharacter = GetPlayerName(CharacterName);
//Send required packets to network
foreach (int member in Character.Network.Guild.Members)
{
//Make sure member s not null
if (member != 0)
{
//Get information for the guildmember
Systems guildmember = GetPlayerMainid(member);
//Make sure the guildmember isnt null
if (guildmember != null)
{
//Make sure the kicked member does not receive the packet
if (guildmember.Character.Information.CharacterID != TargetCharacter.Character.Information.CharacterID)
{
guildmember.client.Send(Packet.GuildUpdate(TargetCharacter.Character, 7, 0, 0, 0));
}
}
}
}
//Send update packet to the kicked player
TargetCharacter.client.Send(Packet.GuildUpdate(TargetCharacter.Character, 7, 0, 0, 0));
//Send guild kick message packet to the kicked player
PacketWriter Writer = new PacketWriter();
//Add opcode
Writer.Create(Systems.SERVER_GUILD_KICK);
//Add static byte 1
Writer.Byte(1);
//Send packet to kicked member
TargetCharacter.client.Send(Writer.GetBytes());
//Send guildkick visual packet update to kicked player
TargetCharacter.Send(Packet.GuildKick(TargetCharacter.Character.Information.UniqueID));
//Remove the player from database
MsSQL.UpdateData("DELETE from guild_members where guild_member_id='" + TargetCharacter.Character.Information.CharacterID + "'");
//Update database
Character.Network.Guild.TotalMembers -= 1;
MsSQL.InsertData("UPDATE guild SET guild_members_t='" + Character.Network.Guild.TotalMembers + "' WHERE guild_name='" + Character.Network.Guild.Name + "'");
TargetCharacter.CleanUp(TargetCharacter);
}
//Catch bad exception errors
catch (Exception ex)
{
//Write information to the console
Console.WriteLine("Guild Kick Error: {0}", ex);
//Write information to the debug log
Systems.Debugger.Write(ex);
}
}
/////////////////////////////////////////////////////////////////////////////////
// Load our unions
/////////////////////////////////////////////////////////////////////////////////
#region Load unions
public void LoadUnions()
{
try
{
//First clear out the guild union info (will clean this later).
if (Character.Network.Guild.Unions != null)
{
Character.Network.Guild.Unions = null;
Character.Network.Guild.UnionMembers = null;
Character.Network.Guild.UnionLeader = 0;
Character.Network.Guild.UniqueUnion = 0;
}
//Then we query the row guildid
int my_union = MsSQL.GetDataInt("SELECT union_unique_id FROM guild_unions WHERE union_guildid='" + Character.Network.Guild.Guildid + "'", "union_unique_id");
//If 0 means we check if we are the union leaders
if (my_union == 0)
{
//Check for union leader
my_union = MsSQL.GetDataInt("SELECT union_unique_id FROM guild_unions WHERE union_leader='" + Character.Network.Guild.Guildid + "'", "union_unique_id");
//If we are the union leader
if (my_union > 0)
{
Character.Network.Guild.UnionLeader = Character.Network.Guild.Guildid;
}
}
//If union is active so count higher then 0
if (my_union > 0)
{
MsSQL unions = new MsSQL("SELECT * FROM guild_unions WHERE union_unique_id='" + my_union + "'");
//Open new sql data reader
using (SqlDataReader reader = unions.Read())
{
//While our reader is reading the information
while (reader.Read())
{
//Check if we allready have main info loaded
//If the union leader isnt the loading guild
if (Character.Network.Guild.UnionLeader == 0)
{
Character.Network.Guild.UnionLeader = reader.GetInt32(1);
}
//Add union to the listening
Character.Network.Guild.Unions.Add(reader.GetInt32(2));
//Set union active
Character.Network.Guild.UnionActive = true;
}
// Repeat for each guild in our union
foreach (int guild in Character.Network.Guild.Unions)
{
//Make sure the guild isnt 0
if (guild != 0)
{
//Get guildplayer details
Systems unionmember = GetGuildPlayer(guild);
//Make sure the player isnt null
if (unionmember != null)
{
//Then add our character id to the member list.
Character.Network.Guild.UnionMembers.Add(Character.Information.CharacterID);
}
}
}
//Close our sql reader.
reader.Close();
}
//Finally send packet for union listening
client.Send(Packet.UnionInfo(this));
}
}
catch (Exception ex)
{
Console.WriteLine("Union Load Error {0}", ex);
Systems.Debugger.Write(ex);
}
}
void Player_Wait_CallBack(object e)
{
try
{
if (Character.Information.Quit)
{
//##############################################
// checks before logout
//##############################################
if (Character.Position.Walking)
{
Character.Position.RecordedTime = 0;
Timer.Movement.Dispose();
Timer.Movement = null;
}
//##############################################
// checks before logout
//##############################################
if (Character.Information.CheckParty)
{
LeaveParty();
}
//##############################################
// checks before logout
//##############################################
if (Character.Network.Guild.Guildid != 0)
{
Character.Information.Online = 0;
//Send packets to network and spawned players
foreach (int member in Character.Network.Guild.Members)
{
//Make sure the member is there
if (member != 0)
{
//We dont send this info to the invited user.
if (member != Character.Information.CharacterID)
{
//If the user is not the newly invited member get player info
Systems tomember = GetPlayerMainid(member);
//Send guild update packet
if (tomember != null)
{
tomember.client.Send(Packet.GuildUpdate(Character, 6, Character.Information.CharacterID, 0, 0));
}
}
}
}
Character.Network.Guild.Members.Remove(Character.Information.CharacterID);
Character.Network.Guild.MembersClient.Remove(this.client);
}
//##############################################
// checks before logout
//##############################################
if (Character.Transport.Right)
{
Character.Transport.Horse.DeSpawnMe();
}
if (Character.Grabpet.Active)
{
UnSummonPetLogoff(Character.Grabpet.Details.UniqueID);
}
if (Character.Attackpet.Active)
{
UnSummonPetLogoff(Character.Attackpet.Details.UniqueID);
}
if (Character.Network.Exchange.Window)
{
Exchange_Close();
}
//##############################################
// checks before logout
//##############################################
MsSQL ms = new MsSQL("SELECT * FROM friends WHERE owner='" + Character.Information.CharacterID + "'");
int count = ms.Count();
if (count >= 0)
{
using (SqlDataReader reader = ms.Read())
{
while (reader.Read())
{
int getid = reader.GetInt32(2);
Systems sys = GetPlayerid(getid);
if (sys != null)
{
sys.client.Send(Packet.FriendData(Character.Information.CharacterID, 4, Character.Information.Name, Character, true));
}
}
}
}
//##############################################
// Send packet leave game
//##############################################
client.Send(Packet.EndLeaveGame());
//##############################################
// Updated database
//##############################################
MsSQL.UpdateData("UPDATE character SET online='0' WHERE id='" + Character.Information.CharacterID + "'");
//##############################################
// Remove all remaining parts
//##############################################
BuffAllClose();
DeSpawnMe();
SavePlayerPosition();
SavePlayerInfo();
this.client.Close();
this.Character.Dispose();
this.Dispose();
Character.InGame = false;
Disconnect("normal");
}
Timer.Logout.Dispose();
}
catch (Exception ex)
{
Console.WriteLine("Logout error: {0}", ex);
}
}
/////////////////////////////////////////////////////////////////////////
//Guild Disbanding
/////////////////////////////////////////////////////////////////////////
#region Guild Disband
void GuildDisband()
{
try
{
foreach (int member in Character.Network.Guild.Members)
{
if (member != 0)
{
Systems guildplayer = GetPlayerMainid(member);
if (guildplayer != null)
{
if (guildplayer.Character.Information.CharacterID != Character.Information.CharacterID)
{
//Guild disband message packet
guildplayer.client.Send(Packet.GuildUpdate(Character, 2, 0, 0, 0));
//Remove guild name and details from player
Send(Packet.GuildKick(guildplayer.Character.Information.UniqueID));
//State packet
guildplayer.client.Send(Packet.StatePack(guildplayer.Character.Information.UniqueID, 4, 0, false));
//Set all values to null.
guildplayer.Character.Network.Guild.Members.Remove(guildplayer.Character.Information.CharacterID);
guildplayer.Character.Network.Guild.MembersClient.Remove(guildplayer.client);
guildplayer.Character.Network.Guild.Guildid = 0;
if (guildplayer.Character.Network.Guild.UniqueUnion != 0)
{
guildplayer.Character.Network.Guild.UnionActive = false;
guildplayer.Character.Network.Guild.UnionMembers.Remove(guildplayer.Character.Information.CharacterID);
}
}
}
}
}
//Guild disband message packet
client.Send(Packet.GuildUpdate(Character, 2, 0, 0, 0));
//Remove guild name and details from player
Send(Packet.GuildKick(Character.Information.UniqueID));
//State packet
client.Send(Packet.StatePack(Character.Information.UniqueID, 4, 0, false));
//Set all values to null.
//Remove all rows that contains guildname
MsSQL.UpdateData("DELETE FROM guild_members WHERE guild_id=" + Character.Network.Guild.Guildid + "");
//Remove guild from guild table
MsSQL.UpdateData("DELETE FROM guild WHERE id=" + Character.Network.Guild.Guildid + "");
//Remove ourself
if (Character.Network.Guild.UniqueUnion != 0)
{
Character.Network.Guild.UnionActive = false;
Character.Network.Guild.UnionMembers.Remove(Character.Information.CharacterID);
}
Character.Network.Guild.Members.Remove(Character.Information.UniqueID);
Character.Network.Guild.MembersClient.Remove(client);
Character.Network.Guild.Guildid = 0;
//Packet Final message
client.Send(Packet.PromoteOrDisband(1));
}
catch (Exception ex)
{
Console.WriteLine("Guild Disband Error: {0}", ex);
Systems.Debugger.Write(ex);
}
}
void Player_Movement(object e)
{
try
{
if (Character.Position.RecordedTime <= 0)
{
if (Timer.Movement != null)
{
Timer.Movement.Dispose();
}
Character.Position.Walking = false;
if (Character.Action.PickUping)
{
Player_PickUpItem();
}
Character.Position.z = Character.Position.wZ;
if (Timer.SpawnWatch.ElapsedMilliseconds >= 10)
{
ObjectSpawnCheck();
Timer.SpawnWatch.Restart();
}
Movement_CaveTeleport();
}
else
{
//If player is in a party send location update packet to each member
if (Character.Network.Party != null)
{
foreach (int member in Character.Network.Party.Members)
{
if (member != Character.Information.UniqueID)
{
Systems memberinfo = GetPlayer(member);
memberinfo.client.Send(Packet.Party_Data(6, member));
}
}
}
if (Character.Action.nAttack)
{
Character.Position.kX -= (Character.Position.wX * 10) / 100;
Character.Position.kY -= (Character.Position.wY * 10) / 100;
if (Character.Information.Item.wID != 0)
{
if (Math.Sqrt(Character.Position.kX * Character.Position.kX + Character.Position.kY * Character.Position.kY) <= Data.ItemBase[Character.Information.Item.wID].ATTACK_DISTANCE)
{
Character.Position.RecordedTime = 0;
if (Character.Action.nAttack)
{
ActionAttack();
}
if (Timer.SpawnWatch.ElapsedMilliseconds >= 150)
{
this.ObjectSpawnCheck();
Timer.SpawnWatch.Restart();
}
Timer.Movement.Dispose();
Character.Position.z = Character.Position.wZ;
Character.Action.PickUping = false;
Character.Position.Walking = false;
return;
}
}
else
{
if (Math.Sqrt(Character.Position.kX * Character.Position.kX + Character.Position.kY * Character.Position.kY) <= 1)
{
Character.Position.RecordedTime = 0;
if (Character.Action.nAttack)
{
ActionAttack();
}
if (Timer.SpawnWatch.ElapsedMilliseconds >= 1000)
{
this.ObjectSpawnCheck();
Timer.SpawnWatch.Restart();
}
Timer.Movement.Dispose();
Character.Position.z = Character.Position.wZ;
Character.Action.PickUping = false;
Character.Position.Walking = false;
return;
}
}
}
else if (Character.Action.sAttack)
{
Character.Position.kX -= (Character.Position.wX * 10) / 100;
Character.Position.kY -= (Character.Position.wY * 10) / 100;
double test = Character.Action.Skill.Distance;
if (test == 0)
{
test = Data.ItemBase[Character.Information.Item.wID].ATTACK_DISTANCE;
}
if (Math.Sqrt(Character.Position.kX * Character.Position.kX + Character.Position.kY * Character.Position.kY) < test)
{
if (Character.Action.sAttack)
{
StartSkill();
}
Character.Position.RecordedTime = 0;
Character.aRound = new bool[10];
if (Timer.SpawnWatch.ElapsedMilliseconds >= 1000)
{
this.ObjectSpawnCheck();
Timer.SpawnWatch.Restart();
}
Timer.Movement.Dispose();
Character.Position.z = Character.Position.wZ;
Character.Action.PickUping = false;
Character.Position.Walking = false;
return;
}
}
Character.aRound = new bool[10];
Character.Position.x += (Character.Position.wX * 10) / 100;
Character.Position.y += (Character.Position.wY * 10) / 100;
if (Character.Transport.Right)
{
Character.Transport.Horse.x = Character.Position.x;
Character.Transport.Horse.y = Character.Position.y;
}
Character.Position.RecordedTime -= (Character.Position.Time * 0.1);
if (Timer.SpawnWatch.ElapsedMilliseconds >= 10)
{
this.ObjectSpawnCheck();
this.ObjectAttackCheck();
Timer.SpawnWatch.Restart();
}
}
}
catch (Exception ex)
{
Console.WriteLine("Move call error: {0}", ex);
Systems.Debugger.Write(ex);
}
}
public void PingTimerCallBack(object e)
{
try
{
TimeSpan t = DateTime.Now - lastPing;
if (client.State)
{
Ping();
}
if (!client.State && Player != null)
{
Console.BackgroundColor = ConsoleColor.Black;
MsSQL.UpdateData("UPDATE users SET online='" + 0 + "' WHERE id='" + Player.AccountName + "'");
MsSQL.UpdateData("UPDATE character SET online='0' WHERE id='" + Character.Information.CharacterID + "'");
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("[@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@]");
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("@Evo-Debug : Srevo has debugged: {0}", Character.Information.Name);
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("[@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@]");
Console.ForegroundColor = ConsoleColor.Green;
if (Character.Grabpet.Active)
{
UnSummonPetLogoff(Character.Grabpet.Details.UniqueID);
}
if (Character.Attackpet.Active)
{
UnSummonPetLogoff(Character.Attackpet.Details.UniqueID);
}
if (Character.Network.Party != null)
{
LeaveParty();
}
if (Character.Network.Guild.Guildid != 0)
{
Character.Information.Online = 0;
//Send packets to network and spawned players
foreach (int member in Character.Network.Guild.Members)
{
//Make sure the member is there
if (member != 0)
{
//We dont send this info to the invited user.
if (member != Character.Information.CharacterID)
{
//If the user is not the newly invited member get player info
Systems tomember = GetPlayerMainid(member);
//Send guild update packet
if (tomember != null)
{
tomember.client.Send(Packet.GuildUpdate(Character, 6, Character.Information.CharacterID, 0, 0));
}
}
}
}
Character.Network.Guild.Members.Remove(Character.Information.CharacterID);
Character.Network.Guild.MembersClient.Remove(this.client);
}
if (this.Character.Transport.Right)
{
this.Character.Transport.Horse.DeSpawnMe();
}
if (this.Character.Grabpet.Active)
{
this.Character.Grabpet.Details.DeSpawnMe();
}
if (this.Character.Network.Exchange.Window)
{
this.Exchange_Close();
}
#region Friend list
MsSQL ms = new MsSQL("SELECT * FROM friends WHERE owner='" + Character.Information.CharacterID + "'");
int count = ms.Count();
if (count >= 0)
{
using (SqlDataReader reader = ms.Read())
{
while (reader.Read())
{
int getid = reader.GetInt32(2);
Systems sys = GetPlayerid(getid);
if (sys != null)
{
sys.client.Send(Packet.FriendData(Character.Information.CharacterID, 4, Character.Information.Name, Character, true));
}
}
}
}
else
{
client.Send(Packet.SendFriendListstatic());
}
#endregion
BuffAllClose();
DeSpawnMe();
SavePlayerPosition();
SavePlayerInfo();
this.client.Close();
this.Character.Dispose();
this.Dispose();
Character.InGame = false;
Disconnect("normal");
lock (Systems.clients)
{
Systems.clients.Remove(this);
}
}
}
catch (NullReferenceException nex)
{
Console.WriteLine("Timer.PingTimerCallBack: {0}", nex);
PingStop();
}
catch (Exception ex)
{
Console.WriteLine("Debug error: {0}", ex);
}
}
void NormalRequest()
{
try
{
//Create new packet reader
PacketReader Reader = new PacketReader(PacketInformation.buffer);
//Get invited member
int Target = Reader.Int32();
//Get party type
byte PartyType = Reader.Byte();
//Close reader
Reader.Close();
//Get target player information
Systems InvitedPlayer = GetPlayer(Target);
//First we check the our own player level
if (Character.Information.Level < 5)
{
//Send message
//Return
return;
}
//Check target level
if (InvitedPlayer.Character.Information.Level < 5)
{
//Send message
//Return
return;
}
//Set target information for invited player
InvitedPlayer.Character.Network.TargetID = Character.Information.UniqueID;
//If the player inviting, has no party yet.
if (Character.Network.Party == null)
{
//Create new party
party Party = new party();
//Set leader of party
Party.LeaderID = Character.Information.UniqueID;
//Set party type
Party.Type = PartyType;
//Add to party net info
Character.Network.Party = Party;
}
//If the target player has no party yet.
if (InvitedPlayer.Character.Network.Party == null)
{
//Send invitation packet
InvitedPlayer.client.Send(Packet.PartyRequest(2, this.Character.Information.UniqueID, PartyType));
//Set invite bools
InvitedPlayer.Character.Information.CheckParty = true;
Character.Information.CheckParty = true;
}
}
//Catch bad exception errors
catch (Exception ex)
{
//Write information to the console
Console.WriteLine(ex);
//Write information to the debug log
Systems.Debugger.Write(ex);
}
}
public void ChangeHitRate_E2AH(Systems Target, int slot, bool delete, bool UpdatePacket)
{
try
{
if (!delete)
{
if (Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties1["E2AH"] != 0)
{
int amount = Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties1["E2AH"];
Target.Character.Action.Buff.UpdatedStats[slot].Hit = amount;
Target.Character.Stat.Hit += Target.Character.Action.Buff.UpdatedStats[slot].Hit;
}
}
else
{
if (Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties1["E2AH"] != 0)
{
Target.Character.Stat.Hit -= Target.Character.Action.Buff.UpdatedStats[slot].Hit;
Target.Character.Action.Buff.UpdatedStats[slot].Hit = 0;
}
}
if (UpdatePacket) Target.client.Send(Packet.PlayerStat(Target.Character));
}
catch (Exception ex)
{
Systems.Debugger.Write(ex);
}
}
void CharacterRequest()
{
try
{
//Open packet reader
PacketReader Reader = new PacketReader(PacketInformation.buffer);
//Get targeted player information
Systems sys = GetPlayer(Character.Network.TargetID);
if (this.Character.State.UnionApply && sys.Character.State.UnionApply)
{
if (Reader.Byte() == 1 && Reader.Byte() == 0)
{
//Need to sniff decline packet info
Character.State.UnionApply = false;
sys.Character.State.UnionApply = false;
}
else
{
//Check for null and set unique id for union and insert our own guild.
if (sys.Character.Network.Guild.Unions == null)
{
int uniqueid = MsSQL.GetRowsCount("SELECT * FROM guild_unions");
sys.Character.Network.Guild.UniqueUnion = uniqueid + 1;
MsSQL.InsertData("INSERT INTO guild_unions (union_leader, union_guildid, union_unique_id) VALUES ('" + sys.Character.Network.Guild.Guildid + "','" + sys.Character.Network.Guild.Guildid + "','" + sys.Character.Network.Guild.UniqueUnion + "')");
}
//Update database
MsSQL.InsertData("INSERT INTO guild_unions (union_leader, union_guildid, union_unique_id) VALUES ('" + sys.Character.Network.Guild.Guildid + "','" + Character.Network.Guild.Guildid + "','" + sys.Character.Network.Guild.UniqueUnion + "')");
//Send union packet to newly joined player
client.Send(Packet.UnionInfo(this));
//Send update packet to all guilds in union
foreach (int member in Character.Network.Guild.Members)
{
//Make sure the member is there
if (member != 0)
{
//If the user is not the newly invited member get player info
Systems tomember = GetPlayerMainid(member);
//Send guild update packet
if (tomember != null)
{
if (!tomember.Character.Network.Guild.SingleSend)
{
if (Character.Information.CharacterID != tomember.Character.Information.CharacterID)
{
tomember.Character.Network.Guild.SingleSend = true;
tomember.client.Send(Packet.GuildUpdate(Character, 14, 0, 0, 0));
}
}
}
}
}
foreach (int member in Character.Network.Guild.UnionMembers)
{
//Make sure the member is there
if (member != 0)
{
//If the user is not the newly invited member get player info
Systems tomember = GetPlayerMainid(member);
//Send guild update packet
if (tomember != null)
{
if (!tomember.Character.Network.Guild.SingleSend)
{
tomember.Character.Network.Guild.SingleSend = true;
tomember.client.Send(Packet.GuildUpdate(Character, 14, 0, 0, 0));
}
}
}
}
//Disable the bool again
foreach (int member in Character.Network.Guild.Members)
{
//Make sure member isnt null
if (member != 0)
{
//Get guildmember details
Systems guildmember = GetPlayerMainid(member);
//Make sure guildmember isnt null
if (guildmember != null)
{
//Disable bool to allow resend new packets.
guildmember.Character.Network.Guild.SingleSend = false;
}
}
}
//Disable the bool again
foreach (int member in Character.Network.Guild.UnionMembers)
{
//Make sure member isnt null
if (member != 0)
{
//Get guildmember details
Systems guildmember = GetPlayerMainid(member);
//Make sure guildmember isnt null
if (guildmember != null)
{
//Disable bool to allow resend new packets.
guildmember.Character.Network.Guild.SingleSend = false;
}
}
}
//Reset bools
Character.State.UnionApply = false;
sys.Character.State.UnionApply = false;
}
}
//------------------------------------- [ Exchange invite ] -------------------------------------//
else if (this.Character.State.Exchanging && sys.Character.State.Exchanging)
{
if (Reader.Byte() == 1 && Reader.Byte() == 0)
{
sys.client.Send(Packet.Exchange_Cancel());
Character.State.Exchanging = false;
sys.Character.State.Exchanging = false;
}
else
{
sys.client.Send(Packet.OpenExhangeWindow(1, this.Character.Information.UniqueID));
client.Send(Packet.OpenExhangeWindow(sys.Character.Information.UniqueID));
Character.Network.Exchange.Window = true;
Character.Network.Exchange.ItemList = new List <DarkEmu_GameServer.Global.slotItem>();
sys.Character.Network.Exchange.Window = true;
sys.Character.Network.Exchange.ItemList = new List <DarkEmu_GameServer.Global.slotItem>();
}
}
//------------------------------------- [ Guild invite ] -------------------------------------//
else if (this.Character.State.GuildInvite && sys.Character.State.GuildInvite)
{
//If byte equals 2 the type is denied
if (Reader.Byte() == 2)
{
//Denied request
Character.State.GuildInvite = false;
sys.Character.State.GuildInvite = false;
//Send refused packet to sender
sys.client.Send(Packet.IngameMessages(SERVER_GUILD, IngameMessages.UIIT_MSG_GUILDERR_JOIN_GUILD_REFUSED));
}
//If not denied we start adding the new member
else
{
//Invite guild member (Add member count + 1).
int guildmemberadd = sys.Character.Network.Guild.Members.Count + 1;
//Update database
MsSQL.InsertData("INSERT INTO guild_members (guild_id, guild_member_id, guild_rank, guild_points, guild_fortress, guild_grant, guild_perm_join, guild_perm_withdraw, guild_perm_union, guild_perm_storage, guild_perm_notice) VALUES ('" + sys.Character.Network.Guild.Guildid + "','" + Character.Information.CharacterID + "','10','0','1','" + "" + "','0','0','0','0','0')");
MsSQL.UpdateData("UPDATE guild SET guild_members_t='" + guildmemberadd + "' WHERE guild_name='" + sys.Character.Network.Guild.Name + "'");
//Reload new member and load character data for guildinfo
LoadPlayerGuildInfo(true);
//Send packets to network and spawned players
foreach (int member in Character.Network.Guild.Members)
{
//Make sure the member is there
if (member != 0)
{
//We dont send this info to the invited user.
if (member != Character.Information.CharacterID)
{
//If the user is not the newly invited member get player info
Systems tomember = GetPlayerMainid(member);
//Send guild update packet
tomember.LoadPlayerGuildInfo(true);
tomember.client.Send(Packet.GuildUpdate(Character, 1, Character.Information.CharacterID, 0, 0));
tomember.client.Send(Packet.GuildSetOnline(Character.Network.Guild, Character.Information.UniqueID));
tomember.client.Send(Packet.GuildUpdate(Character, 6, Character.Information.CharacterID, 0, 0));
}
//Send information to the invited player
else
{
//Send guild data packets to invited
client.Send(Packet.SendGuildStart());
client.Send(Packet.SendGuildInfo(Character.Network.Guild));
client.Send(Packet.SendGuildEnd());
//Load union data for new invited player
LoadUnions();
}
}
}
//Set bools to false for new invite
Character.State.GuildInvite = false;
sys.Character.State.GuildInvite = false;
}
}
//------------------------------------- [ Party invite ] -------------------------------------//
else
{
//If invitation is accepted
if (Reader.Byte() == 1 && Reader.Byte() == 1)
{
//First we set our main checks (Check if player is in party or not).
if (Character.Network.Party != null)
{
return;
}
//Set bools for check
Character.Information.CheckParty = true;
sys.Character.Information.CheckParty = true;
//Set main party information
party JoiningParty = sys.Character.Network.Party;
//Check party type members allowed need message if full
if (JoiningParty.Type == 4 && JoiningParty.Members.Count > 3)
{
//Send party is full message to player
client.Send(Packet.IngameMessages(Systems.SERVER_PARTY_MESSAGES, IngameMessages.UIIT_MSG_PARTYERR_ALREADY_FULL));
return;
}
if (JoiningParty.Type == 5 && JoiningParty.Members.Count > 7)
{
//Send party is full message to player
client.Send(Packet.IngameMessages(Systems.SERVER_PARTY_MESSAGES, IngameMessages.UIIT_MSG_PARTYERR_ALREADY_FULL));
return;
}
//If the current count == 0 then add party and add me
if (JoiningParty.Members.Count == 0)
{
//Add ourselfs to the party list
JoiningParty.Members.Add(sys.Character.Information.UniqueID);
//Add our client to the party list
JoiningParty.MembersClient.Add(sys.client);
//Set party id
JoiningParty.ptid = Party.Count + 1;
//Set party network info
sys.Character.Network.Party = JoiningParty;
//Send permissions
sys.client.Send(Packet.Party_Member(sys.Character.Information.UniqueID));
//Send party data to leader
sys.client.Send(Packet.Party_DataMember(JoiningParty));
//Send party data packet to leader (Other player that joined).
sys.client.Send(Packet.Party_Data(2, Character.Information.UniqueID));
//Add invited member to the list
JoiningParty.Members.Add(Character.Information.UniqueID);
JoiningParty.MembersClient.Add(client);
//Set party info for invited member
Character.Network.Party = JoiningParty;
//Send permissions
client.Send(Packet.PartyOwnerInformation(Character.Information.UniqueID));
//Send party data
client.Send(Packet.Party_DataMember(JoiningParty));
//return
return;
}
//If there are more members in the current party
else
{
//Repeat for each member using count
for (byte b = 0; b <= JoiningParty.Members.Count - 1; b++)
{
//Get player information from [b]
Systems others = GetPlayer(JoiningParty.Members[b]);
//Send party data to member
others.client.Send(Packet.Party_Data(2, Character.Information.UniqueID));
}
//Add the invited member to list
JoiningParty.Members.Add(Character.Information.UniqueID);
//Add the invited client to the list
JoiningParty.MembersClient.Add(client);
//Set party
Character.Network.Party = JoiningParty;
//Send permissions
client.Send(Packet.PartyOwnerInformation(Character.Information.UniqueID));
//Send party data
client.Send(Packet.Party_DataMember(JoiningParty));
return;
}
}
//If denied request
else
{
//Send denied message to the player joining
client.Send(Packet.IngameMessages(Systems.SERVER_PARTY_MEMBER, IngameMessages.UIIT_MSG_PARTYERR_JOIN_PARTY_REFUSED));
//Set both bools to false so inviting can be done again
sys.Character.Information.CheckParty = false;
Character.Information.CheckParty = false;
}
}
}
//Catch bad exception errors
catch (Exception ex)
{
//Write information to the console
Console.WriteLine("Request error: {0}", ex);
//Write information to the debug log
Debugger.Write(ex);
}
}
public void ChangeInt_inti(Systems Target, int slot, bool delete,bool UpdatePacket)
{
try
{
if (!delete)
{
int amount;
if (Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties1["inti"] != 0)
{
amount = Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties1["inti"];
Target.Character.Action.Buff.UpdatedStats[slot].Intelligence = (short)amount;
}
//TODO majd uncomment.
/*if (Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties2.ContainsKey("inti"))
{
amount = Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties2["inti"];
Target.Character.Action.Buff.UpdatedStats[slot].Intelligence = (short)((Target.Character.Stat.Intelligence / 100) * (amount));
}*/
Target.Character.Stat.Intelligence += Target.Character.Action.Buff.UpdatedStats[slot].Intelligence;
}
else
{
Target.Character.Stat.Intelligence -= Target.Character.Action.Buff.UpdatedStats[slot].Intelligence;
Target.Character.Action.Buff.UpdatedStats[slot].Intelligence = 0;
}
if (UpdatePacket) Target.client.Send(Packet.PlayerStat(Target.Character));
}
catch (Exception ex)
{
Systems.Debugger.Write(ex);
}
}
public static byte[] UnionInfo(Systems c)
{
PacketWriter Writer = new PacketWriter();
Writer.Create(Systems.SERVER_GUILD_UNIONS);
Writer.DWord(c.Character.Information.CharacterID); // Union owner id
Writer.DWord(7); // ??Need to check
Writer.DWord(c.Character.Network.Guild.Guildid); // Union leader guild id
Writer.Byte(c.Character.Network.Guild.Unions.Count); // Count guilds in union
//Get all guilds details
foreach (int guild in c.Character.Network.Guild.Unions)
{
//Load other guild data
Systems.MsSQL guild_data = new Systems.MsSQL("SELECT * FROM guild WHERE id='" + guild + "'");
using (System.Data.SqlClient.SqlDataReader reader = guild_data.Read())
{
while (reader.Read())
{
string Guildname = reader.GetString(1);
byte Guildlevel = reader.GetByte(2);
byte Guildmembercount = reader.GetByte(6);
int Ownerid = reader.GetInt32(9);
string Charname = Systems.MsSQL.GetData("SELECT name FROM character WHERE id='" + Ownerid + "'", "name").ToString();
int Charmodel = Convert.ToInt32(Systems.MsSQL.GetData("SELECT chartype FROM character WHERE id='" + Ownerid + "'", "chartype"));
Writer.DWord(guild); //Guild ID
Writer.Text(reader.GetString(1)); //Guildname
Writer.Byte(reader.GetByte(2)); //Guildlevel
Writer.Text(Charname); //Ownername
Writer.DWord(Charmodel); //Owner model
Writer.Byte(reader.GetByte(6)); //Guild member count
//Get guild details
Systems Guildmembers = Systems.GetGuildPlayer(guild);
//Add clients that are online to union list
//Null check
if (Guildmembers != null)
{
foreach (int member in Guildmembers.Character.Network.Guild.Members)
{
//make sure member isnt 0
if (member != 0)
{
//Get player details
Systems getmember = Systems.GetPlayerMainid(member);
//Make sure that the player is there
if (getmember != null)
{
//Add client to union list
c.Character.Network.Guild.UnionMembers.Add(getmember.Character.Information.CharacterID);
//Add to member
if (c.Character.Information.CharacterID != getmember.Character.Information.CharacterID)
{
getmember.Character.Network.Guild.UnionMembers.Add(c.Character.Information.CharacterID);
}
}
}
}
}
}
}
}
return(Writer.GetBytes());
}
public void ChangeSpeed_hste(Systems Target, int slot, bool delete,bool UpdatePacket)
{
try
{
if (!delete)
{
int amount;
if (Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties1["hste"] != 0)
{
amount = Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties1["hste"];
Target.Character.Speed.Updateded[slot] += (Target.Character.Speed.RunSpeed / 100) * amount;
}
Target.Character.Speed.RunSpeed += Target.Character.Speed.Updateded[slot];
}
else
{
Target.Character.Speed.RunSpeed -= Target.Character.Speed.Updateded[slot];
Target.Character.Speed.Updateded[slot] = 0;
}
if (UpdatePacket) Target.client.Send(Packet.SetSpeed(Target.Character.Information.UniqueID, Target.Character.Speed.WalkSpeed, Target.Character.Speed.RunSpeed));
}
catch (Exception ex)
{
Systems.Debugger.Write(ex);
}
}
void GuildPermissions()
{
try
{
//Create new packet reader
PacketReader Reader = new PacketReader(PacketInformation.buffer);
//Skip first
Reader.Skip(1);
//Read member id
int memberid = Reader.Int32();
//Read permission byte
byte permissions = (byte)Reader.Int32();
//Set new char bits 8
char[] bits = new char[8];
//Repeat for each 8 bits
for (int i = 0; i < 8; ++i)
{
bits[i] = (char)0;
}
//Convert bits to string / to char array
bits = Convert.ToString(permissions, 2).ToCharArray();
//Close reader
Reader.Close();
//Set amount to player targetindex
int targetindex = this.Character.Network.Guild.MembersInfo.FindIndex(i => i.MemberID == memberid);
//If character is online
if (this.Character.Network.Guild.MembersInfo[targetindex].Online)
{
//Get detailed player information
Systems member = GetPlayerMainid(memberid);
//Set bits
member.Character.Network.Guild.joinRight = bits[4] == '1' ? true : false;
member.Character.Network.Guild.withdrawRight = bits[3] == '1' ? true : false;
member.Character.Network.Guild.unionRight = bits[2] == '1' ? true : false;
member.Character.Network.Guild.guildstorageRight = bits[0] == '1' ? true : false;
member.Character.Network.Guild.noticeeditRight = bits[1] == '1' ? true : false;
}
// set new amount to every guild members guild class
foreach (int m in Character.Network.Guild.Members)
{
//Set int index (Find member id)
int index = Character.Network.Guild.MembersInfo.FindIndex(i => i.MemberID == m);
//If the character is online
if (Character.Network.Guild.MembersInfo[index].Online)
{
//Get detailed information of the player
Systems sys = Systems.GetPlayerMainid(m);
//Set new guild player
Global.guild_player mygp = new Global.guild_player();
int myindex = 0;
//Repeat for each player
foreach (Global.guild_player gp in sys.Character.Network.Guild.MembersInfo)
{
//if the member id equals the player
if (gp.MemberID == memberid)
{
//Set my gp
mygp = gp;
//Set bits
mygp.joinRight = bits[4] == '1' ? true : false;
mygp.withdrawRight = bits[3] == '1' ? true : false;
mygp.unionRight = bits[2] == '1' ? true : false;
mygp.guildstorageRight = bits[0] == '1' ? true : false;
mygp.noticeeditRight = bits[1] == '1' ? true : false;
break;
}
//Index ++
myindex++;
}
//Set membersinfo index as mygp
sys.Character.Network.Guild.MembersInfo[myindex] = mygp;
}
}
//Update guild database information rights
MsSQL.UpdateData("UPDATE guild_members SET guild_perm_join='" + bits[4] + "',guild_perm_withdraw='" + bits[3] + "',guild_perm_union='" + bits[2] + "',guild_perm_storage='" + bits[0] + "',guild_perm_notice='" + bits[1] + "' WHERE guild_member_id='" + memberid + "'");
//Send to everyone in guild update of permissions
Character.Network.Guild.Send(Packet.GuildUpdate(Character, 4, 0, permissions, 0));
}
//If an error happens
catch (Exception ex)
{
//Write the information to the console
Console.WriteLine("Guild permission error: {0}", ex);
//Write information to the debug log
Systems.Debugger.Write(ex);
}
}
public bool SkillAdd_Properties(Systems Target, string PropertiesName, bool UpdatePacket, byte slot = 255, int skillid = -1)
{
try
{
switch (PropertiesName)
{
case "hpi":
ChangeMaxHP_hpi(Target, slot, false, UpdatePacket);
break;
case "mpi":
ChangeMaxMP_mpi(Target, slot, false, UpdatePacket);
break;
case "dru":
ChangeAtk_dru(Target, slot, false,UpdatePacket);
break;
case "er":
ChangeParry_er(Target, slot, false,UpdatePacket);
break;
case "stri":
ChangeStr_stri(Target, slot, false,UpdatePacket);
break;
case "inti":
ChangeInt_inti(Target, slot, false, UpdatePacket);
break;
case "cr":
ChangeCrit_cr(Target, slot, false,UpdatePacket);
break;
case "br":
ChangeBlockingRatio_br(Target, slot, false,UpdatePacket);
break;
case "spda":
Change_spda(Target, slot, false,UpdatePacket);
break;
case "ru":
ChangeRange_ru(Target, slot, false,UpdatePacket);
break;
case "dgmp":
ChangeAbsorbMP_dgmp(Target, slot, false,UpdatePacket);
break;
case "defp":
ChangeDefPower_defp(Target, slot, false, UpdatePacket);
break;
case "hste":
ChangeSpeed_hste(Target,slot,false,UpdatePacket);
break;
case "drci":
ChangeCriticalParry_dcri(Target, slot, false, UpdatePacket);
break;
case "heal":
HealHPMP(Target, slot, skillid, false, UpdatePacket);
break;
case "E1SA": // setvaluek ( valószínű ) nem így lesznek
ChangePhyAtk_E1SA(Target, slot, false, UpdatePacket);
break;
case "E2SA":
ChangePhyAtk_E2SA(Target, slot, false, UpdatePacket);
break;
case "E2AH":
ChangeHitRate_E2AH(Target, slot, false, UpdatePacket);
break;
case "terd":
ChangeParry_terd(Target, slot, false, UpdatePacket);
break;
case "chcr":
ChangeTargetHp_chcr(Target, slot, false, UpdatePacket);
break;
case "cmcr":
ChangeTargetHp_cmcr(Target, slot, false, UpdatePacket);
break;
case "thrd":
ChangeDecAttkRate_thrd(Target, slot, false, UpdatePacket);
break;
}
}
catch (Exception ex)
{
Console.WriteLine("BuffAdd_Properties() error..");
Systems.Debugger.Write(ex);
}
return false;
}
void GuildPromote()
{
try
{
//Read client information int32 id
PacketReader reader = new PacketReader(PacketInformation.buffer);
int guildid = reader.Int32();
reader.Close();
//When a guild has reached its max level
if (Character.Network.Guild.Level == 5)
{
//Send packet to client and return (Message level up max).
client.Send(Packet.IngameMessages(Systems.SERVER_GUILD_WAIT, IngameMessages.UIIT_MSG_ERROR_GUILD_LEVEL_UP_FULL));
return;
}
//Definition for gold needed
int GoldRequired;
//Definition for guild points needed
int GuildPointRequired;
//Check if player is allready in process of upgrading
if (!IsUpgrading)
{
//Set bool to true, so we cant dupe
IsUpgrading = true;
//Load player guild information before we continue (Check last info).
LoadPlayerGuildInfo(false);
//Create switch on guildl evel
switch (Character.Network.Guild.Level)
{
case 1:
GoldRequired = 3000000;
GuildPointRequired = 5400;
break;
case 2:
GoldRequired = 9000000;
GuildPointRequired = 50400;
break;
case 3:
GoldRequired = 15000000;
GuildPointRequired = 135000;
break;
case 4:
GoldRequired = 21000000;
GuildPointRequired = 378000;
break;
default:
return;
}
//Set new guild level definition + 1
int NewLevel = Character.Network.Guild.Level + 1;
//Set new guild storage slot amount
int NewStorageSlots = Character.Network.Guild.StorageSlots + 30;
//If character's gold is not enough
if (Character.Information.Gold < GoldRequired)
{
//Send message to client
client.Send(Packet.IngameMessages(SERVER_GUILD_PROMOTE_MSG, IngameMessages.UIIT_MSG_ERROR_GUILD_LEVEL_UP_GOLD_DEFICIT));
return;
}
//Not enough guildpoints
if (Character.Network.Guild.PointsTotal < GuildPointRequired)
{
//Send client message
client.Send(Packet.IngameMessages(SERVER_GUILD_PROMOTE_MSG, IngameMessages.UIIT_MSG_ERROR_GUILD_LEVEL_UP_GP_DEFICIT));
return;
}
//Max level
if (Character.Network.Guild.Level == 5)
{
//Send client message
client.Send(Packet.IngameMessages(SERVER_GUILD_PROMOTE_MSG, IngameMessages.UIIT_MSG_ERROR_GUILD_LEVEL_UP_FULL));
return;
}
//If everything else is fine
else
//Upgrade guild initiate
{
//If max level return just incase.
if (Character.Network.Guild.Level == 5)
{
return;
}
//Reduct guildpoints
Character.Network.Guild.PointsTotal -= GuildPointRequired;
//If the upgrade is final upgrade set points to 0
if (Character.Network.Guild.Level == 4)
{
Character.Network.Guild.PointsTotal = 0;
}
//Reduct gold
Character.Information.Gold -= GoldRequired;
//Send update information to client
client.Send(Packet.InfoUpdate(1, Character.Network.Guild.PointsTotal, 0));
//Send success message to client
client.Send(Packet.PromoteOrDisband(2));
//Update guild in database
MsSQL.UpdateData("UPDATE guild SET guild_level='" + NewLevel + "',guild_points='" + Character.Network.Guild.PointsTotal + "',guild_storage_slots='" + NewStorageSlots + "' WHERE guild_name='" + Character.Network.Guild.Name + "'");
//Repeat for each member in our guild
foreach (int member in Character.Network.Guild.Members)
{
//Check if memeber is not null
if (member != 0)
{
//Get detailed member information
Systems memberinfo = GetPlayerMainid(member);
//Make sure the member is not null
if (memberinfo != null)
{
//Reload information for the current guild member
memberinfo.LoadPlayerGuildInfo(false);
//Send guild update packet for current guild member
memberinfo.client.Send(Packet.GuildUpdate(Character, 5, 0, 0, 0));
}
}
}
//Save player's gold
SaveGold();
//Send update gold packet to client
client.Send(Packet.UpdateGold(Character.Information.Gold));
}
}
//Disable the bool so we can upgrade again
IsUpgrading = false;
}
//If any error accures
catch (Exception ex)
{
//Write error to the console
Console.WriteLine("Guild Promote Error: {0}", ex);
//Write error to debug log
Systems.Debugger.Write(ex);
}
}
public void StallBuy()
{
try
{
if (!Character.Network.Stall.isOpened)
{
return;
}
PacketReader Reader = new PacketReader(PacketInformation.buffer);
byte stallslot = Reader.Byte();
stall currentStall = Character.Network.Stall;
stall.stallItem sitem = currentStall.ItemList.Find(i => (i.stallSlot == stallslot));
// stall buyer update
byte slot = GetFreeSlot();
if (slot <= 12)
{
return;
}
if (Character.Information.Gold >= (long)sitem.price)
{
Character.Information.Gold -= (long)sitem.price;
client.Send(Packet.UpdateGold(Character.Information.Gold));
SaveGold();
}
else
{
return; //insufficent gold
}
// staller update
if (currentStall.ItemList.Contains(sitem))
{
Systems staller = GetPlayer(currentStall.ownerID);
staller.Character.Information.Gold += (long)sitem.price;
staller.client.Send(Packet.UpdateGold(staller.Character.Information.Gold));
MsSQL.UpdateData("update character set gold='" + staller.Character.Information.Gold + "' where id='" + staller.Character.Information.CharacterID + "'");
//MsSQL.UpdateData("delete from char_items where itemnumber='item" + sitem.Item.Slot + "' AND owner='" + staller.Character.Information.CharacterID + "'");
Systems.MsSQL.InsertData("UPDATE char_items SET owner='" + Character.Information.CharacterID + "',slot='" + slot + "',itemnumber='item" + slot + "' WHERE owner='" + staller.Character.Information.CharacterID + "' AND itemid='" + sitem.Item.ID + "' AND id='" + sitem.Item.dbID + "' AND storagetype='0'");
//take item out from stall
if (currentStall.ItemList.Count == 1)
{
staller.Character.Stall.Stallactive = false;
Character.Stall.Stallactive = false;
}
currentStall.ItemList.Remove(sitem);
client.Send(Packet.StallBuyItem(stallslot, 1));
currentStall.Send(Packet.StallBuyItem2(Character.Information.Name, stallslot, currentStall.ItemList));
}
else
{
Disconnect("ban");
Console.WriteLine("Autobanned user: "******" Due to hacking");
}
}
catch (Exception ex)
{
Systems.Debugger.Write(ex);
}
}
public void LoadGuildMembers()
{
//Wrap our code in a try to catch bad exception errors
try
{
//Load guild member id's
LoadGuildMemberIds(Character.Network.Guild.Guildid, ref Character.Network.Guild.Members);
//Repeat for each member in the guild member list
foreach (int Guildmember in Character.Network.Guild.Members)
{
//Set new guild player information
Global.guild_player PlayerGuild = new Global.guild_player();
//Set guildmember id
PlayerGuild.MemberID = Guildmember;
//Create new mssql query to get player information
Systems.MsSQL ms = new Systems.MsSQL("SELECT * FROM character WHERE id='" + Guildmember + "'");
//Create mssql data reader
using (System.Data.SqlClient.SqlDataReader reader = ms.Read())
{
//While the reader is reading
while (reader.Read())
{
//Get player model
PlayerGuild.Model = reader.GetInt32(3);
//Get player xsector
PlayerGuild.Xsector = reader.GetByte(16);
//Get player ysector
PlayerGuild.Ysector = reader.GetByte(17);
//Get player level
PlayerGuild.Level = reader.GetByte(5);
//Get player name
PlayerGuild.Name = reader.GetString(2);
//Get player online state
PlayerGuild.Online = (reader.GetInt32(47) == 1);
//If player is online
if (PlayerGuild.Online)
{
//Get detailed player information
Systems sys = GetPlayerMainid(Guildmember);
//Make sure sys is not null
if (sys != null)
{
//Add the character client to the client list
this.Character.Network.Guild.MembersClient.Add(sys.client);
}
}
}
}
//Create new query to select from table guild_members
ms = new Systems.MsSQL("SELECT * FROM guild_members WHERE guild_member_id='" + Guildmember + "'");
//Create new sql data reader
using (System.Data.SqlClient.SqlDataReader reader = ms.Read())
{
//While the sql data reader is reading
while (reader.Read())
{
//Get player rights
PlayerGuild.joinRight = (reader.GetByte(7) == 1);
PlayerGuild.withdrawRight = (reader.GetByte(8) == 1);
PlayerGuild.unionRight = (reader.GetByte(9) == 1);
PlayerGuild.guildstorageRight = (reader.GetByte(10) == 1);
PlayerGuild.noticeeditRight = (reader.GetByte(11) == 1);
PlayerGuild.FWrank = reader.GetByte(6);
//Get player donated gp
PlayerGuild.DonateGP = reader.GetInt32(4);
//Get player rank
PlayerGuild.Rank = reader.GetByte(3);
}
}
//Close mssql
ms.Close();
//Add our character to the guild member info
Character.Network.Guild.MembersInfo.Add(PlayerGuild);
}
}
//Catch bad exceptions
catch (Exception ex)
{
//Write error to the console
Console.WriteLine(ex);
//Write error to the debug log file
Systems.Debugger.Write(ex);
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Monster Summon Scrolls
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void HandleSummon(int scrollid)
{
try
{
//if (this.Character.Information.Level < 10) return;
int count = 1;//Default should be set to 1
//single scroll
if (scrollid == 3936)
{
count = 5;
}
//party scroll
if (scrollid == 3935)
{
if (this.Character.Network.Party == null)
{
return;
}
if (this.Character.Network.Party.Members.Count < 5)
{
return;
}
count = this.Character.Network.Party.Members.Count;
}
int model = GetStrongMobByLevel(this.Character.Information.Level);
byte type = Data.ObjectBase[model].ObjectType;
for (int i = 1; i <= count; i++)
{
obj Spawn = new obj();
Spawn.ID = model;
Spawn.Type = type;
Spawn.Ids = new Global.ID(Global.ID.IDS.Object);
Spawn.UniqueID = Spawn.Ids.GetUniqueID;
Spawn.x = Character.Position.x;
Spawn.z = Character.Position.z;
Spawn.y = Character.Position.y;
Spawn.oX = Spawn.x;
Spawn.oY = Spawn.y;
Spawn.xSec = Character.Position.xSec;
Spawn.ySec = Character.Position.ySec;
Spawn.AutoMovement = true;
Spawn.State = 1;
Spawn.Move = 1;
Spawn.SpeedWalk = Data.ObjectBase[Spawn.ID].SpeedWalk;
Spawn.SpeedRun = Data.ObjectBase[Spawn.ID].SpeedRun;
Spawn.SpeedZerk = Data.ObjectBase[Spawn.ID].SpeedZerk;
Spawn.HP = Data.ObjectBase[model].HP;
Spawn.Agresif = Data.ObjectBase[model].Agresif;
Spawn.LocalType = 1;
Spawn.AutoSpawn = false;
Spawn.Kat = 1;
Systems.aRound(ref Spawn.x, ref Spawn.y, 1);
Systems.Objects.Add(Spawn);
Spawn.SpawnMe();
}
}
catch (Exception ex)
{
Systems.Debugger.Write(ex);
}
}
public static void ExecuteCommand(string aCommand, Socket aSocket)
{
try
{
if (aCommand != null)
{
string[] command = aCommand.Split(' ');
if (command[0] == "/help")
{
if (aSocket == null)
{
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine(" Ingame notice: Type 1 space then message.");
Console.WriteLine(" //clear");
Console.WriteLine(" //repairitems");
Console.WriteLine(" //respawn_unique");
Console.WriteLine(" //event");
Console.WriteLine(" //shutdown");
Console.WriteLine(" //manager");
Console.ForegroundColor = ConsoleColor.Yellow;
}
else
{
sendSocket(aSocket, "Ingame notice: Type 1 space then message." + Environment.NewLine);
sendSocket(aSocket, " //clear = cleanup unused memory" + Environment.NewLine);
sendSocket(aSocket, " //repairitems" + Environment.NewLine);
sendSocket(aSocket, " //respawn_unique" + Environment.NewLine);
sendSocket(aSocket, " //event" + Environment.NewLine);
sendSocket(aSocket, " //shutdown" + Environment.NewLine);
}
}
else if (command[0] == "//clear")
{
System.GC.Collect();
GC.Collect(0, GCCollectionMode.Forced);
sendSocket(aSocket, "done memory cleanup" + Environment.NewLine);
}
else if (command[0] == "//shutdown")
{
byte waitTime = 5;
if (command.Length > 1)
{
waitTime = System.Convert.ToByte(command[1]);
}
if (aSocket != null)
{
aSocket.Send(Encoding.ASCII.GetBytes("SHUTDOWN_START" + Environment.NewLine));
}
lock (Systems.clients)
{
Console.WriteLine("{0}stopping server and sending notice to clients ...", DarkEmu_GameServer.Global.Product.Prefix);
sendSocket(aSocket, "SHUTDOWN: stopping server and sending notice to clients ..." + Environment.NewLine);
net.ServerCheck(true);
net.Stop(); // disable any new connection
try
{
Systems.SendAll(Packet.ChatPacket(7, 0, "The server is stopping, your information will be saved.", ""));
Systems.SendAll(Packet.StartingLeaveGame(waitTime, 0));
}
catch { }
Thread.Sleep(waitTime);
Console.WriteLine("@SHUTDOWN: logoff clients ...");
sendSocket(aSocket, "@SHUTDOWN: logoff clients ..." + Environment.NewLine);
while (Systems.clients.Count > 0)
{
try
{
try
{
Systems.clients[0].Send(Packet.EndLeaveGame());
}
catch { }
//Ignore new character case (used for disconnect kick).
Systems c = new Systems();
Systems.clients[0].Disconnect("normal");
}
catch { }
}
}
sendSocket(aSocket, "SHUTDOWN_END" + Environment.NewLine);
cancelServer = true;
Systems.UpdateServerInfo(0);
//Environment.Exit(0);
}
else if (command[0] == "//repairitems")
{
int fixeditem = 0;
Systems.MsSQL ms = new Systems.MsSQL("SELECT * FROM char_items");
using (System.Data.SqlClient.SqlDataReader reader = ms.Read())
{
while (reader.Read())
{
short amount = reader.GetInt16(7);
if (amount < 1)
{
fixeditem++;
amount = 1;
Systems.MsSQL.InsertData("UPDATE char_items SET quantity='" + amount + "' WHERE itemnumber='" + "item" + reader.GetByte(5) + "' AND owner='" + reader.GetInt32(3) + "' AND itemid='" + reader.GetInt32(2) + "'");
}
}
}
Console.ForegroundColor = ConsoleColor.Magenta;
Console.WriteLine("@Gameserver: Items Repaired: {0}", fixeditem);
Console.ForegroundColor = ConsoleColor.Yellow;
sendSocket(aSocket, String.Format("@Gameserver: Items Repaired: {0}", fixeditem) + Environment.NewLine);
}
else if (command[0] == "//respawn_unique")
{
DarkEmu_GameServer.GlobalUnique.StartTGUnique(6000 * 10, 6000 * 10);
DarkEmu_GameServer.GlobalUnique.StartUriUnique(7000 * 10, 7000 * 10);
DarkEmu_GameServer.GlobalUnique.StartIsyUnique(8000 * 10, 8000 * 10);
DarkEmu_GameServer.GlobalUnique.StartLordUnique(9000 * 10, 9000 * 10);
DarkEmu_GameServer.GlobalUnique.StartDemonUnique(10000 * 10, 10000 * 10);
DarkEmu_GameServer.GlobalUnique.StartCerbUnique(11000 * 10, 11000 * 10);
DarkEmu_GameServer.GlobalUnique.StartIvyUnique(11000 * 10, 11000 * 10);
//Game.GlobalUnique.StartRoc(11000 * 10, 11000 * 10);
DarkEmu_GameServer.GlobalUnique.StartMedusa(11000 * 10, 11000 * 10);
DarkEmu_GameServer.GlobalUnique.StartNeith(11000 * 10, 11000 * 10);
//Game.GlobalUnique.StartSphinx(11000 * 10, 11000 * 10);
DarkEmu_GameServer.GlobalUnique.StartIsis(11000 * 10, 11000 * 10);
sendSocket(aSocket, "done respawn" + Environment.NewLine);
}
else if (command[0] == "//event")
{
EventMain eventnew = new EventMain(System.IO.Directory.GetCurrentDirectory() + "/data/event.txt");
eventnew.Start();
sendSocket(aSocket, "Event Started" + Environment.NewLine);
}
else if (command[0] == "")
{
string information = aCommand;
DarkEmu_GameServer.Systems c = new DarkEmu_GameServer.Systems();
DarkEmu_GameServer.Systems.SendAll(c.sendnoticecon(7, 0, information, ""));
Console.WriteLine("Notice: " + information);
sendSocket(aSocket, "Sent Notice: " + information + Environment.NewLine);
}
}
}
catch (Exception ex)
{
Console.WriteLine("Program.Main {0}", ex);
}
}
public void Send(byte[] buff, Systems.Client client)
{
for (byte b = 0; b <= MembersClient.Count - 1; b++)
{
if (MembersClient[b] != client)
MembersClient[b].Send(buff);
}
}
///////////////////////////////////////////////////////////////////////////
// Frostbite state
///////////////////////////////////////////////////////////////////////////
#region Frost Bite
public static void GenerateEffect_fb(object target, int skillid)
{
// Get effects parameters
int Power = Data.SkillBase[skillid].Properties1["fb"];
int Probability = Data.SkillBase[skillid].Properties2["fb"];
int Random = Seed.Next(1, 100);
byte slot;
// if effect succeeded
if (Random <= Probability)
{
if (target.GetType().ToString() == "DarkEmu_GameServer.Systems") // player
{
Systems sys = target as Systems;
if (sys.Character.State.Die == true)
{
return;
}
slot = sys.DeBuffGetFreeSlot();
sys.Character.Action.DeBuff.Effect.EffectID[slot] = EffectNumbers.FROSTBITE;
sys.Character.Action.DeBuff.Effect.SkillID[slot] = skillid;
sys.StartEffectTimer(Power * 100, slot);
sys.Send(Packet.EffectUpdate(sys.Character.Information.UniqueID, EffectNumbers.FROSTBITE, true));
// attack speed
sys.Character.Speed.AttackSpeedModifier = 1.5;
sys.Character.Speed.RunSpeed /= 2;
sys.Character.Speed.WalkSpeed /= 2;
sys.Character.Speed.BerserkSpeed /= 2;
sys.Send(Packet.SetSpeed(sys.Character.Information.UniqueID, sys.Character.Speed.WalkSpeed, sys.Character.Speed.RunSpeed));
}
else if (target.GetType().ToString() == "DarkEmu_GameServer.obj") // mob
{
obj os = target as obj;
if (os.Die == true)
{
return;
}
slot = os.DeBuffGetFreeSlot();
os.DeBuff.Effect.EffectID[slot] = EffectNumbers.FROSTBITE;
os.DeBuff.Effect.SkillID[slot] = skillid;
//target.os.DeBuff.Effect.EffectPower[slot] = Power;
os.StartEffectTimer(Power * 100, slot);
os.Send(Packet.EffectUpdate(os.UniqueID, EffectNumbers.FROSTBITE, true));
// attack speed
os.AttackSpeed = 1.5;
// movement speed
os.SpeedRun /= 2;
os.SpeedWalk /= 2;
//Set our bool active
os.Frostbite = true;
os.Send(Packet.SetSpeed(os.UniqueID, os.SpeedWalk, os.SpeedRun));
}
}
}
public static void HealHPMP(Systems Target, int slot, int skillid, bool delete, bool UpdatePacket)
{
try
{
int amount;
int sid;
// get skillid from parameters
if (skillid == -1)
sid = Target.Character.Action.Buff.SkillID[slot];
else
sid = skillid;
if (!delete)
{
// if hp full
if (Target.Character.Stat.SecondHp == Target.Character.Stat.Hp) return;
if (Data.SkillBase[sid].Properties1["heal"] != 0)
{
amount = Data.SkillBase[sid].Properties1["heal"];
// add the calculated amount
if (Target.Character.Stat.SecondHp + amount < Target.Character.Stat.Hp)
Target.Character.Stat.SecondHp += amount;
else if (Target.Character.Stat.SecondHp != Target.Character.Stat.Hp)
Target.Character.Stat.SecondHp += Target.Character.Stat.Hp - Target.Character.Stat.SecondHp;
if (UpdatePacket) Target.UpdateHp();
}
if (Data.SkillBase[sid].Properties2["heal"] != 0)
{
amount = Data.SkillBase[sid].Properties2["heal"];
amount = (Target.Character.Stat.Hp / 100) * amount;
// add the calculated amount
if (Target.Character.Stat.SecondHp + amount < Target.Character.Stat.Hp)
Target.Character.Stat.SecondHp += amount;
else if (Target.Character.Stat.SecondHp != Target.Character.Stat.Hp)
Target.Character.Stat.SecondHp += Target.Character.Stat.Hp - Target.Character.Stat.SecondHp;
if (UpdatePacket) Target.UpdateHp();
}
if (Data.SkillBase[sid].Properties3["heal"] != 0)
{
amount = Data.SkillBase[sid].Properties3["heal"];
// add the calculated amount
if (Target.Character.Stat.SecondMP + amount < Target.Character.Stat.Mp)
Target.Character.Stat.SecondMP += amount;
else if (Target.Character.Stat.SecondMP != Target.Character.Stat.Mp)
Target.Character.Stat.SecondMP += Target.Character.Stat.Mp - Target.Character.Stat.SecondMP;
if (UpdatePacket) Target.UpdateMp();
}
if (Data.SkillBase[sid].Properties3["heal"] != 0)
{
amount = Data.SkillBase[sid].Properties4["heal"];
amount = (Target.Character.Stat.Mp / 100) * amount;
// add the calculated amount
if (Target.Character.Stat.SecondMP + amount < Target.Character.Stat.Mp)
Target.Character.Stat.SecondMP += amount;
else if (Target.Character.Stat.SecondMP != Target.Character.Stat.Mp)
Target.Character.Stat.SecondMP += Target.Character.Stat.Mp - Target.Character.Stat.SecondMP;
if (UpdatePacket) Target.UpdateMp();
}
}
else
{
//dunno....
}
}
catch (Exception ex)
{
Systems.Debugger.Write(ex);
}
}
// collision detection 2D - /With Linear Algebra/
public static bool isCollided_onMovement(Global.vektor fromPos, Global.vektor toPos, ref Global.vektor CollisionPoint, Systems c)
{
try
{
fromPos.x = packetx(fromPos.x, fromPos.xSec) / 20.0f;
fromPos.y = packety(fromPos.y, fromPos.ySec) / 20.0f;
toPos.x = packetx(toPos.x, toPos.xSec) / 20.0f;
toPos.y = packety(toPos.y, toPos.ySec) / 20.0f;
// iterated line
Global.vektor Line_A = new Global.vektor();
Global.vektor Line_B = new Global.vektor();
List <Global.vektor> CollisionPoints = new List <Global.vektor>();
// get current region to filter out the objects
short region = makeRegion(fromPos.xSec, fromPos.ySec);
// get all entitys in this region and try to cut them with our movement line
foreach (Global.SectorObject.n7nEntity obj in Data.MapObject[region].entitys)
{
foreach (Global.SectorObject.n7nEntity.sLine line in obj.OutLines)
{
// if not passable
if (line.flag != 0)
{
Line_A.x = obj.Points[line.PointA].x + obj.Position.x;
Line_A.y = obj.Points[line.PointA].y + obj.Position.y;
Line_B.x = obj.Points[line.PointB].x + obj.Position.x;
Line_B.y = obj.Points[line.PointB].y + obj.Position.y;
if (lineSegmentIntersection(fromPos, toPos, Line_A, Line_B, ref CollisionPoints))
{
Console.WriteLine("x:{0} y:{1}", gamex(CollisionPoints[0].x, fromPos.xSec), gamey(CollisionPoints[0].y, fromPos.ySec));
}
}
}
}
if (CollisionPoints.Count == 0)
{
return(false);
}
// set the nearest collision point for return point
double minDistance = gamedistance(fromPos.x, fromPos.y, CollisionPoints[0].x, CollisionPoints[0].y);
foreach (Global.vektor cp in CollisionPoints)
{
//double currentDistance = gamedistance(fromPos.x, fromPos.y, cp.x, cp.y);
double currentDistance = gamedistance(fromPos, cp);
if (currentDistance <= minDistance)
{
CollisionPoint.x = cp.x;
CollisionPoint.y = cp.y;
}
}
// translate the collision point on the movement line to get real coordinates (not the exact point of collision)
double sin_alpha = Math.Abs(CollisionPoints[0].y - fromPos.y) / minDistance;
double cos_alpha = Math.Abs(CollisionPoints[0].x - fromPos.x) / minDistance;
CollisionPoints[0].y = (float)(sin_alpha * (minDistance - 3));
CollisionPoints[0].x = (float)(cos_alpha * (minDistance - 3));
}
catch (Exception ex)
{
Console.WriteLine("Collision detection failed: {0}", ex.Message);
}
return(true);
}
public void ChangeDefPower_defp(Systems Target, int slot, bool delete, bool UpdatePacket)
{
try
{
int amount;
if (!delete)
{
if (Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties1["defp"] != 0)
{
amount = Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties1["defp"];
Target.Character.Action.Buff.UpdatedStats[slot].PhyDef = amount;
Target.Character.Stat.PhyDef += Target.Character.Action.Buff.UpdatedStats[slot].PhyDef;
}
if (Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties2["defp"] != 0)
{
amount = Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties2["defp"];
Target.Character.Action.Buff.UpdatedStats[slot].MagDef = amount;
Target.Character.Stat.MagDef += Target.Character.Action.Buff.UpdatedStats[slot].MagDef;
}
if (Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties3["defp"] != 0)
{
//nemtudjuk
}
}
else
{
if (Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties1["defp"] != 0)
{
Target.Character.Stat.PhyDef -= Target.Character.Action.Buff.UpdatedStats[slot].PhyDef;
Target.Character.Action.Buff.UpdatedStats[slot].PhyDef = 0;
}
if (Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties2["defp"] != 0)
{
Target.Character.Stat.MagDef -= Target.Character.Action.Buff.UpdatedStats[slot].MagDef;
Target.Character.Action.Buff.UpdatedStats[slot].MagDef = 0;
}
if (Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties3["defp"] != 0)
{
//nemtudjuk
}
}
if (UpdatePacket) Target.client.Send(Packet.PlayerStat(Target.Character));
}
catch (Exception ex)
{
Systems.Debugger.Write(ex);
}
}
public void ChangeMaxMP_mpi(Systems Target, int slot, bool delete, bool UpdatePacket)
{
try
{
if (!delete)
{
if (Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties1["mpi"] != 0) // point inc
{
int amount = Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties1["mpi"];
Target.Character.Action.Buff.UpdatedStats[slot].Mp = amount;
}
if (Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties2["mpi"] != 0) // %inc
{
int amount = Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties2["mpi"];
Target.Character.Action.Buff.UpdatedStats[slot].Mp = (Target.Character.Stat.Hp / 100) * (amount);
}
Target.Character.Stat.Mp += Target.Character.Action.Buff.UpdatedStats[slot].Mp;
Target.Character.Stat.SecondMP += Target.Character.Action.Buff.UpdatedStats[slot].Mp;
if ((Target.Character.Stat.SecondMP + Target.Character.Action.Buff.UpdatedStats[slot].Mp) > Target.Character.Stat.Mp)
{
Target.Character.Stat.SecondMP = Target.Character.Stat.Mp;
}
else
{
Target.Character.Stat.SecondMP += Target.Character.Action.Buff.UpdatedStats[slot].Mp;
}
}
else
{
// sub it
Target.Character.Stat.Mp -= Target.Character.Action.Buff.UpdatedStats[slot].Mp;
// dont want negative mana
if (Target.Character.Stat.SecondMP - Target.Character.Action.Buff.UpdatedStats[slot].Mp < 1)
{
Target.Character.Stat.SecondMP = 1;
}
else
{
Target.Character.Stat.SecondMP -= Target.Character.Action.Buff.UpdatedStats[slot].Mp;
}
Target.Character.Action.Buff.UpdatedStats[slot].Mp = 0;
}
if (UpdatePacket) Target.client.Send(Packet.PlayerStat(Target.Character));
}
catch (Exception ex)
{
Systems.Debugger.Write(ex);
}
}
public void ChangeHitrate_hr(Systems Target, int slot, bool delete,bool UpdatePacket)
{
try
{
//AttackRate = HitRate ???
int amount;
if (!delete)
{
if (Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties1.ContainsKey("hr"))
{
amount = Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties1["hr"];
}
}
if (UpdatePacket) Target.client.Send(Packet.PlayerStat(Target.Character));
}
catch (Exception ex)
{
Systems.Debugger.Write(ex);
}
}
public void ChangePhyAtk_E2SA(Systems Target, int slot, bool delete, bool UpdatePacket)
{
try
{
int amount;
if (!delete)
{
if (Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties1["E2SA"] != 0)
{
amount = Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties1["E2SA"];
Target.Character.Action.Buff.UpdatedStats[slot].MinPhyAttack = (Target.Character.Stat.MinPhyAttack / 100) * amount;
Target.Character.Action.Buff.UpdatedStats[slot].MaxPhyAttack = (Target.Character.Stat.MaxPhyAttack / 100) * amount;
Target.Character.Stat.MinPhyAttack += Target.Character.Action.Buff.UpdatedStats[slot].MinPhyAttack;
Target.Character.Stat.MaxPhyAttack += Target.Character.Action.Buff.UpdatedStats[slot].MaxPhyAttack;
}
}
else
{
if (Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties1["E2SA"] != 0)
{
Target.Character.Stat.MinPhyAttack -= Target.Character.Action.Buff.UpdatedStats[slot].MinPhyAttack;
Target.Character.Stat.MaxPhyAttack -= Target.Character.Action.Buff.UpdatedStats[slot].MaxPhyAttack;
Target.Character.Action.Buff.UpdatedStats[slot].MinPhyAttack = 0;
Target.Character.Action.Buff.UpdatedStats[slot].MaxPhyAttack = 0;
}
}
if (UpdatePacket) Target.client.Send(Packet.PlayerStat(Target.Character));
}
catch (Exception ex)
{
Systems.Debugger.Write(ex);
}
}
public void ChangeMaxHP_hpi(Systems Target, int slot, bool delete, bool UpdatePacket)
{
try
{
if (!delete)
{
int amount;
if (Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties1["hpi"] != 0) // point inc
{
amount = Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties1["hpi"];
Target.Character.Action.Buff.UpdatedStats[slot].Hp = amount;
}
if (Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties2["hpi"] != 0) // %inc
{
amount = Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties2["hpi"];
Target.Character.Action.Buff.UpdatedStats[slot].Hp = (Target.Character.Stat.Hp / 100) * (amount);
}
// add it
Target.Character.Stat.Hp += Target.Character.Action.Buff.UpdatedStats[slot].Hp;
Target.Character.Stat.SecondHp += Target.Character.Action.Buff.UpdatedStats[slot].Hp;
if ((Target.Character.Stat.SecondHp + Target.Character.Action.Buff.UpdatedStats[slot].Hp) > Target.Character.Stat.Hp)
{
Target.Character.Stat.SecondHp = Target.Character.Stat.Hp;
}
else
{
Target.Character.Stat.SecondHp += Target.Character.Action.Buff.UpdatedStats[slot].Hp;
}
}
else
{
// sub it
Target.Character.Stat.Hp -= Target.Character.Action.Buff.UpdatedStats[slot].Hp;
// dont kill him :)
if (Target.Character.Stat.SecondHp - Target.Character.Action.Buff.UpdatedStats[slot].Hp < 1)
{
Target.Character.Stat.SecondHp = 1;
}
else
{
Target.Character.Stat.SecondHp -= Target.Character.Action.Buff.UpdatedStats[slot].Hp;
}
Target.Character.Action.Buff.UpdatedStats[slot].Hp = 0;
}
if (UpdatePacket) Target.client.Send(Packet.PlayerStat(Target.Character));
}
catch (Exception ex)
{
Systems.Debugger.Write(ex);
}
}
void DonateGP()
{
//First we write our function inside a catcher
try
{
//Max level of guild wont allow new gp donations.
if (Character.Network.Guild.Level == 5)
{
//Send error message to client
client.Send(Packet.IngameMessages(SERVER_GUILD_PROMOTE_MSG, IngameMessages.UIIT_MSG_GUILD_LACK_GP));
return;
}
//Open our packet reader
PacketReader reader = new PacketReader(PacketInformation.buffer);
//Read donated gp amount (int).
int donatedgp = reader.Int32();
//Close packet reader
reader.Close();
//Anti hack checking (If donated gp higher is then the player skillpoints.
if (donatedgp > Character.Information.SkillPoint)
{
return;
}
//Calculate total
int totalgp = Character.Network.Guild.PointsTotal + donatedgp;
//Set guild points total
Character.Network.Guild.PointsTotal += donatedgp;
//Set skill points minus donated amount
Character.Information.SkillPoint -= donatedgp;
//Set donated gp + donated skill points
Character.Network.Guild.DonateGP += donatedgp;
//Save our information (Skill points).
SavePlayerInfo();
//Update database total guild points
MsSQL.UpdateData("UPDATE guild SET guild_points='" + totalgp + "' WHERE guild_name='" + Character.Network.Guild.Name + "'");
//Update database donated player guild points amount
MsSQL.UpdateData("UPDATE guild_members SET guild_points='" + Character.Network.Guild.DonateGP + "' WHERE guild_member_id='" + Character.Information.CharacterID + "'");
//Send packets to donator.
client.Send(Packet.InfoUpdate(1, totalgp, 0));
//Send donated gp info
PacketWriter writer = new PacketWriter();
//Add opcode
writer.Create(Systems.SERVER_GUILD_DONATE_GP);
//Write static byte 1
writer.Byte(1);
//Write dword int value donated gp amount.
writer.DWord(donatedgp);
//Send bytes to client
client.Send(writer.GetBytes());
//Repeat for each member in our guild
foreach (int member in Character.Network.Guild.Members)
{
//Make sure that the member isnt null
if (member != 0)
{
//Now we get the detailed information for each member
Systems guildmember = GetPlayerMainid(member);
//Make sure the guildmember is still there
if (guildmember != null)
{
//Send guild update packets to each member (Donated gp information and % bar update).
guildmember.client.Send(Packet.GuildUpdate(Character, 13, 0, 0, totalgp));
guildmember.client.Send(Packet.GuildUpdate(Character, 9, 0, 0, totalgp));
}
}
}
}
//Catch any bad exception error
catch (Exception ex)
{
//Write information to the console
Console.WriteLine("Donate GP Error {0}", ex);
//Write information to the debug log.
Systems.Debugger.Write(ex);
}
}
public void ChangeParry_er(Systems Target, int slot, bool delete,bool UpdatePacket)
{
try
{
if (!delete)
{
int amount;
if (Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties1["er"] != 0) // parry inc
{
amount = Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties1["er"];
Target.Character.Action.Buff.UpdatedStats[slot].Parry = amount;
Target.Character.Stat.Parry += Target.Character.Action.Buff.UpdatedStats[slot].Parry;
}
else if (Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties2["er"] != 0) // parry %inc?
{
}
}
else
{
if (Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties1["er"] != 0) // parry inc
{
Target.Character.Stat.Parry -= Target.Character.Action.Buff.UpdatedStats[slot].Parry;
Target.Character.Action.Buff.UpdatedStats[slot].Parry = 0;
}
else if (Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties2["er"] != 0) // parry %inc?
{
}
}
if (UpdatePacket) Target.client.Send(Packet.PlayerStat(Target.Character));
}
catch (Exception ex)
{
Systems.Debugger.Write(ex);
}
}
public static void ExecuteCommand(string aCommand, Socket aSocket)
{
try
{
if (aCommand != null)
{
string[] command = aCommand.Split(' ');
if (command[0] == "/help")
{
if (aSocket == null)
{
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine(" Ingame notice: Type 1 space then message.");
Console.WriteLine(" //clear");
Console.WriteLine(" //repairitems");
Console.WriteLine(" //respawn_unique");
Console.WriteLine(" //event");
Console.WriteLine(" //shutdown");
Console.WriteLine(" //manager");
Console.ForegroundColor = ConsoleColor.Yellow;
}
else
{
sendSocket(aSocket, "Ingame notice: Type 1 space then message." + Environment.NewLine);
sendSocket(aSocket, " //clear = cleanup unused memory" + Environment.NewLine);
sendSocket(aSocket, " //repairitems" + Environment.NewLine);
sendSocket(aSocket, " //respawn_unique" + Environment.NewLine);
sendSocket(aSocket, " //event" + Environment.NewLine);
sendSocket(aSocket, " //shutdown" + Environment.NewLine);
}
}
else if (command[0] == "//clear")
{
System.GC.Collect();
GC.Collect(0, GCCollectionMode.Forced);
sendSocket(aSocket, "done memory cleanup" + Environment.NewLine);
}
else if (command[0] == "//shutdown")
{
byte waitTime = 5;
if (command.Length > 1)
{
waitTime = System.Convert.ToByte(command[1]);
}
if (aSocket != null)
{
aSocket.Send(Encoding.ASCII.GetBytes("SHUTDOWN_START" + Environment.NewLine));
}
lock (Systems.clients)
{
Console.WriteLine("{0}stopping server and sending notice to clients ...", DarkEmu_GameServer.Global.Product.Prefix);
sendSocket(aSocket, "SHUTDOWN: stopping server and sending notice to clients ..." + Environment.NewLine);
net.ServerCheck(true);
net.Stop(); // disable any new connection
try
{
Systems.SendAll(Packet.ChatPacket(7, 0, "The server is stopping, your information will be saved.", ""));
Systems.SendAll(Packet.StartingLeaveGame(waitTime, 0));
}
catch { }
Thread.Sleep(waitTime);
Console.WriteLine("@SHUTDOWN: logoff clients ...");
sendSocket(aSocket, "@SHUTDOWN: logoff clients ..." + Environment.NewLine);
while (Systems.clients.Count > 0)
{
try
{
try
{
Systems.clients[0].Send(Packet.EndLeaveGame());
}
catch { }
//Ignore new character case (used for disconnect kick).
Systems c = new Systems();
Systems.clients[0].Disconnect("normal");
}
catch { }
}
}
sendSocket(aSocket, "SHUTDOWN_END" + Environment.NewLine);
cancelServer = true;
Systems.UpdateServerInfo(0);
//Environment.Exit(0);
}
else if (command[0] == "//repairitems")
{
int fixeditem = 0;
Systems.MsSQL ms = new Systems.MsSQL("SELECT * FROM char_items");
using (System.Data.SqlClient.SqlDataReader reader = ms.Read())
{
while (reader.Read())
{
short amount = reader.GetInt16(7);
if (amount < 1)
{
fixeditem++;
amount = 1;
Systems.MsSQL.InsertData("UPDATE char_items SET quantity='" + amount + "' WHERE itemnumber='" + "item" + reader.GetByte(5) + "' AND owner='" + reader.GetInt32(3) + "' AND itemid='" + reader.GetInt32(2) + "'");
}
}
}
Console.ForegroundColor = ConsoleColor.Magenta;
Console.WriteLine("@Gameserver: Items Repaired: {0}", fixeditem);
Console.ForegroundColor = ConsoleColor.Yellow;
sendSocket(aSocket, String.Format("@Gameserver: Items Repaired: {0}", fixeditem) + Environment.NewLine);
}
else if (command[0] == "//respawn_unique")
{
DarkEmu_GameServer.GlobalUnique.StartTGUnique(6000 * 10, 6000 * 10);
DarkEmu_GameServer.GlobalUnique.StartUriUnique(7000 * 10, 7000 * 10);
DarkEmu_GameServer.GlobalUnique.StartIsyUnique(8000 * 10, 8000 * 10);
DarkEmu_GameServer.GlobalUnique.StartLordUnique(9000 * 10, 9000 * 10);
DarkEmu_GameServer.GlobalUnique.StartDemonUnique(10000 * 10, 10000 * 10);
DarkEmu_GameServer.GlobalUnique.StartCerbUnique(11000 * 10, 11000 * 10);
DarkEmu_GameServer.GlobalUnique.StartIvyUnique(11000 * 10, 11000 * 10);
//Game.GlobalUnique.StartRoc(11000 * 10, 11000 * 10);
DarkEmu_GameServer.GlobalUnique.StartMedusa(11000 * 10, 11000 * 10);
DarkEmu_GameServer.GlobalUnique.StartNeith(11000 * 10, 11000 * 10);
//Game.GlobalUnique.StartSphinx(11000 * 10, 11000 * 10);
DarkEmu_GameServer.GlobalUnique.StartIsis(11000 * 10, 11000 * 10);
sendSocket(aSocket, "done respawn" + Environment.NewLine);
}
else if (command[0] == "//event")
{
EventMain eventnew = new EventMain(System.IO.Directory.GetCurrentDirectory() + "/data/event.txt");
eventnew.Start();
sendSocket(aSocket, "Event Started" + Environment.NewLine);
}
else if (command[0] == "")
{
string information = aCommand;
DarkEmu_GameServer.Systems c = new DarkEmu_GameServer.Systems();
DarkEmu_GameServer.Systems.SendAll(c.sendnoticecon(7, 0, information, ""));
Console.WriteLine("Notice: " + information);
sendSocket(aSocket, "Sent Notice: " + information + Environment.NewLine);
}
}
}
catch (Exception ex)
{
Console.WriteLine("Program.Main {0}", ex);
}
}
public void ChangeRange_ru(Systems Target, int slot, bool delete,bool UpdatePacket)
{
try
{
if (!delete)
{
int amount;
if (Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties1["ru"] != 0)
{
amount = Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties1["ru"];
Target.Character.Action.Buff.UpdatedStats[slot].EkstraMetre = (byte)amount;
Target.Character.Stat.EkstraMetre += Target.Character.Action.Buff.UpdatedStats[slot].EkstraMetre;
}
}
else
{
Target.Character.Stat.EkstraMetre -= Target.Character.Action.Buff.UpdatedStats[slot].EkstraMetre;
Target.Character.Action.Buff.UpdatedStats[slot].EkstraMetre = 0;
}
if (UpdatePacket) Target.client.Send(Packet.PlayerStat(Target.Character));
}
catch (Exception ex)
{
Systems.Debugger.Write(ex);
}
}
void ActionNormalAttack()
{
try
{
float x = 0, y = 0;
bool[] aRound = null;
if (Character.Action.Object != null)
{
//Set target object as object
obj TargetInformation = Character.Action.Object as obj;
//If our target object is a monster
#region Attacking a monster
if (Data.ObjectBase[TargetInformation.ID].Object_type == Global.objectdata.NamdedType.MONSTER)
{
//If state is dead
if (TargetInformation.State == 4)
{
//Set normal attack bool to false
Character.Action.nAttack = false;
//Stop attack timer
StopAttackTimer();
}
if (TargetInformation.Agro == null)
{
TargetInformation.Agro = new List <_agro>();
}
x = (float)TargetInformation.x;
y = (float)TargetInformation.y;
if (!TargetInformation.Attacking)
{
TargetInformation.AddAgroDmg(Character.Information.UniqueID, 1);
}
if (TargetInformation.Die || TargetInformation.GetDie)
{
StopAttackTimer();
return;
}
}
#endregion
//If attacking a player
#region Attacking a player
if (Data.ObjectBase[TargetInformation.ID].Object_type == Global.objectdata.NamdedType.PLAYER)
{
if (!Character.Information.PvP)
{
Character.Action.nAttack = false;
StopAttackTimer();
return;
}
Systems sys = Character.Action.Object as Systems;
if (sys.Character.State.LastState == 4)
{
StopAttackTimer();
return;
}
if (!(Character.Information.PvP && sys.Character.Information.PvP))
{
StopAttackTimer();
return;
}
if (!Character.InGame)
{
StopAttackTimer();
return;
}
x = sys.Character.Position.x;
y = sys.Character.Position.y;
aRound = sys.Character.aRound;
}
#endregion
double distance = Formule.gamedistance(Character.Position.x,
Character.Position.y,
x,
y);
if (Character.Information.Item.wID == 0)
{
distance -= 0.5;
}
else
{
distance -= Data.ItemBase[Character.Information.Item.wID].ATTACK_DISTANCE;
}
if (distance > 0)
{
float farkx = x;
float farky = y;
if (Character.Information.Item.wID == 0)
{
Character.Position.wX = farkx - Character.Position.x - 0;
Character.Position.wY = farky - Character.Position.y - 0;
Character.Position.kX = Character.Position.wX;
Character.Position.kY = Character.Position.wY;
}
else
{
Character.Position.wX = farkx - Character.Position.x - (float)Data.ItemBase[Character.Information.Item.wID].ATTACK_DISTANCE;
Character.Position.wY = farky - Character.Position.y - (float)Data.ItemBase[Character.Information.Item.wID].ATTACK_DISTANCE;
Character.Position.kX = Character.Position.wX;
Character.Position.kY = Character.Position.wY;
}
Send(Packet.Movement(new DarkEmu_GameServer.Global.vektor(Character.Information.UniqueID,
(float)Formule.packetx((float)farkx, Character.Position.xSec),
(float)Character.Position.z,
(float)Formule.packety((float)farky, Character.Position.ySec),
Character.Position.xSec,
Character.Position.ySec)));
Character.Position.Time = (distance / (Character.Speed.RunSpeed * 0.0768)) * 1000.0;
Character.Position.RecordedTime = Character.Position.Time;
Character.Position.packetxSec = Character.Position.xSec;
Character.Position.packetySec = Character.Position.ySec;
Character.Position.packetX = (ushort)Formule.packetx((float)farkx, Character.Position.xSec);
Character.Position.packetY = (ushort)Formule.packety((float)farky, Character.Position.ySec);
Character.Position.Walking = true;
StartMovementTimer((int)(Character.Position.Time * 0.1));
return;
}
}
ActionAttack();
}
catch (Exception ex)
{
Console.WriteLine("Normal Attack Error : {0}", ex);
Systems.Debugger.Write(ex);
}
}
public void ChangeStr_stri(Systems Target, int slot, bool delete,bool UpdatePacket)
{
try
{
if (!delete)
{
int amount;
if (Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties1["stri"] != 0)
{
amount = Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties1["stri"];
Target.Character.Action.Buff.UpdatedStats[slot].Strength = (short)amount;
}
/*if (Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties2.ContainsKey("stri"))
{
amount = Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties2["stri"];
Target.Character.Action.Buff.UpdatedStats[slot].Strength = (short)((Target.Character.Stat.Strength / 100) * (amount));
}*/
Target.Character.Stat.Strength += Target.Character.Action.Buff.UpdatedStats[slot].Strength;
}
else
{
Target.Character.Stat.Strength -= Target.Character.Action.Buff.UpdatedStats[slot].Strength;
Target.Character.Action.Buff.UpdatedStats[slot].Strength = 0;
}
if (UpdatePacket) Target.client.Send(Packet.PlayerStat(Target.Character));
}
catch (Exception ex)
{
Systems.Debugger.Write(ex);
}
}
/////////////////////////////////////////////////////////////////////////////////
// Spawn system
/////////////////////////////////////////////////////////////////////////////////
public void ObjectSpawnCheck()
{
try
{
if (this.Character.deSpawning)
{
return;
}
int spawnrange = 80;
lock (this)
{
//Make sure character info is not null or not spawning yet allready.
if (this.Character != null && !this.Character.Spawning)
{
//Set spawn state to true so cannot be doubled
this.Character.Spawning = true;
//Repeat for each client ingame
#region Clients
for (int i = 0; i < Systems.clients.Count; i++)
{
//Get defined information for the client
Systems playerspawn = Systems.clients[i];
//Make sure that the spawning case is not ourselfs, or not spawned yet and not null
if (playerspawn != null && playerspawn != this && !Character.Spawned(playerspawn.Character.Information.UniqueID) && playerspawn.Character.Information.Name != this.Character.Information.Name)
{
//If our position is lower or higher then 50 + spawnrange of that of the player
if (playerspawn.Character.Position.x >= (Character.Position.x - 50) && playerspawn.Character.Position.x <= ((Character.Position.x - 50) + spawnrange) && playerspawn.Character.Position.y >= (Character.Position.y - 50) && playerspawn.Character.Position.y <= ((Character.Position.y - 50) + spawnrange))
{
//Make sure the unique id is not null
if (playerspawn.Character.Information.UniqueID != 0)
{
Character.Spawn.Add(playerspawn.Character.Information.UniqueID);
client.Send(Packet.ObjectSpawn(playerspawn.Character));
}
//Spawn ourselfs to the other players currently in spawn range.
ObjectPlayerSpawn(playerspawn);
}
}
}
#endregion
//Repeat for each helper object
#region Helper objects
for (int i = 0; i < Systems.HelperObject.Count; i++)
{
//If the helper object is not null , or not spawned for us yet and the unique id is not null
if (Systems.HelperObject[i] != null && !Systems.HelperObject[i].Spawned(this.Character.Information.UniqueID))
{
//If our position is lower or higher then 50 + spawnrange of that of the object
if (this.Character.Position.x >= (Systems.HelperObject[i].x - 50) && this.Character.Position.x <= ((Systems.HelperObject[i].x - 50) + spawnrange) && this.Character.Position.y >= (Systems.HelperObject[i].y - 50) && this.Character.Position.y <= ((Systems.HelperObject[i].y - 50) + spawnrange))
{
if (Systems.HelperObject[i].UniqueID != 0)
{
//Add our spawn
Systems.HelperObject[i].Spawn.Add(this.Character.Information.UniqueID);
//Send visual packet
this.client.Send(Packet.ObjectSpawn(Systems.HelperObject[i]));
}
}
}
}
#endregion
/*
#region Special objects
* for (int i = 0; i < Systems.SpecialObjects.Count; i++)
* {
* //If the special object is not null , or not spawned for us yet and the unique id is not null
* if (Systems.SpecialObjects[i] != null && !Systems.SpecialObjects[i].Spawned(this.Character.Information.UniqueID))
* {
* //If our position is lower or higher then 50 + spawnrange of that of the object
* if (this.Character.Position.x >= (Systems.SpecialObjects[i].x - 50) && this.Character.Position.x <= ((Systems.SpecialObjects[i].x - 50) + spawnrange) && this.Character.Position.y >= (Systems.SpecialObjects[i].y - 50) && this.Character.Position.y <= ((Systems.SpecialObjects[i].y - 50) + spawnrange))
* {
* if (Systems.SpecialObjects[i].UniqueID != 0)
* {
* //Add our spawn
* Systems.SpecialObjects[i].Spawn.Add(this.Character.Information.UniqueID);
* //Send visual packet
* client.Send(Packet.ObjectSpawn(Systems.SpecialObjects[i]));
* //Console.WriteLine("Spawning {0}", Data.ObjectBase[Systems.Objects[i].ID].Name);
* }
* }
* }
* }
#endregion
*/
//Repeat for each object
#region Objects
for (int i = 0; i < Systems.Objects.Count; i++)
{
//If the helper object is not null , or not spawned for us yet and the unique id is not null
if (Systems.Objects[i] != null && !Systems.Objects[i].Spawned(this.Character.Information.UniqueID))
{
//If our position is lower or higher then 50 + spawnrange of that of the object
if (this.Character.Position.x >= (Systems.Objects[i].x - 50) && this.Character.Position.x <= ((Systems.Objects[i].x - 50) + spawnrange) && this.Character.Position.y >= (Systems.Objects[i].y - 50) && this.Character.Position.y <= ((Systems.Objects[i].y - 50) + spawnrange))
{
if (Systems.Objects[i].UniqueID != 0 && !Systems.Objects[i].Die)
{
//Add our spawn
Systems.Objects[i].Spawn.Add(this.Character.Information.UniqueID);
//Send visual packet
client.Send(Packet.ObjectSpawn(Systems.Objects[i]));
//Console.WriteLine("Spawning {0}", Data.ObjectBase[Systems.Objects[i].ID].Name);
}
}
}
}
#endregion
//Repeat for each world item
#region Helper objects
for (int i = 0; i < Systems.WorldItem.Count; i++)
{
//If the helper object is not null , or not spawned for us yet and the unique id is not null
if (Systems.WorldItem[i] != null && !Systems.WorldItem[i].Spawned(this.Character.Information.UniqueID))
{
//If our position is lower or higher then 50 + spawnrange of that of the object
if (this.Character.Position.x >= (Systems.WorldItem[i].x - 50) && this.Character.Position.x <= ((Systems.WorldItem[i].x - 50) + spawnrange) && this.Character.Position.y >= (Systems.WorldItem[i].y - 50) && this.Character.Position.y <= ((Systems.WorldItem[i].y - 50) + spawnrange))
{
if (Systems.WorldItem[i].UniqueID != 0)
{
//Add our spawn
Systems.WorldItem[i].Spawn.Add(this.Character.Information.UniqueID);
//Send visual packet
this.client.Send(Packet.ObjectSpawn(Systems.WorldItem[i]));
}
}
}
}
#endregion
//If we are riding a horse and its not spawned to the player yet
#region Transports
if (Character.Transport.Right)
{
//If not spawned
if (!Character.Transport.Spawned)
{
//Set bool true
Character.Transport.Spawned = true;
//Spawn horse object
Character.Transport.Horse.SpawnMe();
//Send visual update player riding horse
Character.Transport.Horse.Send(Packet.Player_UpToHorse(this.Character.Information.UniqueID, true, Character.Transport.Horse.UniqueID));
}
}
#endregion
//Reset bool to false so we can re-loop the function
this.Character.Spawning = false;
ObjectDeSpawnCheck();
}
//If something wrong happened and we are null, we set our bool false as well.
this.Character.Spawning = false;
}
}
catch (Exception ex)
{
//If any exception happens we disable the loop bool for re-use
this.Character.Spawning = false;
Console.WriteLine("Spawn check error {0}", ex);
Systems.Debugger.Write(ex);
}
}
public void Change_spda(Systems Target, int slot, bool delete,bool UpdatePacket)
{
try
{
double amount;
if (!delete)
{
if (Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties1.ContainsKey("spda")) //Phydef decrease?
{
amount = Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties1["spda"];
Target.Character.Action.Buff.UpdatedStats[slot].uPhyDef = (Target.Character.Stat.PhyDef / 100) * (amount);
Target.Character.Stat.PhyDef -= Target.Character.Action.Buff.UpdatedStats[slot].uPhyDef;
}
if (Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties2.ContainsKey("spda")) //Phy attack inc?
{
amount = Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties2["spda"];
Target.Character.Stat.UpdatededPhyAttack = (Target.Character.Stat.MaxPhyAttack / 100) * (amount);
Target.Character.Stat.MaxPhyAttack += Target.Character.Stat.UpdatededPhyAttack;
}
}
else
{
Target.Character.Stat.PhyDef += Target.Character.Action.Buff.UpdatedStats[slot].uPhyDef;
Target.Character.Stat.MaxPhyAttack -= Target.Character.Stat.UpdatededPhyAttack;
}
if (UpdatePacket) Target.client.Send(Packet.PlayerStat(Target.Character));
}
catch (Exception ex)
{
Systems.Debugger.Write(ex);
}
}
void Chat()
{
/*
* We use for each now, to make sure there wont be any issues
* Incase the list we send the packet to can have none connected clients.
* To prevent bugging of chat we repeat and check each client before sending.
*/
try
{
//Set our list of ranged players
List <int> Rangedplayers = Character.Spawn;
//Create new packet reader for reading packet data
PacketReader Reader = new PacketReader(PacketInformation.buffer);
//Chat type byte (for our switch case).
byte chatType = Reader.Byte();
//Byte chat index
byte chatIndex = Reader.Byte();
//Link count byte
byte linkCount = Reader.Byte();
//Create switch to switch on type of chat (normal party etc).
switch (chatType)
{
//--------------------------------- [Normal chat] ---------------------------------//
case 1:
//Read written text from packet data
string Text = Reader.Text3();
//Close packet reader
Reader.Close();
// .additem 111 12
if (Character.Information.GM == 1 && Text[0] == '.')
{
gmCommands(Text);
}
//Repeat for each in range player
foreach (int member in Rangedplayers)
{
//Make sure the member is not null
if (member != 0)
{
//Make sure its not sending to our client
if (member != Character.Information.UniqueID)
{
//Get member detail
Systems memberinfo = GetPlayer(member);
//Send packet to the in range player
memberinfo.client.Send(Packet.ChatPacket(chatType, Character.Information.UniqueID, Text, null));
}
}
}
//Send chatindex packet to ourselfs
client.Send(Packet.ChatIndexPacket(chatType, chatIndex));
break;
//--------------------------------- [Normal chat pink] ---------------------------------//
case 3:
//Check if our character has gm rights or not
if (Character.Information.GM == 1)
{
//Read packet information (text typed).
Text = Reader.Text3();
//Close packet reader
Reader.Close();
//Repeat for each player in our range list
foreach (int member in Rangedplayers)
{
//Check if the member is not null
if (member != 0)
{
//Make sure its not sending to our own client
if (member != Character.Information.UniqueID)
{
//Get member detail
Systems memberinfo = GetPlayer(member);
//Send packet to the member
memberinfo.client.Send(Packet.ChatPacket(chatType, Character.Information.UniqueID, Text, null));
}
}
}
//Send chat index to our client
client.Send(Packet.ChatIndexPacket(chatType, chatIndex));
break;
}
//If character tried to use pink chat but isnt a gm
else
{
//We ban the player for hacking attempt.
Disconnect("ban");
}
break;
//--------------------------------- [Private chat] ---------------------------------//
case 2:
//Read from packet data who we are sending the message to
string Target = Reader.Text();
//Get information from the given player we send to
Systems Targetplayer = GetPlayerName(Target);
//Make sure the player sending to is not null
if (Targetplayer != null)
{
//Make sure the player is ingame (Not teleporting or such).
if (Targetplayer.Character.InGame)
{
//Read the message from the packet data
Text = Reader.Text3();
//Close the packet reader
Reader.Close();
//Send packet to our target
Targetplayer.client.Send(Packet.ChatPacket(chatType, 0, Text, this.Character.Information.Name));
//Send chatindex packet to ourselfs
client.Send(Packet.ChatIndexPacket(chatType, chatIndex));
}
}
break;
//--------------------------------- [Party chat] ---------------------------------//
case 4:
//Make sure the player is in a party
if (Character.Network.Party != null)
{
//Read the text the player has typed from packet data
Text = Reader.Text3();
//Close packet reader
Reader.Close();
//Repeat for each member in the party member list
foreach (int member in Character.Network.Party.Members)
{
//Make sure the member isnt null (0)
if (member != 0)
{
//Get detailed info for the player
Systems memberinfo = GetPlayer(member);
//Send packet information to the member for chat
memberinfo.client.Send(Packet.ChatPacket(chatType, Character.Information.UniqueID, Text, this.Character.Information.Name));
}
}
//Finally send chatindex packet to ourselfs
client.Send(Packet.ChatIndexPacket(chatType, chatIndex));
}
break;
//--------------------------------- [Guild chat] ---------------------------------//
case 5:
//Read message beeing send from packet data
Text = Reader.Text3();
//Close packet reader
Reader.Close();
//Repeat for each member in the guild member list
foreach (int member in Character.Network.Guild.Members)
{
//Make sure the member is not null (0)
if (member != 0)
{
//Get guild member detailed information
Systems Guildmember = GetPlayerMainid(member);
//Again check if the guild member is not null
if (Guildmember != null)
{
//Send chat packet to the member
Guildmember.client.Send(Packet.ChatPacket(chatType, Character.Information.UniqueID, Text, this.Character.Information.Name));
}
}
}
//Send chat index packet to our client
client.Send(Packet.ChatIndexPacket(chatType, chatIndex));
break;
//--------------------------------- [Global chat] ---------------------------------//
case 6:
//Get sender name from packet data
string Sender = Reader.Text();
//Get message from packet data
Text = Reader.Text3();
//Send to every client connected and logged in
SendAll(Packet.ChatPacket(chatType, Character.Information.UniqueID, " " + Text, Sender));
break;
//--------------------------------- [Notice chat] ---------------------------------//
case 7:
//Make sure the character sending is a gm
if (Character.Information.GM == 1)
{
//Get message from packet data
Text = Reader.Text3();
//Close packet reader
Reader.Close();
//Send to everyone ingame (using void sendnoticecon).
SendAll(sendnoticecon(chatType, Character.Information.UniqueID, Text, null));
}
//If the character is not a gm
else
{
//Disconnect and ban the player for hack attempt
Disconnect("ban");
}
break;
//--------------------------------- [Stall chat] ---------------------------------//
case 9:
//Read message from packet data
Text = Reader.Text3();
//Close packet reader
Reader.Close();
//Repeat for each member in the stall
foreach (int stallmember in Character.Network.Stall.Members)
{
//Make sure the stall member isnt null 0
if (stallmember != 0)
{
//Get stall member details
Systems member = GetPlayer(stallmember);
//Make sure the member isnt null
if (member != null)
{
//Send chat packet to the member
member.client.Send(Packet.ChatPacket(chatType, Character.Network.Stall.ownerID, Text, this.Character.Information.Name));
}
}
}
//Send chat index to ourselfs
client.Send(Packet.ChatIndexPacket(chatType, chatIndex));
break;
//--------------------------------- [Academy chat] ---------------------------------//
case 10:
//Todo academy system then chat.
break;
//--------------------------------- [Union chat] ---------------------------------//
case 11:
//Read message from packet data
Text = Reader.Text3();
//Close packet reader
Reader.Close();
//If the character has no union
if (!Character.Network.Guild.UnionActive)
{
//Return
return;
}
//Else for each member in the union
foreach (int member in Character.Network.Guild.UnionMembers)
{
//Make sure the union member is not null 0
if (member != 0)
{
//Get member detailed information
Systems tomember = GetPlayerMainid(member);
//Make sure the member is not null
if (tomember != null)
{
//Make sure the member isnt ourself
if (tomember.Character.Information.CharacterID != Character.Information.CharacterID)
{
//Send packet to the union member
tomember.client.Send(Packet.ChatPacket(chatType, Character.Information.UniqueID, Text, Character.Information.Name));
}
}
}
}
//Repeat for each member in the guild
foreach (int member in Character.Network.Guild.Members)
{
//Make sure the member isnt null 0
if (member != 0)
{
//Get member detailed information
Systems tomember = GetPlayerMainid(member);
//Make sure the member isnt null
if (tomember != null)
{
//Make sure the member isnt ourself
if (tomember.Character.Information.CharacterID != Character.Information.CharacterID)
{
//Send packet to the member
tomember.Character.Network.Guild.SingleSend = false;
}
}
}
}
//Finally send chat index packet to ourself
client.Send(Packet.ChatIndexPacket(chatType, chatIndex));
break;
}
}
//If an exception error happens
catch (Exception errorinformation)
{
//Write the information to the console
Console.WriteLine("Chat error {0}", errorinformation);
//Write the information to the log system
Systems.Debugger.Write(errorinformation);
}
}
public static void StallItemPacket(List <stall.stallItem> ItemList, PacketWriter Writer)
{
for (byte i = 0; i < ItemList.Count; i++)
{
//Define item id
int itemid = ItemList[i].Item.ID;
//Temp disable mall type, todo : Enable PRE-Mall to sell in stalls.
if (Data.ItemBase[itemid].Name.Contains("MALL"))
{
return;
}
Systems.LoadBluesid(ItemList[i].Item.dbID);
Writer.Byte(ItemList[i].stallSlot);
Writer.DWord(0);
Writer.DWord(itemid);
//Define what types of item we are adding to the stall
if (Data.ItemBase[itemid].Type == Global.item_database.ArmorType.ARMOR ||
Data.ItemBase[itemid].Type == Global.item_database.ArmorType.GARMENT ||
Data.ItemBase[itemid].Type == Global.item_database.ArmorType.GM ||
Data.ItemBase[itemid].Type == Global.item_database.ArmorType.HEAVY ||
Data.ItemBase[itemid].Type == Global.item_database.ArmorType.LIGHT ||
Data.ItemBase[itemid].Type == Global.item_database.ArmorType.PROTECTOR ||
Data.ItemBase[itemid].Type == Global.item_database.ArmorType.ROBE ||
Data.ItemBase[itemid].Itemtype == Global.item_database.ItemType.EARRING ||
Data.ItemBase[itemid].Itemtype == Global.item_database.ItemType.RING ||
Data.ItemBase[itemid].Itemtype == Global.item_database.ItemType.NECKLACE ||
Data.ItemBase[itemid].Itemtype == Global.item_database.ItemType.BLADE ||
Data.ItemBase[itemid].Itemtype == Global.item_database.ItemType.BOW ||
Data.ItemBase[itemid].Itemtype == Global.item_database.ItemType.EU_AXE ||
Data.ItemBase[itemid].Itemtype == Global.item_database.ItemType.EU_CROSSBOW ||
Data.ItemBase[itemid].Itemtype == Global.item_database.ItemType.EU_DAGGER ||
Data.ItemBase[itemid].Itemtype == Global.item_database.ItemType.EU_DARKSTAFF ||
Data.ItemBase[itemid].Itemtype == Global.item_database.ItemType.EU_HARP ||
Data.ItemBase[itemid].Itemtype == Global.item_database.ItemType.EU_STAFF ||
Data.ItemBase[itemid].Itemtype == Global.item_database.ItemType.EU_SWORD ||
Data.ItemBase[itemid].Itemtype == Global.item_database.ItemType.EU_TSTAFF ||
Data.ItemBase[itemid].Itemtype == Global.item_database.ItemType.EU_TSWORD ||
Data.ItemBase[itemid].Itemtype == Global.item_database.ItemType.GLAVIE ||
Data.ItemBase[itemid].Itemtype == Global.item_database.ItemType.SPEAR ||
Data.ItemBase[itemid].Itemtype == Global.item_database.ItemType.SWORD ||
Data.ItemBase[itemid].Itemtype == Global.item_database.ItemType.CH_SHIELD ||
Data.ItemBase[itemid].Itemtype == Global.item_database.ItemType.EU_SHIELD)
{
Writer.Byte(ItemList[i].Item.PlusValue);
Writer.LWord(0);
Writer.DWord(Data.ItemBase[ItemList[i].Item.ID].Defans.Durability);
if (Data.ItemBlue[ItemList[i].Item.dbID].totalblue != 0)
{
Writer.Byte(Convert.ToByte(Data.ItemBlue[ItemList[i].Item.dbID].totalblue));
for (int a = 1; a <= Data.ItemBlue[ItemList[i].Item.dbID].totalblue; a++)
{
Writer.DWord(Data.MagicOptions.Find(mg => (mg.Name == Convert.ToString(Data.ItemBlue[ItemList[i].Item.dbID].blue[i]))).ID);
Writer.DWord(Data.ItemBlue[ItemList[i].Item.dbID].blueamount[i]);
}
}
else
{
Writer.Byte(0);
}
Writer.Word(1);
Writer.Word(2);
Writer.Word(3);
}
else if (Data.ItemBase[itemid].Etctype == Global.item_database.EtcType.STONES)
{
Writer.Word(ItemList[i].Item.Amount);
Writer.Byte(0);
}
else if (Data.ItemBase[itemid].Etctype == Global.item_database.EtcType.MONSTERMASK)
{
Writer.DWord(0);//Todo : Load monster mask monster model id here
return;
}
else if (Data.ItemBase[itemid].Etctype == Global.item_database.EtcType.ELIXIR)
{
Writer.Word(1);
}
else if (Data.ItemBase[itemid].Itemtype == Global.item_database.ItemType.ARROW ||
Data.ItemBase[itemid].Itemtype == Global.item_database.ItemType.BOLT ||
Data.ItemBase[itemid].Etctype == Global.item_database.EtcType.HP_POTION ||
Data.ItemBase[itemid].Etctype == Global.item_database.EtcType.MP_POTION ||
Data.ItemBase[itemid].Etctype == Global.item_database.EtcType.VIGOR_POTION ||
Data.ItemBase[itemid].Etctype == Global.item_database.EtcType.SPEED_POTION ||
Data.ItemBase[itemid].Ticket == Global.item_database.Tickets.BEGINNER_HELPERS ||
Data.ItemBase[itemid].Etctype == Global.item_database.EtcType.ELIXIR ||
Data.ItemBase[itemid].Etctype == Global.item_database.EtcType.ALCHEMY_MATERIAL ||
Data.ItemBase[itemid].Etctype == Global.item_database.EtcType.EVENT ||
Data.ItemBase[itemid].Class_D == 3)
{
Writer.Word(ItemList[i].Item.Amount);
}
Writer.Byte(ItemList[i].Item.Slot);
Writer.Word(ItemList[i].Item.Amount);
Writer.LWord(ItemList[i].price);
}
Writer.Byte(0xFF);
}
// collision detection 2D - /With Linear Algebra/
public static bool isCollided_onMovement(Global.vektor fromPos, Global.vektor toPos, ref Global.vektor CollisionPoint, Systems c)
{
try
{
fromPos.x = packetx(fromPos.x, fromPos.xSec) / 20.0f;
fromPos.y = packety(fromPos.y, fromPos.ySec) / 20.0f;
toPos.x = packetx(toPos.x, toPos.xSec) / 20.0f;
toPos.y = packety(toPos.y, toPos.ySec) / 20.0f;
// iterated line
Global.vektor Line_A = new Global.vektor();
Global.vektor Line_B = new Global.vektor();
List<Global.vektor> CollisionPoints = new List<Global.vektor>();
// get current region to filter out the objects
short region = makeRegion(fromPos.xSec, fromPos.ySec);
// get all entitys in this region and try to cut them with our movement line
foreach (Global.SectorObject.n7nEntity obj in Data.MapObject[region].entitys)
{
foreach (Global.SectorObject.n7nEntity.sLine line in obj.OutLines)
{
// if not passable
if (line.flag != 0)
{
Line_A.x = obj.Points[line.PointA].x + obj.Position.x;
Line_A.y = obj.Points[line.PointA].y + obj.Position.y;
Line_B.x = obj.Points[line.PointB].x + obj.Position.x;
Line_B.y = obj.Points[line.PointB].y + obj.Position.y;
if (lineSegmentIntersection(fromPos, toPos, Line_A, Line_B, ref CollisionPoints))
{
Console.WriteLine("x:{0} y:{1}", gamex(CollisionPoints[0].x, fromPos.xSec), gamey(CollisionPoints[0].y, fromPos.ySec));
}
}
}
}
if (CollisionPoints.Count == 0) return false;
// set the nearest collision point for return point
double minDistance = gamedistance(fromPos.x, fromPos.y, CollisionPoints[0].x, CollisionPoints[0].y);
foreach (Global.vektor cp in CollisionPoints)
{
//double currentDistance = gamedistance(fromPos.x, fromPos.y, cp.x, cp.y);
double currentDistance = gamedistance(fromPos, cp);
if (currentDistance <= minDistance)
{
CollisionPoint.x = cp.x;
CollisionPoint.y = cp.y;
}
}
// translate the collision point on the movement line to get real coordinates (not the exact point of collision)
double sin_alpha = Math.Abs(CollisionPoints[0].y - fromPos.y) / minDistance;
double cos_alpha = Math.Abs(CollisionPoints[0].x - fromPos.x) / minDistance;
CollisionPoints[0].y = (float)(sin_alpha * (minDistance - 3));
CollisionPoints[0].x = (float)(cos_alpha * (minDistance - 3));
}
catch (Exception ex)
{
Console.WriteLine("Collision detection failed: {0}", ex.Message);
}
return true;
}
/////////////////////////////////////////////////////////////////////////////////
// Spawn system (Spawn our char to others).
/////////////////////////////////////////////////////////////////////////////////
void ObjectPlayerSpawn(Systems s)
{
try
{
if (!s.Character.Spawned(this.Character.Information.UniqueID) && this.Character.Information.UniqueID != 0 && !s.Character.Spawning)
{
//We loop the spawn check for the player that needs it.
s.ObjectSpawnCheck();
}
}
catch (Exception ex)
{
Console.WriteLine("Object player spawn error {0}", ex);
Systems.Debugger.Write(ex);
}
}
public void AddRemoveBlues(Systems ch, Global.slotItem item, bool add)
{
try
{
LoadBluesid(item.dbID);
string name;
if (Data.ItemBlue.ContainsKey(item.dbID))
{
for (int k = 0; k < Data.ItemBlue[item.dbID].totalblue; k++)
{
name = Convert.ToString(Data.ItemBlue[item.dbID].blue[k]);
switch (name)
{
case "MATTR_INT":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_INT"))
{
if (add)
{
ch.Character.Stat.Intelligence += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceInfo(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
else
{
ch.Character.Stat.Intelligence -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceMinus(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_STR":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_STR"))
{
if (add)
{
ch.Character.Stat.Strength += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthInfo(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
else
{
ch.Character.Stat.Strength -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthMinus(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_LUCK":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_LUCK"))
{
if (add)
ch.Character.Blues.Luck += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Blues.Luck -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
}
break;
case "MATTR_HP":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_HP"))
{
if (add)
ch.Character.Stat.Hp += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Stat.Hp -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.client.Send(Packet.PlayerStat(ch.Character));
ch.UpdateHp();
ch.SavePlayerInfo();
}
break;
case "MATTR_MP":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_MP"))
{
if (add)
ch.Character.Stat.Mp += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Stat.Mp -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.client.Send(Packet.PlayerStat(ch.Character));
ch.UpdateMp();
ch.SavePlayerInfo();
}
break;
case "MATTR_REGENHPMP": // hp/mp regen inc(%)
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_REGENHPMP"))
{
if (add)
{
ch.Character.Blues.mpregen += Convert.ToDouble(Data.ItemBlue[item.dbID].blueamount[k]);
ch.Character.Blues.hpregen += Convert.ToDouble(Data.ItemBlue[item.dbID].blueamount[k]);
}
else
{
ch.Character.Blues.mpregen -= Convert.ToDouble(Data.ItemBlue[item.dbID].blueamount[k]);
ch.Character.Blues.hpregen -= Convert.ToDouble(Data.ItemBlue[item.dbID].blueamount[k]);
}
}
break;
case "MATTR_RESIST_FROSTBITE":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_RESIST_FROSTBITE"))
{
if (add)
ch.Character.Blues.Resist_Frostbite += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Blues.Resist_Frostbite -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
}
break;
case "MATTR_RESIST_ESHOCK":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_RESIST_ESHOCK"))
{
if (add)
ch.Character.Blues.Resist_Eshock += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Blues.Resist_Eshock -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
}
break;
case "MATTR_RESIST_BURN":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_RESIST_BURN"))
{
if (add)
ch.Character.Blues.Resist_Burn += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Blues.Resist_Burn -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
}
break;
case "MATTR_RESIST_POISON":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_RESIST_POISON"))
{
if (add)
ch.Character.Blues.Resist_Poison += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Blues.Resist_Poison -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
}
break;
case "MATTR_RESIST_ZOMBIE":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_RESIST_ZOMBIE"))
{
if (add)
ch.Character.Blues.Resist_Zombie += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Blues.Resist_Zombie -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
}
break;
case "MATTR_STR_3JOB":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_STR_3JOB"))
{
if (add)
{
ch.Character.Stat.Strength += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthInfo(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
else
{
ch.Character.Stat.Strength -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthMinus(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_INT_3JOB":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_INT_3JOB"))
{
if (add)
{
ch.Character.Stat.Intelligence += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceInfo(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
else
{
ch.Character.Stat.Intelligence -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceMinus(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_STR_AVATAR":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_STR_AVATAR"))
{
if (add)
{
ch.Character.Stat.Strength += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthInfo(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
else
{
ch.Character.Stat.Strength -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthMinus(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_INT_AVATAR":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_INT_AVATAR"))
{
if (add)
{
ch.Character.Stat.Intelligence += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceInfo(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
else
{
ch.Character.Stat.Intelligence -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceMinus(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_AVATAR_STR":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_STR"))
{
if (add)
{
ch.Character.Stat.Strength += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthInfo(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
else
{
ch.Character.Stat.Strength -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthMinus(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_AVATAR_INT":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_INT"))
{
if (add)
{
ch.Character.Stat.Intelligence += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceInfo(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
else
{
ch.Character.Stat.Intelligence -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceMinus(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_AVATAR_HR":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_HR"))
{
if (add)
{
ch.Character.Blues.UpdatedStats[item.dbID].Hit = (ch.Character.Stat.Hit / 100) * Convert.ToDouble(Data.ItemBlue[item.dbID].blueamount[k]);
ch.Character.Stat.Hit += ch.Character.Blues.UpdatedStats[item.dbID].Hit;
}
else
{
ch.Character.Stat.Hit -= ch.Character.Blues.UpdatedStats[item.dbID].Hit;
ch.Character.Blues.UpdatedStats[item.dbID].Hit = 0;
}
ch.client.Send(Packet.PlayerStat(ch.Character));
ch.SavePlayerInfo();
}
break;
case "MATTR_AVATAR_ER":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_ER"))
{
if (add)
{
ch.Character.Blues.UpdatedStats[item.dbID].Parry = (ch.Character.Stat.Parry / 100) * Convert.ToDouble(Data.ItemBlue[item.dbID].blueamount[k]);
ch.Character.Stat.Parry += ch.Character.Blues.UpdatedStats[item.dbID].Parry;
}
else
{
ch.Character.Stat.Parry -= ch.Character.Blues.UpdatedStats[item.dbID].Parry;
ch.Character.Blues.UpdatedStats[item.dbID].Parry = 0;
}
ch.client.Send(Packet.PlayerStat(ch.Character));
ch.SavePlayerInfo();
}
break;
case "MATTR_ER": //parry rate inc
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_ER"))
{
if (add)
{
ch.Character.Blues.UpdatedStats[item.dbID].Parry = (ch.Character.Stat.Parry / 100) * Convert.ToDouble(Data.ItemBlue[item.dbID].blueamount[k]);
ch.Character.Stat.Parry += ch.Character.Blues.UpdatedStats[item.dbID].Parry;
}
else
{
ch.Character.Stat.Parry -= ch.Character.Blues.UpdatedStats[item.dbID].Parry;
ch.Character.Blues.UpdatedStats[item.dbID].Parry = 0;
}
ch.client.Send(Packet.PlayerStat(ch.Character));
ch.SavePlayerInfo();
}
break;
case "MATTR_HR": //attack rate inc (%)
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_HR"))
{
if (add)
{
ch.Character.Blues.UpdatedStats[item.dbID].Hit = (ch.Character.Stat.Hit / 100) * Convert.ToDouble(Data.ItemBlue[item.dbID].blueamount[k]);
ch.Character.Stat.Hit += ch.Character.Blues.UpdatedStats[item.dbID].Hit;
}
else
{
ch.Character.Stat.Hit -= ch.Character.Blues.UpdatedStats[item.dbID].Hit;
ch.Character.Blues.UpdatedStats[item.dbID].Hit = 0;
}
ch.client.Send(Packet.PlayerStat(ch.Character));
ch.SavePlayerInfo();
}
break;
case "MATTR_AVATAR_HP":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_HP"))
{
if (add)
ch.Character.Stat.Hp += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Stat.Hp -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.client.Send(Packet.PlayerStat(ch.Character));
ch.UpdateHp();
ch.SavePlayerInfo();
}
break;
case "MATTR_AVATAR_MP":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_MP"))
{
if (add)
ch.Character.Stat.Mp += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Stat.Mp -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.client.Send(Packet.PlayerStat(ch.Character));
ch.UpdateMp();
ch.SavePlayerInfo();
}
break;
case "MATTR_AVATAR_DRUA": // damage increase
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_DRUA"))
{
if (add)
{
ch.Character.Blues.UpdatedStats[item.dbID].MinPhyAttack = (ch.Character.Stat.MinPhyAttack / 100) * Convert.ToDouble(Data.ItemBlue[item.dbID].blueamount[k]);
ch.Character.Blues.UpdatedStats[item.dbID].MaxPhyAttack = (ch.Character.Stat.MaxPhyAttack / 100) * Convert.ToDouble(Data.ItemBlue[item.dbID].blueamount[k]);
ch.Character.Blues.UpdatedStats[item.dbID].MinMagAttack = (ch.Character.Stat.MinMagAttack / 100) * Convert.ToDouble(Data.ItemBlue[item.dbID].blueamount[k]);
ch.Character.Blues.UpdatedStats[item.dbID].MaxMagAttack = (ch.Character.Stat.MaxMagAttack / 100) * Convert.ToDouble(Data.ItemBlue[item.dbID].blueamount[k]);
ch.Character.Stat.MinPhyAttack += ch.Character.Blues.UpdatedStats[item.dbID].MinPhyAttack;
ch.Character.Stat.MaxPhyAttack += ch.Character.Blues.UpdatedStats[item.dbID].MaxPhyAttack;
ch.Character.Stat.MinMagAttack += ch.Character.Blues.UpdatedStats[item.dbID].MinMagAttack;
ch.Character.Stat.MaxMagAttack += ch.Character.Blues.UpdatedStats[item.dbID].MaxMagAttack;
}
else
{
ch.Character.Stat.MinPhyAttack -= ch.Character.Blues.UpdatedStats[item.dbID].MinPhyAttack;
ch.Character.Stat.MaxPhyAttack -= ch.Character.Blues.UpdatedStats[item.dbID].MaxPhyAttack;
ch.Character.Stat.MinMagAttack -= ch.Character.Blues.UpdatedStats[item.dbID].MinMagAttack;
ch.Character.Stat.MaxMagAttack -= ch.Character.Blues.UpdatedStats[item.dbID].MaxMagAttack;
ch.Character.Blues.UpdatedStats[item.dbID].MinPhyAttack = 0;
ch.Character.Blues.UpdatedStats[item.dbID].MaxPhyAttack = 0;
ch.Character.Blues.UpdatedStats[item.dbID].MinMagAttack = 0;
ch.Character.Blues.UpdatedStats[item.dbID].MaxMagAttack = 0;
}
ch.client.Send(Packet.PlayerStat(ch.Character));
ch.SavePlayerInfo();
}
break;
case "MATTR_AVATAR_DARA": // damage absorption
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_DARA"))
{
if (add)
{
//ch.Character.Stat.phy_Absorb += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
//ch.Character.Stat.mag_Absorb += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
}
else
{
//ch.Character.Stat.phy_Absorb -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
//ch.Character.Stat.mag_Absorb -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
}
}
break;
case "MATTR_AVATAR_MDIA": // ignore monster defense
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_MDIA"))
{
if (add)
{
ch.Character.Blues.MonsterIgnorance += Convert.ToInt32(Data.ItemBlue[item.dbID].blueamount[k]);
}
else
{
ch.Character.Blues.MonsterIgnorance -= Convert.ToInt32(Data.ItemBlue[item.dbID].blueamount[k]);
}
}
break;
case "MATTR_AVATAR_HPRG": //hp recovery increase
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_HPRG"))
{
if (add)
{
ch.Character.Blues.hpregen += Convert.ToDouble(Data.ItemBlue[item.dbID].blueamount[k]);
}
else
{
ch.Character.Blues.hpregen -= Convert.ToDouble(Data.ItemBlue[item.dbID].blueamount[k]);
}
}
break;
case "MATTR_AVATAR_MPRG": //mp recovery increase
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_MPRG"))
{
if (add)
{
ch.Character.Blues.mpregen += Convert.ToDouble(Data.ItemBlue[item.dbID].blueamount[k]);
}
else
{
ch.Character.Blues.mpregen -= Convert.ToDouble(Data.ItemBlue[item.dbID].blueamount[k]);
}
}
break;
case "MATTR_RESIST_STUN":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_RESIST_STUN"))
{
if (add)
ch.Character.Blues.Resist_Stun += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Blues.Resist_Stun -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
}
break;
case "MATTR_RESIST_CSMP":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_RESIST_CSMP"))
{
if (add)
ch.Character.Blues.Resist_CSMP += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Blues.Resist_CSMP -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
}
break;
case "MATTR_RESIST_DISEASE":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_RESIST_DISEASE"))
{
if (add)
ch.Character.Blues.Resist_Disease += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Blues.Resist_Disease -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
}
break;
case "MATTR_RESIST_SLEEP":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_RESIST_SLEEP"))
{
if (add)
ch.Character.Blues.Resist_Sleep += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Blues.Resist_Sleep -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
}
break;
case "MATTR_RESIST_FEAR":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_RESIST_FEAR"))
{
if (add)
ch.Character.Blues.Resist_Fear += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Blues.Resist_Fear -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
}
break;
case "MATTR_NASRUN_UMDU": //damage increase(only @ uniques)
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_NASRUN_UMDU"))
{
if (add)
{
ch.Character.Blues.UniqueDMGInc += Convert.ToInt32(Data.ItemBlue[item.dbID].blueamount[k]);
}
else
{
ch.Character.Blues.UniqueDMGInc += Convert.ToInt32(Data.ItemBlue[item.dbID].blueamount[k]);
}
}
break;
case "MATTR_NASRUN_HPNA": //maximum hp increase
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_NASRUN_HPNA"))
{
if (add)
{
ch.Character.Stat.Hp += Convert.ToInt32(Data.ItemBlue[item.dbID].blueamount[k]);
ch.Character.Stat.SecondHp += Convert.ToInt32(Data.ItemBlue[item.dbID].blueamount[k]);
}
else
{
ch.Character.Stat.Hp -= Convert.ToInt32(Data.ItemBlue[item.dbID].blueamount[k]);
ch.Character.Stat.SecondHp -= Convert.ToInt32(Data.ItemBlue[item.dbID].blueamount[k]);
}
ch.UpdateHp();
ch.SavePlayerInfo();
}
break;
case "MATTR_NASRUN_MPNA": //maximum mp increase
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_NASRUN_MPNA"))
{
if (add)
{
ch.Character.Stat.Mp += Convert.ToInt32(Data.ItemBlue[item.dbID].blueamount[k]);
ch.Character.Stat.SecondMP += Convert.ToInt32(Data.ItemBlue[item.dbID].blueamount[k]);
}
else
{
ch.Character.Stat.Mp -= Convert.ToInt32(Data.ItemBlue[item.dbID].blueamount[k]);
ch.Character.Stat.SecondMP -= Convert.ToInt32(Data.ItemBlue[item.dbID].blueamount[k]);
}
ch.UpdateMp();
ch.SavePlayerInfo();
}
break;
case "MATTR_NASRUN_BLOCKRATE": //blocking rate increase
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_NASRUN_BLOCKRATE"))
{
if (add)
{
ch.Character.Stat.BlockRatio += Convert.ToInt32(Data.ItemBlue[item.dbID].blueamount[k]);
}
else
{
ch.Character.Stat.BlockRatio -= Convert.ToInt32(Data.ItemBlue[item.dbID].blueamount[k]);
}
ch.client.Send(Packet.PlayerStat(ch.Character));
ch.SavePlayerInfo();
}
break;
case "MATTR_STR_SET":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_STR_SET"))
{
if (add)
{
ch.Character.Stat.Strength += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthInfo(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
else
{
ch.Character.Stat.Strength -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthMinus(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_INT_SET":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_INT_SET"))
{
if (add)
{
ch.Character.Stat.Intelligence += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceInfo(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
else
{
ch.Character.Stat.Intelligence -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceMinus(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_ER_SET":
break;
case "MATTR_HP_SET":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_HP_SET"))
{
if (add)
ch.Character.Stat.Hp += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Stat.Hp -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.client.Send(Packet.PlayerStat(ch.Character));
ch.UpdateHp();
ch.SavePlayerInfo();
}
break;
case "MATTR_MP_SET":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_MP_SET"))
{
if (add)
ch.Character.Stat.Mp += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Stat.Mp -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.client.Send(Packet.PlayerStat(ch.Character));
ch.UpdateMp();
ch.SavePlayerInfo();
}
break;
case "MATTR_LUCK_SET":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_LUCK_SET"))
{
if (add)
ch.Character.Blues.Luck += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Blues.Luck -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
}
break;
case "MATTR_AVATAR_STR_2":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_STR_2"))
{
if (add)
{
ch.Character.Stat.Strength += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthInfo(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
else
{
ch.Character.Stat.Strength -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthMinus(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_AVATAR_STR_3":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_STR_3"))
{
if (add)
{
ch.Character.Stat.Strength += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthInfo(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
else
{
ch.Character.Stat.Strength -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthMinus(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_AVATAR_STR_4":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_STR_4"))
{
if (add)
{
ch.Character.Stat.Strength += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthInfo(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
else
{
ch.Character.Stat.Strength -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthMinus(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_AVATAR_INT_2":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_INT_2"))
{
if (add)
{
ch.Character.Stat.Intelligence += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceInfo(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
else
{
ch.Character.Stat.Intelligence -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceMinus(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_AVATAR_INT_3":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_INT_3"))
{
if (add)
{
ch.Character.Stat.Intelligence += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceInfo(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
else
{
ch.Character.Stat.Intelligence -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceMinus(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_AVATAR_INT_4":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_INT_4"))
{
if (add)
{
ch.Character.Stat.Intelligence += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceInfo(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
else
{
ch.Character.Stat.Intelligence -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceMinus(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_AVATAR_MDIA_2":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_MDIA_2"))
{
if (add)
{
ch.Character.Blues.MonsterIgnorance += Convert.ToInt32(Data.ItemBlue[item.dbID].blueamount[k]);
}
else
{
ch.Character.Blues.MonsterIgnorance -= Convert.ToInt32(Data.ItemBlue[item.dbID].blueamount[k]);
}
}
break;
case "MATTR_AVATAR_MDIA_3":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_MDIA_3"))
{
if (add)
{
ch.Character.Blues.MonsterIgnorance += Convert.ToInt32(Data.ItemBlue[item.dbID].blueamount[k]);
}
else
{
ch.Character.Blues.MonsterIgnorance -= Convert.ToInt32(Data.ItemBlue[item.dbID].blueamount[k]);
}
}
break;
case "MATTR_AVATAR_MDIA_4":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_MDIA_4"))
{
if (add)
{
ch.Character.Blues.MonsterIgnorance += Convert.ToInt32(Data.ItemBlue[item.dbID].blueamount[k]);
}
else
{
ch.Character.Blues.MonsterIgnorance -= Convert.ToInt32(Data.ItemBlue[item.dbID].blueamount[k]);
}
}
break;
case "MATTR_AVATAR_LUCK":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_LUCK"))
{
if (add)
ch.Character.Blues.Luck += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Blues.Luck -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
}
break;
case "MATTR_AVATAR_LUCK_2":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_LUCK_2"))
{
if (add)
ch.Character.Blues.Luck += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Blues.Luck -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
}
break;
case "MATTR_AVATAR_LUCK_3":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_LUCK_4"))
{
if (add)
ch.Character.Blues.Luck += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Blues.Luck -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
}
break;
case "MATTR_AVATAR_LUCK_4":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_AVATAR_LUCK_4"))
{
if (add)
ch.Character.Blues.Luck += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Blues.Luck -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
}
break;
case "MATTR_RESIST_ALL_SET":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_RESIST_ALL_SET"))
{
if (add)
ch.Character.Blues.Resist_All += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Blues.Resist_All -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
}
break;
case "MATTR_TRADE_STR":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_TRADE_STR"))
{
if (add)
{
ch.Character.Stat.Strength += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthInfo(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
else
{
ch.Character.Stat.Strength -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthMinus(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_TRADE_STR_2":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_TRADE_STR_2"))
{
if (add)
{
ch.Character.Stat.Strength += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthInfo(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
else
{
ch.Character.Stat.Strength -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthMinus(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_TRADE_STR_3":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_TRADE_STR_3"))
{
if (add)
{
ch.Character.Stat.Strength += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthInfo(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
else
{
ch.Character.Stat.Strength -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateStrengthMinus(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateHp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_TRADE_INT":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_TRADE_INT"))
{
if (add)
{
ch.Character.Stat.Intelligence += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceInfo(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
else
{
ch.Character.Stat.Intelligence -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceMinus(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_TRADE_INT_2":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_TRADE_INT_2"))
{
if (add)
{
ch.Character.Stat.Intelligence += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceInfo(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
else
{
ch.Character.Stat.Intelligence -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceMinus(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_TRADE_INT_3":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_TRADE_INT_3"))
{
if (add)
{
ch.Character.Stat.Intelligence += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceInfo(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
else
{
ch.Character.Stat.Intelligence -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.UpdateIntelligenceMinus(Convert.ToSByte(Data.ItemBlue[item.dbID].blueamount[k]));
ch.SetStat();
ch.UpdateMp();
}
ch.SavePlayerInfo();
}
break;
case "MATTR_TRADE_HP":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_TRADE_HP"))
{
if (add)
ch.Character.Stat.Hp += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Stat.Hp -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.client.Send(Packet.PlayerStat(ch.Character));
ch.UpdateHp();
ch.SavePlayerInfo();
}
break;
case "MATTR_TRADE_HP_2":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_TRADE_HP_2"))
{
if (add)
ch.Character.Stat.Hp += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Stat.Hp -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.client.Send(Packet.PlayerStat(ch.Character));
ch.UpdateHp();
ch.SavePlayerInfo();
}
break;
case "MATTR_TRADE_HP_3":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_TRADE_HP_3"))
{
if (add)
ch.Character.Stat.Hp += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Stat.Hp -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.client.Send(Packet.PlayerStat(ch.Character));
ch.UpdateHp();
ch.SavePlayerInfo();
}
break;
case "MATTR_TRADE_MP":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_TRADE_MP"))
{
if (add)
ch.Character.Stat.Mp += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Stat.Mp -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.client.Send(Packet.PlayerStat(ch.Character));
ch.UpdateMp();
ch.SavePlayerInfo();
}
break;
case "MATTR_TRADE_MP_2":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_TRADE_MP_2"))
{
if (add)
ch.Character.Stat.Mp += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Stat.Mp -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.client.Send(Packet.PlayerStat(ch.Character));
ch.UpdateMp();
ch.SavePlayerInfo();
}
break;
case "MATTR_TRADE_MP_3":
if (Data.ItemBlue[item.dbID].blue.Contains("MATTR_TRADE_MP_3"))
{
if (add)
ch.Character.Stat.Mp += Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
else
ch.Character.Stat.Mp -= Convert.ToInt16(Data.ItemBlue[item.dbID].blueamount[k]);
ch.client.Send(Packet.PlayerStat(ch.Character));
ch.UpdateMp();
ch.SavePlayerInfo();
}
break;
}
}
}
else
{
Console.WriteLine("[BlueSystem] ItemBlue for ID {0} not found", item.dbID);
}
}
catch (Exception ex)
{
Console.WriteLine("Blue add/remove error {0}", ex);
Systems.Debugger.Write(ex);
}
}
public static byte[] Party_Data(byte type, int id)
{
//Create new packet writer
PacketWriter Writer = new PacketWriter();
//Add opcode
Writer.Create(Systems.SERVER_PARTY_DATA);
//Write type byte
Writer.Byte(type);
//Create switch for type given
switch (type)
{
case 1:
//Remove party state
Writer.Byte(0x0b);
Writer.Byte(0);
//Return all bytes for sending
return(Writer.GetBytes());
case 2:
//Formed party new member update
Systems CharacterInformation = Systems.GetPlayer(id);
//Write static byte
Writer.Byte(0xFF);
//Write unique character id
Writer.DWord(CharacterInformation.Character.Information.UniqueID);
//Write character name
Writer.Text(CharacterInformation.Character.Information.Name);
//Write character model
Writer.DWord(CharacterInformation.Character.Information.Model);
//Write character level
Writer.Byte(CharacterInformation.Character.Information.Level);
//Write static byte
Writer.Byte(0xAA);
//Write x and y sector
Writer.Byte(CharacterInformation.Character.Position.xSec);
Writer.Byte(CharacterInformation.Character.Position.ySec);
//Write x z y
Writer.Word(Formule.packetx(CharacterInformation.Character.Position.x, CharacterInformation.Character.Position.xSec));
Writer.Word(CharacterInformation.Character.Position.z);
Writer.Word(Formule.packety(CharacterInformation.Character.Position.y, CharacterInformation.Character.Position.ySec));
//Write double word 1
Writer.Word(1);
Writer.Word(1);
//If character is in a guild
if (CharacterInformation.Character.Network.Guild.Name != null)
{
//Write guild name
Writer.Text(CharacterInformation.Character.Network.Guild.Name);
}
//If character has no guild
else
{
//Write 0 word value
Writer.Word(0);
}
//Static byte
Writer.Byte(0);
//Permissions
Writer.DWord(0);
Writer.DWord(0);
//Return all bytes for sending
return(Writer.GetBytes());
case 3:
//Write character id
Writer.DWord(id);
//Write static byte 4
Writer.Byte(4);
//Return all bytes for sending
return(Writer.GetBytes());
case 6:
//Update player location and stat
CharacterInformation = Systems.GetPlayer(id);
//Calculate hp and mp
int partyPercentMP = (int)Math.Round((decimal)(CharacterInformation.Character.Stat.SecondMP * 10) / CharacterInformation.Character.Stat.Mp) << 4;
int partyPercentHP = (int)Math.Round((decimal)(CharacterInformation.Character.Stat.SecondHp * 10) / CharacterInformation.Character.Stat.Hp);
//Set percent information
int partyPercent = partyPercentHP | partyPercentMP;
//Write character id
Writer.DWord(id);
//If character is moving
if (CharacterInformation.Character.Position.Walking)
{
//Write byte 20
Writer.Byte(0x20);
//Write location information
Writer.Byte(CharacterInformation.Character.Position.packetxSec);
Writer.Byte(CharacterInformation.Character.Position.packetySec);
Writer.Word(CharacterInformation.Character.Position.packetX);
Writer.Word(CharacterInformation.Character.Position.packetZ);
Writer.Word(CharacterInformation.Character.Position.packetY);
//Write double word 1
Writer.Word(1);
Writer.Word(1);
}
//If not walking
else
{
//Write static byte 4
Writer.Byte(4);
//Write hp mp information
Writer.Byte((byte)partyPercent);
}
//Return all bytes for sending
return(Writer.GetBytes());
case 9:
//New leader id
Writer.DWord(id);
//Return all bytes for sending
return(Writer.GetBytes());
}
//Return all bytes for sending
return(Writer.GetBytes());
}
void GuildStorage()
{
//Wrap our function inside a catcher
try
{
//If guild level is to low send message
if (Character.Network.Guild.Level == 1)
{
//Need to sniff to check what opcode is sending for the message
client.Send(Packet.IngameMessages(Systems.SERVER_GUILD_STORAGE, IngameMessages.GUILD_STORAGE_LEVEL_TO_LOW));
}
//If guild level is 2 meaning it has storage option
else
{
//Make sure the user has guild storage rights
if (Character.Network.Guild.guildstorageRight)
{
//Check if other guild members are currently in storage
foreach (int member in Character.Network.Guild.Members)
{
//Make sure member isnt 0
if (member != 0)
{
//Get player details
Systems getplayer = GetPlayerMainid(member);
//Make sure player isnt null
if (getplayer != null)
{
//Check if the player is using storage
if (getplayer.Character.Network.Guild.UsingStorage)
{
//Send storage message error
client.Send(Packet.IngameMessages(Systems.SERVER_GUILD_WAIT, IngameMessages.UIIT_MSG_STRGERR_STORAGE_OPERATION_BLOCKED));
return;
}
}
}
}
//Make sure that the user isnt using storage allready
if (!Character.Network.Guild.UsingStorage)
{
byte type = 1;
//Set user as active storage user
Character.Network.Guild.UsingStorage = true;
//Send storage begin packet
client.Send(Packet.GuildStorageStart(type));
}
}
//If the player has no storage rights
else
{
//Send error message to user not allowed
client.Send(Packet.IngameMessages(SERVER_GUILD_STORAGE, IngameMessages.UIIT_MSG_STRGERR_STORAGE_OPERATION_BLOCKED));
}
}
}
//Catch any bad errors
catch (Exception ex)
{
//Write information to the console
Console.WriteLine("GuildStorage Open Error: {0}", ex);
//Write information to the debug log
Systems.Debugger.Write(ex);
}
}
public static byte[] Exchange_ItemPacket(int id, List <Global.slotItem> Exhange, bool mine)
{
PacketWriter Writer = new PacketWriter();
Writer.Create(Systems.SERVER_EXCHANGE_ITEM);
Writer.DWord(id);
Writer.Byte(Exhange.Count);
for (byte i = 0; i < Exhange.Count; i++)
{
Systems.LoadBluesid(Exhange[i].dbID);
if (mine)
{
Writer.Byte(Exhange[i].Slot);
}
Writer.Byte(i);
Writer.DWord(0);
Writer.DWord(Exhange[i].ID);
if (Data.ItemBase[Exhange[i].ID].Type == Global.item_database.ArmorType.ARMOR ||
Data.ItemBase[Exhange[i].ID].Type == Global.item_database.ArmorType.GARMENT ||
Data.ItemBase[Exhange[i].ID].Type == Global.item_database.ArmorType.GM ||
Data.ItemBase[Exhange[i].ID].Type == Global.item_database.ArmorType.HEAVY ||
Data.ItemBase[Exhange[i].ID].Type == Global.item_database.ArmorType.LIGHT ||
Data.ItemBase[Exhange[i].ID].Type == Global.item_database.ArmorType.PROTECTOR ||
Data.ItemBase[Exhange[i].ID].Type == Global.item_database.ArmorType.ROBE ||
Data.ItemBase[Exhange[i].ID].Itemtype == Global.item_database.ItemType.EARRING ||
Data.ItemBase[Exhange[i].ID].Itemtype == Global.item_database.ItemType.RING ||
Data.ItemBase[Exhange[i].ID].Itemtype == Global.item_database.ItemType.NECKLACE ||
Data.ItemBase[Exhange[i].ID].Itemtype == Global.item_database.ItemType.BLADE ||
Data.ItemBase[Exhange[i].ID].Itemtype == Global.item_database.ItemType.BOW ||
Data.ItemBase[Exhange[i].ID].Itemtype == Global.item_database.ItemType.EU_AXE ||
Data.ItemBase[Exhange[i].ID].Itemtype == Global.item_database.ItemType.EU_CROSSBOW ||
Data.ItemBase[Exhange[i].ID].Itemtype == Global.item_database.ItemType.EU_DAGGER ||
Data.ItemBase[Exhange[i].ID].Itemtype == Global.item_database.ItemType.EU_DARKSTAFF ||
Data.ItemBase[Exhange[i].ID].Itemtype == Global.item_database.ItemType.EU_HARP ||
Data.ItemBase[Exhange[i].ID].Itemtype == Global.item_database.ItemType.EU_STAFF ||
Data.ItemBase[Exhange[i].ID].Itemtype == Global.item_database.ItemType.EU_SWORD ||
Data.ItemBase[Exhange[i].ID].Itemtype == Global.item_database.ItemType.EU_TSTAFF ||
Data.ItemBase[Exhange[i].ID].Itemtype == Global.item_database.ItemType.EU_TSWORD ||
Data.ItemBase[Exhange[i].ID].Itemtype == Global.item_database.ItemType.GLAVIE ||
Data.ItemBase[Exhange[i].ID].Itemtype == Global.item_database.ItemType.SPEAR ||
Data.ItemBase[Exhange[i].ID].Itemtype == Global.item_database.ItemType.SWORD ||
Data.ItemBase[Exhange[i].ID].Itemtype == Global.item_database.ItemType.CH_SHIELD ||
Data.ItemBase[Exhange[i].ID].Itemtype == Global.item_database.ItemType.EU_SHIELD)
{
Writer.Byte(Exhange[i].PlusValue);
Writer.LWord(0);
Writer.DWord(Data.ItemBase[Exhange[i].ID].Defans.Durability);
if (Data.ItemBlue[Exhange[i].dbID].totalblue != 0)
{
Writer.Byte(Convert.ToByte(Data.ItemBlue[Exhange[i].dbID].totalblue));
for (int a = 1; a <= Data.ItemBlue[Exhange[i].dbID].totalblue; a++)
{
Writer.DWord(Data.MagicOptions.Find(mg => (mg.Name == Convert.ToString(Data.ItemBlue[Exhange[i].dbID].blue[i]))).ID);
Writer.DWord(Data.ItemBlue[Exhange[i].dbID].blueamount[i]);
}
}
else
{
Writer.Byte(0);
}
Writer.Word(1);
Writer.Word(2);
Writer.Word(3);
}
else if (Data.ItemBase[Exhange[i].ID].Etctype == Global.item_database.EtcType.STONES)
{
Writer.Word(Exhange[i].Amount);
Writer.Byte(0);
}
else if (Data.ItemBase[Exhange[i].ID].Etctype == Global.item_database.EtcType.MONSTERMASK)
{
Writer.DWord(0);
}
else if (Data.ItemBase[Exhange[i].ID].Etctype == Global.item_database.EtcType.ELIXIR)
{
Writer.Word(1);
}
else if (Data.ItemBase[Exhange[i].ID].Itemtype == Global.item_database.ItemType.ARROW ||
Data.ItemBase[Exhange[i].ID].Itemtype == Global.item_database.ItemType.BOLT ||
Data.ItemBase[Exhange[i].ID].Etctype == Global.item_database.EtcType.HP_POTION ||
Data.ItemBase[Exhange[i].ID].Etctype == Global.item_database.EtcType.MP_POTION ||
Data.ItemBase[Exhange[i].ID].Etctype == Global.item_database.EtcType.VIGOR_POTION ||
Data.ItemBase[Exhange[i].ID].Etctype == Global.item_database.EtcType.SPEED_POTION ||
Data.ItemBase[Exhange[i].ID].Ticket == Global.item_database.Tickets.BEGINNER_HELPERS ||
Data.ItemBase[Exhange[i].ID].Etctype == Global.item_database.EtcType.ELIXIR ||
Data.ItemBase[Exhange[i].ID].Etctype == Global.item_database.EtcType.ALCHEMY_MATERIAL ||
Data.ItemBase[Exhange[i].ID].Etctype == Global.item_database.EtcType.EVENT ||
Data.ItemBase[Exhange[i].ID].Class_D == 3)
{
Writer.Word(Exhange[i].Amount);
}
}
return(Writer.GetBytes());
}
// dgmp stat ellenőrzése hogy mire jó??
public void ChangeAbsorbMP_dgmp(Systems Target, int slot, bool delete,bool UpdatePacket)
{
try
{
if (!delete)
{
int amount;
if (Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties1["dgmp"] != 0)
{
amount = Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties1["dgmp"];
Target.Character.Stat.Absorb_mp = amount;
}
}
else
{
Target.Character.Stat.Absorb_mp = 0;
}
if (UpdatePacket) Target.client.Send(Packet.PlayerStat(Target.Character));
}
catch (Exception ex)
{
Systems.Debugger.Write(ex);
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Exchange Approve
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Exchange_Approve()
{
try
{
Systems sys = GetPlayer(Character.Network.TargetID);
client.Send(Packet.Exchange_Approve());
Character.Network.Exchange.Approved = true;
if (sys.Character.Network.Exchange.Approved)
{
#region Gold update
if (Character.Network.Exchange.Gold != 0)
{
Character.Information.Gold -= Character.Network.Exchange.Gold;
client.Send(Packet.UpdateGold(Character.Information.Gold));
SaveGold();
sys.Character.Information.Gold += Character.Network.Exchange.Gold;
sys.client.Send(Packet.UpdateGold(sys.Character.Information.Gold));
sys.SaveGold();
}
if (sys.Character.Network.Exchange.Gold != 0)
{
sys.Character.Information.Gold -= sys.Character.Network.Exchange.Gold;
sys.client.Send(Packet.UpdateGold(sys.Character.Information.Gold));
sys.SaveGold();
Character.Information.Gold += sys.Character.Network.Exchange.Gold;
client.Send(Packet.UpdateGold(Character.Information.Gold));
SaveGold();
}
#endregion
#region Items
if (Character.Network.Exchange.ItemList.Count > 0)
{
foreach (Global.slotItem item in Character.Network.Exchange.ItemList)
{
byte t_slot = sys.GetFreeSlot();
Systems.MsSQL.InsertData("UPDATE char_items SET owner='" + sys.Character.Information.CharacterID + "' WHERE owner='" + Character.Information.CharacterID + "' AND itemid='" + item.ID + "' AND id='" + item.dbID + "' AND storagetype='0'");
}
}
if (sys.Character.Network.Exchange.ItemList.Count > 0)
{
foreach (Global.slotItem item in sys.Character.Network.Exchange.ItemList)
{
byte t_slot = GetFreeSlot();
Systems.MsSQL.InsertData("UPDATE char_items SET owner='" + Character.Information.CharacterID + "' WHERE owner='" + sys.Character.Information.CharacterID + "' AND itemid='" + item.ID + "' AND id='" + item.dbID + "' AND storagetype='0'");
}
}
#endregion
client.Send(Packet.Exchange_Finish());
sys.client.Send(Packet.Exchange_Finish());
Character.State.Exchanging = false;
sys.Character.State.Exchanging = false;
}
}
catch (Exception ex)
{
Systems.Debugger.Write(ex);
}
}
public void ChangeBlockingRatio_br(Systems Target, int slot, bool delete,bool UpdatePacket)
{
try
{
int amount;
if (!delete)
{
if (Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties1["br"] != 0)
{
amount = Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties2["br"];
Target.Character.Action.Buff.UpdatedStats[slot].BlockRatio = amount;
}
if (Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties2["br"] != 0)
{
amount = Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties2["br"];
Target.Character.Action.Buff.UpdatedStats[slot].BlockRatio = (Target.Character.Stat.BlockRatio / 100) * (amount);
}
Target.Character.Stat.BlockRatio += Target.Character.Action.Buff.UpdatedStats[slot].BlockRatio;
}
else
{
Target.Character.Stat.BlockRatio -= Target.Character.Action.Buff.UpdatedStats[slot].BlockRatio;
Target.Character.Action.Buff.UpdatedStats[slot].BlockRatio = 0;
}
if (UpdatePacket) Target.client.Send(Packet.PlayerStat(Target.Character));
}
catch (Exception ex)
{
Systems.Debugger.Write(ex);
}
}
public void Send(Systems sys, byte[] buff)
{
try
{
if (Spawned(sys.Character.Information.UniqueID))
{
sys.client.Send(buff);
}
}
catch (Exception ex)
{
Console.WriteLine("Send error: {0}", ex);
}
}
public void ChangeCriticalParry_dcri(Systems Target, int slot, bool delete,bool UpdatePacket)
{
try
{
int amount;
if (!delete)
{
if (Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties1["dcri"] != 0)
{
amount = Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties1["dcri"];
Target.Character.Stat.CritParryRatio += amount;
}
}
else
{
amount = Data.SkillBase[Target.Character.Action.Buff.SkillID[slot]].Properties1["dcri"];
Target.Character.Stat.CritParryRatio -= amount;
}
if (UpdatePacket) Target.client.Send(Packet.PlayerStat(Target.Character));
}
catch (Exception ex)
{
Systems.Debugger.Write(ex);
}
}
public targetObject(object o, Systems player)
{
try
{
os = null;
o_x = 0;
o_y = 0;
magdef = 0;
phydef = 0;
type = false;
if (o == null) return;
main = player;
if (main == null) return;
if (o.GetType().ToString() == "DarkEmu_GameServer.obj")
{
os = o as obj;
if (os.Die) { player.StopAttackTimer(); return; }
o_x = (float)os.x;
o_y = (float)os.y;
xsec = os.xSec;
ysec = os.ySec;
magdef = Data.ObjectBase[os.ID].MagDef;
phydef = Data.ObjectBase[os.ID].PhyDef;
id = os.UniqueID;
type = false;
hps = os.HP;
state = os.State;
main.Character.Action.MonsterID.Add(os.UniqueID);
mabsrob = 0;
os.Target = player;
}
if (o.GetType().ToString() == "DarkEmu_GameServer.Systems")
{
sys = o as Systems;
o_x = sys.Character.Position.x;
o_y = sys.Character.Position.y;
xsec = sys.Character.Position.xSec;
ysec = sys.Character.Position.ySec;
magdef = sys.Character.Stat.MagDef;
phydef = sys.Character.Stat.PhyDef;
id = sys.Character.Information.UniqueID;
absorbphy = sys.Character.Stat.phy_Absorb;
absorbmag = sys.Character.Stat.mag_Absorb;
state = sys.Character.State.LastState;
hps = sys.Character.Stat.SecondHp;
type = true;
mabsrob = sys.Character.Stat.Absorb_mp;
}
}
catch (Exception ex)
{
Console.WriteLine("Target object error : {0}", ex);
Systems.Debugger.Write(ex);
}
}
/////////////////////////////////////////////////////////////////////////
//Formed party join response
/////////////////////////////////////////////////////////////////////////
void FormedResponse()
{
try
{
//Open our packet data reader
PacketReader reader = new PacketReader(PacketInformation.buffer);
int Requestermodel = reader.Int32();
int Characterid = reader.Int32();
byte responsetype = reader.Byte();
reader.Close();
//Get player information
Systems sys = GetPlayer(Characterid);
//If the requester is not in a party yet
if (sys.Character.Network.Party == null)
{
//If party doesnt excist anymore or is not listed anymore
if (Character.Network.Party != null)
{
//If not formed anymore
if (!Character.Network.Party.IsFormed)
{
//Send cannot find party message
sys.client.Send(Packet.IngameMessages(Systems.SERVER_PARTY_MESSAGES, IngameMessages.UIIT_MSG_PARTYERR_CANT_FIND_PARTY));
return;
}
}
//If party is null
else
{
//Send cannot find party message
sys.client.Send(Packet.IngameMessages(Systems.SERVER_PARTY_MESSAGES, IngameMessages.UIIT_MSG_PARTYERR_CANT_FIND_PARTY));
return;
}
//Accept new member
if (responsetype == 1)
{
//Check party type members allowed need message if full
if (Character.Network.Party.Type == 4 && Character.Network.Party.Members.Count > 3)
{
//Add msg party full
return;
}
if (Character.Network.Party.Type == 5 && Character.Network.Party.Members.Count > 7)
{
//Add msg party full
return;
}
//Send packets to creator and invited member
sys.client.Send(Packet.Party_Member(sys.Character.Information.UniqueID));
client.Send(Packet.PartyOwnerInformation(Character.Information.UniqueID));
//Set bools for check
Character.Information.CheckParty = true;
//Bool for requester
sys.Character.Information.CheckParty = true;
//Add member
Character.Network.Party.Members.Add(sys.Character.Information.UniqueID);
Character.Network.Party.MembersClient.Add(sys.client);
//Send packet for each member in party
foreach (int member in Character.Network.Party.Members)
{
if (member != 0)
{
Systems mainParty = GetPlayer(member);
//If the member is the owner
if (mainParty != null)
{
if (mainParty.Character.Information.CharacterID == Character.Information.CharacterID)
{
//Just send update packet
mainParty.client.Send(Packet.Party_DataMember(mainParty.Character.Network.Party));
}
//For other members
else
{
//Send member joined packet
mainParty.client.Send(Packet.JoinResponseMessage(1));
//Send update packet
mainParty.client.Send(Packet.Party_DataMember(Character.Network.Party));
//Set new party data
mainParty.Character.Network.Party = Character.Network.Party;
}
}
}
}
}
//Refuse
else
{
//If the party is a new party
if (sys.Character.Network.Party.Members.Count < 1)
{
Character.Information.CheckParty = false;
}
else
{
sys.client.Send(Packet.Party_Member(sys.Character.Information.UniqueID));
Character.Information.CheckParty = false;
}
}
}
}
catch (Exception ex)
{
Console.WriteLine("Formed response error {0}", ex);
Systems.Debugger.Write(ex);
}
}