public BaseData GetNextScenario() { #region 读取json文件 if (index < fDatas.Count) { int type = fDatas[index].type; switch (type) { case 0: BaseData info1 = new SceneInfo(); info1 = fDatas[index]; index++; return(info1); case 1: BaseData info2 = new CharacterItem(); info2 = fDatas[index]; index++; return(info2); case 2: BaseData info3 = new SceneInfo(); info3 = fDatas[index]; index = 0; return(info3); default: break; } } return(null); #endregion }
/** * Adds an item to current user * * @param int id item id * @param int amount item quantity * * @return bool */ public bool addItem(int id, int amount = 1) { bool success; CharacterItem characterItem = Service.getOne <CharacterItem>("FROM inventory WHERE item == ?", id); if (characterItem != null) { characterItem.quantity += amount; characterItem.save(); success = true; } else { CharacterItem item = new CharacterItem { item = id, quantity = amount }; success = item.create(); } // reload inventory if (success) { try { QuestManager.Instance.sendAction(id, Task.ActorType.Item, Task.ActionType.GetItem, amount); Inventory.Instance.reload(); } catch (Exception) { } } return(success); }
public override void ReceiveDamage(IAttackerEntity attacker, CharacterItem weapon, Dictionary <DamageElement, MinMaxFloat> allDamageAmounts, CharacterBuff debuff, uint hitEffectsId) { if (!IsServer || IsDead() || !CanReceiveDamageFrom(attacker)) { return; } base.ReceiveDamage(attacker, weapon, allDamageAmounts, debuff, hitEffectsId); var attackerCharacter = attacker as BaseCharacterEntity; // If character is not dead, try to attack if (!IsDead()) { BaseCharacterEntity targetEntity; if (!TryGetTargetEntity(out targetEntity)) { // If no target enemy, set target enemy as attacker SetAttackTarget(attackerCharacter); } else if (attackerCharacter != targetEntity && Random.value > 0.5f) { // Random 50% to change target when receive damage from anyone SetAttackTarget(attackerCharacter); } } }
public static CharacterItem GetRandomedWeapon(this ICharacterData data, out bool isLeftHand) { isLeftHand = false; // Find right hand and left and to set result weapon var rightHand = data.EquipWeapons.rightHand; var leftHand = data.EquipWeapons.leftHand; var rightWeaponItem = rightHand.GetWeaponItem(); var leftWeaponItem = leftHand.GetWeaponItem(); if (rightWeaponItem != null && leftWeaponItem != null) { // Random right hand or left hand weapon isLeftHand = Random.Range(0, 1) == 1; return(!isLeftHand ? rightHand : leftHand); } else if (rightWeaponItem != null) { isLeftHand = false; return(rightHand); } else if (leftWeaponItem != null) { isLeftHand = true; return(leftHand); } return(CharacterItem.Create(GameInstance.Singleton.DefaultWeaponItem)); }
public void Deserialize(NetDataReader reader) { // Right hand rightHand = (CharacterItem)reader.GetValue(typeof(CharacterItem)); // Left hand leftHand = (CharacterItem)reader.GetValue(typeof(CharacterItem)); }
public override float GetEquipmentBonusRate(CharacterItem characterItem) { if (characterItem.GetMaxDurability() <= 0) { return(1); } var durabilityRate = (float)characterItem.durability / (float)characterItem.GetMaxDurability(); if (durabilityRate > 0.5f) { return(1f); } else if (durabilityRate > 0.3f) { return(0.75f); } else if (durabilityRate > 0.15f) { return(0.5f); } else if (durabilityRate > 0.05f) { return(0.25f); } else { return(0f); } }
void ReinforceItemSuccess() { if (ItemDataViewer.DefaultInstance.GetCurrentTargetItem().GetItemType() == Item.E_TYPE.EQUIPMENT) { EquipmentItem item = m_Item as EquipmentItem; EquipmentItem titem = ItemDataViewer.DefaultInstance.GetCurrentTargetItem() as EquipmentItem; if (!item || !titem) { return; } titem.IncreaseReinforceCount(item.GetReinforceCount() + 1); } else if (ItemDataViewer.DefaultInstance.GetCurrentTargetItem().GetItemType() == Item.E_TYPE.CHARACTER) { CharacterItem item = m_Item as CharacterItem; CharacterItem titem = ItemDataViewer.DefaultInstance.GetCurrentTargetItem() as CharacterItem; if (!item || !titem) { return; } titem.IncreaseReinforceCount(item.GetReinforceCount() + 1); } InventoryManager.Instance.DestroyItem(m_Item); InventoryViewer.RefreshAllSlots(); ItemDataViewer.DefaultInstance.Refresh(); m_LobbyCanvasUI.GetStatusUI().Refresh(); }
internal void CollectedItem(CharacterItem item) { Vector2 pos = Camera.main.WorldToScreenPoint(item.transform.position); GameObject go = GameObject.Instantiate(_bagChildPrefab, transform); go.transform.position = pos; Text text = go.GetComponentInChildren <Text>(); text.text = item.Character.ToString(); _bagChildItems[_bagChildItems.Count - 1].Show = false; foreach (var arrow in _arrows) { Color color = arrow.color; color.a = 0.1f; arrow.DOColor(color, 0.25f).OnComplete(() => { color.a = 1f; arrow.DOColor(color, 0.25f).Play(); }).Play(); } go.transform.DOMove(RightBox.transform.position, 1f).OnComplete(() => { _bagChildItems[_bagChildItems.Count - 1].Show = true; GameObject.Destroy(go); }).Play(); }
/// <summary> /// This will be called on server to use item /// </summary> /// <param name="dataId"></param> protected virtual void NetFuncUseItem(short itemIndex) { if (!CanUseItem()) { return; } if (itemIndex >= nonEquipItems.Count) { return; } CharacterItem characterItem = nonEquipItems[itemIndex]; if (characterItem.IsLock()) { return; } Item potionItem = characterItem.GetPotionItem(); if (potionItem != null && this.DecreaseItemsByIndex(itemIndex, 1)) { ApplyPotionBuff(potionItem, characterItem.level); } Item petItem = characterItem.GetPetItem(); if (petItem != null && this.DecreaseItemsByIndex(itemIndex, 1)) { ApplyItemPetSummon(petItem, characterItem.level, characterItem.exp); } }
IEnumerator Attack() { UserPiece = GameManager.ci; useskil = true; AttackMethod(); while (GameManager.state == GameState.InterruptPhase) { yield return(null); } useskil = false; AttackRecalc(); while (GameManager.state == GameState.AttackReCulc) { yield return(null); } GameManager.DiceFix = 0; GameManager.DamFix = 0; UserPiece = null; SetTarget = null; SetSkill = null; thdice = 0; pname = ""; DestroyCheck(); }
protected virtual void NetFuncSwapOrMergeNonEquipItems(short index1, short index2) { if (!CanDoActions() || index1 >= nonEquipItems.Count || index2 >= nonEquipItems.Count) { return; } CharacterItem nonEquipItem1 = nonEquipItems[index1]; CharacterItem nonEquipItem2 = nonEquipItems[index2]; if (nonEquipItem1.dataId == nonEquipItem2.dataId && nonEquipItem1.NotEmptySlot() && nonEquipItem2.NotEmptySlot()) { // Merge or swap if (nonEquipItem1.IsFull() || nonEquipItem2.IsFull()) { // Swap NetFuncSwapNonEquipItems(index1, index2); } else { // Merge NetFuncMergeNonEquipItems(index1, index2); } } else { // Swap NetFuncSwapNonEquipItems(index1, index2); } }
protected void NetFuncMergeNonEquipItems(short index1, short index2) { if (!CanDoActions() || index1 >= nonEquipItems.Count || index2 >= nonEquipItems.Count) { return; } CharacterItem nonEquipItem1 = nonEquipItems[index1]; CharacterItem nonEquipItem2 = nonEquipItems[index2]; short maxStack = nonEquipItem2.GetMaxStack(); if (nonEquipItem2.amount + nonEquipItem1.amount <= maxStack) { nonEquipItem2.amount += nonEquipItem1.amount; nonEquipItems[index2] = nonEquipItem2; nonEquipItems.RemoveAt(index1); } else { short mergeAmount = (short)(maxStack - nonEquipItem2.amount); nonEquipItem2.amount = maxStack; nonEquipItem1.amount -= mergeAmount; nonEquipItems[index1] = nonEquipItem1; nonEquipItems[index2] = nonEquipItem2; } }
/// <summary> /// This will be called at server to order character to unequip equipments /// </summary> /// <param name="fromEquipPosition"></param> protected virtual void NetFuncUnEquipItem(byte byteInventoryType, short index) { if (!CanDoActions()) { return; } EquipWeapons tempEquipWeapons = EquipWeapons; CharacterItem unEquipItem = CharacterItem.Empty; switch ((InventoryType)byteInventoryType) { case InventoryType.EquipWeaponRight: unEquipItem = tempEquipWeapons.rightHand; tempEquipWeapons.rightHand = CharacterItem.Empty; EquipWeapons = tempEquipWeapons; break; case InventoryType.EquipWeaponLeft: unEquipItem = tempEquipWeapons.leftHand; tempEquipWeapons.leftHand = CharacterItem.Empty; EquipWeapons = tempEquipWeapons; break; case InventoryType.EquipItems: unEquipItem = equipItems[index]; equipItems.RemoveAt(index); UpdateEquipItemIndexes(); break; } if (unEquipItem.NotEmptySlot()) { nonEquipItems.Add(unEquipItem); } }
private bool ReadCharacterItem(MySQLRowsReader reader, out CharacterItem result, bool resetReader = true) { if (resetReader) { reader.ResetReader(); } if (reader.Read()) { result = new CharacterItem(); result.id = reader.GetString("id"); result.dataId = reader.GetInt32("dataId"); result.level = reader.GetInt16("level"); result.amount = reader.GetInt16("amount"); result.equipSlotIndex = reader.GetByte("equipSlotIndex"); result.durability = reader.GetFloat("durability"); result.exp = reader.GetInt32("exp"); result.lockRemainsDuration = reader.GetFloat("lockRemainsDuration"); result.ammo = reader.GetInt16("ammo"); result.sockets = ReadSockets(reader.GetString("sockets")); return(true); } result = CharacterItem.Empty; return(false); }
public async UniTask <bool> IncreaseStorageItems(StorageId storageId, CharacterItem addingItem) { #if UNITY_STANDALONE && !CLIENT_BUILD Storage storge = GetStorage(storageId, out _); AsyncResponseData <IncreaseStorageItemsResp> resp = await DbServiceClient.IncreaseStorageItemsAsync(new IncreaseStorageItemsReq() { StorageType = storageId.storageType, StorageOwnerId = storageId.storageOwnerId, WeightLimit = storge.weightLimit, SlotLimit = storge.slotLimit, Item = addingItem, }); if (!resp.IsSuccess || UITextKeys.NONE != resp.Response.Error) { // Error ocurring, storage may overwhelming let's it drop items to ground return(false); } SetStorageItems(storageId, resp.Response.StorageCharacterItems); NotifyStorageItemsUpdated(storageId.storageType, storageId.storageOwnerId); return(true); #else return(false); #endif }
public async Task <IActionResult> PutCharacterItem(long id, CharacterItem characterItem) { if (id != characterItem.Id) { return(BadRequest()); } _context.Entry(characterItem).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!CharacterItemExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
private void SetupList(UIList list, DealingCharacterItems dealingItems, List <UICharacterItem> uiList) { CacheItemSelectionManager.DeselectSelectedUI(); List <CharacterItem> filterItems = new List <CharacterItem>(); foreach (DealingCharacterItem dealingItem in dealingItems) { CharacterItem characterItem = dealingItem.characterItem; filterItems.Add(characterItem); } uiList.Clear(); list.Generate(filterItems, (index, characterItem, ui) => { UICharacterItem uiCharacterItem = ui.GetComponent <UICharacterItem>(); uiCharacterItem.Setup(new CharacterItemTuple(characterItem, characterItem.level, InventoryType.NonEquipItems), null, -1); uiCharacterItem.Show(); uiList.Add(uiCharacterItem); }); CacheItemSelectionManager.Clear(); foreach (UICharacterItem tempDealingItemUI in tempDealingItemUIs) { CacheItemSelectionManager.Add(tempDealingItemUI); } foreach (UICharacterItem tempAnotherDealingItemUI in tempAnotherDealingItemUIs) { CacheItemSelectionManager.Add(tempAnotherDealingItemUI); } }
public void UseSkillButtonClick() { UseSkill = skillList[selectSkill.value]; TargetPiece = targetList[target.value]; TypeSpritter(); panel.SetActive(false); }
private void SetupList(UIList list, DealingCharacterItems dealingItems, List <UICharacterItem> uiList) { ItemSelectionManager.DeselectSelectedUI(); var filterItems = new List <CharacterItem>(); foreach (var dealingItem in dealingItems) { var characterItem = new CharacterItem(); characterItem.dataId = dealingItem.dataId; characterItem.level = dealingItem.level; characterItem.amount = dealingItem.amount; characterItem.durability = dealingItem.durability; filterItems.Add(characterItem); } uiList.Clear(); list.Generate(filterItems, (index, characterItem, ui) => { var uiCharacterItem = ui.GetComponent <UICharacterItem>(); uiCharacterItem.Setup(new CharacterItemTuple(characterItem, characterItem.level, string.Empty), null, -1); uiCharacterItem.Show(); uiList.Add(uiCharacterItem); }); ItemSelectionManager.Clear(); foreach (var tempDealingItemUI in tempDealingItemUIs) { ItemSelectionManager.Add(tempDealingItemUI); } foreach (var tempAnotherDealingItemUI in tempAnotherDealingItemUIs) { ItemSelectionManager.Add(tempAnotherDealingItemUI); } }
public async Task <ActionResult <CharacterItem> > PostCharacterItem(CharacterItem characterItem) { _context.CharacterItems.Add(characterItem); await _context.SaveChangesAsync(); return(CreatedAtAction(nameof(GetCharacterItem), new { id = characterItem.Id }, characterItem)); }
public static async Task <CharacterItem> DivideResourceAndSaveAsync(MainRepository repo, CharacterItem item, int resourceSize) { if (item.Resource <= resourceSize) { return(item); } item.Resource -= resourceSize; var newItem = new CharacterItem { Type = item.Type, Status = item.Status, CharacterId = item.CharacterId, TownId = item.TownId, IntLastStatusChangedGameDate = item.IntLastStatusChangedGameDate, Resource = resourceSize, }; await GenerateItemAndSaveAsync(repo, newItem); await StatusStreaming.Default.SendAllAsync(ApiData.From(newItem)); await StatusStreaming.Default.SendAllAsync(ApiData.From(item)); return(newItem); }
private void ReceivedDamage_PvpGetGold( Vector3 fromPosition, IGameEntity attacker, CombatAmountType combatAmountType, int damage, CharacterItem weapon, BaseSkill skill, short skillLevel) { if (!IsServer) { return; } if (attacker == null || attacker.Entity == Entity || !(attacker.Entity is BasePlayerCharacterEntity)) { return; } if (!this.IsDead()) { return; } int rewardGold = 100; (attacker.Entity as BasePlayerCharacterEntity).RewardCurrencies(new Reward() { gold = rewardGold }, 1f, RewardGivenType.None); }
protected virtual void NetFuncBuyNpcItem(short itemIndex, short amount) { if (currentNpcDialog == null) { return; } NpcSellItem[] sellItems = currentNpcDialog.sellItems; if (sellItems == null || itemIndex >= sellItems.Length) { return; } NpcSellItem sellItem = sellItems[itemIndex]; if (!gameplayRule.CurrenciesEnoughToBuyItem(this, sellItem, amount)) { gameManager.SendServerGameMessage(ConnectionId, GameMessage.Type.NotEnoughGold); return; } int dataId = sellItem.item.DataId; if (this.IncreasingItemsWillOverwhelming(dataId, amount)) { gameManager.SendServerGameMessage(ConnectionId, GameMessage.Type.CannotCarryAnymore); return; } gameplayRule.DecreaseCurrenciesWhenBuyItem(this, sellItem, amount); this.IncreaseItems(CharacterItem.Create(dataId, 1, amount)); }
private IEnumerator MoveItemFromStorageRoutine(BasePlayerCharacterEntity playerCharacterEntity, StorageId storageId, short storageItemIndex, short amount, short nonEquipIndex) { List <CharacterItem> storageItemList = new List <CharacterItem>(); ReadStorageItemsJob readStorageItemsJob = new ReadStorageItemsJob(Database, storageId.storageType, storageId.storageOwnerId); readStorageItemsJob.Start(); yield return(StartCoroutine(readStorageItemsJob.WaitFor())); if (readStorageItemsJob.result != null) { // Set storage items storageItemList = readStorageItemsJob.result; } if (storageItemIndex < 0 || storageItemIndex >= storageItemList.Count) { // Don't do anything, if storage item index is invalid } else { // Prepare storage data Storage storage = GetStorage(storageId); bool isLimitSlot = storage.slotLimit > 0; short slotLimit = storage.slotLimit; // Prepare item data CharacterItem movingItem = storageItemList[storageItemIndex].Clone(); movingItem.amount = amount; if (nonEquipIndex < 0 || nonEquipIndex >= playerCharacterEntity.NonEquipItems.Count || playerCharacterEntity.NonEquipItems[nonEquipIndex].IsEmptySlot() || playerCharacterEntity.NonEquipItems[nonEquipIndex].dataId == movingItem.dataId) { // Add to inventory or merge bool isOverwhelming = playerCharacterEntity.IncreasingItemsWillOverwhelming(movingItem.dataId, movingItem.amount); if (!isOverwhelming && playerCharacterEntity.IncreaseItems(movingItem)) { // Remove from storage storageItemList.DecreaseItemsByIndex(storageItemIndex, amount); } } else { // Swapping CharacterItem storageItem = storageItemList[storageItemIndex]; CharacterItem nonEquipItem = playerCharacterEntity.NonEquipItems[nonEquipIndex]; storageItemList[storageItemIndex] = nonEquipItem; playerCharacterEntity.NonEquipItems[nonEquipIndex] = storageItem; } storageItemList.FillEmptySlots(isLimitSlot, slotLimit); } // Update storage list immediately // TODO: Have to test about race condition while running multiple-server UpdateStorageItemsJob updateStorageItemsJob = new UpdateStorageItemsJob(Database, storageId.storageType, storageId.storageOwnerId, storageItemList); updateStorageItemsJob.Start(); yield return(StartCoroutine(updateStorageItemsJob.WaitFor())); // Update storage items to characters that open the storage UpdateStorageItemsToCharacters(usingStorageCharacters[storageId], storageItemList); }
protected virtual void OnSelectCharacterClass(BaseCharacter baseCharacter) { eventOnSelectCharacterClass.Invoke(baseCharacter); PlayerCharacterByDataId.TryGetValue(baseCharacter.DataId, out selectedPlayerCharacter); if (SelectedPlayerCharacter != null) { // Set creating player character data SelectedDataId = baseCharacter.DataId; // Prepare equip items List <CharacterItem> equipItems = new List <CharacterItem>(); foreach (Item armorItem in SelectedPlayerCharacter.armorItems) { if (armorItem == null) { continue; } equipItems.Add(CharacterItem.Create(armorItem)); } // Set model equip items SelectedModel.SetEquipItems(equipItems); // Prepare equip weapons EquipWeapons equipWeapons = new EquipWeapons(); if (SelectedPlayerCharacter.rightHandEquipItem != null) { equipWeapons.rightHand = CharacterItem.Create(SelectedPlayerCharacter.rightHandEquipItem); } if (SelectedPlayerCharacter.leftHandEquipItem != null) { equipWeapons.leftHand = CharacterItem.Create(SelectedPlayerCharacter.leftHandEquipItem); } // Set model equip weapons SelectedModel.SetEquipWeapons(equipWeapons); } }
private void ReceivedDamage_PvpGetGold( Vector3 fromPosition, IGameEntity attacker, CombatAmountType combatAmountType, int damage, CharacterItem weapon, BaseSkill skill, short skillLevel) { if (!IsServer) { return; } if (attacker == null || attacker.Entity == Entity || !(attacker.Entity is BasePlayerCharacterEntity)) { return; } int rewardGold = 100; BasePlayerCharacterEntity character = (attacker.Entity as BasePlayerCharacterEntity); if (!this.IsDead()) { return; } character.Gold = character.Gold.Increase(rewardGold); GameInstance.ServerGameMessageHandlers.NotifyRewardGold(character.ConnectionId, rewardGold); }
public static CharacterItem GetAvailableWeapon(this ICharacterData data, ref bool isLeftHand) { CharacterItem rightHand = data.EquipWeapons.rightHand; Item rightWeaponItem = rightHand.GetWeaponItem(); CharacterItem leftHand = data.EquipWeapons.leftHand; Item leftWeaponItem = leftHand.GetWeaponItem(); if (!isLeftHand) { if (rightWeaponItem != null) { return(rightHand); } if (rightWeaponItem == null && leftWeaponItem != null) { isLeftHand = true; return(leftHand); } } else { if (leftWeaponItem != null) { return(leftHand); } if (leftWeaponItem == null && rightWeaponItem != null) { isLeftHand = false; return(rightHand); } } isLeftHand = false; return(CharacterItem.Create(GameInstance.Singleton.DefaultWeaponItem)); }
protected virtual void NetFuncSellItem(short index, short amount) { if (IsDead() || index >= nonEquipItems.Count) { return; } if (currentNpcDialog == null || currentNpcDialog.type != NpcDialogType.Shop) { return; } CharacterItem nonEquipItem = nonEquipItems[index]; if (!nonEquipItem.NotEmptySlot() || amount > nonEquipItem.amount) { return; } Item item = nonEquipItem.GetItem(); if (this.DecreaseItemsByIndex(index, amount)) { gameplayRule.IncreaseCurrenciesWhenSellItem(this, item, amount); } }
public static async Task SetCharacterPendingAsync(MainRepository repo, CharacterItem item, Character chara) { if (item.Status == CharacterItemStatus.CharacterHold || item.Status == CharacterItemStatus.CharacterPending) { if (item.CharacterId == chara.Id) { return; } var oldChara = await repo.Character.GetByIdAsync(item.CharacterId); if (oldChara.HasData) { await ReleaseCharacterAsync(repo, item, oldChara.Data); } } var system = await repo.System.GetAsync(); item.Status = CharacterItemStatus.CharacterPending; item.CharacterId = chara.Id; item.TownId = 0; item.LastStatusChangedGameDate = system.GameDateTime; await CharacterService.StreamCharacterAsync(repo, chara); await StatusStreaming.Default.SendAllAsync(ApiData.From(item)); }
protected virtual void NetFuncSetDealingItem(short itemIndex, short amount) { if (DealingState != DealingState.Dealing) { gameManager.SendServerGameMessage(ConnectionId, GameMessage.Type.InvalidDealingState); return; } if (itemIndex >= nonEquipItems.Count) { return; } DealingCharacterItems dealingItems = DealingItems; for (int i = dealingItems.Count - 1; i >= 0; --i) { if (itemIndex == dealingItems[i].nonEquipIndex) { dealingItems.RemoveAt(i); break; } } CharacterItem characterItem = nonEquipItems[itemIndex].Clone(); characterItem.amount = amount; DealingCharacterItem dealingItem = new DealingCharacterItem(); dealingItem.nonEquipIndex = itemIndex; dealingItem.characterItem = characterItem; dealingItems.Add(dealingItem); // Update to clients DealingItems = dealingItems; }
void Awake() { _charStatus = GetComponent<CharacterStatus> (); _charMotor = GetComponent<CharacterMotor> (); _charItem = GetComponent<CharacterItem> (); anim = GetComponent<Animator> (); _myAgent = GetComponentInChildren<NavMeshAgent> (); }
public int guardButtonPressed { get; private set; } // CharacterStatus accesses this when recovering from stun so we need it public. void Awake() { _anim = GetComponent<Animator> (); _charStatus = GetComponent<CharacterStatus> (); _charMotor = GetComponent<CharacterMotor>(); _charAttacking = GetComponent<CharacterAttacking> (); _charItem = GetComponent<CharacterItem> (); }
public static void insertTestItems() { CharacterItem item = new CharacterItem (); item.id = 1; item.item = 1; item.character = 1; item.quantity = 2; item.create(); }
public void Initilize(CharacterItem itemToSpawn) { //Debug.Log("Spawning: " + itemToSpawn.ToString()); //Load from resources here; GameObject characterItemPrefab = (GameObject) Instantiate(Resources.Load(PREFAB_FOLDER + itemToSpawn), transform.position, transform.rotation); Item characterItem = characterItemPrefab.GetComponent<Item>(); if(!characterItem) { Debug.LogError("Item Prefab missing Item component in " +itemToSpawn.ToString() ); return; } PossibleSpawns.Remove(this); characterItem.mAreaSpawn = spawnArea; Destroy(gameObject); }
public void SpawnItem(CharacterItem ItemToSpawn) { //Get random spawn point if(ItemToSpawn != null) { //Debug.Log("Spawning Item: " + ItemToSpawn); ItemSpawnPoint point; if(ItemSpawnPoint.PossibleSpawns.Count > 1) { int index = new Random().Next(0, ItemSpawnPoint.PossibleSpawns.Count - 1); point = ItemSpawnPoint.PossibleSpawns[index]; point.Initilize(ItemToSpawn); } } }
/** * Adds an item to current user * * @param int id item id * @param int amount item quantity * * @return bool */ public bool addItem(int id, int amount = 1) { bool success; CharacterItem characterItem = Service.getOne<CharacterItem>("FROM inventory WHERE item == ?", id); if (characterItem != null) { characterItem.quantity += amount; characterItem.save(); success = true; } else { CharacterItem item = new CharacterItem { item = id, quantity = amount }; success = item.create (); } Debug.Log(success); // reload inventory if (success) { try { Inventory.Instance.reload(); } catch (Exception) {} } return success; }
/** * Adds an item to current user * * @param int id item id * @param int amount item quantity * * @return bool */ public bool addItem(int id, int amount = 1) { CharacterItem item = new CharacterItem { item = id, quantity = amount }; bool success = item.create (); // reload inventory if (success) { try { Inventory.Instance.reload(); } catch (Exception) {} } return success; }
public void AddBagItem(CharacterItem ci) { BagItems.Add (ci); }
public float StrafeDir { get { return _strafeDir; } } // Current amount we are strafing. void Awake() { _charStatus = GetComponent<CharacterStatus> (); _charMotor = GetComponent<CharacterMotor> (); _charAttacking = GetComponent<CharacterAttacking> (); _charItem = GetComponent<CharacterItem> (); Agent = GetComponentInChildren<NavMeshAgent> (); Agent.stoppingDistance = 0.1f; // default distance to stop from a target that I use. }
public Item get(CharacterItem cItem) { Item itm = Service.db.SelectKey<Item> ("item", cItem.item); itm.characterItem = cItem; return itm; }
/** * Validate if this item can be set on the select equipment position * */ public bool isValidEquipmentPosition(CharacterItem.equipmentPosition pos) { switch (type) { case ItemType.Weapon: if (pos == CharacterItem.equipmentPosition.handLeft || pos == CharacterItem.equipmentPosition.handRight) { return true; } break; case ItemType.Armor: switch (subType) { case ItemSubType.Head: if (pos == CharacterItem.equipmentPosition.head) { return true; } break; case ItemSubType.Hands: if (pos == CharacterItem.equipmentPosition.hands) { return true; } break; } break; case ItemType.Consumable: case ItemType.Container: case ItemType.Useless: return false; } return false; }