public static ushort LoginUser(string aID, ref string aPass, ref WorldMgr.player aPlayer, bool localConnect)
{
if (Helpers.Manager.clients.Count >= Helpers.Manager.maxSlots)
{
return 0; // crowded
}
DB ms = new DB("SELECT * FROM users WHERE id = '" + aID + "'");
if (ms.Count() == 0)
{
ms.Close();
return 1;
}
ms = new DB("SELECT * FROM users WHERE id = '" + aID + "' AND password='******'");
if (ms.Count() == 0)
{
ms.Close();
return 5;
}
using (System.Data.SqlClient.SqlDataReader reader = ms.Read())
{
while (reader.Read())
{
if (reader.GetString(1).ToLower() == aID.ToLower()) // id
{
if (reader.GetByte(3) == 1) // online
{
ms.Close();
return 2; // already online
}
if (reader.GetInt32(5) == 1) // banned
{
aPass = reader.GetString(4);
ms.Close();
return 3; // banned
}
if (aPlayer == null && localConnect) DB.query("UPDATE users SET online=1 WHERE userid='" + reader.GetInt32(0) + "'");
aPlayer = new WorldMgr.player();
aPlayer.AccountName = aID;
aPlayer.Password = aPass; // Nukei: ?? whats the reason for saving password in memory ?
aPlayer.ID = reader.GetInt32(0);
aPlayer.pGold = reader.GetInt64(7);
aPlayer.Silk = reader.GetInt32(6);
aPlayer.SilkPrem = reader.GetInt32(9);
aPlayer.wSlots = reader.GetByte(11);
ms.Close();
return 4;
}
}
}
ms.Close();
return 6; // Bilinmeyen geri dönüş:Özel bir durum oluşmadı. (Mecburi Gönderim)
}
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);
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Private Message Open
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public void PrivateMessageOpen()
{
try
{
PacketReader Reader = new PacketReader(PacketInformation.buffer);
/////////////////////////////////////////////////////////////////////////////////////
byte type = Reader.Byte();
short typeget = (short)type;
Reader.Close();
DB ms = new DB("SELECT * FROM message WHERE receiver='" + Character.Information.Name + "' AND idinfo ='" + typeget + "'");
using (SqlDataReader reader = ms.Read())
{
while (reader.Read())
{
string messageinfo = reader.GetString(3);
client.Send(Packet.PrivateMessageOpen(type, messageinfo));
DB.query("UPDATE message SET status='1' WHERE receiver='" + Character.Information.Name + "' AND idinfo ='" + type + "'");
}
}
ms.Close();
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
public static byte[] PrivateMessageCheck(WorldMgr.character c)
{
DB ms = new DB("SELECT * FROM message WHERE receiver='" + c.Information.Name + "'");
PacketWriter Writer = new PacketWriter();
int count = ms.Count();
Writer.Create(OperationCode.SERVER_PM_MESSAGE);
Writer.Byte(1);//Static
Writer.Byte(Convert.ToByte(count));//Total count
using (System.Data.SqlClient.SqlDataReader reader = ms.Read())
{
while (reader.Read())
{
string pmfrom = reader.GetString(1);
string pmto = reader.GetString(2);
string pmmessage = reader.GetString(3);
byte pmstatus = reader.GetByte(4);
DateTime pmdate = Convert.ToDateTime(reader.GetDateTime(5));
Writer.Text(pmfrom); // Message From
Writer.DWord(0x8A070000); // date
Writer.DWord(0xC7058401); // date
Writer.Byte(pmstatus); // Status (0 = Unread) (1 = Read)
}
ms.Close();
}
return Writer.GetBytes();
}
public static byte[] OpenWarehouse2(byte storageslots, WorldMgr.player c)
{
PacketWriter Writer = new PacketWriter();
Writer.Create(OperationCode.SERVER_OPEN_WAREPROB);
Writer.Byte(storageslots);
DB ms = new DB("SELECT * FROM char_items WHERE storageacc='" + c.ID + "' AND storagetype='1'");
Writer.Byte(ms.Count());
using (System.Data.SqlClient.SqlDataReader reader = ms.Read())
{
while (reader.Read())
Item.AddItemPacket(Writer, reader.GetByte(5), reader.GetInt32(2), reader.GetByte(4), reader.GetInt16(6), reader.GetInt32(7), reader.GetInt32(0), reader.GetInt32(9),reader.GetInt32(30));
}
ms.Close();
return Writer.GetBytes();
}
public static byte[] HonorRank(WorldMgr.character c)
{
DB ms = new DB("SELECT * FROM rank_honor");
PacketWriter Writer = new PacketWriter();
int countinfo = ms.Count();
Writer.Create(OperationCode.SERVER_HONOR_RANK);
Writer.Byte(1);
int i = 0;
Writer.Byte(Convert.ToByte(countinfo));
using (SqlDataReader reader = ms.Read())
{
while (reader.Read())
{
byte rankicon = reader.GetByte(1);
string rankname = reader.GetString(2);
byte ranklevel = reader.GetByte(3);
byte ranklevelc = reader.GetByte(4);
int graduatesc = reader.GetInt32(5);
int rankposc = reader.GetInt32(6);
Writer.DWord(i + 1);
Writer.Byte(rankicon);
Writer.Text(rankname);
Writer.Byte(ranklevel);
Writer.Byte(ranklevelc);
Writer.DWord(graduatesc);
//If player has no guild, we write a 0 word value
if (c.Network.Guild.Name == null)
{
Writer.Word(0);
}
//If player has a guild we write the guild name.
else
{
Writer.Text(c.Network.Guild.Name);
}
i++;
}
ms.Close();
}
return Writer.GetBytes();
}
///////////////////////////////////////////////////////////////////////////
// Grab pet information packet
///////////////////////////////////////////////////////////////////////////
public static byte[] Pet_Information_grab(CLGameServer.WorldMgr.pet_obj o, byte slot)
{
PacketWriter Writer = new PacketWriter();
Writer.Create(OperationCode.SERVER_PET_INFORMATION);
try
{
//////////////////////////////////////////////////////////////////////////////////////
// Grabpet structure
//////////////////////////////////////////////////////////////////////////////////////
Writer.DWord(o.UniqueID); //Unique ID
Writer.DWord(o.Model); //Pet Model
Writer.DWord(0x00006D); //Settings
Writer.DWord(0x00006D); //Settings
Writer.DWord(0x000047); //Settings 0x47 grab pet active 0 disabled
if (o.Petname != "No name") //###############
Writer.Text(o.Petname); // Name region
else //
Writer.Word(0); //###############
Writer.Byte(o.Slots); //Slots count inventory pet
//////////////////////////////////////////////////////////////////////////////////////
// Grabpet item inventory
//////////////////////////////////////////////////////////////////////////////////////
DB ms = new DB("SELECT * FROM char_items WHERE owner='" + o.OwnerID + "' AND pet_storage_id='" + o.UniqueID + "'");
Writer.Byte(ms.Count());
using (System.Data.SqlClient.SqlDataReader reader = ms.Read())
{
while (reader.Read())
Item.AddItemPacket(Writer, reader.GetByte(5), reader.GetInt32(2), reader.GetByte(4), reader.GetInt16(6), reader.GetInt32(7), reader.GetInt32(0), reader.GetInt32(9), reader.GetInt32(30));
}
ms.Close();
//////////////////////////////////////////////////////////////////////////////////////
// Other
//////////////////////////////////////////////////////////////////////////////////////
Writer.DWord(o.OwnerID); //Character ID
Writer.Byte(slot); //Slot location of the pet
//////////////////////////////////////////////////////////////////////////////////////
}
catch (Exception ex)
{
Log.Exception(ex);
}
return Writer.GetBytes();
}
public static void PrivateItemPacket(PacketWriter Writer, int id, byte max, byte avatar, bool mspawn)
{
try
{
List<byte> slots = new List<byte>();
DB ms = new DB("SELECT * FROM char_items WHERE owner='" + id + "' AND slot >= '0' AND slot <= '" + max + "' AND inavatar='" + avatar + "' AND storagetype='0' AND quantity='1'");
using (System.Data.SqlClient.SqlDataReader reader = ms.Read())
{
int count = ms.Count();
Writer.Byte(count);
while (reader.Read())
{
byte slot = reader.GetByte(5);
byte plusvalue = reader.GetByte(4);
int itemid = reader.GetInt32(2);
if (itemid != 0)
{
if (!slots.Exists(delegate (byte bk)
{
return bk == slot;
}))
{
slots.Add(slot);
}
Writer.DWord(itemid);
Writer.Byte(plusvalue);
}
}
}
ms.Close();
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
//###########################################################################################
// Reverse scrolls
//###########################################################################################
void HandleReverse(int itemid ,byte select, int objectlocationid)
{
try
{
//Remove loc // add loc to case 7
if (Character.Position.Walking) return;
if (Character.Action.PickUping) return;
if (Character.Stall.Stallactive) return;
Character.Information.Scroll = true;
switch (select)
{
//Move to return point
case 2:
Send(Packet.StatePack(Character.Information.UniqueID, 0x0B, 0x01, false));
StartScrollTimer(1000);
SavePlayerReturn();
break;
//Move to last recall point
case 3:
DB ms = new DB("SELECT * FROM character_rev WHERE charname='" + Character.Information.Name + "'");
using (SqlDataReader reader = ms.Read())
{
while (reader.Read())
{
byte xSec = reader.GetByte(2);
byte ySec = reader.GetByte(3);
float x = reader.GetInt32(4);
float z = reader.GetInt32(6);
float y = reader.GetInt32(5);
BuffAllClose();
DeSpawnMe();
ObjectDeSpawnCheck();
client.Send(Packet.TeleportOtherStart());
Character.Position.xSec = xSec;
Character.Position.ySec = ySec;
Character.Position.x = x;
Character.Position.z = z;
Character.Position.y = y;
UpdateXY();
client.Send(Packet.TeleportImage(xSec, ySec));
Character.Teleport = true;
Timer.Scroll = null;
Character.Information.Scroll = false;
}
}
ms.Close();
break;
//Teleport to map location
case 7:
BuffAllClose();
DeSpawnMe();
ObjectDeSpawnCheck();
client.Send(Packet.TeleportOtherStart());
//TODO: Check formula coords are a bit off
Character.Position.xSec = ObjData.Manager.ReverseData[objectlocationid].xSec;
Character.Position.ySec = ObjData.Manager.ReverseData[objectlocationid].ySec;
Character.Position.x = (float)ObjData.Manager.ReverseData[objectlocationid].x;
Character.Position.z = (float)ObjData.Manager.ReverseData[objectlocationid].z;
Character.Position.y = (float)ObjData.Manager.ReverseData[objectlocationid].y;
UpdateXY();
client.Send(Packet.TeleportImage(ObjData.Manager.ReverseData[objectlocationid].xSec, ObjData.Manager.ReverseData[objectlocationid].ySec));
Character.Teleport = true;
Timer.Scroll = null;
Character.Information.Scroll = false;
break;
}
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Repair Items
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void HandleRepair(byte slot, int itemid)
{
try
{
//Here we use 2nd check for item durability to be sure the item repair is needed.
//Check max durability on items < Need to check later for stats
double checkdurability = ObjData.Manager.ItemBase[itemid].Defans.Durability;
//Load our items
DB ms = new DB("SELECT * FROM char_items WHERE owner='" + Character.Information.CharacterID + "'");
using (System.Data.SqlClient.SqlDataReader reader = ms.Read())
{
while (reader.Read())
{
//Read durability from db
int currentdurability = reader.GetInt32(7);
//If durability is lower then item durability
if (currentdurability < checkdurability)
{
//Send repair packet to client
client.Send(Packet.RepairItems(slot, checkdurability));
//Update database information
DB.query("UPDATE char_items SET durability='" + checkdurability + "' WHERE id='" + itemid + "' AND owner='" + Character.Information.CharacterID + "' AND storagetype='0'");
}
}
}
ms.Close();
}
catch (Exception ex)
{
Console.WriteLine("Repair item error {0}", ex);
Log.Exception(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
ObjData.guild_player PlayerGuild = new ObjData.guild_player();
//Set guildmember id
PlayerGuild.MemberID = Guildmember;
//Create new DB query to get player information
DB ms = new DB("SELECT * FROM character WHERE id='" + Guildmember + "'");
//Create DB 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
PlayerMgr sys = Helpers.GetInformation.GetPlayerMainid(Guildmember);
//Make sure sys is not null
if (sys != null)
//Add the character client to the client list
if (!this.Character.Network.Guild.MembersClient.Contains(sys.client))
Character.Network.Guild.MembersClient.Add(sys.client);
}
}
}
//Create new query to select from table guild_members
ms = new DB("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 DB
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
}
}
public void LoadPlayerGuildInfo(bool logon)
{
try
{
DB ms = new DB("SELECT * FROM guild_members WHERE guild_member_id='" + Character.Information.CharacterID + "'");
using (System.Data.SqlClient.SqlDataReader reader = ms.Read())
{
while (reader.Read())
{
Character.Network.Guild.Guildid = reader.GetInt32(1);
Character.Network.Guild.GrantName = reader.GetString(5);
Character.Network.Guild.FWrank = reader.GetByte(6);
Character.Network.Guild.DonateGP = reader.GetInt32(4);
Character.Network.Guild.LastDonate = Character.Network.Guild.DonateGP;
Character.Network.Guild.joinRight = (reader.GetByte(7) == 1);
Character.Network.Guild.withdrawRight = (reader.GetByte(8) == 1);
Character.Network.Guild.unionRight = (reader.GetByte(9) == 1);
Character.Network.Guild.guildstorageRight = (reader.GetByte(10) == 1);
Character.Network.Guild.noticeeditRight = (reader.GetByte(11) == 1);
}
}
ms = new DB("SELECT * FROM guild WHERE id='" + Character.Network.Guild.Guildid + "'");
using (System.Data.SqlClient.SqlDataReader reader2 = ms.Read())
{
while (reader2.Read())
{
Character.Network.Guild.Name = reader2.GetString(1);
Character.Network.Guild.Level = reader2.GetByte(2);
Character.Network.Guild.PointsTotal = reader2.GetInt32(3);
Character.Network.Guild.NewsTitle = reader2.GetString(4);
Character.Network.Guild.NewsMessage = reader2.GetString(5);
Character.Network.Guild.StorageSlots = reader2.GetInt32(7);
Character.Network.Guild.Wargold = reader2.GetInt32(8);
Character.Network.Guild.StorageGold = reader2.GetInt64(11);
Character.Network.Guild.GuildOwner = reader2.GetInt32(9);
}
}
ms = new DB("SELECT * FROM guild_members WHERE guild_id='" + Character.Network.Guild.Guildid + "'");
Character.Network.Guild.TotalMembers = Convert.ToByte(ms.Count());
ms.Close();
//Set max players allowed in guild
switch (Character.Network.Guild.Level)
{
case 1:
Character.Network.Guild.MaxMembers = 20;
break;
case 2:
Character.Network.Guild.MaxMembers = 25;
break;
case 3:
Character.Network.Guild.MaxMembers = 30;
break;
case 4:
Character.Network.Guild.MaxMembers = 35;
break;
case 5:
Character.Network.Guild.MaxMembers = 50;
break;
}
//Only load on player login
if (logon)
{
LoadGuildMembers();
}
}
catch (Exception ex)
{
Console.WriteLine("LoadPlayerGuildInfo error {0}", ex);
}
}
/////////////////////////////////////////////////////////////////////////////////
// Avatar Equiped
/////////////////////////////////////////////////////////////////////////////////
void ItemAvatarEquip(byte fromSlot, byte toSlot)
{
#region Avatar equiped
try
{
GetFreeSlot();
ObjData.slotItem toItem = new ObjData.slotItem();
ObjData.slotItem fromItem = GetItem((uint)Character.Information.CharacterID, fromSlot, 0);
DB ms = new DB("SELECT * FROM char_items WHERE itemnumber='avatar" + toSlot + "' AND owner='" + Character.Information.CharacterID + "'");
using (System.Data.SqlClient.SqlDataReader reader = ms.Read())
{
while (reader.Read())
{
toItem.ID = reader.GetInt32(2);
toItem.dbID = reader.GetInt32(0);
}
}
ms.Close();
if (toItem.ID != 0) return;
if (fromItem.ID == 0) return;
if (!CheckGender(Character.Information.Model, fromItem.ID))
{
return;
}
else
{
string nonquery = "UPDATE char_items SET itemnumber='avatar" + toSlot + "',inAvatar='1',slot='" + toSlot + "' WHERE owner='" + Character.Information.CharacterID + "' AND itemnumber='item" + fromSlot + "' AND id='" + fromItem.dbID + "'";
DB.query(nonquery);
}
Send(Packet.MoveItemEnquipEffect(Character.Information.UniqueID, toSlot, fromItem.ID, 0));
client.Send(Packet.MoveItem(36, fromSlot, toSlot, 1, 0, "MOVE_INSIDE_INVENTORY"));
}
catch (Exception ex)
{
Log.Exception(ex);
}
#endregion
}
void HandleAttackPet(byte slot, int ItemID)
{
try
{
//Check if player level is high enough to spawn.
if (!CheckItemLevel(Character.Information.Level, ItemID))
{
client.Send(Packet.MoveItemError(0x6C, 0x18));
}
//If ok we continue to spawn the attack pet.
else
{
//Our sql query
DB ms = new DB("SELECT * FROM pets WHERE pet_itemid='" + ItemID + "' AND playerid='" + Character.Information.CharacterID + "'");
//Create new pet object.
WorldMgr.pet_obj o = new WorldMgr.pet_obj();
//Open our data reader
using (SqlDataReader reader = ms.Read())
{
//Start reading data from the query above.
while (reader.Read())
{
Character.Attackpet.Uniqueid = reader.GetInt32(11);
Character.Attackpet.Spawned = true;
o.UniqueID = Character.Attackpet.Uniqueid;
o.Model = ObjData.objectdata.GetItem(ObjData.Manager.ItemBase[ItemID].ObjectName); o.Level = reader.GetByte(13);
o.exp = reader.GetInt64(14);
o.x = Character.Position.x + Rnd.Next(1, 3);
o.z = Character.Position.z;
o.y = Character.Position.y + Rnd.Next(1, 3);
o.xSec = Character.Position.xSec;
o.ySec = Character.Position.ySec;
o.OwnerID = Character.Information.CharacterID;
o.OwnerName = Character.Information.Name;
o.Walking = Character.Position.Walking;
o.Petname = reader.GetString(3);
o.Named = 3;
o.Run = Character.Speed.RunSpeed;
o.Walk = Character.Speed.WalkSpeed;
o.Zerk = Character.Speed.BerserkSpeed;
}
ms.Close();
}
//We set our pet active bool, so user cannot spawn multiple.
Character.Attackpet.Active = true;
o.Information = true;
//Set all details above to definitions
Character.Attackpet.Details = o;
//Global spawn the pet
Helpers.Manager.HelperObject.Add(o);
//Spawn ourselfs
o.SpawnMe();
//Send then packet required (Pet information block).
client.Send(Packet.AttackPetStats(o, slot));
client.Send(Packet.AttackPetHGP(o));
//Update pet status to active (For relog purposes).
DB.query("UPDATE pets SET pet_active='1' WHERE pet_unique='" + Character.Grabpet.Grabpetid + "' AND playerid='" + Character.Information.CharacterID + "'");
}
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
/////////////////////////////////////////////////////////////////////////////////
// Get player inventory items (We will use this for stacking and checking).
// So herer's the simple one ive made we can use to check player inventory
/////////////////////////////////////////////////////////////////////////////////
public static List<byte> GetPlayerItems(WorldMgr.character c)
{
List<byte> items = new List<byte>();
DB ms = new DB("SELECT * FROM char_items WHERE owner='" + c.Information.CharacterID + "'");
using (System.Data.SqlClient.SqlDataReader reader = ms.Read())
{
while (reader.Read())
{
items.Add(reader.GetByte(5));
}
}
ms.Close();
return items;
}
/////////////////////////////////////////////////////////////////////////////////
// Avatar Unequiped
/////////////////////////////////////////////////////////////////////////////////
void ItemAvatarUnEquip(byte fromSlot, byte toSlot)
{
#region Avatar unequiped
try
{
GetFreeSlot();
ObjData.slotItem toItem = GetItem((uint)Character.Information.CharacterID, toSlot, 0);
int avatarid = 0;
int dbID = 0;
if (toItem.ID != 0) toSlot = GetFreeSlot();
if (toSlot <= 12) return;
DB ms = new DB("SELECT * FROM char_items WHERE itemnumber='avatar" + fromSlot + "' AND owner='" + Character.Information.CharacterID + "' AND inAvatar='1'");
using (System.Data.SqlClient.SqlDataReader reader = ms.Read())
{
while (reader.Read())
{
avatarid = reader.GetInt32(2);
dbID = reader.GetInt32(0);
}
}
ms.Close();
client.Send(Packet.MoveItem(35, fromSlot, toSlot, 1,0,"MOVE_INSIDE_INVENTORY"));
Send(Packet.MoveItemUnequipEffect(Character.Information.UniqueID, fromSlot, avatarid));
string nonquery = "UPDATE char_items SET itemnumber='item" + toSlot + "',slot='" + toSlot + "',inAvatar='0' WHERE owner='" + Character.Information.CharacterID + "' AND itemnumber='avatar" + fromSlot + "' AND id='" + dbID + "'";
DB.query(nonquery);
}
catch (Exception ex)
{
Log.Exception(ex);
}
#endregion
}
public static byte[] CharacterDataLoad(WorldMgr.character c)
{
PacketWriter Writer = new PacketWriter();
Writer.Create(OperationCode.SERVER_PLAYERDATA);
/////////////////////////////////////////////////////// Character basic info
#region Basic info
Writer.DWord(c.Ids.GetLoginID);
Writer.DWord(c.Information.Model);
Writer.Byte(c.Information.Volume);
Writer.Byte(c.Information.Level);
Writer.Byte(c.Information.Level);
Writer.LWord(c.Information.XP);
Writer.DWord(c.Information.SpBar);
Writer.LWord(c.Information.Gold);
Writer.DWord(c.Information.SkillPoint);
Writer.Word(c.Information.Attributes);
Writer.Byte(c.Information.BerserkBar);
Writer.DWord(988);
Writer.DWord(c.Stat.SecondHp);
Writer.DWord(c.Stat.SecondMP);
Writer.Bool(c.Information.Level < 20 ? true : false);
#endregion
/////////////////////////////////////////////////////// Character Player Kill Info
#region Pk information
//DB perfection reading with multiple data adapters... while this one is open i can still read anything else from the database
//With no speed reduction...
DB checkpk = new DB("SELECT * FROM character WHERE name ='" + c.Information.Name + "'");
using (System.Data.SqlClient.SqlDataReader getinfo = checkpk.Read())
{
while (getinfo.Read())
{
byte dailypk = getinfo.GetByte(48);
byte pklevel = getinfo.GetByte(49);
byte murderlevel = getinfo.GetByte(50);
Writer.Byte(dailypk);
Writer.Word(pklevel);
Writer.DWord(murderlevel);
if (murderlevel != 0) c.Information.Murderer = true;
}
}
#endregion
/////////////////////////////////////////////////////// Character Title
#region Title
Writer.Byte(c.Information.Title);
#endregion
/////////////////////////////////////////////////////// Character Pvpstate
#region Pvp
Writer.Byte(c.Information.Pvpstate);
if (c.Information.Pvpstate > 0)
c.Information.PvP = true;
#endregion
/////////////////////////////////////////////////////// Character Items
#region Item
Writer.Byte(c.Information.Slots);
DB ms = new DB("SELECT * FROM char_items WHERE owner='" + c.Information.CharacterID + "' AND slot >= '0' AND slot <= '" + c.Information.Slots + "' AND inavatar='0' AND storagetype='0'");
Writer.Byte(ms.Count());
using (System.Data.SqlClient.SqlDataReader msreader = ms.Read())
{
while (msreader.Read())
{
short amount = msreader.GetInt16(6);
if (amount < 1) amount = 1;
DB.query("UPDATE char_items SET quantity='" + amount + "' WHERE owner='" + c.Information.CharacterID + "' AND itemid='" + msreader.GetInt32(2) + "' AND id='" + msreader.GetInt32(0) + "' AND storagetype='0'");
if (msreader.GetByte(5) == 6)
c.Information.Item.wID = Convert.ToInt32(msreader.GetInt32(2));
if (msreader.GetByte(5) == 7)
{
c.Information.Item.sID = msreader.GetInt32(2);
c.Information.Item.sAmount = msreader.GetInt16(6);
}
Item.AddItemPacket(Writer, msreader.GetByte(5), msreader.GetInt32(2), msreader.GetByte(4), amount, msreader.GetInt32(7),msreader.GetInt32(0), msreader.GetInt32(9), msreader.GetInt32(30));
}
}
ms.Close();
//Avatar
Writer.Byte(5);
ms = new DB("SELECT * FROM char_items WHERE owner='" + c.Information.CharacterID + "' AND slot >= '0' AND slot <= '" + c.Information.Slots + "' AND inavatar='1' AND storagetype='0'");
Writer.Byte(ms.Count());
using (System.Data.SqlClient.SqlDataReader msreader = ms.Read())
{
while (msreader.Read())
{
Item.AddItemPacket(Writer, msreader.GetByte(5), msreader.GetInt32(2), msreader.GetByte(4), msreader.GetInt16(6), msreader.GetInt32(7), msreader.GetInt32(0), msreader.GetInt32(9),msreader.GetInt32(30));
}
}
ms.Close();
Writer.Byte(0);
// job mastery
Writer.Byte(0x0B);
Writer.Byte(0);
Writer.Byte(0);
#endregion
/////////////////////////////////////////////////////// Mastery
#region Mastery
if (c.Information.Model <= 12000)
{
for (byte i = 1; i <= 7; i++)
{
Writer.Byte(1);
Writer.DWord(c.Stat.Skill.Mastery[i]);
Writer.Byte(c.Stat.Skill.Mastery_Level[i]);
}
}
else
{
if (c.Information.Model >= 14000)
{
for (byte i = 1; i < 7; i++)
{
Writer.Byte(1);
Writer.DWord(c.Stat.Skill.Mastery[i]);
Writer.Byte(c.Stat.Skill.Mastery_Level[i]);
}
}
}
#endregion
/////////////////////////////////////////////////////// Skills
#region Skill
Writer.Byte(2);
Writer.Byte(0);
for (int i = 1; i <= c.Stat.Skill.AmountSkill; i++)
{
Writer.Byte(1);
Writer.DWord(c.Stat.Skill.Skill[i]);
Writer.Byte(1);
}
Writer.Byte(2);
#endregion
/////////////////////////////////////////////////////// Quests
#region Quest
Writer.Word(1); // how many Quest ids completed/aborted
Writer.DWord(1);// Quest id
Writer.Byte(0);//number of Quests that are live
#endregion
Writer.Byte(0);//? for now
/////////////////////////////////////////////////////// Talisman
#region Talisman
Writer.DWord(1);//new
Writer.DWord(1);//new
Writer.DWord(0);//? for now
Writer.DWord(0x0C);//new
#endregion
/////////////////////////////////////////////////////// Position + id + speed
#region Character id / Position / Speed
Writer.DWord(c.Information.UniqueID);
Writer.Byte(c.Position.xSec);
Writer.Byte(c.Position.ySec);
if (!FileDB.CheckCave(c.Position.xSec, c.Position.ySec))
{
Writer.Float(Formule.packetx(c.Position.x, c.Position.xSec));
Writer.Float(c.Position.z);
Writer.Float(Formule.packety(c.Position.y, c.Position.ySec));
}
else
{
Writer.Float(Formule.cavepacketx(c.Position.x));// Added for cave Coords
Writer.Float(c.Position.z);
Writer.Float(Formule.cavepackety(c.Position.y));// Added for cave Coords
}
Writer.Word(0); // Angle
Writer.Byte(0);
Writer.Byte(1);
Writer.Byte(0);
Writer.Word(0); // Angle
Writer.Word(0);
Writer.Byte(0);
Writer.Bool(false); //berserk
Writer.Byte(0);//new ?
Writer.Float(c.Speed.WalkSpeed);
Writer.Float(c.Speed.RunSpeed);
Writer.Float(c.Speed.BerserkSpeed);
#endregion
/////////////////////////////////////////////////////// Premium Tickets
#region Premium ticket
Writer.Byte(0); //ITEM_MALL_GOLD_TIME_SERVICE_TICKET_4W
#endregion
/////////////////////////////////////////////////////// GM Check + Name
#region GM Check + Name
Writer.Text(c.Information.Name);
#endregion
/////////////////////////////////////////////////////// Character jobs
#region Character Job / hunter thief trader ( old job things )
//Writer info with job name when on job
/*if (c.Job.state == 1 && c.Job.Jobname != "0")
{
Writer.Text(c.Job.Jobname);
Writer.Byte(3);
Writer.Byte(1);
Writer.DWord(0);
Writer.DWord(0);
Writer.DWord(0);
Writer.Byte(0);
Writer.Byte(0);
Writer.Byte(0);
}
//Write basic info noname
if (c.Job.Jobname == "0")
{
Writer.Word(0);
Writer.Byte(3);
Writer.Byte(1);
Writer.DWord(0);
Writer.DWord(0);
Writer.DWord(0);
Writer.Byte(0);
Writer.Byte(0);
Writer.Byte(0);
}
//Write no info
else
{
Writer.Word(0);
Writer.Byte(0);
Writer.Byte(1);
Writer.DWord(0);
Writer.DWord(0);
Writer.DWord(0);
Writer.Byte(0);
Writer.Byte(0);
Writer.Byte(0);
}*/
#endregion
#region New job system
if (c.Job.state == 1)
{
Writer.Text(c.Job.Jobname);
Writer.Byte(1);
Writer.Byte(c.Job.level);//Level job
Writer.Byte(c.Information.Level);//Level char
Writer.Byte(1); // job level? myb
Writer.LWord(0);// job exp probably y
Writer.Byte(0);
Writer.Byte(0);
Writer.Byte(0);
Writer.Byte(0);
}
else
{
Writer.Word(0);
Writer.Byte(0);
Writer.Byte(0);
Writer.Byte(2); // job type
Writer.Byte(1); // job level? myb
Writer.LWord(0);// job exp probably y
Writer.Byte(0);
Writer.Byte(0);
Writer.Byte(0);
Writer.Byte(0);
}
#endregion
/////////////////////////////////////////////////////// Pvp / Pk State
#region Pvp / Pk State
if (c.Information.Pvpstate == 1 || c.Information.Murderer)
{
Writer.Byte(0x22);
}
else if (c.Information.Pvpstate == 0 || !c.Information.Murderer)
{
Writer.Byte(0xFF);
}
#endregion
/////////////////////////////////////////////////////// Guide Data
#region Guide Data this data stacks on itself so if guide id is 0400000000000000 and next guide is 0300000000000000 the data to send is 0700000000000000
for (int i = 0; i < 8; ++i)//Main Guide Packet Info
{
Writer.Byte(c.Guideinfo.G1[i]);//Reads From Int Array
}
#endregion
/////////////////////////////////////////////////////// Account / Gm Check
#region Account ID + Gm Check
Writer.DWord(c.Account.ID);
Writer.Byte(c.Information.GM);
#endregion
/////////////////////////////////////////////////////// Quickbar + Autopotion
#region Bar information
Writer.Byte(7);
PlayerQuickBar(Writer, c.Information.CharacterID);
PlayerAutoPot(Writer, c.Information.CharacterID);
#endregion
/////////////////////////////////////////////////////// Academy
#region Academy
Writer.Byte(0); // number of player in academy
/* // if we have players there
Writer.Byte(1);
Writer.Text("asd");
*/
Writer.Byte(0);//added byte today for 1.310
Writer.Byte(0);
Writer.Word(1);
Writer.Word(1);
Writer.Byte(0);
Writer.Byte(1);
#endregion
return Writer.GetBytes();
}
public static byte[] GuildStorageData(WorldMgr.character c)
{
DB getstorage = new DB("SELECT * FROM char_items WHERE guild_storage_id='" + c.Network.Guild.Guildid + "' AND storagetype='3'");
int itemcount = getstorage.Count();
PacketWriter Writer = new PacketWriter();
Writer.Create(OperationCode.SERVER_GUILD_STORAGE3);
Writer.Byte(c.Network.Guild.StorageSlots);
Writer.Byte(itemcount);
if (itemcount != 0)
{
using (System.Data.SqlClient.SqlDataReader reader = getstorage.Read())
{
while (reader.Read())
{
Item.AddItemPacket(Writer, reader.GetByte(5), reader.GetInt32(2), reader.GetByte(4), reader.GetInt16(6), reader.GetInt32(7), reader.GetInt32(0), reader.GetInt32(9), reader.GetInt32(30));
}
}
}
getstorage.Close();
return Writer.GetBytes();
}
public static byte[] RankListsActivityThief()
{
DB ms = new DB("SELECT TOP 50 * FROM rank_job_activity WHERE job_type='2'");
PacketWriter Writer = new PacketWriter();
int countinfo = ms.Count();
int i = 0;
Writer.Create(OperationCode.SERVER_RANK_LISTS);
Writer.Byte(1);
Writer.Byte(1);
Writer.Byte(0);
Writer.Byte(Convert.ToByte(countinfo));
using (SqlDataReader reader = ms.Read())
{
for (i = 0; i < countinfo; )
{
while (reader.Read())
{
byte rank = reader.GetByte(2);
string name = reader.GetString(3);
byte level = reader.GetByte(4);
int exp = reader.GetInt32(5);
byte title = reader.GetByte(6);
Writer.Byte(rank);
Writer.Text(name);
Writer.Byte(level);
Writer.DWord(exp);
Writer.Byte(title);
i++;
}
}
ms.Close();
}
return Writer.GetBytes();
}
///////////////////////////////////////////////////////////////////////////
// Load grabpet
///////////////////////////////////////////////////////////////////////////
public void HandleGrabPet(byte slot, int ItemID)
{
try
{
//Checks before we continue (Level check).
if (!CheckItemLevel(Character.Information.Level, ItemID))
{
client.Send(Packet.MoveItemError(0x6C, 0x18));
}
//Else we continue
else
{
//Our database query for loading pet information.
DB ms = new DB("SELECT * FROM pets WHERE pet_itemid='" + ItemID + "' AND playerid='" + Character.Information.CharacterID + "'");
//Get detailed item information.
ObjData.slotItem item = GetItem((uint)Character.Information.CharacterID, slot, 0);
//Get item model information
int model = ObjData.objectdata.GetItem(ObjData.Manager.ItemBase[ItemID].ObjectName);
//Create new pet object
WorldMgr.pet_obj o = new WorldMgr.pet_obj();
//Our sql data reader
using (SqlDataReader reader = ms.Read())
{
//While our reader is open we read all info below.
while (reader.Read())
{
int itemid = reader.GetInt32(7);
Character.Grabpet.Grabpetid = item.dbID;
o.UniqueID = Character.Grabpet.Grabpetid;
o.Model = model;
o.Slots = reader.GetByte(8);
o.x = Character.Position.x + Rnd.Next(1, 3);
o.z = Character.Position.z;
o.y = Character.Position.y + Rnd.Next(1, 3);
o.xSec = Character.Position.xSec;
o.ySec = Character.Position.ySec;
o.OwnerID = Character.Information.CharacterID;
o.OwnerName = Character.Information.Name;
o.Walking = Character.Position.Walking;
o.Petname = reader.GetString(3);
o.Named = 2;
o.Run = Character.Speed.RunSpeed;
o.Walk = Character.Speed.WalkSpeed;
o.Zerk = Character.Speed.BerserkSpeed;
}
ms.Close();
}
//We set our pet active bool, so user cannot spawn multiple.
Character.Grabpet.Active = true;
o.Information = true;
//Set all details above to definitions
Character.Grabpet.Details = o;
//Global spawn the pet
Helpers.Manager.HelperObject.Add(o);
//Spawn ourselfs
o.SpawnMe();
//Send then packet required (Pet information block).
client.Send(Packet.Pet_Information_grab(o, slot));
//Update pet status to active (For relog purposes).
DB.query("UPDATE pets SET pet_active='1' WHERE pet_unique='" + Character.Grabpet.Grabpetid + "' AND playerid='" + Character.Information.CharacterID + "'");
}
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Character listening packet
////////////////////////////////////////////////////////////////////////////////////////////////////////////
public static byte[] CharacterListing(string name)
{
DB ms = new DB("SELECT TOP 4 * FROM character WHERE account='" + name + "'");
PacketWriter Writer = new PacketWriter();
Writer.Create(OperationCode.SERVER_CHARACTERSCREEN); // Select opcode
Writer.Byte(2); // Static byte 2
Writer.Byte(1); // Static byte 1
Writer.Byte(ms.Count()); // Byte WorldMgr.character count
using (System.Data.SqlClient.SqlDataReader reader = ms.Read())
{
while (reader.Read())
{
Writer.DWord(reader.GetInt32(3)); // DWord Skin Model
Writer.Text(reader.GetString(2)); // String Name
Writer.Byte(reader.GetByte(4)); // Byte Skin Volume
Writer.Byte(reader.GetByte(5)); // Byte Level
Writer.LWord(reader.GetInt64(12)); // Long Experience
Writer.Word(reader.GetInt16(6)); // Word STR
Writer.Word(reader.GetInt16(7)); // Word INT
Writer.Word(reader.GetInt16(8)); // Attribute points
Writer.DWord(reader.GetInt32(9)); // HP
Writer.DWord(reader.GetInt32(10)); // MP
TimeSpan ts = Convert.ToDateTime(reader.GetDateTime(43)) - DateTime.Now;
double time = ts.TotalMinutes;
if (Math.Round(time) > 0)
{
Writer.Byte(1);
Writer.DWord(Math.Round(time));
}
else
{
Writer.Byte(0);
}
if (Math.Round(time) < 0 && DateTime.Now != reader.GetDateTime(43))
{
DB.query("UPDATE character SET deleted='1' Where id='" + reader.GetInt32(0) + "'");
}
Writer.Word(0);
Writer.Byte(0);
Function.Items.PrivateItemPacket(Writer, reader.GetInt32(0), 8, 0,false);
Function.Items.PrivateItemPacket(Writer, reader.GetInt32(0), 5, 1,false);
}
//Jobtype information
byte jobinfo = Convert.ToByte(DB.GetData("SELECT * FROM users WHERE id='"+ name +"'", "jobtype"));
Writer.Byte(jobinfo);
}
ms.Close();
return Writer.GetBytes();
}
public void PlayerDataLoad()
{
//Wrap our function inside a catcher
try
{
//////////////////////////////////////////////////////////////////////////////////////
// Load Character Data
//////////////////////////////////////////////////////////////////////////////////////
#region Character Data
//If Character is null we return
if (Character == null) return;
//Set new sql query for character information
DB ms = new DB("SELECT * FROM character WHERE name='" + Character.Information.Name + "'");
//Open new sql data reader
using (SqlDataReader reader = ms.Read())
{
//While our reader is reading the information
while (reader.Read())
{
// Character id information
Character.Information.CharacterID = reader.GetInt32(0);
Character.Account.ID = Player.ID;
// Character model information
Character.Information.Model = reader.GetInt32(3);
Character.Information.Race = ObjData.Manager.ObjectBase[Character.Information.Model].Race;
Character.Information.Volume = reader.GetByte(4);
// Character base stats
Character.Information.Level = reader.GetByte(5);
Character.Stat.Strength = reader.GetInt16(6);
Character.Stat.Intelligence = reader.GetInt16(7);
Character.Information.Attributes = reader.GetInt16(8);
Character.Stat.Hp = reader.GetInt32(9);
Character.Stat.Mp = reader.GetInt32(10);
// Character gold information
Character.Information.Gold = reader.GetInt64(11);
// Character Points
Character.Information.XP = reader.GetInt64(12);
Character.Information.SpBar = reader.GetInt32(13);
Character.Information.SkillPoint = reader.GetInt32(14);
// Character GM information
Character.Information.GM = reader.GetByte(15);
// Character Location
Character.Position.xSec = reader.GetByte(16);
Character.Position.ySec = reader.GetByte(17);
Character.Position.x = reader.GetInt32(19);
Character.Position.y = reader.GetInt32(20);
Character.Position.z = reader.GetInt32(21);
Character.Information.Place = reader.GetByte(40);
// Character Main Stats
Character.Stat.SecondHp = reader.GetInt32(22);
Character.Stat.SecondMP = reader.GetInt32(23);
Character.Stat.MinPhyAttack = reader.GetInt32(24);
Character.Stat.MaxPhyAttack = reader.GetInt32(25);
Character.Stat.MinMagAttack = reader.GetInt32(26);
Character.Stat.MaxMagAttack = reader.GetInt32(27);
Character.Stat.PhyDef = reader.GetInt16(28);
Character.Stat.MagDef = reader.GetInt16(29);
Character.Stat.Hit = reader.GetInt16(30);
Character.Stat.Parry = reader.GetInt16(31);
Character.Speed.WalkSpeed = reader.GetInt32(33);
Character.Speed.RunSpeed = reader.GetInt32(34);
Character.Speed.BerserkSpeed = reader.GetInt32(35);
Character.Information.BerserkBar = reader.GetByte(36);
Character.Stat.mag_Absorb = reader.GetInt16(38);
Character.Stat.phy_Absorb = reader.GetInt16(39);
// Character Other information
Character.Information.Pvpstate = reader.GetByte(45);
Character.Account.StorageGold = Player.pGold;
Character.Account.StorageSlots = Player.wSlots;
Character.Information.ExpandedStorage = reader.GetByte(53);
Character.Information.Slots = reader.GetInt32(44);
Character.Information.Title = reader.GetByte(41);
Character.Information.Online = reader.GetInt32(47);
Character.Information.StallModel = reader.GetInt32(52);
// Character Guide Info
Character.Guideinfo.G1 = new int[8];//Main Int Array Fro Guide Packet
Character.Guideinfo.Gchk = new int[8];//Main Guide Check Packet Array
//Read guide information
string Guideread = reader.GetString(51);
int t = 0;
for (int g = 0; g < 8; ++g)
{
Character.Guideinfo.G1[g] = int.Parse(Guideread.Substring(t, 2), System.Globalization.NumberStyles.HexNumber, null);
t = t + 2;
}
for (int gc = 0; gc < 8; ++gc)
{
Character.Guideinfo.Gchk[gc] = 0;
}
}
}
//Close our sql data reader
ms.Close();
#endregion
//////////////////////////////////////////////////////////////////////////////////////
// Set Skill And Mastery Information Max
//////////////////////////////////////////////////////////////////////////////////////
#region Set Skill / Mastery
Character.Stat.Skill.Mastery = new int[8];
Character.Stat.Skill.Mastery_Level = new byte[8];
Character.Stat.Skill.Skill = new int[20000];
#endregion
//////////////////////////////////////////////////////////////////////////////////////
// Load Mastery Data
//////////////////////////////////////////////////////////////////////////////////////
#region Load Mastery Data
//New sql query to get mastery information
ms = new DB("SELECT * FROM mastery WHERE owner='" + Character.Information.CharacterID + "'");
//Open new sql data reader
using (SqlDataReader reader = ms.Read())
{
//Set byte to 1 default
byte c = 1;
//While sql data reader is reading
while (reader.Read())
{
//We add the mastery information and level
Character.Stat.Skill.Mastery[c] = reader.GetInt32(1);
Character.Stat.Skill.Mastery_Level[c] = reader.GetByte(2);
c++;
}
}
//Close our sql data reader
ms.Close();
#endregion
//////////////////////////////////////////////////////////////////////////////////////
// Load Skill Data
//////////////////////////////////////////////////////////////////////////////////////
#region Load Skill Data
//Create new query to get skill data
ms = new DB("SELECT * FROM saved_skills WHERE owner='" + Character.Information.CharacterID + "'");
//Get skill count from reader
using (SqlDataReader reader = ms.Read())
Character.Stat.Skill.AmountSkill = ms.Count();
//Set default i to 1
int i = 1;
//Open new sql data reder
using (SqlDataReader reader = ms.Read())
{
//While the reader is reading
while (reader.Read())
{
//Add the skill id
Character.Stat.Skill.Skill[i] = reader.GetInt32(2);
i++;
}
}
//Close the sql data reader
ms.Close();
#endregion
//////////////////////////////////////////////////////////////////////////////////////
// Load Remaining information
//////////////////////////////////////////////////////////////////////////////////////
#region Load Remaining Data
//Update x / y
UpdateXY();
//If character's current hp is lower then 1
if (Character.Stat.SecondHp < 1)
{
//Reset player location to return point, and fill the hp half of the max.
Character.Stat.SecondHp = (Character.Stat.Hp / 2);
Teleport_UpdateXYZ(Character.Information.Place);
}
//Set balande for player
SetBalance();
//Check our file information
CheckFile();
//Set stats for player
SetStat();
#endregion
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
public static byte[] SendFriendList(byte count, WorldMgr.character c)
{
PacketWriter Writer = new PacketWriter();
Writer.Create(OperationCode.SERVER_SEND_FRIEND_LIST);
//Groups
DB ms = new DB("SELECT * FROM friends_groups WHERE playerid='"+ c.Information.CharacterID +"'");
int groupcount = ms.Count();
groupcount = groupcount + 1;
Writer.Byte((byte)groupcount);
Writer.Word(0);
Writer.Text("NonClassified");
int groupid = 0;
using (System.Data.SqlClient.SqlDataReader reader = ms.Read())
{
while (reader.Read())
{
string groupname = reader.GetString(2);
groupid = groupid +1;
Writer.Word((short)groupid);
Writer.Text(groupname);
}
}
//Friends
Writer.Byte(count);
ms = new DB("SELECT * FROM friends WHERE owner='"+ c.Information.CharacterID +"'");
using (System.Data.SqlClient.SqlDataReader reader = ms.Read())
{
while (reader.Read())
{
int model = Convert.ToInt32(DB.GetData("SELECT * FROM character WHERE id='" + reader.GetInt32(2) + "'", "chartype"));
int status = Convert.ToInt32(DB.GetData("SELECT * FROM character WHERE id='" + reader.GetInt32(2) + "'", "Online"));
int charid = Convert.ToInt32(DB.GetData("SELECT * FROM character WHERE id='" + reader.GetInt32(2) + "'", "id"));
string charname = DB.GetData("SELECT * FROM character WHERE id='" + reader.GetInt32(2) + "'", "name");
string groupname = reader.GetString(4);
Writer.DWord(charid); // Friend CharID
Writer.Text(charname); // Friend Name
Writer.DWord(model); // Friend Model Type
if (groupname == "none")
Writer.Word(0);
else
Writer.Word(groupid);
if (status != 0)
{
Writer.Byte(0); // Friend is online
}
else
{
Writer.Byte(1); // Inverted, Friend is offline
}
}
reader.Close();
}
ms.Close();
return Writer.GetBytes();
}
void GetFriendsList()
{
//Wrap our function inside a catcher
try
{
//Set new sql query to get friend information
DB ms = new DB("SELECT * FROM friends WHERE owner='" + Character.Information.CharacterID + "'");
//Count our friends
int count = ms.Count();
//If we have a friend in the list
if (count > 0)
{
//Send our packet
client.Send(Packet.SendFriendList(Convert.ToByte(count), Character));
//Open new sql data reader
using (SqlDataReader reader = ms.Read())
{
//While our sql data reader is reading
while (reader.Read())
{
//Get player id information of friend
int getid = reader.GetInt32(2);
//Get detailed information for our friend
PlayerMgr sys = Helpers.GetInformation.GetPlayerid(getid);
//If the character is online
if (sys != null)
{
//We send online state change packet
sys.client.Send(Packet.FriendData(Character.Information.CharacterID, 4, Character.Information.Name, Character, false));
}
}
}
//Close our sql reader
ms.Close();
}
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
public static byte GetAmmoSlot(WorldMgr.character ch)
{
DB ms = new DB("SELECT * FROM char_items WHERE owner='" + ch.Information.CharacterID + "' AND (itemid='62' OR itemid='3655' OR itemid='10376' OR itemid='10727')");
byte ammo = 0;
using (System.Data.SqlClient.SqlDataReader reader = ms.Read())
{
while (reader.Read())
{
ammo = reader.GetByte(5);
}
ms.Close();
return Convert.ToByte(ammo);
}
}
void LoadGrabPet()
{
//Wrap our function inside a catcher
try
{
//Query check
DB ms = new DB("SELECT * FROM pets WHERE playerid='" + Character.Information.CharacterID + "' AND pet_active='1'");
//Get active pet count
int checkactive = ms.Count();
//If the player has an active grabpet
if (checkactive > 0)
{
//Set new pet object
WorldMgr.pet_obj o = new WorldMgr.pet_obj();
//Create new data reader for DB
using (SqlDataReader reader = ms.Read())
{
//While the sql data reader is reading
while (reader.Read())
{
//Get pet location inside the player inventory
string slot = reader.GetString(12);
//Check our slot inside the database
int slotcheck = Convert.ToInt32(DB.GetData("SELECT * FROM char_items WHERE itemnumber='" + slot + "' AND owner='" + Character.Information.CharacterID + "' AND storagetype='0'", "slot"));
//Set slot item information (item).
ObjData.slotItem item = GetItem((uint)Character.Information.CharacterID, Convert.ToByte(slotcheck), 0);
//Set model information of the pet
int model = ObjData.item_database.GetItem(ObjData.Manager.ItemBase[item.ID].ObjectName);
//Set id for the pet (First database value is always unique).
Character.Grabpet.Grabpetid = item.dbID;
//Set unique id
o.UniqueID = Character.Grabpet.Grabpetid;
//Pet object model
o.Model = model;
//Spawning location of the pet
o.x = Character.Position.x + Rnd.Next(1, 3);
o.z = Character.Position.z;
o.y = Character.Position.y + Rnd.Next(1, 3);
o.xSec = Character.Position.xSec;
o.ySec = Character.Position.ySec;
//Owner id information
o.OwnerID = Character.Information.CharacterID;
//Owner name information
o.OwnerName = Character.Information.Name;
//Set walking state
o.Walking = Character.Position.Walking;
//Set petname
o.Petname = reader.GetString(3);
//Set our switch case
o.Named = 2;
//Set speed of pet (Need to check speed on official).
o.Run = Character.Speed.RunSpeed - 3;
o.Walk = Character.Speed.WalkSpeed - 3;
o.Zerk = Character.Speed.BerserkSpeed - 3;
//Set grabpet as active so there cant be double spawns
Character.Grabpet.Active = true;
//Set object information to true
o.Information = true;
//Spawn the pet
Helpers.Manager.HelperObject.Add(o);
//Set global information for the pet
Character.Grabpet.Details = o;
//Send the visual packet for details of the pet management
client.Send(Packet.Pet_Information_grab(o, Convert.ToByte(slotcheck)));
//Spawn
o.SpawnMe();
//Update state into database
DB.query("UPDATE pets SET pet_active='1' WHERE pet_unique='" + Character.Grabpet.Grabpetid + "' AND playerid='" + Character.Information.CharacterID + "'");
}
//Close sql reader
ms.Close();
}
//Set state
Character.Grabpet.Active = true;
}
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
/////////////////////////////////////////////////////////////////////////////////
// Get Max Slots
/////////////////////////////////////////////////////////////////////////////////
public byte GetFreeSlotMax()
{
#region Get Max Slots Available
List<byte> ListSlot = new List<byte>(Character.Information.Slots);
DB ms = new DB("SELECT * FROM char_items WHERE owner='" + Character.Information.CharacterID + "' AND slot >= '13' AND slot <= '" + Character.Information.Slots + "' AND inavatar='0'");
using (System.Data.SqlClient.SqlDataReader reader = ms.Read())
{
while (reader.Read())
{
ListSlot.Add(reader.GetByte(5));
}
}
ms.Close();
byte add = 0;
for (byte i = 13; i < Character.Information.Slots; i++)
{
if (!GetCheckFreeSlot(ListSlot, i)) add++;
}
return add;
#endregion
}
void LoadJobData()
{
//Wrap our function inside a catcher
try
{
//Get jobtype information from database
int jobtype = Convert.ToInt32(DB.GetData("SELECT * FROM users WHERE id='" + Player.AccountName + "'", "jobtype"));
//If we have a job so not 0 value
if (jobtype > 0)
{
//Create our query to get all job information
DB ms = new DB("SELECT * FROM character_jobs WHERE character_name='" + Character.Information.Name + "'");
//Open new sql data reader
using (SqlDataReader reader = ms.Read())
{
//While sql data reader is reading
while (reader.Read())
{
//Set global job name
Character.Job.Jobname = reader.GetString(2);
//Set global job type
Character.Job.type = reader.GetByte(3);
//Set global job exp
Character.Job.exp = reader.GetInt32(4);
//Set global job rank
Character.Job.rank = reader.GetByte(5);
//Set global job state
Character.Job.state = reader.GetInt32(6);
//Set global job level
Character.Job.level = reader.GetByte(7);
}
}
//Close our sql data reader.
ms.Close();
}
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
/////////////////////////////////////////////////////////////////////////////////
// Add items to database
/////////////////////////////////////////////////////////////////////////////////
public void AddItem(int itemid, short prob, byte slot, int id, int modelid)
{
#region Add item to db
try
{
if (ObjData.Manager.ItemBase[itemid].Itemtype == ObjData.item_database.ItemType.BLADE ||
ObjData.Manager.ItemBase[itemid].Itemtype == ObjData.item_database.ItemType.CH_SHIELD ||
ObjData.Manager.ItemBase[itemid].Itemtype == ObjData.item_database.ItemType.EU_SHIELD ||
ObjData.Manager.ItemBase[itemid].Itemtype == ObjData.item_database.ItemType.BOW ||
ObjData.Manager.ItemBase[itemid].Itemtype == ObjData.item_database.ItemType.EU_AXE ||
ObjData.Manager.ItemBase[itemid].Itemtype == ObjData.item_database.ItemType.EU_CROSSBOW ||
ObjData.Manager.ItemBase[itemid].Itemtype == ObjData.item_database.ItemType.EU_DAGGER ||
ObjData.Manager.ItemBase[itemid].Itemtype == ObjData.item_database.ItemType.EU_DARKSTAFF ||
ObjData.Manager.ItemBase[itemid].Itemtype == ObjData.item_database.ItemType.EU_HARP ||
ObjData.Manager.ItemBase[itemid].Itemtype == ObjData.item_database.ItemType.EU_STAFF ||
ObjData.Manager.ItemBase[itemid].Itemtype == ObjData.item_database.ItemType.EU_SWORD ||
ObjData.Manager.ItemBase[itemid].Itemtype == ObjData.item_database.ItemType.EU_TSTAFF ||
ObjData.Manager.ItemBase[itemid].Itemtype == ObjData.item_database.ItemType.EU_TSWORD ||
ObjData.Manager.ItemBase[itemid].Itemtype == ObjData.item_database.ItemType.GLAVIE ||
ObjData.Manager.ItemBase[itemid].Itemtype == ObjData.item_database.ItemType.SPEAR ||
ObjData.Manager.ItemBase[itemid].Itemtype == ObjData.item_database.ItemType.SWORD ||
ObjData.Manager.ItemBase[itemid].Itemtype == ObjData.item_database.ItemType.EARRING ||
ObjData.Manager.ItemBase[itemid].Itemtype == ObjData.item_database.ItemType.RING ||
ObjData.Manager.ItemBase[itemid].Itemtype == ObjData.item_database.ItemType.NECKLACE ||
ObjData.Manager.ItemBase[itemid].Type == ObjData.item_database.ArmorType.ARMOR ||
ObjData.Manager.ItemBase[itemid].Type == ObjData.item_database.ArmorType.GARMENT ||
ObjData.Manager.ItemBase[itemid].Type == ObjData.item_database.ArmorType.GM ||
ObjData.Manager.ItemBase[itemid].Type == ObjData.item_database.ArmorType.HEAVY ||
ObjData.Manager.ItemBase[itemid].Type == ObjData.item_database.ArmorType.LIGHT ||
ObjData.Manager.ItemBase[itemid].Type == ObjData.item_database.ArmorType.PROTECTOR ||
ObjData.Manager.ItemBase[itemid].Type == ObjData.item_database.ArmorType.AVATAR ||
ObjData.Manager.ItemBase[itemid].Type == ObjData.item_database.ArmorType.ROBE)
{
DB.query("Insert Into char_items (itemid,plusvalue,durability,owner,itemnumber,slot,storageacc,inavatar,storagetype,charbound) VALUES ('" + itemid + "','" + prob + "','" + ObjData.Manager.ItemBase[itemid].Defans.Durability + "','" + id + "','item" + slot + "','" + slot + "','" + Player.ID + "','0','0','" + ObjData.Manager.ItemBase[itemid].SoulBound + "' )");
}
else if (ObjData.Manager.ItemBase[itemid].Pettype == ObjData.item_database.PetType.GRABPET)
{
DB.query("Insert Into char_items (itemid,plusvalue,durability,owner,itemnumber,slot,storageacc,charbound) VALUES ('" + itemid + "','" + 0 + "','" + ObjData.Manager.ItemBase[itemid].Defans.Durability + "','" + id + "','item" + slot + "','" + slot + "','" + Player.ID + "','" + ObjData.Manager.ItemBase[itemid].SoulBound + "')");
DB ms = new DB("SELECT TOP 1 * FROM char_items WHERE owner='" + Character.Information.CharacterID + "' ORDER BY id DESC");
using (System.Data.SqlClient.SqlDataReader reader = ms.Read())
{
while (reader.Read())
{
int idinfo = reader.GetInt32(0);
DB.query("Insert Into pets (playerid, pet_type, pet_name, pet_state, pet_itemid, pet_active, pet_check, pet_unique) VALUES ('" + Character.Information.CharacterID + "','4','No name','1','" + itemid + "','0','item" + slot + "','" + idinfo + "')");
}
}
ms.Close();
}
else if (ObjData.Manager.ItemBase[itemid].Pettype == ObjData.item_database.PetType.ATTACKPET)
{
DB.query("Insert Into char_items (itemid,plusvalue,durability,owner,itemnumber,slot,storageacc,charbound) VALUES ('" + itemid + "','" + 0 + "','" + ObjData.Manager.ItemBase[itemid].Defans.Durability + "','" + id + "','item" + slot + "','" + slot + "','" + Player.ID + "','" + ObjData.Manager.ItemBase[itemid].SoulBound + "')");
DB ms = new DB("SELECT TOP 1 * FROM char_items WHERE owner='" + Character.Information.CharacterID + "' ORDER BY id DESC");
using (System.Data.SqlClient.SqlDataReader reader = ms.Read())
{
while (reader.Read())
{
int idinfo = reader.GetInt32(0);
DB.query("Insert Into pets (playerid, pet_type, pet_name, pet_state, pet_itemid, pet_active, pet_check, pet_unique) VALUES ('" + Character.Information.CharacterID + "','2','No name','1','" + itemid + "','0','item" + slot + "','" + idinfo + "')");
}
}
ms.Close();
}
else if (ObjData.Manager.ItemBase[itemid].Etctype == ObjData.item_database.EtcType.STONES)
{
DB.query("Insert Into char_items (itemid,plusvalue,durability,owner,itemnumber,slot,storageacc,inavatar,storagetype,charbound) VALUES ('" + itemid + "','" + 0 + "','" + 0 + "','" + id + "','item" + slot + "','" + slot + "','" + Player.ID + "','0','0','" + ObjData.Manager.ItemBase[itemid].SoulBound + "' )");
}
else if (ObjData.Manager.ItemBase[itemid].Etctype == ObjData.item_database.EtcType.MONSTERMASK)
{
DB.query("Insert Into char_items (itemid,plusvalue,durability,owner,itemnumber,slot,storageacc,modelid,charbound) VALUES ('" + itemid + "','" + 0 + "','" + 0 + "','" + id + "','item" + slot + "','" + slot + "','" + Player.ID + "','" + modelid + "','" + ObjData.Manager.ItemBase[itemid].SoulBound + "' )");
}
else
{
if (prob < 2) prob = 1;
DB.query("Insert Into char_items (itemid,quantity,owner,itemnumber,slot,storageacc,charbound) VALUES ('" + itemid + "','" + prob + "','" + id + "','item" + slot + "','" + slot + "','" + Player.ID + "','" + ObjData.Manager.ItemBase[itemid].SoulBound + "' )");
}
}
catch (Exception ex)
{
Console.WriteLine("DB Item add error: ", ex);
}
#endregion
}
void LoadTicket(WorldMgr.character c)
{
//We wrap our function inside a catcher
try
{
//First we get our data from the database.
DB ms = new DB("SELECT * FROM character_tickets WHERE owner ='" + c.Information.CharacterID + "' AND active='1'");
//Check if we have a active ticket
int CheckActive = ms.Count();
//Now if we have one active we continue
if (CheckActive == 1)
{
//Open new sql data reader
using (SqlDataReader reader = ms.Read())
{
//While sql data reader is reading
while (reader.Read())
{
//Set our ticket to active so they cannot use double premium tickets
Character.Premium.Active = true;
//We can use Character.Information.CharacterID but on safe side we read from db to make sure.
Character.Premium.OwnerID = reader.GetInt32(1);
//Get the id information to calculate the % gaining and type etc etc..
Character.Premium.TicketItemID = reader.GetInt32(2);
//Get unique id (incase we need it).
Character.Premium.TicketID = reader.GetInt32(0);
//Get the start time of the ticket
Character.Premium.StartTime = reader.GetDateTime(3);
}
}
//Close our data reader
ms.Close();
//Calculate remaining time left.
TimeSpan Timecheck = Convert.ToDateTime(Character.Premium.StartTime) - DateTime.Now;
double TimeRemaining = Timecheck.TotalMinutes;
//Finally we send our packet to the user (Icon).
client.Send(Packet.PremiumTicketData(Character.Premium.TicketItemID, Convert.ToInt32(TimeRemaining)));
}
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
