/// <summary>
/// Called on every timer tick
/// </summary>
protected override void OnTick()
{
var player = (GamePlayer)m_actionSource;
switch (_enter)
{
case 0:
player.LeaveHouse();
break;
case 1:
if (!player.IsWithinRadius(_house, WorldMgr.VISIBILITY_DISTANCE) || (player.CurrentRegionID != _house.RegionID))
{
ChatUtil.SendSystemMessage(player, string.Format("You are too far away to enter house {0}.", _house.HouseNumber));
return;
}
// make sure player can enter
if (_house.CanEnterHome(player))
{
player.CurrentHouse = _house;
_house.Enter(player);
}
else
{
ChatUtil.SendSystemMessage(player, string.Format("You can't enter house {0}.", _house.HouseNumber));
return;
}
break;
}
}
public virtual void DisplaySyntax(GameClient client, string subcommand1, string subcommand2)
{
if (client == null || !client.IsPlaying)
{
return;
}
var attrib = (CmdAttribute[])GetType().GetCustomAttributes(typeof(CmdAttribute), false);
if (attrib.Length == 0)
{
return;
}
foreach (string sentence in attrib[0].Usage)
{
string[] words = sentence.Split(new[] { ' ' }, 4);
if (words.Length >= 3 && words[1].Equals(subcommand1) && words[2].Equals(subcommand2))
{
ChatUtil.SendSystemMessage(client, sentence, null);
}
}
return;
}
private static void HouseUpgradeDialog(GamePlayer player, byte response)
{
if (response != 0x01)
{
return;
}
var itemWeak = player.TempProperties.getProperty <WeakReference>(DeedWeak, new WeakRef(null));
player.TempProperties.removeProperty(DeedWeak);
var item = (InventoryItem)itemWeak.Target;
var house = (House)player.TempProperties.getProperty <object>(TargetHouse, null);
player.TempProperties.removeProperty(TargetHouse);
if (house == null)
{
ChatUtil.SendSystemMessage(player, "No House selected!");
return;
}
if (item == null || item.SlotPosition == (int)eInventorySlot.Ground ||
item.OwnerID == null || item.OwnerID != player.InternalID)
{
ChatUtil.SendSystemMessage(player, "This does not work without a House Deed.");
return;
}
if (HouseMgr.UpgradeHouse(house, item))
{
player.Inventory.RemoveItem(item);
InventoryLogging.LogInventoryAction(player, $"(HOUSE;{house.HouseNumber})", eInventoryActionType.Other, item.Template, item.Count);
}
}
public virtual void DisplayMessage(GameClient client, string message, params object[] objs)
{
if (client == null || !client.IsPlaying)
{
return;
}
ChatUtil.SendSystemMessage(client, string.Format(message, objs));
return;
}
/// <summary>
/// Called on every timer tick
/// </summary>
protected override void OnTick()
{
var player = (GamePlayer)m_actionSource;
if (!player.IsRiding)
{
ChatUtil.SendSystemMessage(player, "You are not riding any steed!");
return;
}
player.DismountSteed(false);
}
/// <summary>
/// Called on every timer tick
/// </summary>
protected override void OnTick()
{
var player = (GamePlayer)m_actionSource;
if (player.TargetObject == null || player.TargetObject == player)
{
ChatUtil.SendSystemMessage(player, "You have not selected a valid player as your target.");
return;
}
if (!(player.TargetObject is GamePlayer))
{
ChatUtil.SendSystemMessage(player, "You have not selected a valid player as your target.");
return;
}
var target = (GamePlayer)player.TargetObject;
if (player.Group != null && player.Group.Leader != player)
{
ChatUtil.SendSystemMessage(player, "You are not the leader of your group.");
return;
}
if (player.Group != null && player.Group.MemberCount >= ServerProperties.Properties.GROUP_MAX_MEMBER)
{
ChatUtil.SendSystemMessage(player, "The group is full.");
return;
}
if (!GameServer.ServerRules.IsAllowedToGroup(player, target, false))
{
return;
}
if (target.Group != null)
{
ChatUtil.SendSystemMessage(player, "The player is still in a group.");
return;
}
ChatUtil.SendSystemMessage(player, "You have invited " + target.Name + " to join your group.");
target.Out.SendGroupInviteCommand(player,
player.Name + " has invited you to join\n" + player.GetPronoun(1, false) +
" group. Do you wish to join?");
ChatUtil.SendSystemMessage(target,
player.Name + " has invited you to join " + player.GetPronoun(1, false) + " group.");
}
private static void HouseRemovalDialog(GamePlayer player, byte response)
{
if (response != 0x01)
{
return;
}
var itemWeak = player.TempProperties.getProperty <WeakReference>(DeedWeak, new WeakRef(null));
player.TempProperties.removeProperty(DeedWeak);
var item = (InventoryItem)itemWeak.Target;
var house = player.TempProperties.getProperty <House>(TargetHouse, null);
player.TempProperties.removeProperty(TargetHouse);
if (house == null)
{
ChatUtil.SendSystemMessage(player, "No house selected!");
return;
}
if (item == null || item.SlotPosition == (int)eInventorySlot.Ground ||
item.OwnerID == null || item.OwnerID != player.InternalID)
{
ChatUtil.SendSystemMessage(player, "You need a House Removal Deed for this.");
return;
}
// Demand any consignment merchant inventory is removed before allowing a removal
// Again, note that sometimes checks are done here, sometimes in housemgr. In this case, at least,
// player will get remove item back if they answer no! - tolakram
var consignmentMerchant = house.ConsignmentMerchant;
if (consignmentMerchant != null && (consignmentMerchant.DBItems(player).Count > 0 || consignmentMerchant.TotalMoney > 0))
{
ChatUtil.SendSystemMessage(player, "All items and money must be removed from your consignment merchant in order to remove this house!");
return;
}
player.Inventory.RemoveItem(item);
Log.Warn($"HOUSING: {player.Name}:{player.Client.Account.Name} is removing house from lot {house.HouseNumber} owned by {house.OwnerID}");
InventoryLogging.LogInventoryAction(player, $"(HOUSE;{house.HouseNumber})", eInventoryActionType.Other, item.Template, item.Count);
HouseMgr.RemoveHouse(house);
ChatUtil.SendSystemMessage(player, "Your house has been removed!");
}
/// <summary>
/// Does the player want to Log the offset location of the missing housepoint
/// </summary>
/// <param name="player">The player</param>
/// <param name="response">1 = yes 0 = no</param>
private void LogLocation(GamePlayer player, byte response)
{
if (response != 0x01)
{
return;
}
if (player.CurrentHouse == null)
{
return;
}
var a = new HouseHookpointOffset
{
HouseModel = player.CurrentHouse.Model,
HookpointID = _position,
X = player.X - player.CurrentHouse.X,
Y = player.Y - player.CurrentHouse.Y,
Z = player.Z - 25000,
Heading = player.Heading - player.CurrentHouse.Heading
};
if (GameServer.Database.AddObject(a) && House.AddNewOffset(a))
{
ChatUtil.SendSystemMessage(player, "Scripts.Player.Housing.HookPointLogged", _position);
string action = string.Format("HOUSING: {0} logged new HouseHookpointOffset for model {1}, position {2}, offset {3}, {4}, {5}",
player.Name, a.HouseModel, a.HookpointID, a.X, a.Y, a.Z);
log.Debug(action);
GameServer.Instance.LogGMAction(action);
}
else
{
log.Error(
string.Format(
"HOUSING: Player {0} error adding HouseHookpointOffset for model {1}, position {2}, offset {3}, {4}, {5}",
player.Name, a.HouseModel, a.HookpointID, a.X, a.Y, a.Z));
ChatUtil.SendSystemMessage(player, "Error adding position " + _position + ", error recorded in server error Log.");
}
}
/// <summary>
/// Transfer a house to a guild house
/// </summary>
/// <param name="player"></param>
/// <param name="house"></param>
/// <returns></returns>
public static bool HouseTransferToGuild(GamePlayer player, House house)
{
// player must be in a guild
if (player.Guild == null)
{
return(false);
}
// player's guild can't already have a guild house
if (player.Guild.GuildOwnsHouse)
{
return(false);
}
// player needs to own the house to be able to xfer it
if (house.HasOwnerPermissions(player) == false)
{
ChatUtil.SendSystemMessage(player, "You do not own this house!");
return(false);
}
// player needs to be a GM in the guild to xfer his personal house to the guild
if (player.Guild.HasRank(player, Guild.eRank.Leader) == false)
{
ChatUtil.SendSystemMessage(player, "You are not the leader of a guild!");
return(false);
}
// Demand any consignment merchant inventory is removed before allowing a transfer
var consignmentMerchant = house.ConsignmentMerchant;
if (consignmentMerchant != null && (consignmentMerchant.DBItems().Count > 0 || consignmentMerchant.TotalMoney > 0))
{
ChatUtil.SendSystemMessage(player, "All items and money must be removed from your consigmment merchant in order to transfer this house!");
return(false);
}
// send house xfer prompt to player
player.Out.SendCustomDialog(LanguageMgr.GetTranslation(player.Client.Account.Language, "Scripts.Player.Housing.TransferToGuild", player.Guild.Name), MakeGuildLot);
return(true);
}
public virtual void DisplaySyntax(GameClient client)
{
if (client == null || !client.IsPlaying)
{
return;
}
var attrib = (CmdAttribute[])GetType().GetCustomAttributes(typeof(CmdAttribute), false);
if (attrib.Length == 0)
{
return;
}
ChatUtil.SendSystemMessage(client, attrib[0].Description, null);
foreach (string sentence in attrib[0].Usage)
{
ChatUtil.SendSystemMessage(client, sentence, null);
}
return;
}
public override bool Interact(GamePlayer player)
{
if (!base.Interact(player))
{
return(false);
}
House house = HouseMgr.GetHouseByPlayer(player);
if (house != null)
{
//the player might be targeting a lot he already purchased that has no house on it yet
if (house.HouseNumber != DatabaseItem.HouseNumber && player.Client.Account.PrivLevel != (int)ePrivLevel.Admin)
{
ChatUtil.SendSystemMessage(player, "You already own a house!");
return(false);
}
}
if (string.IsNullOrEmpty(DatabaseItem.OwnerID))
{
player.Out.SendCustomDialog("Do you want to buy this lot?\r\n It costs " + Money.GetString(HouseTemplateMgr.GetLotPrice(DatabaseItem)) + "!", BuyLot);
}
else
{
if (HouseMgr.IsOwner(DatabaseItem, player))
{
player.Out.SendMerchantWindow(HouseTemplateMgr.GetLotMarkerItems(this), eMerchantWindowType.Normal);
}
else
{
ChatUtil.SendSystemMessage(player, "You do not own this lot!");
}
}
return(true);
}
public void OnCommand(GameClient client, string[] args)
{
if (IsSpammingCommand(client.Player, "boot"))
{
return;
}
House house = client.Player.CurrentHouse;
if (house == null)
{
DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "Scripts.Players.Boot.InHouseError"));
return;
}
// no permission to banish, return
if (!house.CanBanish(client.Player))
{
DisplayMessage(client, "You do not have permissions to do that.");
return;
}
// check each player, try and find player with the given name (lowercase cmp)
foreach (GamePlayer player in house.GetAllPlayersInHouse())
{
if (player != client.Player && player.Name.ToLower() != args[1].ToLower())
{
ChatUtil.SendSystemMessage(client, "Scripts.Players.Boot.YouRemoved", client.Player.Name);
player.LeaveHouse();
return;
}
}
ChatUtil.SendHelpMessage(client, "Scripts.Players.Boot.NoOneOnline", null);
}
private void ReloadMobs(GamePlayer player, ushort region, string arg1, string arg2)
{
if (region == 0)
{
log.Info("Region reload not supported from console.");
return;
}
ChatUtil.SendSystemMessage(player, "Reloading Mobs: " + arg1 + ", " + arg2 + " ...");
int count = 0;
foreach (GameNPC mob in WorldMgr.GetNPCsFromRegion(region))
{
if (!mob.LoadedFromScript)
{
if (arg1 == "all")
{
mob.RemoveFromWorld();
Mob mobs = GameServer.Database.FindObjectByKey <Mob>(mob.InternalID);
if (mobs != null)
{
mob.LoadFromDatabase(mobs);
mob.AddToWorld();
count++;
}
}
if (arg1 == "realm")
{
eRealm realm = eRealm.None;
if (arg2 == "None")
{
realm = eRealm.None;
}
if (arg2 == "Albion")
{
realm = eRealm.Albion;
}
if (arg2 == "Midgard")
{
realm = eRealm.Midgard;
}
if (arg2 == "Hibernia")
{
realm = eRealm.Hibernia;
}
if (mob.Realm == realm)
{
mob.RemoveFromWorld();
Mob mobs = GameServer.Database.FindObjectByKey <Mob>(mob.InternalID);
if (mobs != null)
{
mob.LoadFromDatabase(mobs);
mob.AddToWorld();
count++;
}
}
}
if (arg1 == "name")
{
if (mob.Name == arg2)
{
mob.RemoveFromWorld();
Mob mobs = GameServer.Database.FindObjectByKey <Mob>(mob.InternalID);
if (mobs != null)
{
mob.LoadFromDatabase(mobs);
mob.AddToWorld();
count++;
}
}
}
if (arg1 == "model")
{
if (mob.Model == Convert.ToUInt16(arg2))
{
mob.RemoveFromWorld();
WorldObject mobs = GameServer.Database.FindObjectByKey <WorldObject>(mob.InternalID);
if (mobs != null)
{
mob.LoadFromDatabase(mobs);
mob.AddToWorld();
count++;
}
}
}
}
}
ChatUtil.SendSystemMessage(player, count + " mobs reloaded!");
}
public void OnCommand(GameClient client, string[] args)
{
if (args.Length == 1)
{
DisplaySyntax(client);
return;
}
string param = string.Empty;
if (args.Length > 2)
{
param = string.Join(" ", args, 2, args.Length - 2);
}
GameStaticItem targetObject = client.Player.TargetObject as GameStaticItem;
if (targetObject == null && args[1] != "create" && args[1] != "fastcreate" && args[1] != "target" && args[1] != "quests")
{
client.Out.SendMessage("Type /object for command overview", eChatType.CT_System, eChatLoc.CL_SystemWindow);
return;
}
switch (args[1])
{
case "info":
{
List <string> info = new List <string>();
string name = "(blank name)";
if (!string.IsNullOrEmpty(targetObject.Name))
{
name = targetObject.Name;
}
info.Add(" OID: " + targetObject.ObjectID);
info.Add(" Type: " + targetObject.GetType());
info.Add(" ");
info.Add(" Name: " + name);
info.Add(" Model: " + targetObject.Model);
info.Add(" Emblem: " + targetObject.Emblem);
info.Add(" Realm: " + targetObject.Realm);
if (targetObject.Owners.LongLength > 0)
{
info.Add(" ");
info.Add(" Owner: " + targetObject.Owners[0].Name);
}
if (string.IsNullOrEmpty(targetObject.OwnerID) == false)
{
info.Add(" ");
info.Add(" OwnerID: " + targetObject.OwnerID);
}
if (targetObject.RespawnInterval > 0)
{
info.Add("RespawnInterval (seconds): " + targetObject.RespawnInterval);
}
info.Add(" ");
WorldInventoryItem invItem = targetObject as WorldInventoryItem;
if (invItem != null)
{
info.Add(" Count: " + invItem.Item.Count);
}
info.Add(" ");
info.Add(" Location: X= " + targetObject.X + " ,Y= " + targetObject.Y + " ,Z= " + targetObject.Z);
client.Out.SendCustomTextWindow("[ " + name + " ]", info);
break;
}
case "movehere":
{
targetObject.X = client.Player.X;
targetObject.Y = client.Player.Y;
targetObject.Z = client.Player.Z;
targetObject.Heading = client.Player.Heading;
targetObject.SaveIntoDatabase();
break;
}
case "create":
{
string theType = "DOL.GS.GameStaticItem";
if (args.Length > 2)
{
theType = args[2];
}
GameStaticItem obj = CreateItem(client, theType);
if (obj != null)
{
DisplayMessage(client, "Obj created: OID=" + obj.ObjectID);
}
break;
}
case "fastcreate":
{
string objName = "new object";
ushort modelID = 100;
if (args.Length > 2)
{
objName = args[2];
}
if (args.Length > 3)
{
ushort.TryParse(args[3], out modelID);
}
GameStaticItem obj = CreateItem(client, null);
if (obj != null)
{
obj.Name = objName;
obj.Model = modelID;
DisplayMessage(client, "Object created: OID = " + obj.ObjectID);
}
break;
}
case "model":
{
ushort model;
try
{
model = Convert.ToUInt16(args[2]);
targetObject.Model = model;
targetObject.SaveIntoDatabase();
DisplayMessage(client, "Object model changed to: " + targetObject.Model);
}
catch (Exception)
{
DisplayMessage(client, "Type /object for command overview");
return;
}
break;
}
case "modelinc":
{
ushort model = targetObject.Model;
try
{
if (model < 4249)
{
model++;
targetObject.Model = model;
targetObject.SaveIntoDatabase();
DisplayMessage(client, "Object model changed to: " + targetObject.Model);
}
else
{
DisplayMessage(client, "Highest object model reached!");
}
}
catch (Exception)
{
DisplayMessage(client, "Type /object for command overview");
return;
}
break;
}
case "modeldec":
{
ushort model = targetObject.Model;
try
{
if (model != 1)
{
model--;
targetObject.Model = model;
targetObject.SaveIntoDatabase();
DisplayMessage(client, "Object model changed to: " + targetObject.Model);
}
else
{
DisplayMessage(client, "Object model cannot be 0!");
}
}
catch (Exception)
{
DisplayMessage(client, "Type /object for command overview");
return;
}
break;
}
case "emblem":
{
int emblem;
try
{
emblem = Convert.ToInt32(args[2]);
targetObject.Emblem = emblem;
targetObject.SaveIntoDatabase();
DisplayMessage(client, "Object emblem changed to: " + targetObject.Emblem);
}
catch (Exception)
{
DisplayMessage(client, "Type /object for command overview");
return;
}
break;
}
case "realm":
{
eRealm realm = eRealm.None;
if (args[2] == "0")
{
realm = eRealm.None;
}
if (args[2] == "1")
{
realm = eRealm.Albion;
}
if (args[2] == "2")
{
realm = eRealm.Midgard;
}
if (args[2] == "3")
{
realm = eRealm.Hibernia;
}
targetObject.Realm = realm;
targetObject.SaveIntoDatabase();
DisplayMessage(client, "Object realm changed to: " + targetObject.Realm);
break;
}
case "name":
{
if (param != string.Empty)
{
targetObject.Name = param;
targetObject.SaveIntoDatabase();
DisplayMessage(client, "Object name changed to: " + targetObject.Name);
}
break;
}
case "noname":
{
targetObject.Name = string.Empty;
targetObject.SaveIntoDatabase();
DisplayMessage(client, "Object name removed");
break;
}
case "copy":
{
GameStaticItem item = CreateItemInstance(client, targetObject.GetType().FullName);
if (item == null)
{
ChatUtil.SendSystemMessage(client, "There was an error creating an instance of " + targetObject.GetType().FullName + "!");
return;
}
item.X = client.Player.X;
item.Y = client.Player.Y;
item.Z = client.Player.Z;
item.CurrentRegion = client.Player.CurrentRegion;
item.Heading = client.Player.Heading;
item.Level = targetObject.Level;
item.Name = targetObject.Name;
item.Model = targetObject.Model;
item.Realm = targetObject.Realm;
item.Emblem = targetObject.Emblem;
item.LoadedFromScript = targetObject.LoadedFromScript;
item.AddToWorld();
item.SaveIntoDatabase();
DisplayMessage(client, "Obj created: OID=" + item.ObjectID);
break;
}
case "save":
{
targetObject.LoadedFromScript = false;
targetObject.SaveIntoDatabase();
DisplayMessage(client, "Object saved to Database");
break;
}
case "remove":
{
targetObject.DeleteFromDatabase();
targetObject.Delete();
DisplayMessage(client, "Object removed from Clients and Database");
break;
}
case "target":
{
foreach (GameStaticItem item in client.Player.GetItemsInRadius(1000))
{
client.Player.TargetObject = item;
DisplayMessage(client, "Target set to nearest object!");
return;
}
DisplayMessage(client, "No objects in 1000 unit range!");
break;
}
case "respawn":
{
int respawn = 0;
if (int.TryParse(args[2], out respawn))
{
targetObject.RespawnInterval = respawn;
targetObject.SaveIntoDatabase();
DisplayMessage(client, "Object RespawnInterval set to " + targetObject.RespawnInterval + " seconds.");
}
break;
}
case "quests":
{
try
{
GameObject.FillDataQuestCache();
client.Player.TargetObject.LoadDataQuests();
if (client.Player.TargetObject is GameNPC)
{
foreach (GamePlayer player in client.Player.TargetObject.GetPlayersInRadius(WorldMgr.VISIBILITY_DISTANCE))
{
player.Out.SendNPCsQuestEffect(client.Player.TargetObject as GameNPC, (client.Player.TargetObject as GameNPC).GetQuestIndicator(player));
}
}
client.Out.SendMessage(targetObject.DataQuestList.Count + " Data Quests loaded for this object.", eChatType.CT_System, eChatLoc.CL_SystemWindow);
}
catch (Exception)
{
DisplayMessage(client, "Error refreshing quests.");
}
break;
}
}
}
public void HandlePacket(GameClient client, GSPacketIn packet)
{
try
{
packet.ReadByte(); // 1=Money 0=Item (?)
int slot = packet.ReadByte(); // Item/money slot
ushort housenumber = packet.ReadShort(); // N° of house
packet.ReadByte(); // unknown
_position = (byte)packet.ReadByte();
int method = packet.ReadByte(); // 2=Wall 3=Floor
int rotation = packet.ReadByte(); // garden items only
var xpos = (short)packet.ReadShort(); // x for inside objs
var ypos = (short)packet.ReadShort(); // y for inside objs.
ChatUtil.SendDebugMessage(client, $"HousingPlaceItem: slot: {slot}, position: {_position}, method: {method}, xpos: {xpos}, ypos: {ypos}");
if (client.Player == null)
{
return;
}
// house must exist
House house = HouseMgr.GetHouse(client.Player.CurrentRegionID, housenumber);
if (house == null)
{
client.Player.Out.SendInventorySlotsUpdate(null);
return;
}
if (slot >= 244 && slot <= 248) // money
{
// check that player has permission to pay rent
if (!house.CanPayRent(client.Player))
{
client.Out.SendInventorySlotsUpdate(new[] { slot });
return;
}
long moneyToAdd = _position;
switch (slot)
{
case 248:
moneyToAdd *= 1;
break;
case 247:
moneyToAdd *= 100;
break;
case 246:
moneyToAdd *= 10000;
break;
case 245:
moneyToAdd *= 10000000;
break;
case 244:
moneyToAdd *= 10000000000;
break;
}
client.Player.TempProperties.setProperty(HousingConstants.MoneyForHouseRent, moneyToAdd);
client.Player.TempProperties.setProperty(HousingConstants.HouseForHouseRent, house);
client.Player.Out.SendInventorySlotsUpdate(null);
client.Player.Out.SendHousePayRentDialog("Housing07");
return;
}
// make sure the item dropped still exists
InventoryItem orgitem = client.Player.Inventory.GetItem((eInventorySlot)slot);
if (orgitem == null)
{
client.Player.Out.SendInventorySlotsUpdate(null);
return;
}
if (orgitem.Id_nb == "house_removal_deed")
{
client.Out.SendInventorySlotsUpdate(null);
// make sure player has owner permissions
if (!house.HasOwnerPermissions(client.Player))
{
ChatUtil.SendSystemMessage(client.Player, "You don't own this house!");
return;
}
client.Player.TempProperties.setProperty(DeedWeak, new WeakRef(orgitem));
client.Player.TempProperties.setProperty(TargetHouse, house);
client.Player.Out.SendCustomDialog(LanguageMgr.GetTranslation(client.Account.Language, "WARNING: You are about to delete this house and all indoor and outdoor items attached to it!"), HouseRemovalDialog);
return;
}
if (orgitem.Id_nb.Contains("cottage_deed") || orgitem.Id_nb.Contains("house_deed") ||
orgitem.Id_nb.Contains("villa_deed") || orgitem.Id_nb.Contains("mansion_deed"))
{
client.Out.SendInventorySlotsUpdate(null);
// make sure player has owner permissions
if (!house.HasOwnerPermissions(client.Player))
{
ChatUtil.SendSystemMessage(client, "You may not change other peoples houses");
return;
}
client.Player.TempProperties.setProperty(DeedWeak, new WeakRef(orgitem));
client.Player.TempProperties.setProperty(TargetHouse, house);
client.Player.Out.SendMessage("Warning:\n This will remove *all* items from your current house!", eChatType.CT_System, eChatLoc.CL_PopupWindow);
client.Player.Out.SendCustomDialog("Are you sure you want to upgrade your House?", HouseUpgradeDialog);
return;
}
if (orgitem.Name == "deed of guild transfer")
{
// player needs to be in a guild to xfer a house to a guild
if (client.Player.Guild == null)
{
client.Out.SendInventorySlotsUpdate(new[] { slot });
ChatUtil.SendSystemMessage(client, "You must be a member of a guild to do that");
return;
}
// player needs to own the house to be able to xfer it
if (!house.HasOwnerPermissions(client.Player))
{
client.Out.SendInventorySlotsUpdate(new[] { slot });
ChatUtil.SendSystemMessage(client, "You do not own this house.");
return;
}
// guild can't already have a house
if (client.Player.Guild.GuildOwnsHouse)
{
client.Out.SendInventorySlotsUpdate(new[] { slot });
ChatUtil.SendSystemMessage(client, "Your Guild already owns a house.");
return;
}
// player needs to be a GM in the guild to xfer his personal house to the guild
if (!client.Player.Guild.HasRank(client.Player, Guild.eRank.Leader))
{
client.Out.SendInventorySlotsUpdate(new[] { slot });
ChatUtil.SendSystemMessage(client, "You are not the leader of a guild.");
return;
}
if (HouseMgr.HouseTransferToGuild(client.Player, house))
{
// This will still take the item even if player answers NO to confirmation.
// I'm fixing consignment, not housing, and frankly I'm sick of fixing stuff! :) - tolakram
client.Player.Inventory.RemoveItem(orgitem);
InventoryLogging.LogInventoryAction(client.Player, "(HOUSE;" + housenumber + ")", eInventoryActionType.Other, orgitem.Template, orgitem.Count);
client.Player.Guild.UpdateGuildWindow();
}
return;
}
if (house.CanChangeInterior(client.Player, DecorationPermissions.Remove))
{
if (orgitem.Name == "interior banner removal")
{
house.IndoorGuildBanner = false;
ChatUtil.SendSystemMessage(client.Player, "Scripts.Player.Housing.InteriorBannersRemoved", null);
return;
}
if (orgitem.Name == "interior shield removal")
{
house.IndoorGuildShield = false;
ChatUtil.SendSystemMessage(client.Player, "Scripts.Player.Housing.InteriorShieldsRemoved", null);
return;
}
if (orgitem.Name == "carpet removal")
{
house.Rug1Color = 0;
house.Rug2Color = 0;
house.Rug3Color = 0;
house.Rug4Color = 0;
ChatUtil.SendSystemMessage(client.Player, "Scripts.Player.Housing.CarpetsRemoved", null);
return;
}
}
if (house.CanChangeExternalAppearance(client.Player))
{
if (orgitem.Name == "exterior banner removal")
{
house.OutdoorGuildBanner = false;
ChatUtil.SendSystemMessage(client.Player, "Scripts.Player.Housing.OutdoorBannersRemoved", null);
return;
}
if (orgitem.Name == "exterior shield removal")
{
house.OutdoorGuildShield = false;
ChatUtil.SendSystemMessage(client.Player, "Scripts.Player.Housing.OutdoorShieldsRemoved", null);
return;
}
}
int objType = orgitem.Object_Type;
if (objType == 49) // Garden items
{
method = 1;
}
else if (orgitem.Id_nb == "housing_porch_deed" || orgitem.Id_nb == "housing_porch_remove_deed" || orgitem.Id_nb == "housing_consignment_deed")
{
method = 4;
}
else if (objType >= 59 && objType <= 64) // Outdoor Roof/Wall/Door/Porch/Wood/Shutter/awning Material item type
{
ChatUtil.SendSystemMessage(client.Player, "Scripts.Player.Housing.HouseUseMaterials", null);
return;
}
else if (objType == 56 || objType == 52 || (objType >= 69 && objType <= 71)) // Indoor carpets 1-4
{
ChatUtil.SendSystemMessage(client.Player, "Scripts.Player.Housing.HouseUseCarpets", null);
return;
}
else if (objType == 57 || objType == 58 || // Exterior banner/shield
objType == 66 || objType == 67) // Interior banner/shield
{
method = 6;
}
else if (objType == 53 || objType == 55 || objType == 68)
{
method = 5;
}
else if (objType == (int)eObjectType.HouseVault)
{
method = 7;
}
ChatUtil.SendDebugMessage(client, $"Place Item: method: {method}");
int pos;
switch (method)
{
case 1: // GARDEN OBJECT
{
if (client.Player.InHouse)
{
client.Out.SendInventorySlotsUpdate(new[] { slot });
return;
}
// no permissions to add to the garden, return
if (!house.CanChangeGarden(client.Player, DecorationPermissions.Add))
{
client.Out.SendInventorySlotsUpdate(new[] { slot });
return;
}
// garden is already full, return
if (house.OutdoorItems.Count >= Properties.MAX_OUTDOOR_HOUSE_ITEMS)
{
ChatUtil.SendSystemMessage(client, "Scripts.Player.Housing.GardenMaxObjects", null);
client.Out.SendInventorySlotsUpdate(new[] { slot });
return;
}
// create an outdoor item to represent the item being placed
var oitem = new OutdoorItem
{
BaseItem = GameServer.Database.FindObjectByKey <ItemTemplate>(orgitem.Id_nb),
Model = orgitem.Model,
Position = (byte)_position,
Rotation = (byte)rotation
};
// add item in db
pos = GetFirstFreeSlot(house.OutdoorItems.Keys);
DBHouseOutdoorItem odbitem = oitem.CreateDBOutdoorItem(housenumber);
oitem.DatabaseItem = odbitem;
GameServer.Database.AddObject(odbitem);
// remove the item from the player's inventory
client.Player.Inventory.RemoveItem(orgitem);
InventoryLogging.LogInventoryAction(client.Player, $"(HOUSE;{housenumber})", eInventoryActionType.Other, orgitem.Template, orgitem.Count);
// add item to outdooritems
house.OutdoorItems.Add(pos, oitem);
ChatUtil.SendSystemMessage(client, "Scripts.Player.Housing.GardenItemPlaced", Properties.MAX_OUTDOOR_HOUSE_ITEMS - house.OutdoorItems.Count);
ChatUtil.SendSystemMessage(client, "Scripts.Player.Housing.GardenItemPlacedName", orgitem.Name);
// update all nearby players
foreach (GamePlayer player in WorldMgr.GetPlayersCloseToSpot(house.RegionID, house, WorldMgr.OBJ_UPDATE_DISTANCE))
{
player.Out.SendGarden(house);
}
// save the house
house.SaveIntoDatabase();
break;
}
case 2: // WALL OBJECT
case 3: // FLOOR OBJECT
{
if (client.Player.InHouse == false)
{
client.Out.SendInventorySlotsUpdate(new[] { slot });
return;
}
// no permission to add to the interior, return
if (!house.CanChangeInterior(client.Player, DecorationPermissions.Add))
{
client.Out.SendInventorySlotsUpdate(new[] { slot });
return;
}
// not a wall object, return
if (!IsSuitableForWall(orgitem) && method == 2)
{
ChatUtil.SendSystemMessage(client, "Scripts.Player.Housing.NotWallObject", null);
client.Out.SendInventorySlotsUpdate(new[] { slot });
return;
}
// not a floor object, return
if (objType != 51 && method == 3)
{
ChatUtil.SendSystemMessage(client, "Scripts.Player.Housing.NotFloorObject", null);
client.Out.SendInventorySlotsUpdate(new[] { slot });
return;
}
// interior already has max items, return
if (house.IndoorItems.Count >= GetMaxIndoorItemsForHouse(house.Model))
{
ChatUtil.SendSystemMessage(client, "Scripts.Player.Housing.IndoorMaxItems", GetMaxIndoorItemsForHouse(house.Model));
client.Out.SendInventorySlotsUpdate(new[] { slot });
return;
}
// create an indoor item to represent the item being placed
var iitem = new IndoorItem
{
Model = orgitem.Model,
Color = orgitem.Color,
X = xpos,
Y = ypos,
Size = orgitem.DPS_AF > 3 ? orgitem.DPS_AF : 100, // max size is 255
Position = _position,
PlacementMode = method,
BaseItem = null
};
// figure out proper rotation for item
int properRotation = client.Player.Heading / 10;
properRotation = properRotation.Clamp(0, 360);
if (method == 2 && IsSuitableForWall(orgitem))
{
properRotation = 360;
if (objType != 50)
{
client.Out.SendInventorySlotsUpdate(new[] { slot });
}
}
iitem.Rotation = properRotation;
pos = GetFirstFreeSlot(house.IndoorItems.Keys);
if (objType == 50 || objType == 51)
{
// its a housing item, so lets take it!
client.Player.Inventory.RemoveItem(orgitem);
InventoryLogging.LogInventoryAction(client.Player, $"(HOUSE;{housenumber})", eInventoryActionType.Other, orgitem.Template, orgitem.Count);
// set right base item, so we can recreate it on take.
if (orgitem.Id_nb.Contains("GuildBanner"))
{
iitem.BaseItem = orgitem.Template;
iitem.Size = 50; // Banners have to be reduced in size
}
else
{
iitem.BaseItem = GameServer.Database.FindObjectByKey <ItemTemplate>(orgitem.Id_nb);
}
}
DBHouseIndoorItem idbitem = iitem.CreateDBIndoorItem(housenumber);
iitem.DatabaseItem = idbitem;
GameServer.Database.AddObject(idbitem);
house.IndoorItems.Add(pos, iitem);
// let player know the item has been placed
ChatUtil.SendSystemMessage(client, "Scripts.Player.Housing.IndoorItemPlaced", GetMaxIndoorItemsForHouse(house.Model) - house.IndoorItems.Count);
switch (method)
{
case 2:
ChatUtil.SendSystemMessage(client, "Scripts.Player.Housing.IndoorWallPlaced", orgitem.Name);
break;
case 3:
ChatUtil.SendSystemMessage(client, "Scripts.Player.Housing.IndoorFloorPlaced", orgitem.Name);
break;
}
// update furniture for all players in the house
foreach (GamePlayer plr in house.GetAllPlayersInHouse())
{
plr.Out.SendFurniture(house, pos);
}
break;
}
case 4: // PORCH
{
// no permission to add to the garden, return
if (!house.CanChangeGarden(client.Player, DecorationPermissions.Add))
{
client.Out.SendInventorySlotsUpdate(new[] { slot });
return;
}
switch (orgitem.Id_nb)
{
case "housing_porch_deed":
// try and add the porch
if (house.AddPorch())
{
// remove the original item from the player's inventory
client.Player.Inventory.RemoveItem(orgitem);
InventoryLogging.LogInventoryAction(client.Player, $"(HOUSE;{housenumber})", eInventoryActionType.Other, orgitem.Template, orgitem.Count);
}
else
{
ChatUtil.SendSystemMessage(client, "Scripts.Player.Housing.PorchAlready", null);
client.Out.SendInventorySlotsUpdate(new[] { slot });
}
return;
case "housing_porch_remove_deed":
var consignmentMerchant = house.ConsignmentMerchant;
if (consignmentMerchant != null && (consignmentMerchant.DBItems(client.Player).Count > 0 || consignmentMerchant.TotalMoney > 0))
{
ChatUtil.SendSystemMessage(client, "All items and money must be removed from your consigmment merchant in order to remove the porch!");
client.Out.SendInventorySlotsUpdate(new[] { slot });
return;
}
// try and remove the porch
if (house.RemovePorch())
{
// remove the original item from the player's inventory
client.Player.Inventory.RemoveItem(orgitem);
InventoryLogging.LogInventoryAction(client.Player, $"(HOUSE;{housenumber})", eInventoryActionType.Other, orgitem.Template, orgitem.Count);
}
else
{
ChatUtil.SendSystemMessage(client, "Scripts.Player.Housing.PorchNone", null);
client.Out.SendInventorySlotsUpdate(new[] { slot });
}
return;
case "housing_consignment_deed":
{
// make sure there is a porch for this consignment merchant!
if (!house.Porch)
{
ChatUtil.SendSystemMessage(client, "Your House needs a Porch first.");
client.Out.SendInventorySlotsUpdate(new[] { slot });
return;
}
// try and add a new consignment merchant
if (house.AddConsignment(0))
{
// remove the original item from the player's inventory
client.Player.Inventory.RemoveItem(orgitem);
InventoryLogging.LogInventoryAction(client.Player, $"(HOUSE;{housenumber})", eInventoryActionType.Other, orgitem.Template, orgitem.Count);
}
else
{
ChatUtil.SendSystemMessage(client, "You can not add a Consignment Merchant here.");
client.Out.SendInventorySlotsUpdate(new[] { slot });
}
return;
}
default:
ChatUtil.SendSystemMessage(client, "Scripts.Player.Housing.PorchNotItem", null);
client.Out.SendInventorySlotsUpdate(new[] { slot });
return;
}
}
case 5: // HOOKPOINT
{
if (client.Player.InHouse == false)
{
client.Out.SendInventorySlotsUpdate(new[] { slot });
return;
}
// no permission to add to the interior, return
if (!house.CanChangeInterior(client.Player, DecorationPermissions.Add))
{
client.Out.SendInventorySlotsUpdate(new[] { slot });
return;
}
// don't allow non-hookpoint items to be dropped on hookpoints
if (IsSuitableForHookpoint(orgitem) == false)
{
client.Out.SendInventorySlotsUpdate(new[] { slot });
return;
}
// if the hookpoint doesn't exist, prompt player to Log it in the database for us
if (house.GetHookpointLocation((uint)_position) == null)
{
client.Out.SendInventorySlotsUpdate(new[] { slot });
if (client.Account.PrivLevel == (int)ePrivLevel.Admin)
{
if (client.Player.TempProperties.getProperty(HousingConstants.AllowAddHouseHookpoint, false))
{
ChatUtil.SendSystemMessage(client, "Scripts.Player.Housing.HookPointID", +_position);
ChatUtil.SendSystemMessage(client, "Scripts.Player.Housing.HookPointCloser", null);
client.Player.Out.SendCustomDialog(LanguageMgr.GetTranslation(client.Account.Language, "Scripts.Player.Housing.HookPointLogLoc"), LogLocation);
}
else
{
ChatUtil.SendDebugMessage(client, "use '/house addhookpoints' to allow addition of new housing hookpoints.");
}
}
}
else if (house.GetHookpointLocation((uint)_position) != null)
{
var point = new DBHouseHookpointItem
{
HouseNumber = house.HouseNumber,
ItemTemplateID = orgitem.Id_nb,
HookpointID = (uint)_position
};
// If we already have soemthing here, do not place more
foreach (var hpitem in GameServer.Database.SelectObjects <DBHouseHookpointItem>("`HouseNumber` = @HouseNumber", new QueryParameter("@HouseNumber", house.HouseNumber)))
{
if (hpitem.HookpointID == point.HookpointID)
{
ChatUtil.SendSystemMessage(client, "Scripts.Player.Housing.HookPointAlready", null);
client.Out.SendInventorySlotsUpdate(new[] { slot });
return;
}
}
if (house.HousepointItems.ContainsKey(point.HookpointID) == false)
{
house.HousepointItems.Add(point.HookpointID, point);
house.FillHookpoint((uint)_position, orgitem.Id_nb, client.Player.Heading, 0);
}
else
{
string error = $"Hookpoint already has item on attempt to attach {orgitem.Id_nb} to hookpoint {_position} for house {house.HouseNumber}!";
Log.ErrorFormat(error);
client.Out.SendInventorySlotsUpdate(new[] { slot });
throw new Exception(error);
}
// add the item to the database
GameServer.Database.AddObject(point);
// remove the original item from the player's inventory
client.Player.Inventory.RemoveItem(orgitem);
InventoryLogging.LogInventoryAction(client.Player, $"(HOUSE;{housenumber})", eInventoryActionType.Other, orgitem.Template, orgitem.Count);
ChatUtil.SendSystemMessage(client, "Scripts.Player.Housing.HookPointAdded", null);
// save the house
house.SaveIntoDatabase();
}
else
{
ChatUtil.SendSystemMessage(client, "Scripts.Player.Housing.HookPointNot", null);
client.Out.SendInventorySlotsUpdate(new[] { slot });
}
// broadcast updates
house.SendUpdate();
break;
}
case 6:
{
// no permission to change external appearance, return
if (!house.CanChangeExternalAppearance(client.Player))
{
client.Out.SendInventorySlotsUpdate(new[] { slot });
return;
}
if (objType == 57) // We have outdoor banner
{
house.OutdoorGuildBanner = true;
ChatUtil.SendSystemMessage(client, "Scripts.Player.Housing.OutdoorBannersAdded", null);
client.Player.Inventory.RemoveItem(orgitem);
InventoryLogging.LogInventoryAction(client.Player, $"(HOUSE;{housenumber})", eInventoryActionType.Other, orgitem.Template, orgitem.Count);
}
else if (objType == 58) // We have outdoor shield
{
house.OutdoorGuildShield = true;
ChatUtil.SendSystemMessage(client, "Scripts.Player.Housing.OutdoorShieldsAdded", null);
client.Player.Inventory.RemoveItem(orgitem);
InventoryLogging.LogInventoryAction(client.Player, $"(HOUSE;{housenumber})", eInventoryActionType.Other, orgitem.Template, orgitem.Count);
}
else if (objType == 66) // We have indoor banner
{
house.IndoorGuildBanner = true;
ChatUtil.SendSystemMessage(client, "Scripts.Player.Housing.InteriorBannersAdded", null);
client.Player.Inventory.RemoveItem(orgitem);
InventoryLogging.LogInventoryAction(client.Player, $"(HOUSE;{housenumber})", eInventoryActionType.Other, orgitem.Template, orgitem.Count);
}
else if (objType == 67) // We have indoor shield
{
house.IndoorGuildShield = true;
ChatUtil.SendSystemMessage(client, "Scripts.Player.Housing.InteriorShieldsAdded", null);
client.Player.Inventory.RemoveItem(orgitem);
InventoryLogging.LogInventoryAction(client.Player, $"(HOUSE;{housenumber})", eInventoryActionType.Other, orgitem.Template, orgitem.Count);
}
else
{
ChatUtil.SendSystemMessage(client, "Scripts.Player.Housing.BadShieldBanner", null);
client.Out.SendInventorySlotsUpdate(new[] { slot });
}
// save the house and broadcast updates
house.SaveIntoDatabase();
house.SendUpdate();
break;
}
case 7: // House vault.
{
if (client.Player.InHouse == false)
{
client.Out.SendInventorySlotsUpdate(new[] { slot });
return;
}
// make sure the hookpoint position is valid
if (_position > HousingConstants.MaxHookpointLocations)
{
ChatUtil.SendSystemMessage(client, "This hookpoint position is unknown, error logged.");
Log.Error($"HOUSING: {client.Player.Name} working with invalid position {_position} in house {house.HouseNumber} model {house.Model}");
client.Out.SendInventorySlotsUpdate(new[] { slot });
return;
}
// if hookpoint doesn't exist, prompt player to Log it in the database for us
if (house.GetHookpointLocation((uint)_position) == null)
{
client.Out.SendInventorySlotsUpdate(new[] { slot });
if (client.Account.PrivLevel == (int)ePrivLevel.Admin)
{
if (client.Player.TempProperties.getProperty(HousingConstants.AllowAddHouseHookpoint, false))
{
ChatUtil.SendSystemMessage(client, "Scripts.Player.Housing.HookPointID", +_position);
ChatUtil.SendSystemMessage(client, "Scripts.Player.Housing.HookPointCloser", null);
client.Player.Out.SendCustomDialog(LanguageMgr.GetTranslation(client.Account.Language, "Scripts.Player.Housing.HookPointLogLoc"), LogLocation);
}
else
{
ChatUtil.SendDebugMessage(client, "use '/house addhookpoints' to allow addition of new housing hookpoints.");
}
}
return;
}
// make sure we have space to add another vult
int vaultIndex = house.GetFreeVaultNumber();
if (vaultIndex < 0)
{
client.Player.Out.SendMessage("You can't add any more vaults to this house!", eChatType.CT_System, eChatLoc.CL_SystemWindow);
client.Out.SendInventorySlotsUpdate(new[] { slot });
return;
}
// If we already have soemthing here, do not place more
foreach (var hpitem in GameServer.Database.SelectObjects <DBHouseHookpointItem>("`HouseNumber` = @HouseNumber", new QueryParameter("@HouseNumber", house.HouseNumber)))
{
if (hpitem.HookpointID == _position)
{
ChatUtil.SendSystemMessage(client, "Scripts.Player.Housing.HookPointAlready", null);
client.Out.SendInventorySlotsUpdate(new[] { slot });
return;
}
}
// create the new vault and attach it to the house
var houseVault = new GameHouseVault(orgitem.Template, vaultIndex);
houseVault.Attach(house, (uint)_position, (ushort)((client.Player.Heading + 2048) % 4096));
// remove the original item from the player's inventory
client.Player.Inventory.RemoveItem(orgitem);
InventoryLogging.LogInventoryAction(client.Player, $"(HOUSE;{housenumber})", eInventoryActionType.Other, orgitem.Template, orgitem.Count);
// save the house and broadcast uodates
house.SaveIntoDatabase();
house.SendUpdate();
return;
}
default:
{
ChatUtil.SendDebugMessage(client, "Place Item: Unknown method, do nothing.");
client.Out.SendInventorySlotsUpdate(null);
break;
}
}
}
catch (Exception ex)
{
Log.Error("HousingPlaceItemHandler", ex);
client.Out.SendMessage("Error processing housing action; the error has been logged!", eChatType.CT_Staff, eChatLoc.CL_SystemWindow);
client.Out.SendInventorySlotsUpdate(null);
}
}
public void HandlePacket(GameClient client, GSPacketIn packet)
{
packet.ReadByte(); // unk1
int position = packet.ReadByte();
ushort housenumber = packet.ReadShort();
ushort angle = packet.ReadShort();
packet.ReadShort(); // unk2
// rotation only works for inside items
if (!client.Player.InHouse)
{
return;
}
// house is null, return
var house = HouseMgr.GetHouse(housenumber);
if (house == null)
{
return;
}
// player is null, return
if (client.Player == null)
{
return;
}
// no permission to change the interior, return
if (!house.CanChangeInterior(client.Player, DecorationPermissions.Add))
{
return;
}
if (house.IndoorItems.ContainsKey(position) == false)
{
return;
}
// grab the item in question
IndoorItem iitem = house.IndoorItems[position];
if (iitem == null)
{
client.Player.Out.SendMessage("error: id was null", eChatType.CT_Help, eChatLoc.CL_SystemWindow);
return;
} // should this ever happen?
// adjust the item's roation
int old = iitem.Rotation;
iitem.Rotation = (iitem.Rotation + angle) % 360;
if (iitem.Rotation < 0)
{
iitem.Rotation = 360 + iitem.Rotation;
}
iitem.DatabaseItem.Rotation = iitem.Rotation;
// save item
GameServer.Database.SaveObject(iitem.DatabaseItem);
ChatUtil.SendSystemMessage(client, $"Interior decoration rotated from {old} degrees to {iitem.Rotation}");
// update all players in the house.
foreach (GamePlayer plr in house.GetAllPlayersInHouse())
{
plr.Client.Out.SendFurniture(house, position);
}
}
public void OnCommand(GameClient client, string[] args)
{
ushort region = 0;
if (client.Player != null)
{
region = client.Player.CurrentRegionID;
}
string arg = "";
int argLength = args.Length - 1;
if (argLength < 1)
{
if (client.Player != null)
{
SendSystemMessageBase(client);
SendSystemMessageMob(client);
SendSystemMessageObject(client);
client.Out.SendMessage(" /reload specs - reload all specializations.", eChatType.CT_System, eChatLoc.CL_SystemWindow);
client.Out.SendMessage(" /reload spells - reload a spells and spelllines, checking db for changed and new spells.", eChatType.CT_System, eChatLoc.CL_SystemWindow);
}
log.Info("/reload command failed, review parameters.");
return;
}
else if (argLength > 1)
{
if (args[2] == "realm" || args[2] == "Realm")
{
if (argLength == 2)
{
SendSystemMessageRealm(client);
return;
}
if (args[3] == "0" || args[3] == "None" || args[3] == "none" || args[3] == "no" || args[3] == "n")
{
arg = "None";
}
else if (args[3] == "1" || args[3] == "a" || args[3] == "alb" || args[3] == "Alb" || args[3] == "albion" || args[3] == "Albion")
{
arg = "Albion";
}
else if (args[3] == "2" || args[3] == "m" || args[3] == "mid" || args[3] == "Mid" || args[3] == "midgard" || args[3] == "Midgard")
{
arg = "Midgard";
}
else if (args[3] == "3" || args[3] == "h" || args[3] == "hib" || args[3] == "Hib" || args[3] == "hibernia" || args[3] == "Hibernia")
{
arg = "Hibernia";
}
else
{
SendSystemMessageRealm(client);
return;
}
}
else if (args[2] == "name" || args[2] == "Name")
{
if (argLength == 2)
{
SendSystemMessageName(client);
return;
}
arg = String.Join(" ", args, 3, args.Length - 3);
}
else if (args[2] == "model" || args[2] == "Model")
{
if (argLength == 2)
{
SendSystemMessageModel(client);
return;
}
arg = args[3];
}
}
if (args[1] == "mob" || args[1] == "Mob")
{
if (argLength == 1)
{
arg = "all";
ReloadMobs(client.Player, region, arg, arg);
}
if (argLength > 1)
{
ReloadMobs(client.Player, region, args[2], arg);
}
}
if (args[1] == "object" || args[1] == "Object")
{
if (argLength == 1)
{
arg = "all";
ReloadStaticItem(region, arg, arg);
}
if (argLength > 1)
{
ReloadStaticItem(region, args[2], arg);
}
}
if (args[1].ToLower() == "spells")
{
SkillBase.ReloadDBSpells();
int loaded = SkillBase.ReloadSpellLines();
if (client != null)
{
ChatUtil.SendSystemMessage(client, string.Format("Reloaded db spells and {0} spells for all lines !", loaded));
}
log.Info(string.Format("Reloaded db spells and {0} spells for all spell lines !", loaded));
return;
}
if (args[1].ToLower() == "specs")
{
int count = SkillBase.LoadSpecializations();
if (client != null)
{
client.Out.SendMessage(string.Format("{0} specializations loaded.", count), eChatType.CT_Important, eChatLoc.CL_SystemWindow);
}
log.Info(string.Format("{0} specializations loaded.", count));
return;
}
return;
}
public override bool ReceiveItem(GameLiving source, InventoryItem item)
{
if (source == null || item == null)
{
return(false);
}
if (!(source is GamePlayer))
{
return(false);
}
var player = (GamePlayer)source;
if (HouseMgr.IsOwner(DatabaseItem, player))
{
switch (item.Id_nb)
{
case "housing_alb_cottage_deed":
CreateHouse(player, 1);
break;
case "housing_alb_house_deed":
CreateHouse(player, 2);
break;
case "housing_alb_villa_deed":
CreateHouse(player, 3);
break;
case "housing_alb_mansion_deed":
CreateHouse(player, 4);
break;
case "housing_mid_cottage_deed":
CreateHouse(player, 5);
break;
case "housing_mid_house_deed":
CreateHouse(player, 6);
break;
case "housing_mid_villa_deed":
CreateHouse(player, 7);
break;
case "housing_mid_mansion_deed":
CreateHouse(player, 8);
break;
case "housing_hib_cottage_deed":
CreateHouse(player, 9);
break;
case "housing_hib_house_deed":
CreateHouse(player, 10);
break;
case "housing_hib_villa_deed":
CreateHouse(player, 11);
break;
case "housing_hib_mansion_deed":
CreateHouse(player, 12);
break;
default:
return(false);
}
player.Inventory.RemoveItem(item);
// Tolakram: Is this always null when purchasing a house?
InventoryLogging.LogInventoryAction(player, "(HOUSE;" + (CurrentHouse == null ? DatabaseItem.HouseNumber : CurrentHouse.HouseNumber) + ")", eInventoryActionType.Other, item.Template, item.Count);
return(true);
}
ChatUtil.SendSystemMessage(player, "You do not own this lot!");
return(false);
}
/// <summary>
/// Handle the packet
/// </summary>
/// <param name="client"></param>
/// <param name="packet"></param>
/// <returns></returns>
public void HandlePacket(GameClient client, GSPacketIn packet)
{
packet.ReadByte(); // unknown
int position = packet.ReadByte();
int housenumber = packet.ReadShort();
int method = packet.ReadByte();
House house = HouseMgr.GetHouse(client.Player.CurrentRegionID, housenumber);
if (house == null)
{
return;
}
if (client.Player == null)
{
return;
}
// log.DebugFormat("House PickupItem - Method: {0}, Position: {0}", method, position);
switch (method)
{
case 1: // garden item
// no permission to remove items from the garden, return
if (!house.CanChangeGarden(client.Player, DecorationPermissions.Remove))
{
return;
}
foreach (var entry in house.OutdoorItems)
{
// continue if this is not the item in question
OutdoorItem oitem = entry.Value;
if (oitem.Position != position)
{
continue;
}
int i = entry.Key;
GameServer.Database.DeleteObject(oitem.DatabaseItem); // delete the database instance
// return indoor item into inventory item, add to player inventory
var invitem = GameInventoryItem.Create(house.OutdoorItems[i].BaseItem);
if (client.Player.Inventory.AddItem(eInventorySlot.FirstEmptyBackpack, invitem))
{
InventoryLogging.LogInventoryAction($"(HOUSE;{house.HouseNumber})", client.Player, eInventoryActionType.Other, invitem.Template, invitem.Count);
}
house.OutdoorItems.Remove(i);
// update garden
client.Out.SendGarden(house);
ChatUtil.SendSystemMessage(client, "Garden object removed.");
ChatUtil.SendSystemMessage(client, $"You get {invitem.Name} and put it in your backpack.");
return;
}
// no object @ position
ChatUtil.SendSystemMessage(client, $"There is no Garden Tile at slot {position}!");
break;
case 2:
case 3: // wall/floor mode
// no permission to remove items from the interior, return
if (!house.CanChangeInterior(client.Player, DecorationPermissions.Remove))
{
return;
}
if (house.IndoorItems.ContainsKey(position) == false)
{
return;
}
IndoorItem iitem = house.IndoorItems[position];
if (iitem == null)
{
client.Player.Out.SendMessage("error: id was null", eChatType.CT_Help, eChatLoc.CL_SystemWindow);
return;
}
if (iitem.BaseItem != null)
{
var item = GameInventoryItem.Create(house.IndoorItems[position].BaseItem);
if (GetItemBack(item))
{
if (client.Player.Inventory.AddItem(eInventorySlot.FirstEmptyBackpack, item))
{
string removalMsg = $"The {item.Name} is cleared from the {(method == 2 ? "wall surface" : "floor")}.";
ChatUtil.SendSystemMessage(client, removalMsg);
InventoryLogging.LogInventoryAction($"(HOUSE;{house.HouseNumber})", client.Player, eInventoryActionType.Other, item.Template, item.Count);
}
else
{
ChatUtil.SendSystemMessage(client, "You need place in your inventory !");
return;
}
}
else
{
ChatUtil.SendSystemMessage(client, $"The {item.Name} is cleared from the wall surface.");
}
}
else if (iitem.DatabaseItem.BaseItemID.Contains("GuildBanner"))
{
var it = new ItemTemplate
{
Id_nb = iitem.DatabaseItem.BaseItemID,
CanDropAsLoot = false,
IsDropable = true,
IsPickable = true,
IsTradable = true,
Item_Type = 41,
Level = 1,
MaxCharges = 1,
MaxCount = 1,
Model = iitem.DatabaseItem.Model,
Emblem = iitem.DatabaseItem.Emblem,
Object_Type = (int)eObjectType.HouseWallObject,
Realm = 0,
Quality = 100
};
string[] idnb = iitem.DatabaseItem.BaseItemID.Split('_');
it.Name = $"{idnb[1]}\'s Banner";
// TODO: Once again with guild banners, templates are memory only and will not load correctly once player logs out - tolakram
var inv = GameInventoryItem.Create(it);
if (client.Player.Inventory.AddItem(eInventorySlot.FirstEmptyBackpack, inv))
{
string invMsg = $"The {inv.Name} is cleared from the {(method == 2 ? "wall surface" : "floor")}.";
ChatUtil.SendSystemMessage(client, invMsg);
InventoryLogging.LogInventoryAction($"(HOUSE;{house.HouseNumber})", client.Player, eInventoryActionType.Other, inv.Template, inv.Count);
}
else
{
ChatUtil.SendSystemMessage(client, "You need place in your inventory !");
return;
}
}
else if (method == 2)
{
ChatUtil.SendSystemMessage(client, "The decoration item is cleared from the wall surface.");
}
else
{
ChatUtil.SendSystemMessage(client, "The decoration item is cleared from the floor.");
}
GameServer.Database.DeleteObject(house.IndoorItems[position].DatabaseItem);
house.IndoorItems.Remove(position);
var pak = new GSTCPPacketOut(client.Out.GetPacketCode(eServerPackets.HousingItem));
if (client.Version >= GameClient.eClientVersion.Version1125)
{
pak.WriteShortLowEndian((ushort)housenumber);
pak.WriteByte(0x01);
pak.WriteByte(0x00);
pak.WriteByte((byte)position);
pak.Fill(0x00, 11);
}
else
{
pak.WriteShort((ushort)housenumber);
pak.WriteByte(0x01);
pak.WriteByte(0x00);
pak.WriteByte((byte)position);
pak.WriteByte(0x00);
}
foreach (GamePlayer plr in house.GetAllPlayersInHouse())
{
plr.Out.SendTCP(pak);
}
break;
}
}
