/// <summary>
/// TEMP METHOD
/// </summary>
public static void FmMyWeapon(Network.WorldClient client, Database.Records.WorldItemRecord item, int type)
{
foreach (var effect in item.Engine.Effects)
{
if (effect.ID == 100)
{
switch (type)
{
case 1: //Force
effect.ID = 97;
break;
case 2: //feu
effect.ID = 99;
break;
case 3: //chance
effect.ID = 96;
break;
case 4: //agi
effect.ID = 98;
break;
}
}
}
}
public static void BuyObject(Network.WorldClient client, string packet)
{
if (client.State == Network.WorldClientState.OnExchangePnj && client.Action.ExchangeNpcID != -1)
{
Database.Records.NpcRecord npc = Helper.NpcHelper.GetTemplate(client.Action.ExchangeNpcID);
string[] data = packet.Substring(2).Split('|');
int templateID = int.Parse(data[0]);
int quantity = int.Parse(data[1]);
if (npc.SaleItems.Split(',').ToList().Contains(data[0]))
{
Database.Records.WorldItemRecord item = Helper.ItemHelper.GenerateItem(client, templateID);
if (client.Character.Kamas >= item.GetTemplate.Price * quantity)
{
if (Helper.ItemHelper.CanCreateStack(item.Template))
{
client.Character.Items.AddItem(item, false, quantity);
}
else
{
client.Character.Items.AddItem(item, true, quantity);
}
client.Action.RemoveKamas(item.GetTemplate.Price * quantity);
}
}
}
}
public static void ExecuteLiveAction()
{
var actions = Database.Records.LiveActionRecord.FindAll();
foreach (var a in actions)
{
var client = World.Helper.WorldHelper.GetClientByCharacter(a.PlayerID);
if (client != null)
{
switch (a.Action)
{
case ITEM_ACTION_ID:
Database.Records.WorldItemRecord item = Helper.ItemHelper.GenerateItem(client, a.Nombre);
client.Character.AddItem(item, 1);
client.Action.SystemMessage("L'objet <b>" + item.GetTemplate.Name + "</b> a ete ajouter a votre inventaire, merci de votre achat !");
client.Action.SaveContents();
break;
default:
Utilities.ConsoleStyle.Error("Action ID no supported yet !");
break;
}
//Delete the record
a.Delete();
}
}
}
public void RemoveItem(Database.Records.WorldItemRecord item, int quantity, bool removeFromDB = true)
{
if (_character != null)
{
if (_character.Player != null)
{
if (item.Quantity - quantity < 1)
{
_character.Player.Send("OR" + item.ID);
item.Owner = -1;
item.SaveAndFlush();
if (removeFromDB)
{
item.DeleteAndFlush();
}
Items.Remove(item);
}
else
{
item.Quantity -= quantity;
RefreshQuantity(item);
}
_character.Player.Action.RefreshPods();
}
}
}
public static void UseItem(World.Network.WorldClient client, string packet)
{
int id = int.Parse(packet.Substring(2).Split('|')[0]);
Database.Records.WorldItemRecord item = client.Character.Items.GetItem(id);
Interop.Scripting.ScriptManager.CallScript("use_item", item.Template, client, item);
}
public static Database.Records.WorldItemRecord GenerateItem(World.Network.WorldClient client, int templateID, bool canGenerateMount = true)
{
try
{
Database.Records.ItemRecord template = Database.Cache.ItemCache.Cache.First(x => x.ID == templateID);
Database.Records.WorldItemRecord item = new Database.Records.WorldItemRecord();
item.Template = templateID;
item.Engine.Effects = template.Engine.GetRandomEffect();
item.Owner = client.Character.ID;
item.Effects = item.Engine.StringEffect();
item.Position = -1;
item.Quantity = 1;
item.SaveAndFlush();
if (canGenerateMount)
{
Database.Records.MountTemplateRecord mount = Helper.MountHelper.GetMountTemplateByScrool(item.Template);
if (mount != null)
{
Database.Records.WorldMountRecord newWMount = Game.Mounts.MountFactory.CreateMount(mount, item.ID, client.Character.ID);
}
}
return(item);
}
catch (Exception e)
{
Utilities.ConsoleStyle.Error("Cant generate items : " + e.ToString());
return(null);
}
}
public static Database.Records.WorldItemRecord GenerateItem(World.Network.WorldClient client, int templateID, bool canGenerateMount = true)
{
try
{
Database.Records.ItemRecord template = Database.Cache.ItemCache.Cache.First(x => x.ID == templateID);
Database.Records.WorldItemRecord item = new Database.Records.WorldItemRecord();
item.Template = templateID;
item.Engine.Effects = template.Engine.GetRandomEffect();
item.Owner = client.Character.ID;
item.Effects = item.Engine.StringEffect();
item.Position = -1;
item.Quantity = 1;
item.SaveAndFlush();
if (canGenerateMount)
{
Database.Records.MountTemplateRecord mount = Helper.MountHelper.GetMountTemplateByScrool(item.Template);
if (mount != null)
{
Database.Records.WorldMountRecord newWMount = Game.Mounts.MountFactory.CreateMount(mount, item.ID, client.Character.ID);
}
}
return item;
}
catch (Exception e)
{
Utilities.ConsoleStyle.Error("Cant generate items : " + e.ToString());
return null;
}
}
public Database.Records.WorldItemRecord AddItem(Database.Records.WorldItemRecord item, bool newStack = false, int quantity = 1)
{
if (item.Position == -1)
{
try
{
dontHaveItem :;
if (!HaveItemWithSameEffects(item.Effects, -1, item.Template) || newStack)
{
item.Quantity = quantity;
item.SaveAndFlush();
Items.Add(item);
if (_character != null)
{
if (_character.Player != null)
{
_character.Player.Send("OAKO" + item.DisplayItem);
_character.Player.Action.RefreshPods();
}
}
return(item);
}
else
{
Database.Records.WorldItemRecord existItem = GetItemWithSameEffects(item.Effects, item.Template);
if (existItem != null)
{
item.DeleteAndFlush();
existItem.Quantity += quantity;
RefreshQuantity(existItem);
return(existItem);
}
else
{
newStack = true;
goto dontHaveItem;
}
}
}
catch (Exception e)
{
Utilities.ConsoleStyle.Error("Cant add item : " + e.ToString());
}
return(null);
}
else
{
if (_character != null)
{
if (_character.Player != null)
{
_character.Player.Send("OAKO" + item.DisplayItem);
_character.Player.Action.RefreshPods();
}
}
Items.Add(item);
return(item);
}
}
public bool HaveOneOfThisItem(Network.WorldClient owner, Database.Records.WorldItemRecord item)
{
if (this.Items.FindAll(x => x.WItem.ID == item.ID).Count > 0)
{
return(true);
}
return(false);
}
public ExchangeItem GetOneOfThisItem(Network.WorldClient owner, Database.Records.WorldItemRecord item)
{
if (this.Items.FindAll(x => x.WItem.ID == item.ID).Count > 0)
{
return(this.Items.FirstOrDefault(x => x.WItem.ID == item.ID));
}
return(null);
}
public static void DropItem(World.Network.WorldClient client, string packet)
{
if (!Utilities.ConfigurationManager.GetBoolValue("EnableDropItems"))
{
client.Action.SystemMessage("Impossible de jeter des objets sur ce serveur, la fonction n'est pas activer !");
return;
}
string[] data = packet.Substring(2).Split('|');
int id = int.Parse(data[0]);
int quantity = int.Parse(data[1]);
if (client.Character.Map.Engine.GetDroppedItem(client.Character.CellID) == null)
{
Database.Records.WorldItemRecord playerItem = client.Character.Items.GetItem(id);
if (playerItem != null)
{
if (quantity == playerItem.Quantity)
{
int itemPos = playerItem.Position;
playerItem.Position = -1;
//Delete the item
if (itemPos != -1)
{
playerItem.Engine.Effects.ForEach(x => client.Character.Stats.ApplyEffect(x, true));
client.Action.RefreshCharacter();
client.Character.Stats.RefreshStats();
client.Action.RefreshRoleplayEntity();
client.Action.RefreshPods();
}
client.Character.Items.RemoveItem(playerItem, playerItem.Quantity, false);
client.Character.Map.Engine.AddNewDroppedItem(playerItem, client.Character.CellID);
}
else if (quantity < playerItem.Quantity)
{
//Remove quantity and create another object stack
Database.Records.WorldItemRecord duplicatedItem = new Database.Records.WorldItemRecord()
{
Template = playerItem.Template,
Quantity = quantity,
Effects = playerItem.Effects,
Position = -1,
};
duplicatedItem.Engine.Load(duplicatedItem.Effects, duplicatedItem.GetTemplate.WeaponInfo);
client.Character.Items.RemoveItem(playerItem, quantity);
client.Character.Map.Engine.AddNewDroppedItem(duplicatedItem, client.Character.CellID);
}
client.Character.RefreshItemSet();
client.Action.RefreshCharacterJob(true);
}
}
else
{
client.Send("BN");
}
}
public void RefreshQuantity(Database.Records.WorldItemRecord item)
{
if (_character != null)
{
if (_character.Player != null)
{
_character.Player.Send("OQ" + item.ID + "|" + item.Quantity);
}
}
}
public static void DropItem(World.Network.WorldClient client, string packet)
{
if (!Utilities.ConfigurationManager.GetBoolValue("EnableDropItems"))
{
client.Action.SystemMessage("Impossible de jeter des objets sur ce serveur, la fonction n'est pas activer !");
return;
}
string[] data = packet.Substring(2).Split('|');
int id = int.Parse(data[0]);
int quantity = int.Parse(data[1]);
if (client.Character.Map.Engine.GetDroppedItem(client.Character.CellID) == null)
{
Database.Records.WorldItemRecord playerItem = client.Character.Items.GetItem(id);
if (playerItem != null)
{
if (quantity == playerItem.Quantity)
{
int itemPos = playerItem.Position;
playerItem.Position = -1;
//Delete the item
if (itemPos != -1)
{
playerItem.Engine.Effects.ForEach(x => client.Character.Stats.ApplyEffect(x, true));
client.Action.RefreshCharacter();
client.Character.Stats.RefreshStats();
client.Action.RefreshRoleplayEntity();
client.Action.RefreshPods();
}
client.Character.Items.RemoveItem(playerItem, playerItem.Quantity, false);
client.Character.Map.Engine.AddNewDroppedItem(playerItem, client.Character.CellID);
}
else if (quantity < playerItem.Quantity)
{
//Remove quantity and create another object stack
Database.Records.WorldItemRecord duplicatedItem = new Database.Records.WorldItemRecord()
{
Template = playerItem.Template,
Quantity = quantity,
Effects = playerItem.Effects,
Position = -1,
};
duplicatedItem.Engine.Load(duplicatedItem.Effects, duplicatedItem.GetTemplate.WeaponInfo);
client.Character.Items.RemoveItem(playerItem, quantity);
client.Character.Map.Engine.AddNewDroppedItem(duplicatedItem, client.Character.CellID);
}
client.Character.RefreshItemSet();
client.Action.RefreshCharacterJob(true);
}
}
else
{
client.Send("BN");
}
}
public ExchangeItem GetOneOfThisItem(Network.WorldClient owner, Database.Records.WorldItemRecord item)
{
var stack = GetStackByOwner(owner);
if (stack.FindAll(x => x.WItem.ID == item.ID).Count > 0)
{
return(stack.FirstOrDefault(x => x.WItem.ID == item.ID));
}
return(null);
}
public bool HaveOneOfThisItem(Network.WorldClient owner, Database.Records.WorldItemRecord item)
{
var stack = GetStackByOwner(owner);
if (stack.FindAll(x => x.WItem.ID == item.ID).Count > 0)
{
return(true);
}
return(false);
}
public Database.Records.WorldItemRecord AddItem(Database.Records.WorldItemRecord item, int quantity)
{
if (World.Helper.ItemHelper.CanCreateStack(item.Template))
{
return(this.Items.AddItem(item, false, quantity));
}
else
{
return(this.Items.AddItem(item, true, quantity));
}
}
public static void WantBuyObject(World.Network.WorldClient client, int id)
{
if (client.Character != null)
{
Database.Records.ShopItemRecord item = Helper.ShopHelper.FindShopItem(id);
if (Communication.Realm.Communicator.Server.MainRealm != null)
{
if (item != null)
{
int price = item.NormalPrice;
if (item.Vip == 1)
{
if (client.Account.Vip != 1)
{
client.Action.SystemMessage("Vous devez etre VIP vous acheter cette objet");
return;
}
}
if (client.Account.Points >= price)
{
Database.Records.ItemRecord template = Database.Cache.ItemCache.Cache.FirstOrDefault(x => x.ID == item.TemplateID);
if (template != null)
{
client.Account.Points -= price;
Communication.Realm.Communicator.Server.MainRealm.SendMessage(new Communication.Realm.Packet.ClientShopPointUpdateMessage(client.Account.Username, client.Account.Points));
Database.Records.WorldItemRecord gItem = Helper.ItemHelper.GenerateItem(client, template.ID);
if (Helper.ItemHelper.CanCreateStack(gItem.Template))
{
client.Character.Items.AddItem(gItem, false, 1);
}
else
{
client.Character.Items.AddItem(gItem, true, 1);
}
Logger.WriteLine("Le compte '" + client.Account.Username + "' a acheter un objet a " + price + " points (" + template.Name + ") a " + DateTime.Now.ToString());
client.Action.SystemMessage("<b>Felicitations !</b> L'objet <i>" + template.Name + "</i> est desormais dans votre inventaire ! Il vous reste <b>" + client.Account.Points + "</b> " + Utilities.ConfigurationManager.GetStringValue("ShopPointName"));
}
}
else
{
client.Action.SystemMessage("Il vous manque <b>" + (price - client.Account.Points) + "</b> " + Utilities.ConfigurationManager.GetStringValue("ShopPointName") + " pour acheter ceci !");
}
}
else
{
client.Action.SystemMessage("L'achat <b>n" + id + "</b> n'existe pas !");
}
}
else
{
client.Action.SystemMessage("Le serveur de connexion n'est pas disponible pour enregistrer votre achat, veuilliez essayer ulterieurement !");
}
}
}
public static void SellObject(Network.WorldClient client, string packet)
{
if (client.State == Network.WorldClientState.OnExchangePnj && client.Action.ExchangeNpcID != -1)
{
string[] data = packet.Substring(2).Split('|');
int quantity = int.Parse(data[1]);
Database.Records.WorldItemRecord item = client.Character.Items.GetItem(int.Parse(data[0]));
if (item != null)
{
if (item.Quantity >= quantity)
{
client.Character.Items.RemoveItem(item, quantity);
client.Action.AddKamas(Math.Abs(quantity * (item.GetTemplate.Price / 10)));
}
}
}
}
public Database.Records.WorldItemRecord DuplicateItem(Database.Records.WorldItemRecord item, int pos, bool send = true)
{
Database.Records.WorldItemRecord newItem = new Database.Records.WorldItemRecord();
newItem.Effects = item.Effects;
newItem.Template = item.Template;
newItem.Position = pos;
newItem.Quantity = 1;
newItem.Owner = item.Owner;
newItem.Engine.Load(newItem.Effects, item.GetTemplate.WeaponInfo);
newItem.SaveAndFlush();
if (send)
{
Items.Add(newItem);
_character.Player.Send("OAKO" + newItem.DisplayItem);
_character.Player.Action.RefreshPods();
}
return(newItem);
}
public void Craft(Network.WorldClient client)
{
var recipe = JobHelper.GetCraft(this.BaseSkill.ID, this.Items);
var chance = this.BaseSkill.GetCraftChance(this.Items.Count);
var success = false;
if (chance >= Utilities.Basic.Rand(0, 100))
{
success = true;
}
System.Threading.Thread.Sleep(750);
if (recipe != null)
{
if (success)
{
Database.Records.WorldItemRecord item = Helper.ItemHelper.GenerateItem(client, recipe.ID);
var i = client.Character.AddItem(item, 1);
client.Action.RefreshPods();
client.Send("EmKO+" + i.ID + "|1|" + recipe.ID + "|" + item.DisplayItem);
client.Send("EcK;" + recipe.ID);
client.Character.Map.Engine.Send("IO" + client.Character.ID + "|+" + recipe.ID);
client.Send("Ea1");
this.LastRecipe = this.Items.ToArray().ToList();
}
else
{
client.Send("EcEF");
}
}
else
{
client.Send("EcEI");
}
this.DeleteRecipeFromClient();
this.Job.SendJob(client);
this.Items.Clear();
this.Refresh();
this.Client.Action.SaveContents();
}
public static Database.Records.WorldItemRecord GenerateItem(int templateID)
{
try
{
Database.Records.ItemRecord template = Database.Cache.ItemCache.Cache.First(x => x.ID == templateID);
Database.Records.WorldItemRecord item = new Database.Records.WorldItemRecord();
item.Template = templateID;
item.Engine.Effects = template.Engine.GetRandomEffect();
item.Owner = -1;
item.Effects = item.Engine.StringEffect();
item.Position = -1;
item.Quantity = 1;
return(item);
}
catch (Exception e)
{
Utilities.ConsoleStyle.Error("Cant generate items : " + e.ToString());
return(null);
}
}
public static Database.Records.WorldItemRecord GenerateItem(int templateID)
{
try
{
Database.Records.ItemRecord template = Database.Cache.ItemCache.Cache.First(x => x.ID == templateID);
Database.Records.WorldItemRecord item = new Database.Records.WorldItemRecord();
item.Template = templateID;
item.Engine.Effects = template.Engine.GetRandomEffect();
item.Owner = -1;
item.Effects = item.Engine.StringEffect();
item.Position = -1;
item.Quantity = 1;
return item;
}
catch (Exception e)
{
Utilities.ConsoleStyle.Error("Cant generate items : " + e.ToString());
return null;
}
}
public static void DeleteItem(World.Network.WorldClient client, string packet)
{
try
{
string[] data = packet.Substring(2).Split('|');
var id = int.Parse(data[0]);
int quantity = int.Parse(data[1]);
if (quantity > 0)
{
Database.Records.WorldItemRecord item = client.Character.Items.GetItem(id);
if (item.Position != -1)
{
item.Engine.Effects.ForEach(x => client.Character.Stats.ApplyEffect(x, true));
client.Character.Stats.RefreshStats();
}
client.Character.Items.RemoveItem(item, quantity);
client.Action.RefreshCharacter();
client.Character.RefreshItemSet();
client.Action.RefreshCharacterJob(true);
}
}
catch { }
}
public void SkillFinished(Network.WorldClient client, IO.InteractiveObject io)
{
try
{
if (JobHelper.GetItemBySkill(this.ID) != -1)
{
var quantity = Utilities.Basic.Rand(this.Min, this.GetDesByLevel());
Database.Records.WorldItemRecord item = Helper.ItemHelper.GenerateItem(client, JobHelper.GetItemBySkill(this.ID));
client.Character.AddItem(item, quantity);
client.Send("IQ" + client.Character.ID + "|" + quantity);
client.Action.RefreshPods();
this.BaseJob.AddExp(this.Exp, client);
}
}
catch (Exception e)
{
Utilities.ConsoleStyle.Error("Can't finish job skill : " + e.ToString());
}
io.SetEmpty();
io.StartRespawnTimer();
}
public void AddNewDroppedItem(Database.Records.WorldItemRecord item, int cellid)
{
this.ShowDroppedItem(item, cellid);
this.DroppedItems.Add(cellid, item);
}
public void ExecuteWithClientArg(ScriptArgs args, World.Network.WorldClient client, params object[] parameters)
{
try
{
switch (args.Args[0])
{
case "player":
switch (args.Args[1])
{
case "goto":
World.Network.World.GoToMap(client, args.GetIntValue(2), args.GetIntValue(3));
break;
case "respawn":
World.Network.World.GoToMap(client, client.Character.SaveMap, client.Character.SaveCell);
break;
case "dialog":
switch (args.Args[2])
{
case "start":
//TODO!
break;
}
break;
case "life":
switch (args.Args[2])
{
case "restore":
client.Action.Regen(int.Parse(args.Args[3]));
break;
}
break;
case "message":
client.Action.SystemMessage(args.GetStringValue(2));
break;
case "align":
switch (args.Args[2])
{
case "set":
if (client.Character.Fighter == null)
{
client.Character.Faction.SetAlign(int.Parse(args.Args[3]));
}
else
{
client.Action.SystemMessage("Impossible en combat !");
}
break;
}
break;
case "need":
switch (args.Args[2])
{
case "mj":
if (client.Account.AdminLevel < int.Parse(args.Args[3]))
{
client.Action.SystemMessage("Vous ne posseder pas les conditions requises !");
return;
}
break;
}
break;
case "look":
switch (args.Args[2])
{
case "set":
client.Character.Look = int.Parse(args.Args[3]);
client.Action.RefreshRoleplayEntity();
break;
case "normal":
break;
}
break;
case "scale":
switch (args.Args[2])
{
case "set":
client.Character.Scal = int.Parse(args.Args[3]);
client.Action.RefreshRoleplayEntity();
break;
case "normal":
client.Character.Scal = 100;
client.Action.RefreshRoleplayEntity();
break;
}
break;
case "elite":
switch (args.Args[2])
{
case "up":
World.Game.Elite.EliteManager.UpElite(client);
break;
}
break;
case "level":
switch (args.Args[2])
{
case "set":
if (client.Character.Fighter == null)
{
Database.Records.ExpFloorRecord floor = World.Helper.ExpFloorHelper.GetCharactersLevelFloor(int.Parse(args.Args[3]));
client.Character.Experience = floor.Character;
client.Action.TryLevelUp();
}
else
{
client.Action.SystemMessage("Impossible en combat !");
}
break;
case "add":
if (client.Character.Fighter == null)
{
int addedLevel = int.Parse(args.Args[3]);
int nextLevel = client.Character.Level + addedLevel;
if (nextLevel > 5000)
{
nextLevel = 5000;
}
Database.Records.ExpFloorRecord floor = World.Helper.ExpFloorHelper.GetCharactersLevelFloor(nextLevel);
client.Character.Experience = floor.Character;
client.Action.TryLevelUp();
}
else
{
client.Action.SystemMessage("Impossible en combat !");
}
break;
}
break;
}
break;
case "ui":
switch (args.Args[1])
{
case "show":
switch (args.Args[2])
{
case "paddock":
client.Character.Map.Engine.ShowPaddocksMounts(client);
break;
case "guild":
client.Send("gn");
break;
}
break;
}
break;
case "this":
switch (args.Args[1])
{
case "item":
switch (args.Args[2])
{
case "remove":
Database.Records.WorldItemRecord toDeleteItem = (Database.Records.WorldItemRecord)parameters[0];
client.Character.Items.RemoveItem(toDeleteItem, 1);
break;
}
break;
}
break;
}
}
catch { }
}
public void ProcessExchange()
{
#region Item Process
foreach (var item in this.ItemsStack1)
{
if (item.Quantity == item.WItem.Quantity)
{
Requester.Character.Items.RemoveItem(item.WItem, item.Quantity, false);
Requested.Character.Items.AddItem(item.WItem, false, item.Quantity);
item.WItem.Owner = Requested.Character.ID;
}
else
{
var newItem = new Database.Records.WorldItemRecord()
{
Owner = Requested.Character.ID,
Template = item.WItem.Template,
Quantity = item.Quantity,
Position = -1,
Effects = item.WItem.Effects,
};
Requester.Character.Items.RemoveItem(item.WItem, item.Quantity);
newItem.Engine.Load(newItem.Effects, newItem.GetTemplate.WeaponInfo);
Requested.Character.Items.AddItem(newItem);
newItem.SaveAndFlush();
}
item.WItem.SaveAndFlush();
}
foreach (var item in this.ItemsStack2)
{
if (item.Quantity == item.WItem.Quantity)
{
Requested.Character.Items.RemoveItem(item.WItem, item.Quantity, false);
Requester.Character.Items.AddItem(item.WItem, false, item.Quantity);
item.WItem.Owner = Requester.Character.ID;
}
else
{
var newItem = new Database.Records.WorldItemRecord()
{
Owner = Requester.Character.ID,
Template = item.WItem.Template,
Quantity = item.Quantity,
Position = -1,
Effects = item.WItem.Effects,
};
Requested.Character.Items.RemoveItem(item.WItem, item.Quantity);
newItem.Engine.Load(newItem.Effects, newItem.GetTemplate.WeaponInfo);
Requester.Character.Items.AddItem(newItem);
newItem.SaveAndFlush();
}
item.WItem.SaveAndFlush();
}
#endregion
#region Kamas Process
Requester.Character.Kamas -= Requester.Action.KamasExchangeStack;
Requested.Character.Kamas += Requester.Action.KamasExchangeStack;
Requested.Character.Kamas -= Requested.Action.KamasExchangeStack;
Requester.Character.Kamas += Requested.Action.KamasExchangeStack;
#endregion
this.Requester.Send("EVa");
this.Requested.Send("EVa");
this.Exit(false);
this.Requester.Action.SaveContents();
this.Requested.Action.SaveContents();
this.Requester.Character.Stats.RefreshStats();
this.Requested.Character.Stats.RefreshStats();
}
public void ProcessExchange()
{
#region Item Process
foreach (var item in this.ItemsStack1)
{
if (item.Quantity == item.WItem.Quantity)
{
Requester.Character.Items.RemoveItem(item.WItem, item.Quantity, false);
Requested.Character.Items.AddItem(item.WItem, false, item.Quantity);
item.WItem.Owner = Requested.Character.ID;
}
else
{
var newItem = new Database.Records.WorldItemRecord()
{
Owner = Requested.Character.ID,
Template = item.WItem.Template,
Quantity = item.Quantity,
Position = -1,
Effects = item.WItem.Effects,
};
Requester.Character.Items.RemoveItem(item.WItem, item.Quantity);
newItem.Engine.Load(newItem.Effects, newItem.GetTemplate.WeaponInfo);
Requested.Character.Items.AddItem(newItem);
newItem.SaveAndFlush();
}
item.WItem.SaveAndFlush();
}
foreach (var item in this.ItemsStack2)
{
if (item.Quantity == item.WItem.Quantity)
{
Requested.Character.Items.RemoveItem(item.WItem, item.Quantity, false);
Requester.Character.Items.AddItem(item.WItem, false, item.Quantity);
item.WItem.Owner = Requester.Character.ID;
}
else
{
var newItem = new Database.Records.WorldItemRecord()
{
Owner = Requester.Character.ID,
Template = item.WItem.Template,
Quantity = item.Quantity,
Position = -1,
Effects = item.WItem.Effects,
};
Requested.Character.Items.RemoveItem(item.WItem, item.Quantity);
newItem.Engine.Load(newItem.Effects, newItem.GetTemplate.WeaponInfo);
Requester.Character.Items.AddItem(newItem);
newItem.SaveAndFlush();
}
item.WItem.SaveAndFlush();
}
#endregion
#region Kamas Process
Requester.Character.Kamas -= Requester.Action.KamasExchangeStack;
Requested.Character.Kamas += Requester.Action.KamasExchangeStack;
Requested.Character.Kamas -= Requested.Action.KamasExchangeStack;
Requester.Character.Kamas += Requested.Action.KamasExchangeStack;
#endregion
this.Requester.Send("EVa");
this.Requested.Send("EVa");
this.Exit(false);
this.Requester.Action.SaveContents();
this.Requested.Action.SaveContents();
this.Requester.Character.Stats.RefreshStats();
this.Requested.Character.Stats.RefreshStats();
}
public void ShowDroppedItem(Database.Records.WorldItemRecord item, int cellid)
{
this.Send("GDO+" + cellid + ";" + item.Template + ";" + 0);
}
public static void EndAction(WorldClient client, string packet)
{
if (packet[3] == '0')
{
#region Battle
/* If in battle */
if (client.Character.Fighter != null)
{
client.Character.Fighter.Team.Fight.PlayerEndMove(client.Character.Fighter);
return;
}
#endregion
#region Cell ID
var oldCell = client.Character.CellID;
client.Character.CellID = client.Character.NextMove;
#endregion
#region Dropped Items
Database.Records.WorldItemRecord droppedItem = client.Character.Map.Engine.GetDroppedItem(client.Character.CellID);
if (droppedItem != null)
{
if (client.Character.Items.HaveItemWithSameEffects(droppedItem.Effects) &&
client.Character.Items.HaveItem(droppedItem.Template))
{
client.Character.Items.AddItem(droppedItem, false, droppedItem.Quantity);
}
else
{
client.Character.Items.AddItem(droppedItem, true, droppedItem.Quantity);
droppedItem.Owner = client.Character.ID;
}
client.Character.Map.Engine.RemoveDroppedItem(droppedItem, client.Character.CellID);
}
#endregion
#region Zaaps
/* Zaap use request */
if (client.State == WorldClientState.OnRequestZaap)
{
if (client.Character.Map.Engine.Zaap != null)
{
if (client.Character.CellID == client.Character.Map.Engine.Zaap.CellID)
{
ZaapHandler.OpenZaapPanel(client);
}
}
}
#endregion
#region Incarnam Teleporter
/* Incarnam statue teleporter request */
if (client.State == WorldClientState.OnRequestIncarnamStatue)
{
Database.Records.IncarnamTeleportRecord incarnamTP = Helper.MapHelper.FindIncarnamTeleporter(client.Character.MapID);
if (incarnamTP != null)
{
if (incarnamTP.CellID == client.Character.CellID)
{
if (incarnamTP.MaxLevel > client.Character.Level)
{
Database.Records.OriginalBreedStartMapRecord startmap = Helper.MapHelper.GetOriginalBreedStartMap(client.Character.Breed);
Network.World.GoToMap(client, startmap.MapID, startmap.CellID);
}
else
{
client.SendImPacket("13");
}
client.State = WorldClientState.None;
}
}
}
#endregion
#region Guild Creator Location
/* Guid creator location */
if (Utilities.ConfigurationManager.GetBoolValue("EnableGuildCreationLocation"))
{
Database.Records.GuildCreatorLocationRecord guildCreator = Helper.MapHelper.FindGuildCreator(client.Character.MapID, client.Character.CellID);
if (guildCreator != null)
{
if (client.Character.Level >= guildCreator.RequiredLevel)
{
//TODO: Check object creator required
client.Send("gn");
}
else
{
client.SendImPacket("13");
}
}
}
#endregion
#region Mount Door
if (client.State == WorldClientState.OnRequestMountDoor)
{
client.Character.Map.Engine.ShowPaddocksMounts(client, client.Character.CellID);
}
#endregion
#region Job
if (client.Action.NextJobSkill != null)
{
var io = client.Character.Map.Engine.GetIO(client.Character.CellID);
if (io != null)
{
if (!client.Action.NextJobSkill.DoSkill(client, io))
{
client.Action.NextJobSkill = null;
}
}
else
{
client.Action.NextJobSkill = null;
}
}
#endregion
#region Monsters
/* Monsters On Pos */
Engines.Map.MonsterGroup monstersOnCell = client.Character.Map.Engine.GetMonsterGroupOnCell(client.Character.CellID);
if (monstersOnCell != null)
{
if (monstersOnCell.Leader == null)
{
return;
}
var freeCell = client.Character.Map.Engine.PathfindingMaker.FreeCellNeightboor(client.Character.CellID);
if (freeCell != -1)
{
client.Character.CellID = freeCell;
}
StartMonstersBattle(client, monstersOnCell);
client.Character.Map.Engine.RemoveMonstersOnMap(monstersOnCell);
client.Character.Map.Engine.Spawner.GenerateOneGroup();
client.Character.Map.Engine.Players.CharactersOnMap.ForEach(x => client.Character.Map.Engine.ShowMonstersGroup(x));
return;
}
#endregion
#region Triggers
/* Change map by trigger */
if (client.Character.Map.Triggers.FindAll(x => x.CellID == client.Character.CellID).Count > 0)
{
Database.Records.TriggerRecord trigger = client.Character.Map.Triggers.FirstOrDefault(x => x.CellID == client.Character.CellID);
if (client.Character.Level >= trigger.LevelRequired)
{
World.Network.World.GoToMap(client, trigger.NextMap, trigger.NextCell);
}
else
{
client.Action.SystemMessage("Vous n'avez pas level requis pour rentrer sur cette carte, level requis : <b>" + trigger.LevelRequired + "</b>");
}
return;
}
#endregion
#region Script
Interop.PythonScripting.ScriptManager.CallEventPlayerMovement(client, oldCell, client.Character.CellID);
#endregion
}
else
{
//Doing job stuff
if (client.Action.NextJobSkill != null)
{
var io = client.Character.Map.Engine.GetIO(client.Character.CellID);
if (io != null)
{
client.Action.NextJobSkill.SkillFinished(client, io);
}
client.Action.NextJobSkill = null;
}
}
client.State = WorldClientState.None;
}
public void APIAddItem(int templateID, int quantity)
{
Database.Records.WorldItemRecord item = Helper.ItemHelper.GenerateItem(this, templateID);
this.Character.AddItem(item, quantity);
}
public ExchangeItem(Database.Records.WorldItemRecord item, int quantity)
{
this.WItem = item;
this.Quantity = quantity;
}
public void RemoveDroppedItem(Database.Records.WorldItemRecord item, int cellid)
{
this.UnShowDroppedItem(cellid);
this.DroppedItems.Remove(cellid);
}
public void ShowDroppedItem(Database.Records.WorldItemRecord item, int cellid, World.Network.WorldClient client)
{
client.Send("GDO+" + cellid + ";" + item.Template + ";" + 0);
}
public Database.Records.WorldItemRecord DuplicateItem(Database.Records.WorldItemRecord item, int pos, bool send = true)
{
Database.Records.WorldItemRecord newItem = new Database.Records.WorldItemRecord();
newItem.Effects = item.Effects;
newItem.Template = item.Template;
newItem.Position = pos;
newItem.Quantity = 1;
newItem.Owner = item.Owner;
newItem.Engine.Load(newItem.Effects, item.GetTemplate.WeaponInfo);
newItem.SaveAndFlush();
if (send)
{
Items.Add(newItem);
_character.Player.Send("OAKO" + newItem.DisplayItem);
_character.Player.Action.RefreshPods();
}
return newItem;
}
