public bool StableToEquip(int mountId)
{
var mount = GetStabledMount(mountId);
if (Character.Level < Mount.RequiredLevel)
{
Character.SendInformationMessage(TextInformationTypeEnum.TEXT_INFORMATION_ERROR, 227, Mount.RequiredLevel);
return(false);
}
if (mount == null)
{
return(false);
}
if (!HasMountRight(mount, true))
{
return(false);
}
Character.RemoveStabledMount(mount);
Paddock.RemoveMountFromStable(mount);
EquipMount(mount);
InventoryHandler.SendExchangeMountStableRemoveMessage(Character.Client, mount);
return(true);
}
public bool InventoryToStable(int itemId)
{
var item = Character.Inventory.TryGetItem(itemId) as MountCertificate;
if (item == null || !item.CanConvert())
{
return(false);
}
if (item.Mount == null)
{
return(false);
}
if (!Character.Inventory.RemoveItem(item))
{
return(false);
}
Character.AddStabledMount(item.Mount);
Paddock.AddMountToStable(item.Mount);
InventoryHandler.SendExchangeMountStableAddMessage(Character.Client, item.Mount);
return(true);
}
public bool PaddockToEquip(int mountId)
{
if (Character.Level < Mount.RequiredLevel)
{
Character.SendInformationMessage(TextInformationTypeEnum.TEXT_INFORMATION_ERROR, 227, Mount.RequiredLevel);
return(false);
}
var mount = Paddock.GetPaddockedMount(Character, mountId);
if (mount == null)
{
return(false);
}
if (!HasMountRight(mount, true))
{
return(false);
}
Paddock.RemoveMountFromPaddock(mount);
Character.SetOwnedMount(mount);
Character.EquipMount(mount);
InventoryHandler.SendExchangeMountPaddockRemoveMessage(Character.Client, mount);
return(true);
}
public void Open()
{
Character.SetDialoger(m_merchant);
InventoryHandler.SendExchangeStartedMessage(Character.Client, ExchangeType);
InventoryHandler.SendExchangeShopStockStartedMessage(Character.Client, Character.MerchantBag);
}
// Use this for initialization
void Start()
{
_inv = InventoryHandler.Instance();
_terrainManager = TerrainManager.Instance();
_GUIManager = GUIManager.Instance();
_popupAction = GameObject.Find("Popup Action");
}
public bool EquipToStable(int mountId)
{
if (!Character.HasEquippedMount())
{
return(false);
}
if (!HasMountRight(Character.EquippedMount))
{
return(false);
}
if (Character.EquippedMount.Id != mountId)
{
return(false);
}
var mount = Character.EquippedMount;
Character.UnEquipMount();
Character.AddStabledMount(mount);
Paddock.AddMountToStable(mount);
InventoryHandler.SendExchangeMountStableAddMessage(Character.Client, mount);
return(true);
}
protected override void OnTraderKamasChanged(Trader trader, uint amount)
{
base.OnTraderKamasChanged(trader, amount);
InventoryHandler.SendExchangeKamaModifiedMessage(FirstTrader.Character.Client, trader != FirstTrader,
(int)amount);
}
public bool checkUnlocked(GameObject other, bool removeUsedKeys)
{
bool enoughKeys = true;
InventoryHandler inventory = other.GetComponent <InventoryHandler>();
ArrayList ownedItems = inventory.getItems();
foreach (string key in neededKeys)
{
if (!ownedItems.Contains(key))
{
enoughKeys = false;
}
}
if (enoughKeys)
{
foreach (string key in neededKeys)
{
inventory.removeItem(key);
}
return(true);
}
else
{
other.gameObject.GetComponent <HelpHandler>().queueText(new HelpText(keyString, 5));
return(false);
}
}
public bool BoostSpell(int id, sbyte spellLevel)
{
bool result;
CharacterSpell spell = this.GetSpell(id);
if (spell == null)
{
InventoryHandler.SendSpellUpgradeFailureMessage(this.Owner.Client);
result = false;
}
else
{
int spellPoints = 0;
if (!this.CanBoostSpell(spell, spellLevel, ref spellPoints, true))
{
result = false;
}
else
{
this.Owner.SpellsPoints -= (ushort)spellPoints;
spell.CurrentLevel = (byte)spellLevel;
InventoryHandler.SendSpellUpgradeSuccessMessage(this.Owner.Client, spell);
result = true;
}
}
return(result);
}
protected override void OnItemAdded(MerchantItem item, bool sendMessage = true)
{
IsDirty = true;
InventoryHandler.SendExchangeShopStockMovementUpdatedMessage(Owner.OpenDialogs.Select(x => x.Character).ToClients(), item);
base.OnItemAdded(item, sendMessage);
}
void Start()
{
manager = GameManager.instance;
playerManager = PlayerManager.instance;
inventory = InventoryHandler.instance;
effectManager = StatusEffectManager.instance;
}
public override void Open()
{
base.Open();
FirstTrader.Character.SetDialoger(FirstTrader);
InventoryHandler.SendExchangeStartOkNpcTradeMessage(FirstTrader.Character.Client, this);
}
public void FindAnyMatchingItemsByKeywords_ShouldReturnMatchingItem()
{
const string inputKeyword = "revolver";
var inventoryItemsToSearch = new List <InventoryItem>()
{
MockItems.MockItemFlare
};
var weaponItemsToSearch = new List <WeaponItem>()
{
MockItems.MockItemGun
};
var keywordsToSearch = MockItems.MockItemGun.KeywordsForPickup;
keywordsToSearch.AddRange(MockItems.MockItemFlare.KeywordsForPickup);
var expectedOutput = new Items
{
InventoryItems = new List <InventoryItem>(),
WeaponItems = new List <WeaponItem>()
{
MockItems.MockItemGun
}
};
var returnedItem = InventoryHandler.FindAnyMatchingItemsByKeywords(inputKeyword, keywordsToSearch,
inventoryItemsToSearch, weaponItemsToSearch);
Assert.IsTrue(expectedOutput.WeaponItems.SequenceEqual(returnedItem.WeaponItems));
}
public bool ModifyItem(int id, uint price)
{
var item = BidHouseManager.Instance.GetBidHouseItem(id);
if (item == null)
{
return(false);
}
if (item.Template.Level > ((BidHouseExchange)Dialog).MaxItemLevel)
{
return(false);
}
var diff = (int)(item.Price - price);
var tax = 0;
tax = diff < 0 ? (int)Math.Round((Math.Abs(diff) * BidHouseManager.TaxPercent) / 100) : (int)Math.Round((Math.Abs(price) * BidHouseManager.TaxModificationPercent) / 100);
if (Character.Kamas < tax)
{
//Vous ne disposez pas d'assez de kamas pour acquiter la taxe de mise en vente...
Character.SendInformationMessage(TextInformationTypeEnum.TEXT_INFORMATION_MESSAGE, 57);
return(false);
}
Character.Inventory.SubKamas(tax);
item.Price = price;
InventoryHandler.SendExchangeBidHouseItemRemoveOkMessage(Character.Client, item.Guid);
InventoryHandler.SendExchangeBidHouseItemAddOkMessage(Character.Client, item.GetObjectItemToSellInBid());
return(true);
}
public int DowngradeSpell(CharacterSpell spell, bool send = true)
{
if (!HasSpell(spell.Id))
{
return(0);
}
if (spell.CurrentLevel <= 1)
{
return(0);
}
spell.CurrentLevel -= 1;
Owner.SpellsPoints += spell.CurrentLevel;
if (!send)
{
return(spell.CurrentLevel);
}
InventoryHandler.SendSpellListMessage(Owner.Client, true);
ContextRoleplayHandler.SendSpellModifySuccessMessage(Owner.Client, spell);
Owner.RefreshStats();
return(spell.CurrentLevel);
}
protected override void OnOpen()
{
InventoryHandler.SendExchangeRequestedTradeMessage(Source.Client, ExchangeTypeEnum.PLAYER_TRADE,
Source, Target);
InventoryHandler.SendExchangeRequestedTradeMessage(Target.Client, ExchangeTypeEnum.PLAYER_TRADE,
Source, Target);
}
private void AdjustLoots()
{
ResetRequiredItems();
foreach (var item in FirstTrader.Items.ToArray())
{
var requiredItem = GetRequiredItem(item.Template.Id);
if (requiredItem != null)
{
requiredItem.Count += item.Stack;
}
else
{
FirstTrader.MoveItemToInventory(item, (int)item.Stack);
}
}
var dofusLegendaire = ItemManager.Instance.TryGetTemplate(NpcDofus.RewardItemId);
var itemDofus = SecondTrader.Items.FirstOrDefault(item => item.Template.Id == dofusLegendaire.Id);
if (itemDofus == null)
{
if (!CanExchange())
{
return;
}
SecondTrader.AddItem(dofusLegendaire, 1);
return;
}
SecondTrader.RemoveItem(itemDofus.Template, itemDofus.Stack);
InventoryHandler.SendExchangeObjectRemovedMessage(FirstTrader.Character.Client, true, itemDofus.Guid);
}
public override void EndExecute(Character character)
{
var count = RollHarvestedItemCount(character);
var bonus = (int)Math.Floor(count * (AgeBonus / 100d));
SetHarvested();
InteractiveObject.SetInteractiveState(InteractiveStateEnum.STATE_ACTIVATED);
if (character.Inventory.IsFull(m_harvestedItem, count))
{
//Votre inventaire est plein. Votre récolte est perdue...
character.SendInformationMessage(TextInformationTypeEnum.TEXT_INFORMATION_MESSAGE, 144);
base.EndExecute(character);
return;
}
character.Inventory.AddItem(m_harvestedItem, count + bonus);
InventoryHandler.SendObtainedItemWithBonusMessage(character.Client, m_harvestedItem, count, bonus);
if (SkillTemplate.ParentJobId != 1)
{
var xp = JobManager.Instance.GetHarvestJobXp((int)SkillTemplate.LevelMin);
character.Jobs[SkillTemplate.ParentJobId].Experience += xp;
}
base.EndExecute(character);
}
public static void SelectCharacter(Client client, int id)
{
CharacterRecord characterRecord = client.Account.Characters.FirstOrDefault(character => character.Id == id);
if (characterRecord != null)
{
CharacterEngine character = new CharacterEngine(characterRecord, client);
client.Character = character;
client.Send(new CharacterSelectedSuccessMessage(character.GetCharacterBaseInformations));
ContextRoleplayHandler.SendEmoteListMessage(client, new sbyte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 19, 21, 22, 23, 24 });
ChatHandler.SendEnabledChannelsMessage(client, new sbyte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 });
InventoryHandler.SendInventoryContentMessage(client, new ObjectItem[0], character.Kamas); //TODO Get the characters items
InventoryHandler.SendInventoryWeightMessage(client, 0, character.MaxPods);
InventoryHandler.SendSpellListMessage(client);
PvPHandler.SendAlignmentRankUpdateMessage(client, 1);
PvPHandler.SendAlignmentSubAreasListMessage(client);
SendSetCharacterRestrictionsMessage(client);
SendLifePointsRegenBeginMessage(client, 10);
SendCharacterStatsListMessage(client);
client.Character.SendLoginMessage();
/*if (tutorial == true)
* {
* character.CurrentMapId = 35651584; //mapid of the tutorial map
* character.CellId = 324;
* client.Send(new QuestStartedMessage(489)); //start the tutorial quest
* }*/
}
else
{
client.Send(new CharacterSelectedErrorMessage());
}
}
private void OnBidHouseItemRemoved(BidHouseItem item, BidHouseCategory category, bool categoryDeleted)
{
if (!Types.Contains((int)item.Template.TypeId))
{
return;
}
if (!BidHouseManager.Instance.GetBidHouseCategories(item.Template.Id, MaxItemLevel).Any())
{
CurrentViewedItem = 0;
InventoryHandler.SendExchangeBidHouseGenericItemRemovedMessage(Character.Client, item);
UpdateCurrentViewedItem(item.Template.Id);
return;
}
if (CurrentViewedItem != item.Template.Id)
{
return;
}
if (categoryDeleted)
{
InventoryHandler.SendExchangeBidHouseInListRemovedMessage(Character.Client, category);
}
else
{
InventoryHandler.SendExchangeBidHouseInListUpdatedMessage(Character.Client, category);
}
}
protected override void OnRuneApplied(CraftResultEnum result, MagicPoolStatus poolStatus)
{
InventoryHandler.SendExchangeCraftResultMagicWithObjectDescMessage(Character.Client, result, ItemToImprove.PlayerItem, ItemEffects, poolStatus);
InventoryHandler.SendExchangeCraftInformationObjectMessage(Character.Client, ItemToImprove.PlayerItem, ItemToImprove.Owner, (ExchangeCraftResultEnum)result);
ItemToImprove.Owner.Inventory.RefreshItem(ItemToImprove.PlayerItem);
}
public bool ModifyItem(MerchantItem item, int quantity, uint price)
{
if (price > 0)
{
item.Price = price;
}
if (quantity > item.Stack)
{
var playerItem = Owner.Inventory.TryGetItem(item.Template, item.Effects);
if (playerItem != null)
{
StoreItem(playerItem, (int)(quantity - item.Stack), price);
}
}
if (quantity > 0 && quantity < item.Stack)
{
TakeBack(item, (int)(item.Stack - quantity));
}
InventoryHandler.SendExchangeShopStockMovementUpdatedMessage(Owner.Client, item);
return(true);
}
public bool UnLearnSpell(int id)
{
CharacterSpell spell = this.GetSpell(id);
bool result;
if (spell == null)
{
result = true;
}
else
{
this.m_spells.Remove(id);
this.m_spellsToDelete.Enqueue(spell.Record);
if (spell.CurrentLevel > 1)
{
int num = 0;
for (int i = 1; i < (int)spell.CurrentLevel; i++)
{
num += i;
}
Character expr_60 = this.Owner;
expr_60.SpellsPoints += (ushort)num;
}
InventoryHandler.SendSpellListMessage(this.Owner.Client, true);
result = true;
}
return(result);
}
/// <summary>
/// Drop all player weapons. Mostly used by on death events.
/// </summary>
/// <param name="client"></param>
public static void DropAllWeapons(Client client)
{
Account account = RetrieveAccount(client);
if (account.Weapons == "")
{
return;
}
client.RemoveAllWeapons();
List <WeaponHash> equipment = JsonConvert.DeserializeObject <List <WeaponHash> >(account.Weapons);
account.Weapons = "";
UpdateAccount(client);
foreach (WeaponHash item in equipment)
{
InventoryHandler.AddDroppedItemToGround(client, new InventoryItem
{
Name = item.ToString(),
StackCount = 1,
IsStackable = false
});
}
}
public bool TakeItemsBack(IEnumerable <int> guids, bool all, bool existing)
{
var newItems = new List <BasePlayerItem>();
var deletedItems = new List <BankItem>();
foreach (var item in Items.Values.Where(x => guids.Contains(x.Guid) || (existing && Owner.Inventory.Any(y => y.Template.Id == x.Template.Id)) || all).ToArray())
{
var newItem = TakeItemBack(item, (int)item.Stack, false);
if (newItem == null)
{
continue;
}
deletedItems.Add(item);
newItems.Add(newItem);
}
InventoryHandler.SendStorageObjectsRemoveMessage(Owner.Client, deletedItems.Select(x => x.Guid));
InventoryHandler.SendObjectsAddedMessage(Owner.Client, newItems.Select(x => x.GetObjectItem()));
InventoryHandler.SendObjectsQuantityMessage(Owner.Client, newItems.Select(x => new ObjectItemQuantity(x.Guid, (int)x.Stack)));
InventoryHandler.SendInventoryWeightMessage(Owner.Client);
return(true);
}
protected override void Start()
{
base.Start();
inventoryHandler = InventoryHandler.instance;
itemSlot = inventoryHandler.currentInventory.itemSlots[slotIndex];
thisPreviewSlot = inventoryHandler.currentInventory.previewSlot;
}
protected void Start()
{
switch (myControllerInput.inputType)
{
case InputType.KEYBOARD:
DownPlatformButton = "E";
RightPlatformButton = "F";
break;
case InputType.PS4_CONTROLLER:
DownPlatformButton = "X";
RightPlatformButton = "O";
break;
case InputType.XBOX_CONTROLLER:
DownPlatformButton = "A";
RightPlatformButton = "B";
break;
}
CameraOriginalPosition = myCamera.orthographicSize;
Stats = GetComponent <Stats>();
feetAnimation = transform.Find("Feet").GetComponent <Animator>();
rb = GetComponent <Rigidbody2D>();
InventoryHandler = GetComponent <InventoryHandler>();
reviveBarHandler = transform.Find("PlayerDownCanvas").GetComponent <ReviveBarHandler>();
PlayerOriginalImage = GetComponent <SpriteRenderer>().sprite;
LootBagHandler = GetComponent <LootBagHandler>();
InteractionPanel = transform.Find("InteractionCollider").GetComponent <InteractionHandler>();
InteractionPanel.InitInteraction(MyHUD);
}
private void OnReady(Trader trader, bool isready)
{
InventoryHandler.SendExchangeIsReadyMessage(Crafter.Character.Client,
trader, isready);
InventoryHandler.SendExchangeIsReadyMessage(Receiver.Character.Client,
trader, isready);
if (Receiver.Kamas > Receiver.Character.Inventory.Kamas)
{
InventoryHandler.SendExchangeCraftResultMessage(Clients, ExchangeCraftResultEnum.CRAFT_FAILED);
FirstTrader.ToggleReady(false);
SecondTrader.ToggleReady(false);
return;
}
if (Crafter.ReadyToApply && Receiver.ReadyToApply)
{
Craft();
Crafter.Character.Inventory.AddKamas(-Receiver.Character.Inventory.SubKamas((int)Receiver.Kamas));
Receiver.SetKamas(0);
ContextRoleplayHandler.SendJobExperienceOtherPlayerUpdateMessage(Receiver.Character.Client, Crafter.Character, Job);
FirstTrader.ToggleReady(false);
SecondTrader.ToggleReady(false);
}
}
// Used when user types 'weapons' or similar command
public static string CreateStringOfWeaponDescriptions(Character.Models.Character player, List <WeaponItem> roomWeapons)
{
var weaponDescriptions = "";
if (roomWeapons != null)
{
foreach (var weapon in roomWeapons)
{
if (weapon?.AttributeRequirementToSee != null && !InventoryHandler.PlayerMeetsRequirementForItem(player, false, weaponItem: weapon))
{
weaponDescriptions += $"{ConsoleStrings.LackingRequirementItemDescription} (<{weapon.AttributeRequirementToSee.RequirementName}> needed) \n\n";
}
else if (weapon.InOriginalLocation)
{
weaponDescriptions += weapon.OriginalPlacementDescription + "\n\n";
}
else
{
weaponDescriptions += weapon.GenericPlacementDescription + "\n\n";
}
}
}
return(weaponDescriptions);
}
// Used when user types 'items' or similar command
public static string CreateStringOfItemDescriptions(Character.Models.Character player, List <InventoryItem> roomItems)
{
var itemDescriptions = "";
if (roomItems != null)
{
foreach (var item in roomItems)
{
if (item?.AttributeRequirementToSee != null && !InventoryHandler.PlayerMeetsRequirementForItem(player, false, item))
{
itemDescriptions += $"{ConsoleStrings.LackingRequirementItemDescription} (<{item.AttributeRequirementToSee.RequirementName}> needed) \n\n";
}
else if (item.InOriginalLocation)
{
itemDescriptions += item.OriginalPlacementDescription + "\n\n";
}
else
{
itemDescriptions += item.GenericPlacementDescription + "\n\n";
}
}
}
return(itemDescriptions);
}
public void processBuyItem(ref byte[] packet)
{
byte[] goByteID = {packet[0],packet[1],packet[2],packet[3]};
UInt32 itemGoID = NumericalUtils.ByteArrayToUint32(goByteID,1);
InventoryHandler inventory = new InventoryHandler();
inventory.processItemAdd(itemGoID,0x10);
// ToDo: decrease the money ?:)
}
public virtual void Initialize(Game1 gameReference, Player playerReference, Sadako sadakoReference, InventoryHandler inventoryHandler, LocationHandler locationHandler, EventHandler eventHandler, RoomDatabase roomDatabase, TileDatabase tileDatabase)
{
this.gameReference = gameReference;
this.playerReference = playerReference;
this.sadakoReference = sadakoReference;
this.inventoryHandler = inventoryHandler;
this.locationHandler = locationHandler;
this.eventHandler = eventHandler;
this.tileDatabase = tileDatabase;
this.roomDatabase = roomDatabase;
}
public string CheckWhatYaSelling(InventoryHandler.Inventory_Item item)
{
if(item.item_attributes.Length < 1)
return "no sale";
string[] attributes = item.item_attributes.Split(',');
int index_BodyModel = 0;
// check if it is an outfit
bool isOutfit = false;
for(int a=0; a< attributes.Length; a++)
{
if(attributes[a].Contains("OUTFIT"))
{
string[] split = attributes[a].Split('=');
int.TryParse(split[1], out index_BodyModel);
isOutfit = true;
break;
}
}
if(!isOutfit)
return "no sale";
// are you wearing it
Multiplayer_Entity player = GameObject.FindGameObjectWithTag("Player").GetComponent<Multiplayer_Entity>();
if(index_BodyModel == player.index_BodyModel)
return "you are still wearing it";
return "";
}
public static void Player_AddItem(InventoryHandler.Inventory_Item customItem, int insertIndex)
{
instance.inventory.lists[0].list_items.Insert(insertIndex, customItem);
// Ensure that the item is flagged in the player data.
string item_key = customItem.item_key;
if ( GLOBAL.Player != null
&& !string.IsNullOrEmpty(item_key))
{
GLOBAL.Player.progress[item_key] = true;
}
Fill_The_Grid(instance.inventory.lists[0], false);
}
public static void Fill_The_Grid(InventoryHandler.Item_List item_list = null, bool isShopGrid = false)
{
RectTransform theGrid = isShopGrid ? instance.the_shop_grid : instance.the_inventory_grid;
// go through the grid
for (int grid_index=0; grid_index < theGrid.childCount; ++grid_index)
{
Transform gridItem = theGrid.GetChild(grid_index);
if (grid_index < item_list.list_items.Count)
{
// item
gridItem.gameObject.SetActive(true);
gridItem.GetComponent<Image>().sprite = item_list.list_items[grid_index].item_iconSprite;
gridItem.GetComponent<Image>().type = Image.Type.Simple;
// show price
if (isShopGrid)
{
string price = GetPrice(item_list.list_items[grid_index].item_attributes);
gridItem.GetChild(0).GetComponent<Text>().text = (price == "0" ? "free" : "$"+price);
}
}
else
{ // empty
gridItem.gameObject.SetActive(false);
}
}
}
public override void Initialize(Game1 gameReference, Player playerReference, Sadako sadakoReference, InventoryHandler inventoryHandler, LocationHandler locationHandler, EventHandler eventHandler, RoomDatabase roomDatabase, TileDatabase tileDatabase)
{
base.Initialize(gameReference, playerReference, sadakoReference, inventoryHandler, locationHandler, eventHandler, roomDatabase, tileDatabase);
}
