/////////////////////////////////////////////////////////////////////////////////
// Friend add response
/////////////////////////////////////////////////////////////////////////////////
public void FriendAddResponse()
{
try
{
PacketReader reader = new PacketReader(PacketInformation.buffer);
int Inviterid = reader.Int32();
int Myid = reader.Int32();
byte State = reader.Byte();
reader.Close();
PlayerMgr sys = Helpers.GetInformation.GetPlayer(Inviterid);
if (sys != null)
{
if (State == 0)
{
//Declined
client.Send(Packet.FriendDecline(Character.Information.Name));
sys.client.Send(Packet.FriendDecline(Character.Information.Name));
}
else
{
//Accepted
sys.client.Send(Packet.FriendData(Myid, 2, Character.Information.Name, Character, false));
client.Send(Packet.FriendData(Inviterid, 2, sys.Character.Information.Name, sys.Character, false));
DB.query("INSERT INTO friends (owner,friend_name,model_info) VALUES ('" + Character.Information.CharacterID + "','" + sys.Character.Information.CharacterID + "','" + sys.Character.Information.Model + "')");
DB.query("INSERT INTO friends (owner,friend_name,model_info) VALUES ('" + sys.Character.Information.CharacterID + "','" + Character.Information.CharacterID + "','" + Character.Information.Model + "')");
}
}
}
catch (Exception ex)
{
Console.WriteLine("Friend Add Response Error {0}", ex);
Log.Exception(ex);
}
}
///////////////////////////////////////////////////////////////////////////
// Grabpet settings
///////////////////////////////////////////////////////////////////////////
public void GrabPetSettings()
{
//Not worked on yet.
PacketReader Reader = new PacketReader(PacketInformation.buffer);
int petid = Reader.Int32();
byte type = Reader.Byte();
int settingsinfo = Reader.Int32();
client.Send(Packet.ChangePetSettings(1, petid, type, settingsinfo));
}
public void RenameParty()
{
try
{
//Create new packet reader
PacketReader reader = new PacketReader(PacketInformation.buffer);
//First integer is party id
int partyid = reader.Int32();
//Second integer is not needed
int NotNeeded = reader.Int32();
//Byte party type
byte ptype = reader.Byte();
//Byte party purpose
byte purpose = reader.Byte();
//Byte minimum level
byte minlevel = reader.Byte();
//Byte max level to enter party
byte maxlevel = reader.Byte();
//Party name lenght
short namel = reader.Int16();
//Party name each character is a word value using text3
string pname = reader.Text3();
//Create new packet writer
PacketWriter Writer = new PacketWriter();
//Add opcode to server packet
Writer.Create(OperationCode.SERVER_PARTY_CHANGENAME);
//Write static byte 1
Writer.Byte(1);
//Write party id
Writer.DWord(partyid);
//Write dword 0
Writer.DWord(0);
//Write party type
Writer.Byte(ptype);
//Write party purpose
Writer.Byte(purpose);
//Write party minimum level
Writer.Byte(minlevel);
//Write party max level
Writer.Byte(maxlevel);
//Write party name
Writer.Text3(pname);
//Send bytes to client
client.Send(Writer.GetBytes());
}
//If a error happens
catch (Exception ex)
{
//Write the exception to the log
}
}
public void GuildTransferLeaderShip()
{
try
{
//Create new packet reader
PacketReader Reader = new PacketReader(PacketInformation.buffer);
//Read guild id
int Guildid = Reader.Int32();
//Read guild member id to transfer to
int GuildMemberID = Reader.Int32();
//Close reader
Reader.Close();
//Get detailed player information
PlayerMgr NewLeader = Helpers.GetInformation.GetPlayerid(GuildMemberID);
//Update database
DB.query("UPDATE guild_members SET guild_rank='10',guild_perm_join='0',guild_perm_withdraw='0',guild_perm_union='0',guild_perm_storage='0',guild_perm_notice='0' WHERE guild_member_id='" + Character.Information.CharacterID + "'");
DB.query("UPDATE guild_members SET guild_rank='0',guild_perm_join='1',guild_perm_withdraw='1',guild_perm_union='1',guild_perm_storage='1',guild_perm_notice='1' WHERE guild_member_id='" + GuildMemberID + "'");
//Repeat for each member in our guild
foreach (int member in Character.Network.Guild.Members)
{
//Make sure member is not null
if (member != 0)
{
//Get information for the guildmember
PlayerMgr guildmember = Helpers.GetInformation.GetPlayerMainid(member);
//Make sure the guildmember isnt null
if (guildmember != null)
{
//Send update packet of new leader
guildmember.client.Send(Packet.GuildUpdate(Character, 3, GuildMemberID, 0, 0));
}
}
}
//Send message to old owner
PacketWriter Writer = new PacketWriter();
//Add opcode
Writer.Create(OperationCode.SERVER_GUILD_TRANSFER_MSG);
//Static byte 1
Writer.Byte(1);
//Send bytes to client
client.Send(Writer.GetBytes());
}
//If a bad exception error happens
catch (Exception ex)
{
Log.Exception(ex);
}
}
/////////////////////////////////////////////////////////////////////////
// Union Apply
/////////////////////////////////////////////////////////////////////////
public void unionapply()
{
try
{
//Open our packet reader
PacketReader Reader = new PacketReader(PacketInformation.buffer);
//Get target id (Targeted).
int Target = Reader.Int32();
//Close reader
Reader.Close();
//Get target details
PlayerMgr targetplayer = Helpers.GetInformation.GetPlayer(Target);
//Make sure the target is still there
if (targetplayer != null)
{
//If allready in union
if (targetplayer.Character.Network.Guild.UnionActive) return;
//Set bools for both players
targetplayer.Character.State.UnionApply = true;
Character.State.UnionApply = true;
//Set target player to us
targetplayer.Character.Network.TargetID = Character.Information.UniqueID;
//Send request to targeted player
targetplayer.client.Send(Packet.PartyRequest(6, Character.Information.UniqueID, 0));
}
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
public void Mastery_Skill_Up()
{
PacketReader Reader = new PacketReader(PacketInformation.buffer);
int SkillID = Reader.Int32();
/*if (Array.Exists(ObjData.Manager.SkillBase, GetSkill => GetSkill.ID == SkillID) == false)
{
Console.WriteLine("SkillID bulunamadı:{0}", Character.Information.Name);
}
*/
if (Character.Information.SkillPoint < ObjData.Manager.SkillBase[SkillID].SkillPoint) { Console.WriteLine("SP LAZIM"); return; }
int check = DB.GetRowsCount("SELECT * FROM saved_skills WHERE skillid = " + SkillID + " AND owner=" + Character.Information.CharacterID);
if (check == 1)
{
client.Send(Packet.Message(OperationCode.SERVER_SKILL_UPDATE, Messages.UIIT_STT_SKILL_LEARN_MASTERY_LIMIT));
return;
}
else
{
Character.Stat.Skill.AmountSkill++;
Character.Stat.Skill.Skill[Character.Stat.Skill.AmountSkill] = SkillID;
}
if (SkillGetOpened(SkillID))
{
Character.Information.SkillPoint -= ObjData.Manager.SkillBase[SkillID].SkillPoint;
client.Send(Packet.InfoUpdate(2, Character.Information.SkillPoint, 0));
client.Send(Packet.SkillUpdate(SkillID));
client.Send(Packet.PlayerStat(Character));
SaveSkill(SkillID);
}
else
{
return;
}
}
public void MakeAlias()
{
try
{
///////////////////////////////////////////////////////////////////////////////////////////////////
PacketReader Reader = new PacketReader(PacketInformation.buffer);
int id = Reader.Int32();
byte type = Reader.Byte();
short nLenght = Reader.Int16();
string name = Reader.String(nLenght);
///////////////////////////////////////////////////////////////////////////////////////////////////
Console.WriteLine(name);
DB ms = new DB("SELECT * FROM character_jobs WHERE job_alias='" + name + "'");
int checkjob = ms.Count();
///////////////////////////////////////////////////////////////////////////////////////////////////
client.Send(Packet.MakeAlias(name, type));
if (checkjob == 0)
{
client.Send(Packet.MakeAlias(name, type));
DB.query("UPDATE character_jobs SET job_alias='" + name + "' WHERE character_name='" + Character.Information.Name + "'");
}
else if (checkjob >= 0)
{
client.Send(Packet.MakeAliasError(name, type));
}
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
public void JoinMerc()
{
try
{
DB ms = new DB("SELECT * FROM character_jobs WHERE character_name='" + Character.Information.Name + "'");
int checkjob = ms.Count();
if (checkjob == 0)
{
/////////////////////////////////////////////////////////////////////////////////////
PacketReader Reader = new PacketReader(PacketInformation.buffer);
int id = Reader.Int32();
byte type = Reader.Byte();
/////////////////////////////////////////////////////////////////////////////////////
client.Send(Packet.InfoUpdate(1, Character.Information.CharacterID, 0));
client.Send(Packet.JoinMerchant(id, type));
/////////////////////////////////////////////////////////////////////////////////////
DB.query("INSERT INTO character_jobs (character_name, job_type) VALUES ('" + Character.Information.Name + "','2')");
ms.Close();
}
else
{
// Not needed cant join job because excist
}
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
public void PartyAddmembers()
{
try
{
//Create new packet reader
PacketReader Reader = new PacketReader(PacketInformation.buffer);
//Read target id
int targetid = Reader.Int32();
//Close packet reader
Reader.Close();
//Get detailed information from target
PlayerMgr InvitedPlayer = Helpers.GetInformation.GetPlayer(targetid);
//Check if the targeted player allready is in a party.
if (InvitedPlayer.Character.Network.Party == null)
{
//Set target id of target player to our id
InvitedPlayer.Character.Network.TargetID = this.Character.Information.UniqueID;
//Send request
InvitedPlayer.client.Send(Packet.PartyRequest(2, Character.Information.UniqueID, Character.Network.Party.Type));
}
}
//Write bad exception errors
catch (Exception ex)
{
//Write error to the console.
Console.WriteLine(ex);
//Write error to the debug log
}
}
public void SelectObject()
{
try
{
if (Character.Information.Scroll) return;
PacketReader Reader = new PacketReader(PacketInformation.buffer);
int objectid = Reader.Int32();
if (objectid == 0) return;
//Character.Action.Target = objectid;
//if (Character.Position.Walking) StopPlayerMovementO(objectid);
if (objectid == Character.Information.UniqueID) return;
WorldMgr.Monsters o = Helpers.GetInformation.GetObject(objectid);
if (o != null)
{
byte[] bb = Packet.SelectObject(objectid, o.ID, o.LocalType, o.HP);
if (bb == null) return;
client.Send(bb);
//Character.Action.Object = o;
return;
}
PlayerMgr sys = Helpers.GetInformation.GetPlayers(objectid);
if (o == null && sys != null)
{
client.Send(Packet.SelectObject(objectid, 0, 5, sys.Character.Stat.Hp));
Character.Action.Object = sys;
return;
}
Reader.Close();
}
catch (Exception ex)
{
Console.WriteLine("Selectobject error: {0}", ex);
}
}
public void GuildWarGold()
{
PacketReader Reader = new PacketReader(PacketInformation.buffer);
int guildid = Reader.Int32();
Reader.Close();
if (Character.Guild.GuildWarGold == 0)
{
//Send Packet Message No War Gold Received
client.Send(Packet.GuildWarMsg(2));
}
else
{
//Sniff packet for war gold
}
}
void HandleRegisterIcon()
{
try
{
PacketReader reader = new PacketReader(PacketInformation.buffer);
byte type = reader.Byte();
int iconlenght = reader.Int32();
string icon = reader.Text();
reader.Close();
string convertedicon = ConvertToHex(icon);
//Save output to .dat file in hex formatting.
}
catch (Exception ex)
{
Console.WriteLine("Guild icon register error {0}", ex);
}
}
public void HandleClosePet()
{
try
{
PacketReader Reader = new PacketReader(PacketInformation.buffer);
int petid = Reader.Int32();
if (petid == Character.Transport.Horse.UniqueID)
{
Send(Packet.Player_UpToHorse(Character.Information.UniqueID, false, petid));
client.Send(Packet.PetSpawn(petid, 1, Character.Transport.Horse));
Character.Transport.Horse.DeSpawnMe();
Character.Transport.Right = false;
if (Character.Position.Walking) Timer.Movement.Dispose();
}
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
public static void ClientCheck(Definitions.Clientdefinition sys)
{
PacketReader Reader = new PacketReader(sys.PacketInformation.buffer);
byte Locale = Reader.Byte();
string Name = Reader.Text();
int Version = Reader.Int32();
Reader.Close();
try
{
if (Name == "SR_Client")
{
sys.client.Send(Core.Packets.Connect._1());
sys.client.Send(Core.Packets.Connect._2());
sys.client.Send(Core.Packets.Connect._3());
sys.client.Send(Core.Packets.Connect._4());
sys.client.Send(Core.Packets.Connect._5());
if (Version == Definitions.Serverdef.SilkroadClientVersion)//
{
sys.client.Send(Core.Packets.Connect.ActualVersion());
}
else if (Version < Definitions.Serverdef.SilkroadClientVersion - 1)//
{
sys.client.Send(Core.Packets.Connect.ClientIsToOld());
}
else if (Version > Definitions.Serverdef.SilkroadClientVersion)//
{
sys.client.Send(Core.Packets.Connect.ClientIsToNew());
}
else
{
//sys.client.Send(Patch.SendPatchFiles());
}
}
}
catch (Exception error)
{
Console.WriteLine("Connect.cs Error: {0}", error);
}
}
public void EnterStall()
{
try
{
if (Character.Information.Scroll) return;
PacketReader Reader = new PacketReader(PacketInformation.buffer);
PlayerMgr staller = Helpers.GetInformation.GetPlayer(Reader.Int32());
Character.Network.Stall = staller.Character.Network.Stall;
staller.Character.Network.Stall.Members.Add(Character.Information.UniqueID);
staller.Character.Network.Stall.MembersClient.Add(client);
client.Send(Packet.EnterStall(Character.Information.UniqueID, staller.Character.Network.Stall));
staller.Character.Network.Stall.Send(Packet.StallPlayerUpdate(Character.Information.UniqueID, 2), client);
Character.Stall.Stallactive = true;
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
public void GuildTitle()
{
//Wrap our function inside a catcher
try
{
//Extra hack check
if (Character.Network.Guild.Level < 4)
return;
//Create new packet reader
PacketReader Reader = new PacketReader(PacketInformation.buffer);
//Read integer guild member selected
int SelectedGuildMember = Reader.Int32();
//Read short lenght of title for guild member
short GuildMemberTitleLEN = Reader.Int16();
//Read string guild member title
string GuildMemberTitle = Reader.String(GuildMemberTitleLEN);
//Close packet reader
Reader.Close();
//Get selected guild member information
PlayerMgr playerinfo = Helpers.GetInformation.GetPlayerMainid(SelectedGuildMember);
//Make sure the character is still there
if (playerinfo.Character != null)
{
//Update database set new title
DB.query("UPDATE guild_members SET guild_grant='" + GuildMemberTitle + "' WHERE guild_member_id='" + playerinfo.Character.Information.CharacterID + "'");
//Send new character guild title update to each player in spawn reach
Send(Packet.GuildSetTitle(Character.Guild.GuildID, playerinfo.Character.Information.Name, GuildMemberTitle));
//Send Final packet to client
playerinfo.client.Send(Packet.GuildSetTitle2(Character.Guild.GuildID, SelectedGuildMember, GuildMemberTitle));
}
}
//Catch bad exception errors
catch (Exception ex)
{
Log.Exception(ex);
}
}
/////////////////////////////////////////////////////////////////////////////////
// Item Switch
/////////////////////////////////////////////////////////////////////////////////
public void ItemMain()
{
#region Item Actions
try
{
if (Character.State.Die || Character.Information.Scroll) return;
PacketReader Reader = new PacketReader(PacketInformation.buffer);
byte iType = Reader.Byte();
switch (iType)
{
case 0:
if (Character.State.Busy) return;
ItemMove(Reader.Byte(), Reader.Byte(), Reader.Int16());
break;
case 1:
ItemMoveInStorage(Reader.Byte(), Reader.Byte(), Reader.Int16());
break;
case 2:
Player_MoveItemToStorage(Reader.Byte(), Reader.Byte(), Reader.Int32());
break;
case 3:
Player_MoveStorageItemToInv(Reader.Byte(), Reader.Byte(), Reader.Int32());
break;
case 4:
ItemMoveToExhangePage(Reader.Byte());
break;
case 5:
ItemMoveExchangeToInv(Reader.Byte());
break;
case 8:
Player_BuyItem(Reader.Byte(), Reader.Byte(), Reader.Int16(), Reader.Int32());
break;
case 9:
Player_SellItem(Reader.Byte(), Reader.Int16(), Reader.UInt16());
break;
case 7:
if (Character.State.Busy) return;
Player_DropItem(Reader.Byte());
break;
case 10:
if (Character.State.Busy) return;
Player_DropGold(Reader.UInt64());
break;
case 11:
Player_TakeGoldW(iType, Reader.Int64());
break;
case 12:
Player_GiveGoldW(iType, Reader.Int64());
break;
case 13:
ItemExchangeGold(Reader.Int64());
break;
case 16:
MovePetToPet(Reader.Int32(), Reader.Byte(), Reader.Byte(), Reader.Int16());
break;
case 24:
//Player_BuyItemFromMall(Reader.Byte(), Reader.Byte(), Reader.Byte(), Reader.Byte(), Reader.Byte(), Reader.Text());
break;
case 26:
MoveItemFromPet(Reader.Int32(), Reader.Byte(), Reader.Byte());
break;
case 27:
MoveItemToPet(Reader.Int32(), Reader.Byte(), Reader.Byte());
break;
case 29:
ItemMoveInStorage(Reader.Byte(), Reader.Byte(), Reader.Int16());//Move inside guild storage
break;
case 30:
Player_MoveItemToStorage(Reader.Byte(), Reader.Byte(), Reader.Int32());//Move to guild storage
break;
case 31:
Player_MoveStorageItemToInv(Reader.Byte(), Reader.Byte(), Reader.Int32());//Move from guild storage
break;
case 32:
Player_GiveGoldW(iType, Reader.Int64());//Guild storage
break;
case 33:
Player_TakeGoldW(iType, Reader.Int64());//Guild storage
break;
case 35:
ItemAvatarUnEquip(Reader.Byte(), Reader.Byte());
break;
case 36:
ItemAvatarEquip(Reader.Byte(), Reader.Byte());
break;
default:
Print.Format("Unknown Item Function:{0}:{1}", iType, Decode.StringToPack(PacketInformation.buffer));
break;
}
Reader.Close();
}
catch (Exception ex)
{
Log.Exception(ex);
}
#endregion
}
public void ActionMain()
{
try
{
if (Character.State.Die) return;
PacketReader Reader = new PacketReader(PacketInformation.buffer);
byte type = Reader.Byte();
if (type != 2)
{
if (Character.Action.Cast) return;
if (Character.Information.Scroll) return;
switch (Reader.Byte())
{
case 1: // normal attack
if (Character.Action.nAttack) return;
if (Character.Action.sAttack) return;
if (Character.Transport.Right) return;
Reader.Byte();
int id = Reader.Int32();
Reader.Close();
object os = Helpers.GetInformation.GetObjects(id);
if (/*(Character.Action.Target == id && Timer.Attack != null) || */ id == Character.Information.UniqueID)
{
Reader.Close();
return;
}
Character.Action.PickUping = false;
Character.Action.Object = os;
Character.Action.nAttack = true;
Character.Action.Target = id;
StartAttackTimer();
break;
case 2://pickup
if (Character.Action.nAttack) return;
if (Character.Action.sAttack) return;
if (Character.Action.sCasting) return;
if (Character.Action.PickUping) return;
Reader.Byte();
int id2 = Reader.Int32();
Reader.Close();
Character.Action.Target = id2;
Character.Action.PickUping = true;
StartPickupTimer(1000);
break;
case 3://trace
if (Character.Action.sAttack) return;
if (Character.Action.sCasting) return;
if (Character.State.Sitting) return;
if (Character.Stall.Stallactive) return;
Reader.Byte();
int id3 = Reader.Int32();
Character.Action.Target = id3;
Reader.Close();
client.Send(Packet.ActionState(1, 1));
Character.Action.PickUping = false;
Player_Trace(id3);
break;
case 4://use skill
if (Character.Action.nAttack)
{
StopAttackTimer();
System.Threading.Thread.Sleep(300);
}
Character.Action.UsingSkillID = Reader.Int32();
SkillMain(Reader.Byte(), Reader);
break;
case 5:
int id4 = Reader.Int32();
byte b_index = SkillGetBuffIndex(id4);
SkillBuffEnd(b_index);
break;
default:
Console.WriteLine("ActionMain case: " + Reader.Byte());
break;
}
}
else
StopAttackTimer();
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
void SkillMain(byte type, PacketReader Reader)
{
try
{
if (!SkillGetOpened(Character.Action.UsingSkillID)) return;
client.Send(Packet.ActionState(1, 1));
switch (type)
{
case 1:
if (Character.Action.sAttack) return;
if (Character.Action.sCasting) return;
if (Character.Action.nAttack) StopAttackTimer();
if (!Base.Skill.CheckWeapon(Character.Information.Item.wID, Character.Action.UsingSkillID))
{
client.Send(Packet.Message(OperationCode.SERVER_ACTION_DATA, Messages.UIIT_SKILL_USE_FAIL_WRONGWEAPON));
client.Send(Packet.Messages2(OperationCode.SERVER_ACTIONSTATE, Messages.UIIT_SKILL_USE_FAIL_WRONGWEAPON));
return;
}
Character.Action.Target = Reader.Int32();
Character.Action.Skill.MainSkill = Character.Action.UsingSkillID;
Character.Action.UsingSkillID = 0;
Character.Action.Object = Helpers.GetInformation.GetObjects(Character.Action.Target);
if (ObjData.Manager.SkillBase[Character.Action.Skill.MainSkill].isAttackSkill)
{
Character.Action.Skill = Base.Skill.Info(Character.Action.Skill.MainSkill, Character);
if (!Character.Action.Skill.canUse || Character.Action.Target == Character.Information.UniqueID) return;
WorldMgr.Monsters o = null;
if (Character.Action.Object != null && Character.Action.Object.GetType().ToString() == "WorldMgr.Monsters")
{
o = Character.Action.Object as WorldMgr.Monsters;
//if (o.AgressiveDMG == null) o.AgressiveDMG = new List<_agro>();
//if (Character.Action.Skill.OzelEffect == 5 && o.State != 4) return;
//if (o.State == 4 && Character.Action.Skill.OzelEffect != 5) return;
}
if (o == null && Character.Action.Object != null && Character.Action.Object.GetType().ToString() == "CLGameServer.PlayerMgr")
{
if (!Character.Information.PvP || Character.State.Die) return;
PlayerMgr sys = Character.Action.Object as PlayerMgr;
//if (Character.Action.Skill.OzelEffect == 5 && sys.Character.State.LastState != 5) return;
//if (sys.Character.State.LastState == 4 && Character.Action.Skill.OzelEffect != 5) return;
}
Character.Action.sAttack = true;
ActionSkillAttack();
Reader.Close();
}
else
{
Character.Action.sAttack = true;
ActionSkill();
}
break;
case 0:
SkillBuff();
break;
case 2:
MovementSkill(Reader);
break;
default:
Console.WriteLine("Skillmain type: {0}", type);
break;
}
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
void MovementSkill(PacketReader Reader)
{
try
{
if (!Character.Action.movementskill)
{
Character.Action.movementskill = true;
MovementSkillTimer(ObjData.Manager.SkillBase[Character.Action.UsingSkillID].Properties1["tele"] + 500);
if (Character.Action.sAttack || Character.Action.sCasting) return;
if (Character.Stat.SecondMP < ObjData.Manager.SkillBase[Character.Action.UsingSkillID].Mana) { client.Send(Packet.ActionPacket(2, 4)); return; }
else
{
Character.Stat.SecondMP -= ObjData.Manager.SkillBase[Character.Action.UsingSkillID].Mana;
UpdateMp();
if (Timer.Movement != null) { Timer.Movement.Dispose(); Character.Position.Walking = false; }
byte xSec = Reader.Byte(), ySec = Reader.Byte();
int x = Reader.Int32(), z = Reader.Int32(), y = Reader.Int32();
Reader.Close();
float gamex = Formule.gamex((float)x, xSec);
float gamey = Formule.gamey((float)y, ySec);
float farkx = gamex - Character.Position.x;
float farky = gamey - Character.Position.y;
float hesapy = 0, hesapx = 0;
while (hesapx + hesapy < ObjData.Manager.SkillBase[Character.Action.UsingSkillID].Properties2["tele"] / 10)
{
Character.Position.x += (farkx / 30);
Character.Position.y += (farky / 30);
hesapx += Math.Abs((farkx / 30));
hesapy += Math.Abs((farky / 30));
}
PacketWriter Writer = new PacketWriter();
Writer.Create(OperationCode.SERVER_ACTION_DATA);
Writer.Byte(1);
Writer.Byte(2);
Writer.Byte(0x30);
int overid = Character.Ids.GetCastingID();
Writer.DWord(Character.Action.UsingSkillID);//skillid
Writer.DWord(Character.Information.UniqueID); //charid
Writer.DWord(overid);//overid
Writer.DWord(0);
Writer.Byte(8);
Writer.Byte(xSec);
Writer.Byte(ySec);
Writer.DWord(Formule.packetx(Character.Position.x, xSec));
Writer.DWord(0);
Writer.DWord(Formule.packety(Character.Position.y, ySec));
Send(Writer.GetBytes());
client.Send(Packet.ActionState(2, 0));
ObjectSpawnCheck();
}
}
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
public void JoinFormedParty()
{
try
{
PacketReader Reader = new PacketReader(PacketInformation.buffer);
//Packet reader party id
int PartyID = Reader.Int32();
Reader.Close();
//Checks
if (PartyID == 0) return;
//Get character id from the party id
int Playerid = Helpers.GetInformation.GetPartyleader(PartyID);
//Get character information
PlayerMgr sys = Helpers.GetInformation.GetPlayer(Playerid);
//Open the invite
sys.client.Send(Packet.JoinFormedRequest(Character, sys.Character));
}
catch (Exception ex)
{
Console.WriteLine("Formed party join error {0}", ex);
}
}
public 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
PlayerMgr sys = Helpers.GetInformation.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.Message(OperationCode.SERVER_PARTY_MESSAGES, Messages.UIIT_MSG_PARTYERR_CANT_FIND_PARTY));
return;
}
}
//If party is null
else
{
//Send cannot find party message
sys.client.Send(Packet.Message(OperationCode.SERVER_PARTY_MESSAGES, Messages.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)
{
PlayerMgr mainParty = Helpers.GetInformation.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);
}
}
void CharacterCreate()
{
//Start wrapper for catching errors
try
{
//Check the amount of characters created (If 4 then we return). Todo: Check if any message shows up.
if (DB.GetRowsCount("SELECT * FROM character WHERE account='" + Player.AccountName + "'") == 4)
return;
//Open our packet reader
PacketReader Reader = new PacketReader(PacketInformation.buffer);
byte tocheck = Reader.Byte();
string name = Reader.Text();
int model = Reader.Int32();
byte volume = Reader.Byte();
int[] Item = new int[4];
Item[0] = Reader.Int32();
Item[1] = Reader.Int32();
Item[2] = Reader.Int32();
Item[3] = Reader.Int32();
Reader.Close();
//Check player name
#region Check Name
//Check the character name before creation
if (CharacterCheck(name))
{
//If bad send informational packet
client.Send(Packet.CharacterName(4));
//Finally return.
return;
}
//Set and disable special characters
if (name.Contains("[")) return;
else if (name.Contains("GM")) return;
else if (name.Contains("]")) return;
else if (name.Contains("-")) return;
#endregion
//Begin creation for EU characters
#region European characters
//Check by model type to see what race we have.
if (model >= 14715 && model <= 14745)
{
//Insert the basic information into the database
DB.query("INSERT INTO character (account, name, chartype, volume, xsect, ysect, xpos, zpos, ypos, savearea,GuideData) VALUES ('" + Player.AccountName + "','" + name + "', '" + model + "', '" + volume + "','79','105','387','1000','1279','20','0000000000000000')");
//Insert reverse scroll data into the database
DB.query("INSERT INTO character_rev (charname, revxsec, revysec, revx, revy, revz) VALUES ('" + name + "','79','105','1000','22','83')");
//Set definition for the character id information
Player.CreatingCharID = Convert.ToInt32(DB.GetData("Select * from character Where name='" + name + "'", "id"));
//Set default information (TODO: Check if all chars have same base).
double MagDef = 3;
double PhyDef = 6;
double Parry = 11;
double Hit = 11;
double MinPhyA = 6;
double MaxPhyA = 9;
double MinMagA = 6;
double MaxMagA = 10;
//Open new framework ini reading
Ini ini;
//Open settings information for start items
ini = new Ini(Environment.CurrentDirectory + @"\Settings\Settings.ini");
//5 Items max for starting characters
string Item1 = ini.GetValue("European.Start", "Item1", "").ToString();
string Item2 = ini.GetValue("European.Start", "Item2", "").ToString();
string Item3 = ini.GetValue("European.Start", "Item3", "").ToString();
string Item4 = ini.GetValue("European.Start", "Item4", "").ToString();
string Item5 = ini.GetValue("European.Start", "Item5", "").ToString();
//The amount related information
string Amount1 = ini.GetValue("European.Start", "Amount1", "").ToString();
string Amount2 = ini.GetValue("European.Start", "Amount2", "").ToString();
string Amount3 = ini.GetValue("European.Start", "Amount3", "").ToString();
string Amount4 = ini.GetValue("European.Start", "Amount4", "").ToString();
string Amount5 = ini.GetValue("European.Start", "Amount5", "").ToString();
//Add the custom items
try
{
AddItem(Convert.ToInt32(Item1), Convert.ToByte(Amount1), 13, Player.CreatingCharID, 0);
AddItem(Convert.ToInt32(Item2), Convert.ToByte(Amount2), 14, Player.CreatingCharID, 0);
AddItem(Convert.ToInt32(Item3), Convert.ToByte(Amount3), 15, Player.CreatingCharID, 0);
AddItem(Convert.ToInt32(Item4), Convert.ToByte(Amount4), 16, Player.CreatingCharID, 0);
AddItem(Convert.ToInt32(Item5), Convert.ToByte(Amount5), 17, Player.CreatingCharID, 0);
}
catch (Exception)
{
}
//Add the base items
AddItem(Item[0], 0, 1, Player.CreatingCharID, 0);
AddItem(Item[1], 0, 4, Player.CreatingCharID, 0);
AddItem(Item[2], 0, 5, Player.CreatingCharID, 0);
AddItem(Item[3], 0, 6, Player.CreatingCharID, 0);
//Set mag defense
MagDef += ObjData.Manager.ItemBase[Item[0]].Defans.MinMagDef;
MagDef += ObjData.Manager.ItemBase[Item[1]].Defans.MinMagDef;
MagDef += ObjData.Manager.ItemBase[Item[2]].Defans.MinMagDef;
//Set phy defence
PhyDef += ObjData.Manager.ItemBase[Item[0]].Defans.MinPhyDef;
PhyDef += ObjData.Manager.ItemBase[Item[1]].Defans.MinPhyDef;
PhyDef += ObjData.Manager.ItemBase[Item[2]].Defans.MinPhyDef;
//Set parry information
Parry += ObjData.Manager.ItemBase[Item[0]].Defans.Parry;
Parry += ObjData.Manager.ItemBase[Item[1]].Defans.Parry;
Parry += ObjData.Manager.ItemBase[Item[2]].Defans.Parry;
//Set hit ratio
Hit += ObjData.Manager.ItemBase[Item[3]].Attack.MinAttackRating;
//Set phy attack
MinPhyA += ObjData.Manager.ItemBase[Item[3]].Attack.Min_LPhyAttack;
MaxPhyA += ObjData.Manager.ItemBase[Item[3]].Attack.Min_HPhyAttack;
//Set mag attack
MinMagA += ObjData.Manager.ItemBase[Item[3]].Attack.Min_LMagAttack;
MaxMagA += ObjData.Manager.ItemBase[Item[3]].Attack.Min_HMagAttack;
//If the 3rd item is a sword or a dark staff
if (Item[3] == 10730 || Item[3] == 10734)
{
//Add the mag def information
MagDef += ObjData.Manager.ItemBase[251].Defans.MinMagDef;
//Add the phy def information
PhyDef += ObjData.Manager.ItemBase[251].Defans.MinPhyDef;
//Add parry ration
Parry += ObjData.Manager.ItemBase[251].Defans.Parry;
//Add shield item
AddItem(10738, 0, 7, Player.CreatingCharID, 0);
}
//If the 3rd item is a crossbow
if (Item[3] == 10733)
{
//We add our base bolts 250
AddItem(10376, 250, 7, Player.CreatingCharID, 0);
}
//Update database information for stats
DB.query("update character set min_phyatk='" + (int)Math.Round(MinPhyA) +
"', max_phyatk='" + Math.Round(MaxPhyA) +
"', min_magatk='" + Math.Round(MinMagA) +
"', max_magatk='" + Math.Round(MaxMagA) +
"', phydef='" + Math.Round(PhyDef) +
"', magdef='" + Math.Round(PhyDef) +
"', parry='" + Math.Round(Parry) +
"', hit='" + Math.Round(Hit) +
"' where name='" + name + "'");
//Add base mastery's for europe characters
AddMastery(513, Player.CreatingCharID); //Warrior
AddMastery(515, Player.CreatingCharID); //Rogue
AddMastery(514, Player.CreatingCharID); //Wizard
AddMastery(516, Player.CreatingCharID); //Warlock
AddMastery(517, Player.CreatingCharID); //Bard
AddMastery(518, Player.CreatingCharID); //Cleric
client.Send(Packet.ScreenSuccess(1));
#endregion
}
//If the character model is an chinese character
else
{
#region Chinese characters
DB.query("INSERT INTO character (account, name, chartype, volume,GuideData) VALUES ('" + Player.AccountName + "','" + name + "', '" + model + "', '" + volume + "','0000000000000000')");
DB.query("INSERT INTO character_rev (charname, revxsec, revysec, revx, revy, revz) VALUES ('" + name + "','168','79','911','1083','-32')");
Player.CreatingCharID = Convert.ToInt32(DB.GetData("Select * from character Where name='" + name + "'", "id"));
#region Item
double MagDef = 3;
double PhyDef = 6;
double Parry = 11;
double Hit = 11;
double MinPhyA = 6;
double MaxPhyA = 9;
double MinMagA = 6;
double MaxMagA = 10;
CLFramework.Ini ini;
ini = new CLFramework.Ini(Environment.CurrentDirectory + @"\Settings\Settings.ini");
string Item1 = ini.GetValue("Chinese.Start", "Item1", "").ToString();
string Item2 = ini.GetValue("Chinese.Start", "Item2", "").ToString();
string Item3 = ini.GetValue("Chinese.Start", "Item3", "").ToString();
string Item4 = ini.GetValue("Chinese.Start", "Item4", "").ToString();
string Item5 = ini.GetValue("Chinese.Start", "Item5", "").ToString();
string Amount1 = ini.GetValue("Chinese.Start", "Amount1", "").ToString();
string Amount2 = ini.GetValue("Chinese.Start", "Amount2", "").ToString();
string Amount3 = ini.GetValue("Chinese.Start", "Amount3", "").ToString();
string Amount4 = ini.GetValue("Chinese.Start", "Amount4", "").ToString();
string Amount5 = ini.GetValue("Chinese.Start", "Amount5", "").ToString();
try
{
AddItem(Convert.ToInt32(Item1), Convert.ToByte(Amount1), 13, Player.CreatingCharID, 0);
AddItem(Convert.ToInt32(Item2), Convert.ToByte(Amount2), 14, Player.CreatingCharID, 0);
AddItem(Convert.ToInt32(Item3), Convert.ToByte(Amount3), 15, Player.CreatingCharID, 0);
AddItem(Convert.ToInt32(Item4), Convert.ToByte(Amount4), 16, Player.CreatingCharID, 0);
AddItem(Convert.ToInt32(Item5), Convert.ToByte(Amount5), 17, Player.CreatingCharID, 0);
}
catch (Exception)
{
}
AddItem(Item[0], 0, 1, Player.CreatingCharID, 0);
AddItem(Item[1], 0, 4, Player.CreatingCharID, 0);
AddItem(Item[2], 0, 5, Player.CreatingCharID, 0);
AddItem(Item[3], 0, 6, Player.CreatingCharID, 0);
MagDef += ObjData.Manager.ItemBase[Item[0]].Defans.MinMagDef;
MagDef += ObjData.Manager.ItemBase[Item[1]].Defans.MinMagDef;
MagDef += ObjData.Manager.ItemBase[Item[2]].Defans.MinMagDef;
PhyDef += ObjData.Manager.ItemBase[Item[0]].Defans.MinPhyDef;
PhyDef += ObjData.Manager.ItemBase[Item[1]].Defans.MinPhyDef;
PhyDef += ObjData.Manager.ItemBase[Item[2]].Defans.MinPhyDef;
Parry += ObjData.Manager.ItemBase[Item[0]].Defans.Parry;
Parry += ObjData.Manager.ItemBase[Item[1]].Defans.Parry;
Parry += ObjData.Manager.ItemBase[Item[2]].Defans.Parry;
Hit += ObjData.Manager.ItemBase[Item[3]].Attack.MinAttackRating;
MinPhyA += ObjData.Manager.ItemBase[Item[3]].Attack.Min_LPhyAttack;
MaxPhyA += ObjData.Manager.ItemBase[Item[3]].Attack.Min_HPhyAttack;
MinMagA += ObjData.Manager.ItemBase[Item[3]].Attack.Min_LMagAttack;
MaxMagA += ObjData.Manager.ItemBase[Item[3]].Attack.Min_HMagAttack;
if (Item[3] == 3632 || Item[3] == 3633)
{
MagDef += ObjData.Manager.ItemBase[251].Defans.MinMagDef;
PhyDef += ObjData.Manager.ItemBase[251].Defans.MinPhyDef;
Parry += ObjData.Manager.ItemBase[251].Defans.Parry;
AddItem(251, 0, 7, Player.CreatingCharID, 0);
}
if (Item[3] == 3636)
{
AddItem(62, 250, 7, Player.CreatingCharID, 0);
}
#endregion
DB.query("update character set min_phyatk='" + (int)Math.Round(MinPhyA) +
"', max_phyatk='" + Math.Round(MaxPhyA) +
"', min_magatk='" + Math.Round(MinMagA) +
"', max_magatk='" + Math.Round(MaxMagA) +
"', phydef='" + Math.Round(PhyDef) +
"', magdef='" + Math.Round(PhyDef) +
"', parry='" + Math.Round(Parry) +
"', hit='" + Math.Round(Hit) +
"' where name='" + name + "'");
AddMastery(257, Player.CreatingCharID); //blade
AddMastery(258, Player.CreatingCharID); //heuksal
AddMastery(259, Player.CreatingCharID); //bow
AddMastery(273, Player.CreatingCharID); //cold
AddMastery(274, Player.CreatingCharID); //light
AddMastery(275, Player.CreatingCharID); //fire
AddMastery(276, Player.CreatingCharID); //force
client.Send(Packet.ScreenSuccess(1));
#endregion
}
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
public 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.Message(OperationCode.SERVER_GUILD_WAIT, Messages.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.Message(OperationCode.SERVER_GUILD_PROMOTE_MSG, Messages.UIIT_MSG_ERROR_GUILD_LEVEL_UP_GOLD_DEFICIT));
return;
}
//Not enough guildpoints
if (Character.Network.Guild.PointsTotal < GuildPointRequired)
{
//Send client message
client.Send(Packet.Message(OperationCode.SERVER_GUILD_PROMOTE_MSG, Messages.UIIT_MSG_ERROR_GUILD_LEVEL_UP_GP_DEFICIT));
return;
}
//Max level
if (Character.Network.Guild.Level == 5)
{
//Send client message
client.Send(Packet.Message(OperationCode.SERVER_GUILD_PROMOTE_MSG, Messages.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
DB.query("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
PlayerMgr memberinfo = Helpers.GetInformation.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)
{
Log.Exception(ex);
}
}
public void PartyBan()
{
try
{
//Open our packet reader
PacketReader Reader = new PacketReader(PacketInformation.buffer);
int TargetID = Reader.Int32();
Reader.Close();
//Get targeted player information
PlayerMgr s = Helpers.GetInformation.GetPlayers(TargetID);
//Remove id of the member
Character.Network.Party.Members.Remove(s.Character.Information.UniqueID);
//Remove the client of the member
Character.Network.Party.MembersClient.Remove(s.client);
//Repeat for each member the updated party information
foreach (int partymember in Character.Network.Party.Members)
{
//Get player information for the next member
PlayerMgr partym = Helpers.GetInformation.GetPlayer(partymember);
//Remove the kicked player
partym.Character.Network.Party.Members.Remove(s.Character.Information.UniqueID);
partym.Character.Network.Party.MembersClient.Remove(s.client);
//If we have one member remaining in the party we disband the party
if (partym.Character.Network.Party.Members.Count == 1)
{
//If its formed in the list remove the listening
if (partym.Character.Network.Party.IsFormed)
partym.DeleteFormedParty(Character.Network.Party.ptid);
//Send update packet to the party member
partym.client.Send(Packet.Party_Data(1, 0));
//Send update packet to the current player
client.Send(Packet.Party_Data(1, 0));
//Set party to null for the current player
Character.Network.Party = null;
//Set party to null for the remaining member
partym.Character.Network.Party = null;
//Set bool for current player
Character.Information.CheckParty = false;
//Set bool for the remaining party member
partym.Character.Information.CheckParty = false;
}
//If there are more members (Not autodisband party).
else
{
//Send the update packet to the party member
partym.client.Send(Packet.Party_Data(3, TargetID));
}
}
//Set the kicked player bool to false
s.Character.Information.CheckParty = false;
//Remove the party network for the kicked player
s.Character.Network.Party = null;
//Send update packet to the kicked player
s.client.Send(Packet.Party_Data(1, 0));
}
catch (Exception ex)
{
Console.WriteLine("Party Ban Error {0}", ex);
}
}
//###########################################################################################
// Start teleporting
//###########################################################################################
public void Teleport_Start()
{
try
{
lock (this)
{
//Checks before we continue
if (Character.Action.PickUping) return;
//Timer checks
StopTimers();
//Open the packet reader
PacketReader Reader = new PacketReader(PacketInformation.buffer);
//Teleport id
int teleportidinfo = Reader.Int32();
//Number
byte number = Reader.Byte();
//Teleport selected
int teleportselect = Reader.Int32();
Reader.Close();
//Find price information
int price = ObjData.Manager.TeleportPrice.Find(pc => (pc.ID == number)).price;
//If the user has less gold then it costs
if (Character.Information.Gold < price)
{
//Send error message
client.Send(Packet.Message(OperationCode.SERVER_TELEPORTSTART, Messages.UIIT_MSG_INTERACTION_FAIL_NOT_ENOUGH_MONEY));
return;
}
//If the user level is lower then the required level
if (ObjData.Manager.TeleportPrice.Find(dd => (dd.ID == teleportselect)).level > 0 && Character.Information.Level < ObjData.Manager.TeleportPrice.Find(dd => (dd.ID == teleportselect)).level)
{
client.Send(Packet.Message(OperationCode.SERVER_TELEPORTSTART, Messages.UIIT_MSG_INTERACTION_FAIL_OUT_OF_REQUIRED_LEVEL_FOR_TELEPORT));
return;
}
//If the user is currently with job transport (TODO).
//Update players gold
Character.Information.Gold -= price;
//Update players gold in database
SaveGold();
//Close buffs
BuffAllClose();
//Send teleport packet #1
client.Send(Packet.TeleportStart());
//Set state
Character.InGame = false;
//Update location
Teleport_UpdateXYZ(Convert.ToByte(teleportselect));
//Despawn objects
ObjectDeSpawnCheck();
//Despawn player to other players
DeSpawnMe();
//Required
client.Send(Packet.TeleportStart2());
//Send loading screen image
client.Send(Packet.TeleportImage(ObjData.Manager.PointBase[Convert.ToByte(teleportselect)].xSec, ObjData.Manager.PointBase[Convert.ToByte(teleportselect)].ySec));
//Set bool
Character.Teleport = true;
/*
List<ObjData.slotItem> EquipedItems = new List<ObjData.slotItem>();
for (byte q = 0; q < 8; q++)
{
EquipedItems.Add(GetItem((uint)Character.Information.CharacterID, q, 0));
}
for (byte qp = 9; qp < 14; qp++)
{
EquipedItems.Add(GetItem((uint)Character.Information.CharacterID, qp, 0));
}
//Needs fixing will check it later.
/*foreach (ObjData.slotItem sitem in EquipedItems)
{
if (ObjData.Manager.ItemBlue[sitem.dbID].totalblue > 0)
{
LoadBluesid(sitem.dbID);
AddRemoveBlues(this, sitem, false);
}
}*/
}
}
catch (Exception ex)
{
Console.WriteLine("Teleport select error {0}", ex);
Log.Exception(ex);
}
}
public static void PlayerQuickBar(PacketWriter Writer, int ID)
{
PacketReader Reader = new PacketReader(System.IO.File.ReadAllBytes(Environment.CurrentDirectory + @"\PlayerData\Hotkey\" + ID + ".ClientSettings"));
byte amm = 0;
int[] skillid = new int[51];
byte[] slotn = new byte[51];
for (byte i = 0; i <= 50; i++)
{
slotn[i] = Reader.Byte();
if (slotn[i] != 0)
{
skillid[i] = Reader.Int32();
amm++;
}
else Reader.Skip(4);
}
Writer.Byte(amm);
for (byte i = 0; i <= 50; i++)
{
if (slotn[i] != 0)
{
Writer.Byte(i);
Writer.Byte(slotn[i]);
Writer.DWord(skillid[i]);
}
}
Reader.Close();
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Job Ranks
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public void RankList()
{
try
{
PacketReader Reader = new PacketReader(PacketInformation.buffer);
/////////////////////////////////////////////////////////////////////////////////////
int Notneeded = Reader.Int32();
byte Type = Reader.Byte();
byte Choice = Reader.Byte();
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
// Rank Trader
/////////////////////////////////////////////////////////////////////////////////////
if (Type == 1)
{
/////////////////////////////////////////////////////////////////////////////////////
// Rank Trader Merchant Activity
/////////////////////////////////////////////////////////////////////////////////////
if (Choice == 0)
{
try
{
DB readsql = new DB("SELECT TOP 50 * FROM rank_job_activity WHERE job_type='1'");
int begin = 0;
int count = readsql.Count();
using (SqlDataReader readinfo = readsql.Read())
{
while (readinfo.Read())
{
for (begin = 0; begin < count; )
{
begin++;
if (begin.Equals(count))
{
client.Send(Packet.RankListsActivityTrader());
return;
}
}
return;
}
}
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
/////////////////////////////////////////////////////////////////////////////////////
// Rank Trader Weekly Donation
/////////////////////////////////////////////////////////////////////////////////////
else if (Choice == 1)
{
try
{
DB readsql = new DB("SELECT TOP 50 * FROM rank_job_donate WHERE job_type='1'");
int begin = 0;
int count = readsql.Count();
using (SqlDataReader readinfo = readsql.Read())
{
while (readinfo.Read())
{
for (begin = 0; begin < count; )
{
begin++;
if (begin.Equals(count))
{
client.Send(Packet.RankListsDonateTrader());
return;
}
}
return;
}
}
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
// Rank List Thief
/////////////////////////////////////////////////////////////////////////////////////
else if (Type == 3)
{
/////////////////////////////////////////////////////////////////////////////////////
// Rank List Thief Activity
/////////////////////////////////////////////////////////////////////////////////////
if (Choice == 0)
{
try
{
DB readsql = new DB("SELECT TOP 50 * FROM rank_job_activity WHERE job_type='3'");
int begin = 0;
int count = readsql.Count();
using (SqlDataReader readinfo = readsql.Read())
{
while (readinfo.Read())
{
for (begin = 0; begin < count; )
{
begin++;
if (begin.Equals(count))
{
client.Send(Packet.RankListsActivityThief());
return;
}
}
return;
}
}
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
/////////////////////////////////////////////////////////////////////////////////////
// Rank List Thief Weekly Donation
/////////////////////////////////////////////////////////////////////////////////////
else if (Choice == 1)
{
try
{
DB readsql = new DB("SELECT TOP 50 * FROM rank_job_donate WHERE job_type='2'");
int begin = 0;
int count = readsql.Count();
using (SqlDataReader readinfo = readsql.Read())
{
while (readinfo.Read())
{
for (begin = 0; begin < count; )
{
begin++;
if (begin.Equals(count))
{
client.Send(Packet.RankListsDonateThief());
return;
}
}
return;
}
}
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
// Rank List Hunter
/////////////////////////////////////////////////////////////////////////////////////
else if (Type == 2) //Type 2 = Hunter
{
/////////////////////////////////////////////////////////////////////////////////////
// Rank List Hunter Activity
/////////////////////////////////////////////////////////////////////////////////////
if (Choice == 0)
{
try
{
DB readsql = new DB("SELECT TOP 50 * FROM rank_job_activity WHERE job_type='2'");
int begin = 0;
int count = readsql.Count();
using (SqlDataReader readinfo = readsql.Read())
{
while (readinfo.Read())
{
for (begin = 0; begin < count; )
{
begin++;
if (begin.Equals(count))
{
client.Send(Packet.RankListsActivityHunter());
return;
}
}
return;
}
}
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
/////////////////////////////////////////////////////////////////////////////////////
// Rank List Hunter Weekly Contribution
/////////////////////////////////////////////////////////////////////////////////////
else if (Choice == 1)
{
try
{
DB readsql = new DB("SELECT TOP 50 * FROM rank_job_donate WHERE job_type='3'");
int begin = 0;
int count = readsql.Count();
using (SqlDataReader readinfo = readsql.Read())
{
while (readinfo.Read())
{
for (begin = 0; begin < count; )
{
begin++;
if (begin.Equals(count))
{
client.Send(Packet.RankListsDonateHunter());
return;
}
}
return;
}
}
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
}
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
public 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
PlayerMgr InvitedPlayer = Helpers.GetInformation.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
WorldMgr.party Party = new WorldMgr.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
}
}
public void DeleteFormedParty(int partynetid)
{
try
{
//If the party is beeing deleted manually from listening
if (partynetid == 0)
{
//Read our packet data
PacketReader Reader = new PacketReader(PacketInformation.buffer);
//Read party id integer
int partyid = Reader.Int32();
//Close packet reader
Reader.Close();
//Find the related party id
Helpers.Manager.Party.Remove(Helpers.Manager.Party.Find(delegate (WorldMgr.party pt)
{
//If found return the information
return pt.IsFormed && (pt.ptid == partyid);
}));
//Send removal packet for listening
PacketWriter Writer = new PacketWriter();
Writer.Create(OperationCode.SERVER_DELETE_FORMED_PARTY);
Writer.Byte(1);
Writer.DWord(partyid);
client.Send(Writer.GetBytes());
//Set party state
Character.Network.Party.IsFormed = false;
}
//If listening is deleted due to auto disband
else
{
//Find the related party given from partynetid
Helpers.Manager.Party.Remove(Helpers.Manager.Party.Find(delegate (WorldMgr.party pt)
{
//Return information
return pt.IsFormed && (pt.ptid == partynetid);
}));
//Remove from listening
PacketWriter Writer = new PacketWriter();
Writer.Create(OperationCode.SERVER_DELETE_FORMED_PARTY);
Writer.Byte(1);
Writer.DWord(partynetid);
client.Send(Writer.GetBytes());
//Set party state
Character.Network.Party.IsFormed = false;
}
//If theres only one member leave and remove party data
if (Character.Network.Party.Members.Count == 1)
{
Character.Network.Party.Members.Remove(Character.Information.UniqueID);
Character.Network.Party.MembersClient.Remove(client);
Character.Network.Party = null;
}
}
//Catch bad exception errors
catch (Exception ex)
{
Log.Exception(ex);
}
}
