상속: MonoBehaviour
예제 #1
0
        public int HandlePacket(GameClient client, GSPacketIn packet)
        {
            int      value  = 0;
            int      num    = 0;
            int      num2   = 0;
            int      num3   = 0;
            int      num4   = 0;
            int      type   = 1;
            int      slot   = packet.ReadInt();
            int      iD     = packet.ReadInt();
            ItemInfo itemAt = client.Player.FightBag.GetItemAt(slot);

            if (itemAt != null)
            {
                client.Player.FightBag.RemoveItem(itemAt);
                ShopItemInfo shopItemInfoById = ShopMgr.GetShopItemInfoById(iD);
                ItemInfo.SetItemType(shopItemInfoById, type, ref value, ref num, ref num2, ref num3, ref num4);
                client.Player.AddGold(value);
            }
            return(0);
        }
예제 #2
0
    public override void UpdateItem(List <object> list)
    {
        ShopItemInfo info = list[index] as ShopItemInfo;

        textTitle.text = info.title;
        Vector4 border = AppRes.borderCellSettingBg;

        TextureUtil.UpdateImageTexture(imageBg, strImageBg[index % 3], false, border);

        Common.SetButtonText(btnBuy, info.artist, 0);
        if (info.isIAP)
        {
            btnBuy.gameObject.SetActive(true);
            // offsetMax.x = -232;
        }
        else
        {
            btnBuy.gameObject.SetActive(false);
            // offsetMax.x = -16;
        }
    }
예제 #3
0
    public override void SetInfo(object data)
    {
        _info = (ShopItemInfo)data;

        ItemsConfig cfg = ItemsConfigLoader.GetConfig(_info.ItemConfigID);

        if (cfg == null)
        {
            return;
        }

        _itemIcon.sprite      = ResourceManager.Instance.GetItemIcon(_info.ItemConfigID);
        _itemBg.sprite        = ResourceManager.Instance.GetIconBgByQuality(cfg.Quality);
        _itemBgCover.sprite   = ResourceManager.Instance.GetIconBgCoverByQuality(cfg.Quality);
        _itemName.text        = cfg.Name + "x" + _info.ContainNum;
        _itemName.color       = _info.IsSoldOut ? new Color(128 / 255f, 128 / 255f, 128 / 255f, 1) : ResourceManager.Instance.GetColorByQuality(cfg.Quality);
        _itemMoneyIcon.sprite = ResourceManager.Instance.GetPriceIcon(_info.PriceType);
        _itemMoneyIcon.SetNativeSize();
        _itemSoldout.material = _info.IsSoldOut ? GUIGrayScale : null;
        _itemMoneyNumber.text = _info.Price.ToString();
    }
예제 #4
0
        public override int HandlePacket(GamePlayer player, GSPacketIn packet)
        {
            int        gold          = 0;
            int        money         = 0;
            int        offer         = 0;
            int        gifttoken     = 0;
            int        type          = 1;
            List <int> needitemsinfo = new List <int>();
            int        index         = packet.ReadInt();
            int        GoodsID       = packet.ReadInt();
            ItemInfo   item          = player.FightBag.GetItemAt(index);

            if (item != null)
            {
                player.FightBag.RemoveItem(item, eItemRemoveType.Sell);
                ShopItemInfo shopitem = ShopMgr.GetShopItemInfoById(GoodsID);
                needitemsinfo = ShopMgr.GetShopItemBuyConditions(shopitem, type, ref gold, ref money, ref offer, ref gifttoken);
                player.AddGold(gold);
            }
            return(0);
        }
예제 #5
0
    public void addItem(string nameOfResource, int quantity = 1)
    {
        if (resourceList.ContainsKey(nameOfResource))
        {
            resourceList[nameOfResource] = resourceList[nameOfResource] + quantity;
        }
        else
        {
            if (!resourcesSeen.Contains(nameOfResource))
            {
                resourcesSeen.Add(nameOfResource);
                ShopItemInfo sellItem = new ShopItemInfo();
                sellItem.name     = nameOfResource;
                sellItem.sellItem = true;
                sellItem.cost     = FindObjectOfType <ShopManager>().resourceCost[nameOfResource];

                sellMenu.GetComponent <Shop>().addShopItem(sellItem);
            }
            resourceList.Add(nameOfResource, quantity);
        }
    }
예제 #6
0
    public static void destroyLootCrate(int rarity)
    {
        if (NumberOfLootCrates == MaxNumberOfLootCrates)
        {
            ShopItemInfo shopItem = new ShopItemInfo();
            shopItem.name = "Common Crate";
            shopItem.cost = 1000;
            FindObjectOfType <canvas>().mainBuyShop.addShopItem(shopItem);

            ShopItemInfo shopItem2 = new ShopItemInfo();
            shopItem.name = "Rare Crate";
            shopItem.cost = 2000;
            FindObjectOfType <canvas>().mainBuyShop.addShopItem(shopItem);

            ShopItemInfo shopItem3 = new ShopItemInfo();
            shopItem.name = "Legendary Crate";
            shopItem.cost = 3000;
            FindObjectOfType <canvas>().mainBuyShop.addShopItem(shopItem);
        }
        NumberOfLootCrates -= 1;
        FindObjectOfType <ShopManager>().lowerAmountOfCrate(rarity);
    }
예제 #7
0
    // SPOLECNY ITERFACE PRO VSECHNY PAGE
    public override void OnItemChange(ShopItemId itemId, bool forceUpdateView)
    {
        base.OnItemChange(itemId, forceUpdateView);

        ShopItemInfo itemInf = ShopDataBridge.Instance.GetItemInfo(itemId);

        string strYouHave = TextDatabase.instance[02900050];

        strYouHave = strYouHave.Replace("%i1", itemInf.OwnedCount.ToString());
        m_CountLabel.SetNewText(strYouHave);
        m_CountLabel.Widget.Show(itemInf.Consumable, true);

        string strAddCount = TextDatabase.instance[02900051];

        strAddCount = strAddCount.Replace("%i1", itemInf.AddCount.ToString());
        m_AddLabel.SetNewText(strAddCount);
        m_AddLabel.Widget.Show(itemInf.Consumable, true);

        string strDuration = TextDatabase.instance[02900052];

        strDuration = strDuration.Replace("%i1", itemInf.BoostDuration.ToString());
        m_DurationLabel.SetNewText(strDuration);
        m_DurationLabel.Widget.Show(itemInf.Consumable && itemInf.BoostDuration > 0, true);

        // hack na zobrazeni boost midifikatoru jen pro nektere itemy
        //pokud je boost 0 nebo male cislo (napr invisibilita) tak to ignorujeme.
        //pokud je vetsi jak 1 tak to znamena jen jiny typ zapisu, takze pak odecitame 100%.
        string strBoostModif = TextDatabase.instance[02900053];
        int    boostMod      = Mathf.CeilToInt(itemInf.BoostModifier * 100);

        if (itemInf.BoostModifier > 1.0f)
        {
            boostMod -= 100;
        }

        strBoostModif = strBoostModif.Replace("%i1", boostMod.ToString());
        m_BoostModLabel.SetNewText(strBoostModif);
        m_BoostModLabel.Widget.Show(itemInf.Consumable && itemInf.BoostModifier >= 0.25f, true);
    }
예제 #8
0
 public static XElement CreateShopInfo(ShopItemInfo shop)
 {
     return(new XElement("Item", new object[]
     {
         new XAttribute("ID", shop.ID),
         new XAttribute("ShopID", shop.ShopID),
         new XAttribute("GroupID", shop.GroupID),
         new XAttribute("TemplateID", shop.TemplateID),
         new XAttribute("BuyType", shop.BuyType),
         new XAttribute("Sort", shop.Sort),
         new XAttribute("IsBind", shop.IsBind),
         new XAttribute("IsVouch", shop.IsVouch),
         new XAttribute("Label", shop.Label),
         new XAttribute("Beat", shop.Beat),
         new XAttribute("AUnit", shop.AUnit),
         new XAttribute("APrice1", shop.APrice1),
         new XAttribute("AValue1", shop.AValue1),
         new XAttribute("APrice2", shop.APrice2),
         new XAttribute("AValue2", shop.AValue2),
         new XAttribute("APrice3", shop.APrice3),
         new XAttribute("AValue3", shop.AValue3),
         new XAttribute("BUnit", shop.BUnit),
         new XAttribute("BPrice1", shop.BPrice1),
         new XAttribute("BValue1", shop.BValue1),
         new XAttribute("BPrice2", shop.BPrice2),
         new XAttribute("BValue2", shop.BValue2),
         new XAttribute("BPrice3", shop.BPrice3),
         new XAttribute("BValue3", shop.BValue3),
         new XAttribute("CUnit", shop.CUnit),
         new XAttribute("CPrice1", shop.CPrice1),
         new XAttribute("CValue1", shop.CValue1),
         new XAttribute("CPrice2", shop.CPrice2),
         new XAttribute("CValue2", shop.CValue2),
         new XAttribute("CPrice3", shop.CPrice3),
         new XAttribute("CValue3", shop.CValue3),
         new XAttribute("IsCheap", shop.IsCheap)
     }));
 }
예제 #9
0
    public void EquipUnequipCurrentItem()
    {
        ShopItemInfo currentItemInfo = _shopItemsCategories[_selectedCategory].ShopItemsInfos[_shopItemsCategories[_selectedCategory].SelectedItem];
        PickupItem   pickupItem      = currentItemInfo.PickupItem;

        AudioManager.Instance.PlayOneShotSound(_equipSound, 1, 0, 2);


        // Unequip all items from the same category, except the one we are about to handle
        foreach (ShopItemInfo shopItemInfo in _shopItemsCategories[_selectedCategory].ShopItemsInfos)
        {
            if ((AmmoPickup)shopItemInfo.PickupItem != pickupItem)
            {
                _saveManager.HandleEquipItem((AmmoPickup)shopItemInfo.PickupItem, false);
                shopItemInfo.HandleEquipSignal(false);
            }
        }

        // The second bool (true here) is ignored, we are instead giving opposite as true to equip/unequip the weapon
        bool newEquipped = _saveManager.HandleEquipItem((AmmoPickup)pickupItem, true, true);

        currentItemInfo.HandleEquipSignal(newEquipped);
    }
예제 #10
0
    public void OnCellItemDidClick(UICellItemBase item)
    {
        int          idx  = item.index;
        ShopItemInfo info = listItem[idx] as ShopItemInfo;

        goldClickItem = info.gold;
        if (info.isIAP)
        {
            string title = Language.main.GetString(AppString.STR_UIVIEWALERT_TITLE_SHOP_START_BUY);
            string msg   = Language.main.GetString(AppString.STR_UIVIEWALERT_MSG_SHOP_START_BUY);
            string yes   = Language.main.GetString(AppString.STR_UIVIEWALERT_YES_SHOP_START_BUY);
            string no    = Language.main.GetString(AppString.STR_UIVIEWALERT_YES_SHOP_START_BUY);
            ViewAlertManager.main.ShowFull(title, msg, yes, no, false, KEYNAME_VIEWALERT, OnUIViewAlertFinished);

            IAP.main.StartBuy(info.id);
            //IAPCallBack(IAP.UNITY_CALLBACK_BUY_DID_Fail);
        }
        else
        {
            if (info.id == ID_GOLD_VIDEO)
            {
                AdKitCommon.main.ShowAdVideo();
            }
            if (info.id == ID_GOLD_SHARE)
            {
                ShowShare();
            }
            if (info.id == ID_GOLD_COMMENT)
            {
                string str_date = GetDateString();
                PlayerPrefs.SetString(KEY_HAS_COMMENT, str_date);
                AppVersion.main.callBackCommentClick = OnUICommentDidClick;
                AppVersion.main.OnComment();
            }
        }
    }
예제 #11
0
    // 购买物品
    public void RequestBuyItem(ShopType shopType, int shopItemID, bool isFixGet)
    {
        ShopItemInfo info = ShopItemInfo(shopType, shopItemID, isFixGet);

        if (info == null)
        {
            return;
        }

        if (GetMoney(info.PriceType) < info.Price)
        {
            UIUtil.ShowMsgFormat("MSG_SHOP_MONEY_LIMIT");
            return;
        }

        PBuyGood data = new PBuyGood();

        data.shopType = (int)shopType;
        data.goodId   = shopItemID;
        data.isFix    = isFixGet;

        NetworkManager.Instance.Send(eCommand.BUY_SHOP_GOOD, data, (buffer) => {
            PComItemList ret = Net.Deserialize <PComItemList>(buffer);
            if (!Net.CheckErrorCode(ret.errorCode, eCommand.BUY_SHOP_GOOD))
            {
                return;
            }

            info.IsSoldOut = true;
            UserManager.Instance.AddItemWithUI(ret);
            CostMoney(info.Price, info.PriceType);
            UIManager.Instance.RefreshWindow <UINewBagView>();
            UIManager.Instance.RefreshWindow <UIShopView>();
            EventDispatcher.TriggerEvent(EventID.EVENT_UI_MAIN_REFRESH_VALUE);
        });
    }
예제 #12
0
    private void OnRefreshShopInfo(PGeneralGoodList ret, ShopType shopType)
    {
        ShopInfo shopInfo = null;

        if (!ShopInfoData.TryGetValue(shopType, out shopInfo))
        {
            shopInfo = new ShopInfo();
            ShopInfoData[shopType] = shopInfo;
        }

        shopInfo.refreshCD.SetTimeMilliseconds(ret.nextAutoRefreshTime);
        shopInfo.refreshCount = ret.refreshTime;

        shopInfo.itemList.Clear();
        foreach (var item in ret.GeneralGoodList)
        {
            ShopItemInfo info = new ShopItemInfo();
            info.Deserialize(item);
            info.PriceType = shopType;
            shopInfo.itemList.Add(info);
        }

        EventDispatcher.TriggerEvent(EventID.EVENT_SHOP_REFRESH_SHOP, shopType);
    }
예제 #13
0
    public Dictionary <string, ShopItemInfo> loadShopItemInfo()
    {
        if (m_bloadShopItemInfoState == false)                                // 상점 정보 로드 이력이 없으면 CSV파일에서 불러온다.
        {
            Debug.Log("CSV 파일 상점 판매 아이템 정보 불러오기");
            TextAsset text    = Resources.Load <TextAsset>("Data/ShopItemInfo"); // 리소스 로드를 통해 테이블을 로드한다.
            string    content = text.text;                                       // 한라인으로 데이터가 나열되어 있다.
            string[]  line    = content.Split('\n');                             // string을 '\n' 기준으로 분리해서 line배열에 넣는다.
            for (int i = 2; i < line.Length - 1; i++)                            // 0 ~ 1번 라인은 테이블 타입 구분 용도로 사용한다. 2번째 라인부터 라인 갯수만큼 테이블 생성 (마지막NULL 한칸 제외해서 -1라인)
            {
                string[]     column = line[i].Split(',');                        // 열의 정보값을 ','로 구분해 column배열에 넣는다. SCV파일은 ,로 구분되어 있으므로
                ShopItemInfo table  = new ShopItemInfo();                        // SCV순서와 구조체 데이터 형식이 일치하여야 함
                string       key    = null;                                      // key값이 될 문자열의 닉네임 보관장소
                int          index  = 0;                                         // 0번째 열부터 시작

                key              = column[index++].Replace("\r", "");
                table.m_eType    = (ITEM_TYPE)int.Parse(column[index++]);
                table.m_iBuyGold = int.Parse(column[index++]);
                m_dicShopItemInfo.Add(key, table);
            }
            m_bloadShopItemInfoState = true;                                // 상점 정보를 로드한 상태로 변경
        }
        return(m_dicShopItemInfo);                                          // 상점 아이템 정보 반환
    }
예제 #14
0
    /// <summary>
    /// 初始化函数,加载文件路径
    /// </summary>
    public void Init()
    {
        shopItemInfoList = new List <ShopItemInfo>();
        shopItemList     = new List <ShopListItem>();
        string    sql = "select * from shop_item_information";
        DataTable dt  = MysqlHelper.ExecuteTable(sql, CommandType.Text, null);

        if (dt.Rows.Count > 0)
        {
            foreach (DataRow item in dt.Rows)
            {
                ShopItemInfo shopItemInfo = new ShopItemInfo();
                shopItemInfo.ShopItemID = int.Parse(item["shop_item_id"].ToString());
                shopItemInfo.ItemID     = int.Parse(item["item_id"].ToString());
                shopItemInfo.Count      = int.Parse(item["shop_item_count"].ToString());
                shopItemInfoList.Add(shopItemInfo);
            }
        }
        for (int i = 0; i < shopItemInfoList.Count; i++)
        {
            ShopListItem si = (ShopListItem)UIPackage.CreateObject("ShopMenu", "ShopListItem");
            si.ShopItemInfo = shopItemInfoList[i];
            si.Item         = ItemManager.Instance.GetItemByID(si.ShopItemInfo.ItemID);
            if (si.Item != null)
            {
                si.SetValues();
                si.AddCountButton.data = i;
                si.CutCountButton.data = i;
                si.BuyButton.data      = i;
                si.AddCountButton.onClick.Add(OnAddCountButtonDown);
                si.CutCountButton.onClick.Add(OnCutCountButtonDown);
                si.BuyButton.onClick.Add(OnBuyButtonDown);
            }
            shopItemList.Add(si);
        }
    }
예제 #15
0
    protected override void OnViewShow()
    {
        base.OnViewShow();

        Debug.Log("Not Funds Show");
        //Show fund info
        if (!ShopDataBridge.Instance.IsIAPFund(AddFundsID))
        {
            Debug.LogError("Selected funds is not IAP: " + AddFundsID);
        }

        ShopItemInfo inf    = ShopDataBridge.Instance.GetItemInfo(AddFundsID);
        string       strBuy = TextDatabase.instance[02030093];

        strBuy = strBuy.Replace("%d1", inf.AddGold.ToString());

        string productId = FundSettingsManager.Instance.Get((E_FundID)(AddFundsID.Id)).GUID.ToString();

        InAppInventory inventory = InAppPurchaseMgr.Instance.Inventory;
        InAppProduct   product   = null;

        if (inventory != null)
        {
            product = inventory.Product(productId);
        }

        if (product != null)
        {
            // add price to the buy label string
            strBuy += " (" + product.Price + " " + product.CurrencyCode + ")";
        }

        GUIBase_Label buyLabel = GuiBaseUtils.PrepareLabel(m_ScreenLayout, "Buy_Label");

        buyLabel.SetNewText(strBuy);
    }
예제 #16
0
    public override void UpdateItem(List <object> list)
    {
        ShopItemInfo info = list[index] as ShopItemInfo;

        textTitle.text = info.title;
        // Vector4 border = AppRes.borderCellSettingBg;
        //  TextureUtil.UpdateImageTexture(imageBg, strImageBg[index % 3], false, border);
        imageBg.UpdateImageByKey(strImageBg[index % 3]);
        // Common.SetButtonText(btnBuy, info.artist, 0);
        btnBuy.textTitle.text = info.artist;
        if (info.isIAP)
        {
            btnBuy.gameObject.SetActive(true);
            // offsetMax.x = -232;
        }
        else
        {
            btnBuy.gameObject.SetActive(false);
        }

        //btnBuy.gameObject.SetActive(true);
        LayOut();
        Invoke("LayOut", 0.2F);
    }
예제 #17
0
 void BuyItem(ShopItemInfo info, int num)
 {
     ServerCustom.instance.SendClientMethods("onClientShopping", long.Parse(info.itemID), num);
     buyIndex = num;
 }
예제 #18
0
 public void DrawPart2(CustomSpriteBatch g)
 {//48pixel de haut 14 icones affiché
     g.Draw(Shop_monter, new Vector2(720, 28), Color.White);
     g.Draw(Shop_descendre, new Vector2(720, 713), Color.White);
     for (int j = 0; j < 2; j += 1)
     {//Véhicule
         if (VehiSelect[j].VehiPos - SelectPos >= 0 && VehiSelect[j].VehiPos - SelectPos <= 13)
         {
             if (VehiSelect[j].IsOpen)
             {
                 g.Draw(VehiIco_p[j], new Vector2(720, (VehiSelect[j].VehiPos - SelectPos + 1) * 48), Color.White);
             }
             else
             {
                 if (MousePos.X > 720 && MousePos.Y > (VehiSelect[j].VehiPos - SelectPos + 1) * 48 && MousePos.Y < (VehiSelect[j].VehiPos - SelectPos + 1) * 48 + 38)
                 {
                     g.Draw(VehiIco_p[j], new Vector2(720, (VehiSelect[j].VehiPos - SelectPos + 1) * 48), Color.FromNonPremultiplied(255, 255, 255, 200));
                 }
                 else
                 {
                     g.Draw(VehiIco_p[j], new Vector2(720, (VehiSelect[j].VehiPos - SelectPos + 1) * 48), Color.FromNonPremultiplied(255, 255, 255, 127));
                 }
             }
         }//Armes
         if (VehiSelect[j].IsOpen)
         {
             for (int i = 0; i < VehiSelect[j].ArmePos.Length; i += 1)
             {
                 if (VehiSelect[j].VehiPos + i - SelectPos + 1 >= 0 && VehiSelect[j].VehiPos + i - SelectPos + 1 <= 13)
                 {
                     if (ActiveSelection.ItemSelected == i + 1)
                     {
                         g.Draw(sprWeaponIconsP[i, j], new Vector2(720, (VehiSelect[j].VehiPos + i - SelectPos + 1) * 48 + 48), Color.White);
                         if (MouseLeftPressed)
                         {
                             if (MousePos.X > 720 && MousePos.Y > (VehiSelect[j].VehiPos + i - SelectPos + 1) * 48 + 48 && MousePos.Y < (VehiSelect[j].VehiPos + i - SelectPos + 1) * 48 + 38 + 48)
                             {
                                 pas = ActiveShopItemInfo.ItemDescription.Length;
                             }
                         }
                     }
                     else
                     {
                         if (MousePos.X > 720 && MousePos.Y > (VehiSelect[j].VehiPos + i - SelectPos + 1) * 48 + 48 && MousePos.Y < (VehiSelect[j].VehiPos + i - SelectPos + 1) * 48 + 38 + 48)
                         {
                             g.Draw(sprWeaponIconsP[i, j], new Vector2(720, (VehiSelect[j].VehiPos + i - SelectPos + 1) * 48 + 48), Color.FromNonPremultiplied(255, 255, 255, 200));
                             if (MouseLeftPressed)
                             {
                                 ActiveShopItemInfo           = VehiSelect[j].WeaponPriceTable[i];
                                 ActiveSelection              = VehiSelect[j];
                                 ActiveSelection.ItemSelected = i + 1;
                                 pas = 0;
                             }
                         }
                         else
                         {
                             g.Draw(sprWeaponIcons[i, j], new Vector2(720, (VehiSelect[j].VehiPos + i - SelectPos + 1) * 48 + 48), Color.FromNonPremultiplied(255, 255, 255, 127));
                         }
                     }
                 }
             }
         }
     }
 }
예제 #19
0
        public void DrawPart1(CustomSpriteBatch g)
        {
            g.DrawString(fntArial13, "Joueur 1" + ": " + ActiveVehicule.Name, new Vector2(5, 540), Color.White);
            g.DrawStringRightAligned(fntArial13, "Argent " + ActiveVehicule.Argent + " $", new Vector2(710, 540), Color.White);

            //Armes Tank
            if (ActiveSelection.ItemSelected > 0)
            {
                int    Select       = ActiveSelection.ItemSelected;
                int    PrixTampon   = 0;
                Weapon ActiveWeapon = null;
                if (Select <= 3)
                {
                    ActiveWeapon = ActiveVehicule.ArrayWeaponPrimary[Select - 1];
                }
                else
                {
                    ActiveWeapon = ActiveVehicule.ArrayWeaponSecondary[Select - 4];
                }
                ShopItemInfo ActivePriceTable = ActiveSelection.WeaponPriceTable[Select - 1];

                g.DrawString(fntArial15, ActiveWeapon.ArmeLevel.ToString(), new Vector2(530, 569), Color.Black);
                g.DrawString(fntArial15, ActiveWeapon.WeaponRateOfFire.ToString(), new Vector2(100, 594), Color.Black);
                g.DrawString(fntArial15, ActiveWeapon.WeaponSpread.ToString(), new Vector2(120, 619), Color.Black);
                g.DrawString(fntArial15, ActiveWeapon.WeaponEnergy.ToString(), new Vector2(160, 644), Color.Black);
                g.DrawString(fntArial15, ActiveWeapon.WeaponDamage.ToString(), new Vector2(120, 669), Color.Black);
                g.DrawString(fntArial15, ActiveWeapon.WeaponResist.ToString(), new Vector2(120, 694), Color.Black);
                g.DrawString(fntArial15, ActiveWeapon.WeaponSpeed.ToString(), new Vector2(170, 719), Color.Black);
                g.DrawString(fntArial15, ActiveWeapon.WeaponSpecial.ToString(), new Vector2(205, 744), Color.Black);

                g.DrawString(fntArial15, ActiveWeapon.WeaponRateOfFireLvl.ToString(), new Vector2(530, 594), Color.Black);
                g.DrawString(fntArial15, ActiveWeapon.WeaponSpreadLvl.ToString(), new Vector2(530, 619), Color.Black);
                g.DrawString(fntArial15, ActiveWeapon.WeaponEnergyLvl.ToString(), new Vector2(530, 644), Color.Black);
                g.DrawString(fntArial15, ActiveWeapon.WeaponDamageLvl.ToString(), new Vector2(530, 669), Color.Black);
                g.DrawString(fntArial15, ActiveWeapon.WeaponResistLvl.ToString(), new Vector2(530, 694), Color.Black);
                g.DrawString(fntArial15, ActiveWeapon.WeaponSpeedLvl.ToString(), new Vector2(530, 719), Color.Black);
                g.DrawString(fntArial15, ActiveWeapon.WeaponSpecialLvl.ToString(), new Vector2(530, 744), Color.Black);

                //Affichage prix si non niveau maximum
                //Arme
                if (ActiveWeapon.ArmeLevel < 3)
                {
                    PrixTampon = ActivePriceTable.BasePrice + ActiveWeapon.ArmeLevel * ActivePriceTable.PriceMultiplier;
                    if (ActiveVehicule.Argent >= PrixTampon)
                    {
                        g.DrawStringRightAligned(fntArial15, PrixTampon + "$", new Vector2(440, 569), Color.Black);
                        if (MousePos.X >= 555 && MousePos.X <= 717 && MousePos.Y >= 570 && MousePos.Y <= 589)
                        {
                            g.Draw(SprShopAmeliorerP, new Vector2(555, 570), Color.White);
                            if (MouseLeftPressed)
                            {
                                ActiveVehicule.Argent -= PrixTampon;
                                ++ActiveWeapon.ArmeLevel;
                            }
                        }
                    }
                    else
                    {
                        g.DrawStringRightAligned(fntArial15, PrixTampon + "$", new Vector2(440, 569), Color.Red);
                    }
                }
                //Cadence
                if (ActiveWeapon.WeaponRateOfFireLvl < ActiveWeapon.ArmeLevel * 3)
                {
                    PrixTampon = ActivePriceTable.RateOfFirePrice * ActiveWeapon.WeaponRateOfFireLvl / 3;
                    if (ActiveVehicule.Argent >= PrixTampon)
                    {
                        g.DrawStringRightAligned(fntArial15, PrixTampon + "$", new Vector2(440, 594), Color.Black);
                        if (MousePos.X >= 555 && MousePos.X <= 717 && MousePos.Y >= 595 && MousePos.Y <= 614)
                        {
                            g.Draw(SprShopAmeliorerP, new Vector2(555, 595), Color.White);
                            if (MouseLeftPressed)
                            {
                                ActiveVehicule.Argent         -= PrixTampon;
                                ActiveWeapon.WeaponRateOfFire -= ActiveWeapon.RateOfFireMod;
                                ++ActiveWeapon.WeaponRateOfFireLvl;
                            }
                        }
                    }
                    else
                    {
                        g.DrawStringRightAligned(fntArial15, PrixTampon + "$", new Vector2(440, 594), Color.Red);
                    }
                }

                #region Dispertion

                switch (Select)
                {
                case 1:
                    if (ActiveWeapon.WeaponSpreadLvl < (ActiveWeapon.ArmeLevel * 2) - 1)
                    {
                        if (ActiveWeapon.WeaponSpreadLvl >= 1)
                        {
                            PrixTampon = ActivePriceTable.SpreadPrice;
                        }
                        else if (ActiveWeapon.WeaponSpreadLvl >= 3)
                        {
                            PrixTampon = ActivePriceTable.SpreadPrice * 2;
                        }
                        else if (ActiveWeapon.WeaponSpreadLvl >= 4)
                        {
                            PrixTampon = ActivePriceTable.SpreadPrice * 3;
                        }

                        PrixTampon *= ActiveWeapon.WeaponSpreadLvl;
                        if (ActiveVehicule.Argent >= PrixTampon)
                        {
                            g.DrawStringRightAligned(fntArial15, PrixTampon + "$", new Vector2(440, 619), Color.Black);

                            if (MousePos.X >= 555 && MousePos.X <= 717 && MousePos.Y >= 619 && MousePos.Y <= 638)
                            {
                                g.Draw(SprShopAmeliorerP, new Vector2(555, 619), Color.White);
                                if (MouseLeftPressed)
                                {
                                    UpgradeSpread(ActiveWeapon, PrixTampon);
                                }
                            }
                        }
                        else
                        {
                            g.DrawStringRightAligned(fntArial15, PrixTampon + "$", new Vector2(440, 619), Color.Red);
                        }
                    }
                    break;

                case 2:
                case 3:
                    if (ActiveWeapon.WeaponSpreadLvl < ActiveWeapon.ArmeLevel)
                    {
                        if (ActiveWeapon.WeaponSpreadLvl >= 1)
                        {
                            PrixTampon = ActivePriceTable.SpreadPrice;
                        }
                        else if (ActiveWeapon.WeaponSpreadLvl >= 3)
                        {
                            PrixTampon = ActivePriceTable.SpreadPrice * 2;
                        }
                        else if (ActiveWeapon.WeaponSpreadLvl >= 4)
                        {
                            PrixTampon = ActivePriceTable.SpreadPrice * 3;
                        }

                        PrixTampon *= ActiveWeapon.WeaponSpreadLvl;
                        if (ActiveVehicule.Argent >= PrixTampon)
                        {
                            g.DrawStringRightAligned(fntArial15, PrixTampon + "$", new Vector2(440, 619), Color.Black);

                            if (MousePos.X >= 555 && MousePos.X <= 717 && MousePos.Y >= 619 && MousePos.Y <= 638)
                            {
                                g.Draw(SprShopAmeliorerP, new Vector2(555, 619), Color.White);
                                if (MouseLeftPressed)
                                {
                                    UpgradeSpread(ActiveWeapon, PrixTampon);
                                }
                            }
                        }
                        else
                        {
                            g.DrawStringRightAligned(fntArial15, PrixTampon + "$", new Vector2(440, 619), Color.Red);
                        }
                    }
                    break;

                case 7:
                    if (ActiveWeapon.WeaponSpreadLvl < ActiveWeapon.ArmeLevel)
                    {
                        if (ActiveWeapon.WeaponSpreadLvl >= 0)
                        {
                            PrixTampon = ActivePriceTable.SpreadPrice;
                        }
                        else if (ActiveWeapon.WeaponSpreadLvl >= 3)
                        {
                            PrixTampon = ActivePriceTable.SpreadPrice * 2;
                        }
                        else if (ActiveWeapon.WeaponSpreadLvl >= 6)
                        {
                            PrixTampon = ActivePriceTable.SpreadPrice * 3;
                        }

                        PrixTampon *= ActiveWeapon.WeaponSpreadLvl;
                        if (ActiveVehicule.Argent >= PrixTampon)
                        {
                            g.DrawStringRightAligned(fntArial15, PrixTampon + "$", new Vector2(440, 619), Color.Black);

                            if (MousePos.X >= 555 && MousePos.X <= 717 && MousePos.Y >= 619 && MousePos.Y <= 638)
                            {
                                g.Draw(SprShopAmeliorerP, new Vector2(555, 619), Color.White);
                                if (MouseLeftPressed)
                                {
                                    UpgradeSpread(ActiveWeapon, PrixTampon);
                                }
                            }
                        }
                        else
                        {
                            g.DrawStringRightAligned(fntArial15, PrixTampon + "$", new Vector2(440, 619), Color.Red);
                        }
                    }
                    break;

                default:
                    if (ActiveWeapon.WeaponSpreadLvl < ActiveWeapon.ArmeLevel * 3)
                    {
                        if (ActiveWeapon.WeaponSpreadLvl >= 0)
                        {
                            PrixTampon = ActivePriceTable.SpreadPrice;
                        }
                        else if (ActiveWeapon.WeaponSpreadLvl >= 3)
                        {
                            PrixTampon = ActivePriceTable.SpreadPrice * 2;
                        }
                        else if (ActiveWeapon.WeaponSpreadLvl >= 6)
                        {
                            PrixTampon = ActivePriceTable.SpreadPrice * 3;
                        }

                        PrixTampon *= ActiveWeapon.WeaponSpreadLvl;
                        if (ActiveVehicule.Argent >= PrixTampon)
                        {
                            g.DrawStringRightAligned(fntArial15, PrixTampon + "$", new Vector2(440, 619), Color.Black);

                            if (MousePos.X >= 555 && MousePos.X <= 717 && MousePos.Y >= 619 && MousePos.Y <= 638)
                            {
                                g.Draw(SprShopAmeliorerP, new Vector2(555, 619), Color.White);
                                if (MouseLeftPressed)
                                {
                                    UpgradeSpread(ActiveWeapon, PrixTampon);
                                }
                            }
                        }
                        else
                        {
                            g.DrawStringRightAligned(fntArial15, PrixTampon + "$", new Vector2(440, 619), Color.Red);
                        }
                    }
                    break;
                }

                #endregion

                //Énergie
                if (ActiveWeapon.WeaponEnergyLvl < ActiveWeapon.ArmeLevel * 3)
                {
                    PrixTampon = ActivePriceTable.EnergyPrice * ActiveWeapon.WeaponEnergyLvl / 3;
                    if (ActiveVehicule.Argent >= PrixTampon)
                    {
                        g.DrawStringRightAligned(fntArial15, PrixTampon + "$", new Vector2(440, 644), Color.Black);

                        if (MousePos.X >= 555 && MousePos.X <= 717 && MousePos.Y >= 645 && MousePos.Y <= 664)
                        {
                            g.Draw(SprShopAmeliorerP, new Vector2(555, 645), Color.White);
                            if (MouseLeftPressed)
                            {
                                ActiveVehicule.Argent     -= PrixTampon;
                                ActiveWeapon.WeaponEnergy -= ActiveWeapon.EnergyMod;
                                ++ActiveWeapon.WeaponEnergyLvl;
                            }
                        }
                    }
                    else
                    {
                        g.DrawStringRightAligned(fntArial15, PrixTampon + "$", new Vector2(440, 644), Color.Red);
                    }
                }
                //Dégât
                if (ActiveWeapon.WeaponDamageLvl < ActiveWeapon.ArmeLevel * 3)
                {
                    PrixTampon = ActivePriceTable.DamagePrice * ActiveWeapon.WeaponDamageLvl / 3;
                    if (ActiveVehicule.Argent >= PrixTampon)
                    {
                        g.DrawStringRightAligned(fntArial15, PrixTampon + "$", new Vector2(440, 669), Color.Black);

                        if (MousePos.X >= 555 && MousePos.X <= 717 && MousePos.Y >= 670 && MousePos.Y <= 689)
                        {
                            g.Draw(SprShopAmeliorerP, new Vector2(555, 670), Color.White);
                            if (MouseLeftPressed)
                            {
                                ActiveVehicule.Argent     -= PrixTampon;
                                ActiveWeapon.WeaponDamage += ActiveWeapon.PowerMod;
                                ++ActiveWeapon.WeaponDamageLvl;
                            }
                        }
                    }
                    else
                    {
                        g.DrawStringRightAligned(fntArial15, PrixTampon + "$", new Vector2(440, 669), Color.Red);
                    }
                }
                //Résistence
                if (ActiveWeapon.WeaponResistLvl < ActiveWeapon.ArmeLevel * 3)
                {
                    PrixTampon = ActivePriceTable.ResistPrice * ActiveWeapon.WeaponResistLvl / 3;
                    if (ActiveVehicule.Argent >= PrixTampon)
                    {
                        g.DrawStringRightAligned(fntArial15, PrixTampon + "$", new Vector2(440, 694), Color.Black);
                        if (MousePos.X >= 555 && MousePos.X <= 717 && MousePos.Y >= 695 && MousePos.Y <= 714)
                        {
                            g.Draw(SprShopAmeliorerP, new Vector2(555, 695), Color.White);
                            if (MouseLeftPressed)
                            {
                                ActiveVehicule.Argent     -= PrixTampon;
                                ActiveWeapon.WeaponResist += ActiveWeapon.ResistMod;
                                ++ActiveWeapon.WeaponResistLvl;
                            }
                        }
                    }
                    else
                    {
                        g.DrawStringRightAligned(fntArial15, PrixTampon + "$", new Vector2(440, 694), Color.Red);
                    }
                }
                //Vitesse
                if (ActiveWeapon.WeaponSpeedLvl < ActiveWeapon.ArmeLevel * 3)
                {
                    PrixTampon = ActivePriceTable.SpeedPrice * ActiveWeapon.WeaponSpeedLvl / 3;
                    if (ActiveVehicule.Argent >= PrixTampon)
                    {
                        g.DrawStringRightAligned(fntArial15, PrixTampon + "$", new Vector2(440, 719), Color.Black);
                        if (MousePos.X >= 555 && MousePos.X <= 717 && MousePos.Y >= 720 && MousePos.Y <= 739)
                        {
                            g.Draw(SprShopAmeliorerP, new Vector2(555, 720), Color.White);
                            if (MouseLeftPressed)
                            {
                                ActiveVehicule.Argent    -= PrixTampon;
                                ActiveWeapon.WeaponSpeed += ActiveWeapon.SpeedMod;
                                ++ActiveWeapon.WeaponSpeedLvl;
                            }
                        }
                    }
                    else
                    {
                        g.DrawStringRightAligned(fntArial15, PrixTampon + "$", new Vector2(440, 719), Color.Red);
                    }
                }
            }

            if (ActiveShopItemInfo.ItemText != null)
            {
                TypewritterText(g, 50, 100, 2);
                g.DrawString(fntArial15, ActiveShopItemInfo.ItemText, new Vector2(150, 569), Color.Black);
            }
            switch (ActiveSelection.ItemSelected)
            {
            //Tank choisi
            case 0:

                g.DrawString(fntArial15, ActiveVehicule.VehiculeLevel.ToString(), new Vector2(530, 569), Color.Black);
                g.DrawString(fntArial15, ActiveVehicule.VehiculePerte.ToString(), new Vector2(160, 644), Color.Black);
                g.DrawString(fntArial15, ActiveVehicule.VehiculeResist.ToString(), new Vector2(120, 694), Color.Black);
                g.DrawString(fntArial15, ActiveVehicule.VehiculeVitesse.ToString(), new Vector2(170, 719), Color.Black);
                g.DrawString(fntArial15, ActiveVehicule.VehiculeSpecial.ToString(), new Vector2(205, 744), Color.Black);
                g.DrawString(fntArial15, ActiveVehicule.VehiculePerteLvl.ToString(), new Vector2(530, 644), Color.Black);
                g.DrawString(fntArial15, ActiveVehicule.VehiculeResistLvl.ToString(), new Vector2(530, 694), Color.Black);
                g.DrawString(fntArial15, ActiveVehicule.VehiculeVitesseLvl.ToString(), new Vector2(530, 719), Color.Black);
                g.DrawString(fntArial15, ActiveVehicule.VehiculeSpecialLvl.ToString(), new Vector2(530, 744), Color.Black);

                //Véhicule
                if (ActiveVehicule.VehiculeLevel < 3)
                {
                    int PrixTampon = ActiveSelection.VehiculePriceTable.BasePrice * ActiveVehicule.VehiculeLevel;
                    if (ActiveVehicule.Argent >= PrixTampon)
                    {
                        g.DrawStringRightAligned(fntArial15, PrixTampon + "$", new Vector2(440, 569), Color.Black);

                        if (MousePos.X >= 555 && MousePos.X <= 717 && MousePos.Y >= 570 && MousePos.Y <= 589)
                        {
                            g.Draw(SprShopAmeliorerP, new Vector2(555, 570), Color.White);
                            if (MouseLeftPressed)
                            {
                                ActiveVehicule.Argent -= PrixTampon;
                                ++ActiveVehicule.VehiculeLevel;
                            }
                        }
                        else
                        {
                            g.Draw(SprShopAmeliorer, new Vector2(555, 570), Color.White);
                        }
                    }
                    else
                    {
                        g.DrawStringRightAligned(fntArial15, PrixTampon + "$", new Vector2(440, 569), Color.Red);
                    }
                }
                //Énergie
                if (ActiveVehicule.VehiculePerteLvl < ActiveVehicule.VehiculeLevel * 3)
                {
                    int PrixTampon = ActiveSelection.VehiculePriceTable.EnergyPrice * ActiveVehicule.VehiculePerteLvl / 3;
                    if (ActiveVehicule.Argent >= PrixTampon)
                    {
                        g.DrawStringRightAligned(fntArial15, PrixTampon + "$", new Vector2(440, 644), Color.Black);

                        if (MousePos.X >= 555 && MousePos.X <= 717 && MousePos.Y >= 645 && MousePos.Y <= 664)
                        {
                            g.Draw(SprShopAmeliorerP, new Vector2(555, 645), Color.White);
                            if (MouseLeftPressed)
                            {
                                ActiveVehicule.Argent        -= PrixTampon;
                                ActiveVehicule.VehiculePerte -= ActiveVehicule.EnergyMod;
                                ++ActiveVehicule.VehiculePerteLvl;
                            }
                        }
                        else
                        {
                            g.Draw(SprShopAmeliorer, new Vector2(555, 645), Color.White);
                        }
                    }
                    else
                    {
                        g.DrawStringRightAligned(fntArial15, PrixTampon + "$", new Vector2(440, 644), Color.Red);
                    }
                }
                //Résistence
                if (ActiveVehicule.VehiculeResistLvl < ActiveVehicule.VehiculeLevel * 3)
                {
                    int PrixTampon = ActiveSelection.VehiculePriceTable.ResistPrice * ActiveVehicule.VehiculeResistLvl / 3;
                    if (ActiveVehicule.Argent >= PrixTampon)
                    {
                        g.DrawStringRightAligned(fntArial15, PrixTampon + "$", new Vector2(440, 694), Color.Black);
                        if (MousePos.X >= 555 && MousePos.X <= 717 && MousePos.Y >= 695 && MousePos.Y <= 714)
                        {
                            g.Draw(SprShopAmeliorerP, new Vector2(555, 695), Color.White);
                            if (MouseLeftPressed)
                            {
                                ActiveVehicule.Argent         -= PrixTampon;
                                ActiveVehicule.VehiculeResist -= ActiveVehicule.ResistMod;
                                ++ActiveVehicule.VehiculeResistLvl;
                            }
                        }
                        else
                        {
                            g.Draw(SprShopAmeliorer, new Vector2(555, 695), Color.White);
                        }
                    }
                    else
                    {
                        g.DrawStringRightAligned(fntArial15, PrixTampon + "$", new Vector2(440, 694), Color.Red);
                    }
                }
                //Vitesse
                if (ActiveVehicule.VehiculeVitesseLvl < ActiveVehicule.VehiculeLevel * 3)
                {
                    int PrixTampon = ActiveSelection.VehiculePriceTable.SpeedPrice * ActiveVehicule.VehiculeVitesseLvl / 3;
                    if (ActiveVehicule.Argent >= PrixTampon)
                    {
                        g.DrawStringRightAligned(fntArial15, PrixTampon + "$", new Vector2(440, 719), Color.Black);
                        if (MousePos.X >= 555 && MousePos.X <= 717 && MousePos.Y >= 720 && MousePos.Y <= 739)
                        {
                            g.Draw(SprShopAmeliorerP, new Vector2(555, 720), Color.White);
                            if (MouseLeftPressed)
                            {
                                ActiveVehicule.Argent             -= PrixTampon;
                                ActiveVehicule.VehiculeVitesse    -= ActiveVehicule.SpeedMod;
                                ActiveVehicule.VehiculeVitesseLvl += 1;
                            }
                        }
                        else
                        {
                            g.Draw(SprShopAmeliorer, new Vector2(555, 720), Color.White);
                        }
                    }
                    else
                    {
                        g.DrawStringRightAligned(fntArial15, PrixTampon + "$", new Vector2(440, 719), Color.Red);
                    }
                }
                //Spécial
                if (ActiveVehicule.VehiculeSpecialLvl < ActiveVehicule.VehiculeLevel * 3)
                {
                    int PrixTampon = ActiveSelection.VehiculePriceTable.SpecialPrice * ActiveVehicule.VehiculeSpecialLvl / 3;
                    if (ActiveVehicule.Argent >= PrixTampon)
                    {
                        g.DrawStringRightAligned(fntArial15, PrixTampon + "$", new Vector2(440, 744), Color.Black);
                        if (MousePos.X >= 555 && MousePos.X <= 717 && MousePos.Y >= 745 && MousePos.Y <= 764)
                        {
                            g.Draw(SprShopAmeliorerP, new Vector2(555, 745), Color.White);
                            if (MouseLeftPressed)
                            {
                                ActiveVehicule.Argent -= PrixTampon;
                                ++ActiveVehicule.VehiculeSpecialLvl;
                                //Niveau 4 = Barre de rage
                                if (ActiveVehicule.VehiculeSpecialLvl == 2)
                                {
                                    ActiveVehicule.VehiculeEnergieMax += 50;
                                }
                                if (ActiveVehicule.VehiculeSpecialLvl == 6)
                                {
                                    ActiveVehicule.VehiculeResistMax += 50;
                                }
                                if (ActiveVehicule.VehiculeSpecialLvl == 8)
                                {
                                    ActiveVehicule.VehiculeResistMax += 50;
                                }
                                if (ActiveVehicule.VehiculeSpecialLvl % 2 == 1)    //1, 3, 5, 7, 9
                                {
                                    ActiveVehicule.VehiculeSpecial += 1;
                                }
                            }
                        }
                        else
                        {
                            g.Draw(SprShopAmeliorer, new Vector2(555, 745), Color.White);
                        }
                    }
                    else
                    {
                        g.DrawStringRightAligned(fntArial15, PrixTampon + "$", new Vector2(440, 744), Color.Red);
                    }
                }
                break;
            }
        }
예제 #20
0
        public override void Update(GameTime gameTime)
        {
            MousePos.X = MouseHelper.MouseStateCurrent.X;
            MousePos.Y = MouseHelper.MouseStateCurrent.Y;

            MouseLeftPressed  = MouseHelper.InputLeftButtonPressed();
            MouseRightPressed = MouseHelper.InputRightButtonPressed();

            if (MousePos.X > 720 && MousePos.Y > 28 && MousePos.Y < 46 && MouseLeftPressed)
            {
                if (SelectPos > 0)
                {
                    SelectPos -= 1;
                }
            }
            if (MousePos.X > 720 && MousePos.Y > 713 && MousePos.Y < 731 && MouseLeftPressed)
            {
                if (SelectPos < Actif - 14)
                {
                    SelectPos += 1;
                }
            }
            for (int j = 0; j < 2; j += 1)
            {
                if (MousePos.X > 720 && MousePos.Y > (VehiSelect[j].VehiPos - SelectPos + 1) * 48 && MousePos.Y < (VehiSelect[j].VehiPos - SelectPos + 1) * 48 + 38)
                {
                    if (MouseLeftPressed)
                    {
                        if (!VehiSelect[j].IsOpen)
                        {
                            VehiSelect[j].IsOpen = true;
                            ActiveShopItemInfo   = VehiSelect[j].VehiculePriceTable;
                            Actif += VehiSelect[j].ArmePos.Length;
                            for (int k = j + 1; k < 2; k += 1)
                            {
                                VehiSelect[k].VehiPos = VehiSelect[j].VehiPos + VehiSelect[j].ArmePos.Length + k;
                            }
                        }
                        if (VehiSelect[j].ItemSelected == VehiSelect[j].VehiPos)
                        {
                            pas = ActiveShopItemInfo.ItemDescription.Length;
                        }
                        else
                        {
                            ActiveShopItemInfo         = VehiSelect[j].VehiculePriceTable;
                            VehiSelect[j].ItemSelected = 0;
                            pas = 0;
                        }
                    }
                    if (MouseRightPressed)
                    {
                        VehiSelect[j].IsOpen = false;
                        Actif -= VehiSelect[j].ArmePos.Length;
                        for (int k = j + 1; k < 2; k += 1)
                        {
                            VehiSelect[k].VehiPos = VehiSelect[j].VehiPos + k;
                        }
                    }
                }
            }
        }
예제 #21
0
        public void LoadShop()
        {
            VehiSelect[0].WeaponPriceTable = new ShopItemInfo[10];
            for (int i = 0; i < 3; i++)
            {
                ShopItemInfo NewPriceTable = new ShopItemInfo();

                NewPriceTable.BasePrice       = 500;
                NewPriceTable.PriceMultiplier = 500;
                NewPriceTable.RateOfFirePrice = 250;
                NewPriceTable.SpreadPrice     = 325;
                NewPriceTable.EnergyPrice     = 200;
                NewPriceTable.DamagePrice     = 275;
                NewPriceTable.ResistPrice     = 300;
                NewPriceTable.SpeedPrice      = 225;
                NewPriceTable.SpecialPrice    = 0;

                VehiSelect[0].WeaponPriceTable[i] = NewPriceTable;
            }
            for (int i = 0; i < 7; i++)
            {
                ShopItemInfo NewPriceTable = new ShopItemInfo();

                NewPriceTable.BasePrice       = 500;
                NewPriceTable.PriceMultiplier = 650;
                NewPriceTable.RateOfFirePrice = 250;
                NewPriceTable.SpreadPrice     = 325;
                NewPriceTable.EnergyPrice     = 200;
                NewPriceTable.DamagePrice     = 275;
                NewPriceTable.ResistPrice     = 300;
                NewPriceTable.SpeedPrice      = 225;
                NewPriceTable.SpecialPrice    = 0;

                VehiSelect[0].WeaponPriceTable[3 + i] = NewPriceTable;
            }

            VehiSelect[1].WeaponPriceTable = new ShopItemInfo[1];

            VehiSelect[0].VehiculePriceTable.ItemDescription  = "Le tank, véhicule surpuissant américain créé de toute pièce en chine.\r\nOutre sa formidable capacité à s'équiper d'armes de plus en plus\r\ndévastatrices, il est aussi très polyvalant et peux se promener sur\r\ntout les type de terrains. Ce goinfre de technologie moderne peut\r\névoluer en tout temps pour mieux écraser les ennemies.";
            VehiSelect[0].VehiculePriceTable.ItemText         = "Tank";
            VehiSelect[0].WeaponPriceTable[0].ItemDescription = "Le canon 1 est l'arme de base, alliant puissance et rapidité de tir.\r\nCe canon tir des obus sans laisser de chance a l'ennemie de riposter,\r\ntout en vous offrant une bonne couverture.";
            VehiSelect[0].WeaponPriceTable[0].ItemText        = "Canon 1";
            VehiSelect[0].WeaponPriceTable[1].ItemDescription = "Le canon 2 est une arme de très grande puissance, capable de\r\ndétruire complètement un adversaire d'un coup. Malheureusement,\r\ntant de puissance diminue la rapidité de tir et augmente son cout\r\nen énergie.";
            VehiSelect[0].WeaponPriceTable[1].ItemText        = "Canon 2";
            VehiSelect[0].WeaponPriceTable[2].ItemDescription = "Le canon 3 est très rapide que ce sois pour tirer ou pour atteindre\r\nun ennemie. Cette arme envoie des décharges d'énergie concentré,\r\nce qui diminue son coup en énergie. Malheureusement si peu d'énergie,\r\ndiminue considérablement sa puissance de feu.";
            VehiSelect[0].WeaponPriceTable[2].ItemText        = "Canon 3";
            VehiSelect[0].WeaponPriceTable[3].ItemDescription = "Le canon flak lance des morceaux de fer en fusion instable, ce qui\r\nles rend très dangereux. La fusion permet d'augmenter les dégâts\r\nrapidement et a faible couts. L'amélioration spéciale permet de rompre\r\nle noyau en plusieurs débris coupant pour finir le travail.";
            VehiSelect[0].WeaponPriceTable[3].ItemText        = "flak";
            VehiSelect[0].WeaponPriceTable[4].ItemDescription = "Le lance missile est une arme de puissance redoutable grâce a sa\r\ncoque en titane. Cette coque lui permet de transpercer plusieurs\r\nennemies, ce qui lui donne une bonne ambivalence.";
            VehiSelect[0].WeaponPriceTable[4].ItemText        = "Lance missile";
            VehiSelect[0].WeaponPriceTable[5].ItemDescription = "Les missiles guidés sont d'une précision mortelle, ce qu'ils perdent\r\nen puissance ils le regagnent grâce à un système de guidage thermique.\r\nCe système empèche tout système de visé au lancement.";
            VehiSelect[0].WeaponPriceTable[5].ItemText        = "Missiles guidé";
            VehiSelect[0].WeaponPriceTable[6].ItemDescription = "Le canon laser est une arme de haute technologie utilisant des rayons\r\nd'énergie pure. Ce laser est doté d'une puissance de feu inoué et\r\nne s'arrète devant presque rien. Cette puissance demande donc une\r\nquantité considérable d'énergie pour être utilisé ainsi qu'un lourd\r\ntemps de rechargement";
            VehiSelect[0].WeaponPriceTable[6].ItemText        = "Canon laser";
            VehiSelect[0].WeaponPriceTable[7].ItemDescription = "L'orbe défensif est un concentré d'énergie pure, ce qui lui offre une\r\nrésistance énorme ainsi que la capacité de gravité autour d'un champ\r\nénergétique assez puissant pour le contenir. Cette énergie est utilisée\r\npour absorber tout impact avec un objet plus petit que lui-même avant\r\nde se vider.";
            VehiSelect[0].WeaponPriceTable[7].ItemText        = "Orbe defensive";
            VehiSelect[0].WeaponPriceTable[8].ItemDescription = "La tourelle défensive est une reproduction de votre tank à plus petit\r\néchelle. Elle s'améliore avec le même système de tir que le tank et\r\npossède donc trois type de tir. Il s'agit d'un mini vous en quelque sorte.";
            VehiSelect[0].WeaponPriceTable[8].ItemText        = "Tourelle  défensive";
            VehiSelect[0].WeaponPriceTable[9].ItemDescription = "Le lance shuriken est une arme antique de haut rang qui découpe vos\r\nennemies comme du babeurre. En plus D'un pouvoir hautement\r\ndestructeur et d'une précision inégalé, Son am?lioration spécial\r\nl'enrobe de bande élastique et lui permette de rebondir.";
            VehiSelect[0].WeaponPriceTable[9].ItemText        = "Lance shuriken";

            VehiSelect[1].VehiculePriceTable.ItemDescription  = "Le pickup, formidable véhicule d'endurance et de puissance. Élevé dans\r\nles montagnes par de grands maitres de la mécanique, cette version\r\npossède une robustesse inégalée tout en possèdant une vaste panoplie\r\nd'armes destructrices. Malheureusement tant de poids et de puissance\r\naugmente sa consommation d'énergie et doit se rechargé souvent.";
            VehiSelect[1].VehiculePriceTable.ItemText         = "Pickup";
            VehiSelect[1].WeaponPriceTable[0].ItemDescription = "Le canon 1 du pickup est littéralement un canon pris sur un bateau\r\nantique nommé La Perle Noire. Modifié par des ingénieurs militaires\r\nretraités de la guerre du Vietnam, cette arme est maintenant plus\r\nrapide et destructrice qu'avant, tout en disposant de porte verre\r\ningénieusement situé dans la chambre de munition pour garder les\r\nliquides au chaud.";
            VehiSelect[1].WeaponPriceTable[0].ItemText        = "Canon 1";
        }
예제 #22
0
        public int HandlePacket(GameClient client, GSPacketIn packet)
        {
            int          num              = 0;
            int          num2             = 0;
            int          num3             = 0;
            int          num4             = 0;
            int          num5             = 0;
            int          iD               = packet.ReadInt();
            int          num6             = 1;
            ShopItemInfo shopItemInfoById = ShopMgr.GetShopItemInfoById(iD);

            if (shopItemInfoById == null)
            {
                return(0);
            }
            ItemTemplateInfo itemTemplateInfo = ItemMgr.FindItemTemplate(shopItemInfoById.TemplateID);

            ItemInfo.SetItemType(shopItemInfoById, num6, ref num, ref num2, ref num3, ref num4, ref num5);
            if (itemTemplateInfo.CategoryID == 10)
            {
                PlayerInfo playerCharacter = client.Player.PlayerCharacter;
                if (client.Player.PlayerCharacter.HasBagPassword && client.Player.PlayerCharacter.IsLocked && (num2 > 0 || num3 > 0 || num4 > 0 || num5 > 0))
                {
                    client.Out.SendMessage(eMessageType.Normal, LanguageMgr.GetTranslation("Bag.Locked", new object[0]));
                    return(0);
                }
                if (num <= playerCharacter.Gold && num2 <= ((playerCharacter.Money < 0) ? 0 : playerCharacter.Money) && num3 <= playerCharacter.Offer && num4 <= playerCharacter.GiftToken && num5 <= playerCharacter.medal)
                {
                    ItemInfo itemInfo = ItemInfo.CreateFromTemplate(itemTemplateInfo, 1, 102);
                    if (shopItemInfoById.BuyType == 0)
                    {
                        if (1 == num6)
                        {
                            itemInfo.ValidDate = shopItemInfoById.AUnit;
                        }
                        if (2 == num6)
                        {
                            itemInfo.ValidDate = shopItemInfoById.BUnit;
                        }
                        if (3 == num6)
                        {
                            itemInfo.ValidDate = shopItemInfoById.CUnit;
                        }
                    }
                    else
                    {
                        if (1 == num6)
                        {
                            itemInfo.Count = shopItemInfoById.AUnit;
                        }
                        if (2 == num6)
                        {
                            itemInfo.Count = shopItemInfoById.BUnit;
                        }
                        if (3 == num6)
                        {
                            itemInfo.Count = shopItemInfoById.CUnit;
                        }
                    }
                    if (client.Player.FightBag.AddItem(itemInfo, 0))
                    {
                        client.Player.RemoveGold(num);
                        client.Player.RemoveMoney(num2);
                        client.Player.RemoveOffer(num3);
                        client.Player.RemoveGiftToken(num4);
                        client.Player.RemoveMedal(num5);
                        LogMgr.LogMoneyAdd(LogMoneyType.Shop, LogMoneyType.Shop_Buy, client.Player.PlayerCharacter.ID, num2, client.Player.PlayerCharacter.Money, num, 0, 0, 0, "牌子编号", itemTemplateInfo.TemplateID.ToString(), num6.ToString());
                    }
                }
                else
                {
                    client.Out.SendMessage(eMessageType.ERROR, LanguageMgr.GetTranslation("PropBuyHandler.NoMoney", new object[0]));
                }
            }
            return(0);
        }
예제 #23
0
    // Start is called before the first frame update
    void Start()
    {
        Vector2 playerPosition = FindObjectOfType <Player>().transform.position;

        float angle = Random.Range(0f, 360f);

        float   xDirection = distanceAway * Mathf.Cos(angle);
        float   yDirection = distanceAway * Mathf.Sin(angle);
        Vector2 offset     = new Vector2(xDirection, yDirection);

        transform.position = playerPosition + offset;

        canvasHolder = FindObjectOfType <canvas>();
        shopManager  = FindObjectOfType <ShopManager>();

        //3 random resources to buy
        int indexOfResource1 = Random.Range(0, listOfResources.Count - 1);
        int indexOfResource2 = Random.Range(0, listOfResources.Count - 1);
        int indexOfResource3 = Random.Range(0, listOfResources.Count - 1);

        while (listOfResources[indexOfResource1].nameOfResource == listOfResources[indexOfResource2].nameOfResource || listOfResources[indexOfResource1].nameOfResource == listOfResources[indexOfResource3].nameOfResource || listOfResources[indexOfResource2].nameOfResource == listOfResources[indexOfResource3].nameOfResource)
        {
            indexOfResource1 = Random.Range(0, listOfResources.Count - 1);
            indexOfResource2 = Random.Range(0, listOfResources.Count - 1);
            indexOfResource3 = Random.Range(0, listOfResources.Count - 1);
        }

        ShopItemInfo buyItem1 = new ShopItemInfo();

        buyItem1.name = listOfResources[indexOfResource1].nameOfResource;
        buyItem1.cost = (int)(shopManager.resourceCost[listOfResources[indexOfResource1].nameOfResource] * additionalCostMultiplier);
        canvasHolder.friendlyBuyShop.GetComponent <Shop>().addShopItem(buyItem1);
        shopManager.listOfResources[0] = listOfResources[indexOfResource1];

        ShopItemInfo buyItem2 = new ShopItemInfo();

        buyItem2.name = listOfResources[indexOfResource2].nameOfResource;
        buyItem2.cost = (int)(shopManager.resourceCost[listOfResources[indexOfResource1].nameOfResource] * additionalCostMultiplier);
        canvasHolder.friendlyBuyShop.GetComponent <Shop>().addShopItem(buyItem2);
        shopManager.listOfResources[1] = listOfResources[indexOfResource2];

        ShopItemInfo buyItem3 = new ShopItemInfo();

        buyItem3.name = listOfResources[indexOfResource3].nameOfResource;
        buyItem3.cost = (int)(shopManager.resourceCost[listOfResources[indexOfResource1].nameOfResource] * additionalCostMultiplier);
        canvasHolder.friendlyBuyShop.GetComponent <Shop>().addShopItem(buyItem3);
        shopManager.listOfResources[2] = listOfResources[indexOfResource3];

        //generate 3 random resources to sell

        indexOfResource1 = Random.Range(0, listOfResources.Count - 1);
        indexOfResource2 = Random.Range(0, listOfResources.Count - 1);
        indexOfResource3 = Random.Range(0, listOfResources.Count - 1);

        while (listOfResources[indexOfResource1].nameOfResource == listOfResources[indexOfResource2].nameOfResource || listOfResources[indexOfResource1].nameOfResource == listOfResources[indexOfResource3].nameOfResource || listOfResources[indexOfResource2].nameOfResource == listOfResources[indexOfResource3].nameOfResource)
        {
            indexOfResource1 = Random.Range(0, listOfResources.Count - 1);
            indexOfResource2 = Random.Range(0, listOfResources.Count - 1);
            indexOfResource3 = Random.Range(0, listOfResources.Count - 1);
        }

        ShopItemInfo sellItem1 = new ShopItemInfo();

        sellItem1.name = listOfResources[indexOfResource1].nameOfResource;

        sellItem1.cost     = (int)(shopManager.resourceCost[listOfResources[indexOfResource1].nameOfResource] * additionalCostMultiplier);
        sellItem1.sellItem = true;
        canvasHolder.friendlySellShop.GetComponent <Shop>().addShopItem(sellItem1);
        itemsTraderIsSelling[0] = listOfResources[indexOfResource1].gameObject;

        ShopItemInfo sellItem2 = new ShopItemInfo();

        sellItem2.name     = listOfResources[indexOfResource2].nameOfResource;
        sellItem2.cost     = (int)(shopManager.resourceCost[listOfResources[indexOfResource2].nameOfResource] * additionalCostMultiplier);
        sellItem2.sellItem = true;
        canvasHolder.friendlySellShop.GetComponent <Shop>().addShopItem(sellItem2);
        itemsTraderIsSelling[1] = listOfResources[indexOfResource2].gameObject;

        ShopItemInfo sellItem3 = new ShopItemInfo();

        sellItem3.name     = listOfResources[indexOfResource3].nameOfResource;
        sellItem3.cost     = (int)(shopManager.resourceCost[listOfResources[indexOfResource3].nameOfResource] * additionalCostMultiplier);
        sellItem3.sellItem = true;
        canvasHolder.friendlySellShop.GetComponent <Shop>().addShopItem(sellItem3);
        itemsTraderIsSelling[2] = listOfResources[indexOfResource3].gameObject;

        health           = maxHealth;
        timeTillDeletion = maxTimeBeforeDeletion;
    }
예제 #24
0
        public static MonsterXfer FromStream(Stream mstream, ThingDb.Thing tt, short ParsingRule)
        {
            MonsterXfer result = new MonsterXfer();

            NoxBinaryReader br = new NoxBinaryReader(mstream);
            result.Direction = (DirectionEncoded) br.ReadUInt64();
            result.ScriptEvents = new string[10];
            // Читаем имена обработчиков скриптовых событий
            for (int i = 0; i < 10; i++)
            {
                if (i == 2)
                    result.DetectEventTimeout = br.ReadUInt16();

                result.ScriptEvents[i] = br.ReadScriptEventString();
            }
            // Пропуск (0)
            if (ParsingRule >= 11)
                br.ReadInt32();
            if (ParsingRule >= 31)
            {
                result.ActionRoamPathFlag = br.ReadByte();
                if (ParsingRule < 51)
                    result.StatusFlags = (NoxEnums.MonsterStatus) br.ReadUInt16();
                else
                    result.StatusFlags = (NoxEnums.MonsterStatus) br.ReadUInt32();

                result.HealthMultiplier = br.ReadSingle();
                result.RetreatRatio = br.ReadSingle();
                result.ResumeRatio = br.ReadSingle();
                result.SightRange = br.ReadSingle();
                if (ParsingRule < 33)
                    br.BaseStream.Seek(2, SeekOrigin.Current);
                result.Aggressiveness = br.ReadSingle();
                if (ParsingRule < 34)
                    result.DefaultAction = br.ReadInt32();
                result.EscortObjName = br.ReadString();
                if (ParsingRule >= 34)
                {
                    int spells = br.ReadInt32();
                    result.KnownSpells = new List<SpellEntry>();
                    string spellName = null;
                    uint spellFlags = 0;

                    for (int i = 0; i < spells; i++)
                    {
                        spellName = br.ReadString();
                        spellFlags = br.ReadUInt32();
                        if (ThingDb.thingdb.Spells.Keys.Contains(spellName))
                            result.KnownSpells.Add(new SpellEntry(spellName, spellFlags));
                    }
                }
                else
                    br.BaseStream.Seek(0x224, SeekOrigin.Current);
                // Задержки между заклинаниями
                if (ParsingRule < 46)
                {
                    result.ReactionCastingDelayMin = (ushort) br.ReadByte();
                    result.ReactionCastingDelayMax = (ushort) br.ReadByte();
                    if (ParsingRule <= 32) br.ReadInt32();
                    result.BuffCastingDelayMin = (ushort) br.ReadByte();
                    result.BuffCastingDelayMax = (ushort) br.ReadByte();
                    if (ParsingRule <= 32) br.ReadInt32();
                    result.DebuffCastingDelayMin = (ushort) br.ReadByte();
                    result.DebuffCastingDelayMax = (ushort) br.ReadByte();
                    if (ParsingRule <= 32) br.ReadInt32();
                    result.OffensiveCastingDelayMin = (ushort) br.ReadByte();
                    result.OffensiveCastingDelayMax = (ushort) br.ReadByte();
                    if (ParsingRule <= 32) br.ReadInt32();
                    result.BlinkCastingDelayMin = (ushort) br.ReadByte();
                    result.BlinkCastingDelayMax = (ushort) br.ReadByte();
                    if (ParsingRule <= 32) br.ReadInt32();
                }
                else
                {
                    result.ReactionCastingDelayMin = br.ReadUInt16();
                    result.ReactionCastingDelayMax = br.ReadUInt16();
                    result.BuffCastingDelayMin = br.ReadUInt16();
                    result.BuffCastingDelayMax = br.ReadUInt16();
                    result.DebuffCastingDelayMin = br.ReadUInt16();
                    result.DebuffCastingDelayMax = br.ReadUInt16();
                    result.OffensiveCastingDelayMin = br.ReadUInt16();
                    result.OffensiveCastingDelayMax = br.ReadUInt16();
                    result.BlinkCastingDelayMin = br.ReadUInt16();
                    result.BlinkCastingDelayMax = br.ReadUInt16();
                }
                if (ParsingRule > 32)
                    result.LockPathDistance = br.ReadSingle();

                if (ParsingRule >= 33)
                {
                    result.SpellPowerLevel = br.ReadInt32();
                    result.AimSkillLevel = br.ReadSingle();
                    if (ParsingRule < 42)
                    {
                        if (br.ReadInt16() == 0)
                            result.Immortal = true;
                    }
                    if (ParsingRule < 53)
                    {
                        int spellIndex = br.ReadInt32();
                        result.TrapSpell1 = ThingDb.thingdb.Spells.Values[spellIndex].Name;
                        spellIndex = br.ReadInt32();
                        result.TrapSpell2 = ThingDb.thingdb.Spells.Values[spellIndex].Name;
                        spellIndex = br.ReadInt32();
                        result.TrapSpell3 = ThingDb.thingdb.Spells.Values[spellIndex].Name;
                    }
                    else
                    {
                        result.TrapSpell1 = br.ReadString();
                        result.TrapSpell2 = br.ReadString();
                        result.TrapSpell3 = br.ReadString();
                    }
                }
                if (ParsingRule >= 34)
                {
                    string action = br.ReadString();
                    result.DefaultAction = Array.IndexOf(NoxEnums.AIActionStrings, action);
                }
                if (ParsingRule >= 41)
                {
                    // здесь придётся читать просто огромное кол-во инфы
                    // однако она используется очень редко, обычно entryType = 4; forced = 0
                    short entryType = br.ReadInt16();
                    if (entryType <= 4)
                    {
                        byte forced = 1;
                        if (entryType >= 2)
                            forced = br.ReadByte();
                        if (forced == 1 || entryType < 2)
                        {
                            return result;
                            // TODO для ПОЛНОЙ совместимости, придётся
                        }
                    }
                }
                if (ParsingRule >= 42)
                {
                    result.Immortal = br.ReadBoolean();
                }
                if (ParsingRule >= 43 && tt.Subclass[(int) ThingDb.Thing.SubclassBitIndex.SHOPKEEPER])
                {
                    // Информация о содержании магазина
                    ShopkeeperInfoStruct si = new ShopkeeperInfoStruct();
                    if (ParsingRule >= 50)
                        si.BuyValueMultiplier = br.ReadSingle();
                    if (ParsingRule >= 61)
                        si.SellValueMultiplier = br.ReadSingle();
                    if (ParsingRule >= 48)
                        si.ShopkeeperGreetingText = br.ReadString();
                    byte items = br.ReadByte();
                    si.ShopItems = new ShopItemInfo[items];
                    for (int i = 0; i < items; i++)
                    {
                        ShopItemInfo item = new ShopItemInfo();
                        if (ParsingRule < 50) br.ReadInt32();
                        item.Count = br.ReadByte();
                        item.Name = br.ReadString();
                        if (ParsingRule >= 47)
                        {
                            item.SpellID = br.ReadString();
                            item.Ench1 = br.ReadString();
                            item.Ench2 = br.ReadString();
                            item.Ench3 = br.ReadString();
                            item.Ench4 = br.ReadString();
                        }
                        si.ShopItems[i] = item;
                    }
                    result.ShopkeeperInfo = si;
                }
                if (ParsingRule >= 44)
                    result.MagicNumber = br.ReadUInt32();
                if (ParsingRule >= 45)
                    result.AddedSubclass = br.ReadUInt32();
                if (ParsingRule >= 49)
                    result.Health = br.ReadInt16();
                if (ParsingRule >= 51)
                {
                    result.SetDefaultResumeRatio = br.ReadBoolean();
                    result.SetDefaultRetreatRatio = br.ReadBoolean();
                    result.SetDefaultMonsterStatus = br.ReadBoolean();
                    result.LearnDefaultSpells = br.ReadBoolean();
                }
                if (ParsingRule >= 54 && tt.Subclass[(int) ThingDb.Thing.SubclassBitIndex.FEMALE_NPC])
                {
                    result.MaidenBodyColors = new Color[6];
                    byte R, G, B;
                    for (int i = 0; i < 6; i++)
                    {
                        R = br.ReadByte();
                        G = br.ReadByte();
                        B = br.ReadByte();
                        result.MaidenBodyColors[i] = Color.FromArgb(R, G, B);
                    }
                    if (ParsingRule >= 55)
                        result.MaidenVoiceSet = br.ReadString();
                }
                if (ParsingRule >= 62)
                {
                    short entryType = br.ReadInt16();
                    if (entryType > 2 || entryType <= 0) return result;

                    byte count = br.ReadByte();
                    result.BuffList = new BuffEntry[count];
                    while (count > 0)
                    {
                        BuffEntry be = new BuffEntry();
                        be.Name = br.ReadString();
                        be.Power = br.ReadByte();
                        be.Duration = br.ReadInt32();
                        if (be.Name == ENCHANT_SHIELD && entryType >= 2)
                            be.ShieldHealth = br.ReadInt32();

                        result.BuffList[count] = be;
                        count--;
                    }
                    Array.Reverse(result.BuffList);
                }
                if (ParsingRule >= 63 && tt.Subclass[(int) ThingDb.Thing.SubclassBitIndex.WOUNDED_NPC])
                    result.WoundedNPCVoiceSet = br.ReadString();
                if (ParsingRule >= 64)
                    result.PoisonLevel = br.ReadByte();
            }
            return result;
        }
예제 #25
0
        public int HandlePacket(GameClient client, GSPacketIn packet)//sendGoodsContinue
        {
            if (client.Player.PlayerCharacter.HasBagPassword && client.Player.PlayerCharacter.IsLocked)
            {
                client.Out.SendMessage(eMessageType.Normal, LanguageMgr.GetTranslation("Bag.Locked", new object[0]));
                return(0);
            }
            new StringBuilder();
            int    num         = packet.ReadInt();
            string translateId = "UserItemContineueHandler.Success";

            for (int i = 0; i < num; i++)
            {
                eBageType eBageType = (eBageType)packet.ReadByte();
                int       num2      = packet.ReadInt();
                int       iD        = packet.ReadInt();
                int       num3      = (int)packet.ReadByte();
                bool      flag      = packet.ReadBoolean();
                int       themvao   = packet.ReadInt();//_loc_3.writeInt(param1[_loc_4][5]);//4.2

                if ((eBageType == eBageType.MainBag && num2 >= 31) || eBageType == eBageType.PropBag || eBageType == eBageType.Consortia)
                {
                    ItemInfo itemAt    = client.Player.GetItemAt(eBageType, num2);
                    int      num4      = 0;
                    int      num5      = 0;
                    int      num6      = 0;
                    int      num7      = 0;
                    int      num8      = 0;
                    int      validDate = itemAt.ValidDate;
                    DateTime arg_C8_0  = itemAt.BeginDate;
                    int      count     = itemAt.Count;
                    bool     flag2     = itemAt.IsValidItem();
                    if (itemAt.ValidDate > 365)
                    {
                        client.Out.SendMessage(eMessageType.Normal, LanguageMgr.GetTranslation("Thời gian sử dụng đả đạt mức tối đa.", new object[0]));
                        break;
                    }
                    ShopItemInfo shopItemInfoById = ShopMgr.GetShopItemInfoById(iD);
                    if (shopItemInfoById.TemplateID != itemAt.TemplateID)
                    {
                        Console.WriteLine("HACK GIA HAN  " + client.Player.Account);
                        return(0);
                    }
                    ItemInfo.SetItemType(shopItemInfoById, num3, ref num4, ref num5, ref num6, ref num7, ref num8);
                    if (num4 <= client.Player.PlayerCharacter.Gold && num5 <= client.Player.PlayerCharacter.Money && num6 <= client.Player.PlayerCharacter.Offer && num7 <= client.Player.PlayerCharacter.GiftToken)
                    {
                        client.Player.RemoveMoney(num5);
                        client.Player.RemoveGold(num4);
                        client.Player.RemoveOffer(num6);
                        client.Player.RemoveGiftToken(num7);
                        if (!flag2 && itemAt.ValidDate != 0)
                        {
                            itemAt.ValidDate = 0;
                        }
                        if (1 == num3)
                        {
                            itemAt.ValidDate += shopItemInfoById.AUnit;
                        }
                        if (2 == num3)
                        {
                            itemAt.ValidDate += shopItemInfoById.BUnit;
                        }
                        if (3 == num3)
                        {
                            itemAt.ValidDate += shopItemInfoById.CUnit;
                        }
                        if (!flag2 && itemAt.ValidDate != 0)
                        {
                            itemAt.BeginDate = DateTime.Now;
                            itemAt.IsUsed    = false;
                        }
                        LogMgr.LogMoneyAdd(LogMoneyType.Shop, LogMoneyType.Shop_Continue, client.Player.PlayerCharacter.ID, num5, client.Player.PlayerCharacter.Money, num4, 0, 0, 0, "牌子编号", itemAt.TemplateID.ToString(), num3.ToString());
                    }
                    else
                    {
                        itemAt.ValidDate = validDate;
                        itemAt.Count     = count;
                        translateId      = "UserItemContineueHandler.NoMoney";
                    }
                    if (eBageType == eBageType.MainBag)
                    {
                        if (flag)
                        {
                            int toSlot = client.Player.MainBag.FindItemEpuipSlot(itemAt.Template);
                            client.Player.MainBag.MoveItem(num2, toSlot, itemAt.Count);
                        }
                        else
                        {
                            client.Player.MainBag.UpdateItem(itemAt);
                        }
                    }
                    else
                    {
                        if (eBageType == eBageType.PropBag)
                        {
                            client.Player.PropBag.UpdateItem(itemAt);
                        }
                        else
                        {
                            client.Player.ConsortiaBag.UpdateItem(itemAt);
                        }
                    }
                }
            }
            client.Out.SendMessage(eMessageType.Normal, LanguageMgr.GetTranslation(translateId, new object[0]));
            return(0);
        }
예제 #26
0
        public override int HandlePacket(GamePlayer player, GSPacketIn packet)
        {
            int                     totalGold          = 0;
            int                     totalMoney         = 0;
            int                     totalOffer         = 0;
            int                     totalGifttoken     = 0;
            int                     buyItemCount       = 0;
            eMessageType            eMsg               = eMessageType.Normal;
            string                  msg                = "UserBuyItemHandler.Success";
            GSPacketIn              pkg                = new GSPacketIn(44);
            List <ItemInfo>         buyItems           = new List <ItemInfo>();
            List <ItemInfo>         canNotBuyItems     = new List <ItemInfo>();
            List <int>              needitemsinfo      = new List <int>();
            Dictionary <int, int>   changeLimitShopsID = new Dictionary <int, int>();
            List <bool>             dresses            = new List <bool>();
            List <int>              places             = new List <int>();
            List <ItemJoinShopInfo> log                = new List <ItemJoinShopInfo>();
            Dictionary <int, int>   playerPayGoods     = new Dictionary <int, int>();
            int                     result2;

            if (player.PlayerCharacter.HasBagPassword && player.PlayerCharacter.IsLocked)
            {
                player.Out.SendMessage(eMessageType.Normal, LanguageMgr.GetTranslation("Bag.Locked", new object[0]));
                result2 = 1;
            }
            else
            {
                ConsortiaInfo consotia = ConsortiaMgr.FindConsortiaInfo(player.PlayerCharacter.ConsortiaID);
                int           count    = packet.ReadInt();
                for (int i = 0; i < count; i++)
                {
                    int          goodsId   = packet.ReadInt();
                    int          type      = packet.ReadInt();
                    string       color     = packet.ReadString();
                    bool         isDress   = packet.ReadBoolean();
                    string       skin      = packet.ReadString();
                    int          place     = packet.ReadInt();
                    bool         isBind    = false;
                    int          gold      = 0;
                    int          money     = 0;
                    int          offer     = 0;
                    int          gifttoken = 0;
                    ShopItemInfo shopItem  = ShopMgr.GetShopItemInfoById(goodsId);
                    if (shopItem != null && shopItem.ShopID != 21 && shopItem.ShopID != 22)
                    {
                        if (shopItem.ShopID == 2 || !ShopMgr.CanBuy(shopItem.ShopID, (consotia == null) ? 1 : consotia.ShopLevel, ref isBind, player.PlayerCharacter.ConsortiaID, player.PlayerCharacter.Riches))
                        {
                            player.Out.SendMessage(eMessageType.ERROR, LanguageMgr.GetTranslation("UserBuyItemHandler.FailbyPermission", new object[0]));
                            result2 = 1;
                            return(result2);
                        }
                        List <int> needsItems = ShopMgr.GetShopItemBuyConditions(shopItem, type, ref gold, ref money, ref offer, ref gifttoken);
                        for (int j = 0; j < needsItems.Count; j += 2)
                        {
                            if (!playerPayGoods.ContainsKey(needsItems[j]))
                            {
                                playerPayGoods.Add(needsItems[j], player.GetItemCount(needsItems[j]));
                            }
                        }
                        bool   result        = true;
                        string needsItemsLog = "";
                        for (int j = 0; j < needsItems.Count; j += 2)
                        {
                            if (playerPayGoods.ContainsKey(needsItems[j]) && playerPayGoods[needsItems[j]] >= needsItems[j + 1])
                            {
                                foreach (int a in needsItems)
                                {
                                    needitemsinfo.Add(a);
                                }
                                string text = needsItemsLog;
                                needsItemsLog = string.Concat(new string[]
                                {
                                    text,
                                    needsItems[j].ToString(),
                                    ":",
                                    needsItems[j + 1].ToString(),
                                    "|"
                                });
                                Dictionary <int, int> dictionary;
                                int key;
                                (dictionary = playerPayGoods)[key = needsItems[j]] = dictionary[key] - needsItems[j + 1];
                            }
                            else
                            {
                                result = false;
                            }
                        }
                        ItemInfo item       = ShopMgr.CreateItem(shopItem, 102, type, color, skin, isBind);
                        int      limitCount = ShopMgr.GetLimitCountByID(goodsId);
                        if (limitCount == -1 || limitCount > 0)
                        {
                            if (result && player.PlayerCharacter.Gold >= gold + totalGold && player.PlayerCharacter.Money >= money + totalMoney && player.PlayerCharacter.Offer >= offer + totalOffer && player.PlayerCharacter.GiftToken >= gifttoken + totalGifttoken)
                            {
                                totalGold      += gold;
                                totalMoney     += money;
                                totalOffer     += offer;
                                totalGifttoken += gifttoken;
                                buyItemCount++;
                                buyItems.Add(item);
                                dresses.Add(isDress);
                                places.Add(place);
                                if (limitCount != -1)
                                {
                                    ShopMgr.SubtractShopLimit(goodsId);
                                    this.Notice(player, goodsId, item.Template.Name);
                                    if (!changeLimitShopsID.ContainsKey(goodsId))
                                    {
                                        changeLimitShopsID.Add(goodsId, ShopMgr.GetLimitCountByID(goodsId));
                                    }
                                    else
                                    {
                                        changeLimitShopsID[goodsId] = ShopMgr.GetLimitCountByID(goodsId);
                                    }
                                }
                                log.Add(new ItemJoinShopInfo(item.TemplateID, item.Count, money, gold, gifttoken, offer, needsItemsLog));
                            }
                            else
                            {
                                canNotBuyItems.Add(item);
                            }
                        }
                    }
                }
                if (buyItems.Count == 0)
                {
                    player.Out.SendMessage(eMessageType.Normal, LanguageMgr.GetTranslation("UserBuyItemHandler.Failed", new object[0]));
                    result2 = 1;
                }
                else
                {
                    int buyFrom = packet.ReadInt();
                    player.RemoveMoney(totalMoney, LogMoneyType.Shop, LogMoneyType.Shop_Buy);
                    player.RemoveGold(totalGold);
                    player.RemoveOffer(totalOffer);
                    player.RemoveGiftToken(totalGifttoken);
                    StringBuilder allPayItemsStr = new StringBuilder();
                    for (int j = 0; j < needitemsinfo.Count; j += 2)
                    {
                        player.RemoveTemplate(needitemsinfo[j], needitemsinfo[j + 1], eItemRemoveType.Shopping);
                        allPayItemsStr.Append(needitemsinfo[j]).Append(",");
                    }
                    foreach (ItemJoinShopInfo templog in log)
                    {
                        //LogMgr.LogMoneyAdd(LogMoneyType.Shop, LogMoneyType.Shop_Buy, player.PlayerCharacter.ID, templog.Moneys, templog.Gold, templog.GiftToken, templog.Offer, templog.OtherPay, templog.TemplateID, 4, templog.Data);
                    }
                    List <ItemInfo> lastItems = new List <ItemInfo>();
                    player.StackItem(ref buyItems);
                    for (int i = 0; i < buyItems.Count; i++)
                    {
                        switch (buyFrom)
                        {
                        case 0:
                        case 3:
                            if (player.AddItem(buyItems[i]))
                            {
                                if (dresses[i])
                                {
                                    player.EquipItem(buyItems[i], places[i]);
                                    msg = "UserBuyItemHandler.Save";
                                }
                            }
                            else
                            {
                                lastItems.Add(buyItems[i]);
                            }
                            break;

                        case 1:
                            if (!UserBuyItemHandler.AddStrengthItemsToHideBag(player, buyItems[i]))
                            {
                                lastItems.Add(buyItems[i]);
                            }
                            break;

                        case 2:
                            if (!UserBuyItemHandler.AddComposeItemsToHideBag(player, buyItems[i]))
                            {
                                lastItems.Add(buyItems[i]);
                            }
                            break;

                        case 4:
                            if (!UserBuyItemHandler.AddFusionItemsToHideBag(player, buyItems[i]))
                            {
                                lastItems.Add(buyItems[i]);
                            }
                            break;
                        }
                    }
                    bool sentMail = false;
                    if (lastItems.Count > 0)
                    {
                        string title = "";
                        sentMail = player.SendItemsToMail(lastItems, "", title, eMailType.BuyItem);
                        msg      = "UserBuyItemHandler.Mail";
                    }
                    if (canNotBuyItems.Count > 0)
                    {
                        string        title   = LanguageMgr.GetTranslation("UserBuyItemHandler.ListTitle", new object[0]);
                        StringBuilder content = new StringBuilder();
                        if (buyItems.Count > 0)
                        {
                            content.Append(LanguageMgr.GetTranslation("UserBuyItemHandler.BuyList", new object[]
                            {
                                buyItems.Count
                            }));
                            for (int i = 0; i < buyItems.Count; i++)
                            {
                                content.Append(string.Format("{0}{1}", (i == 0) ? "" : ";", buyItems[i].Template.Name));
                            }
                        }
                        if (canNotBuyItems.Count > 0)
                        {
                            content.Append(LanguageMgr.GetTranslation("UserBuyItemHandler.NoBuyList", new object[]
                            {
                                "\n"
                            }));
                            for (int j = 0; j < canNotBuyItems.Count; j++)
                            {
                                content.Append(string.Format("{0}{1}", (j == 0) ? "" : ";", canNotBuyItems[j].Template.Name));
                            }
                        }
                        sentMail = player.SendMail(content.ToString(), title, null, eMailType.BuyItem);
                    }
                    if (sentMail)
                    {
                        player.Out.SendMailResponse(player.PlayerCharacter.ID, eMailRespose.Receiver);
                    }
                    player.OnPaid(totalMoney, totalGold, totalOffer, totalGifttoken, allPayItemsStr.ToString());
                    int buyResult = 0;
                    if (buyItemCount == count)
                    {
                        buyResult = (sentMail ? 2 : 1);
                    }
                    pkg.WriteInt(buyResult);
                    pkg.WriteInt(buyFrom);
                    player.Out.SendMessage(eMsg, LanguageMgr.GetTranslation(msg, new object[0]));
                    player.Out.SendTCP(pkg);
                    player.SaveIntoDatabase();

                    this.UpdateLimitShopCount(player, changeLimitShopsID);

                    result2 = 0;
                }
            }
            return(result2);
        }
예제 #27
0
        public override int HandlePacket(GamePlayer player, GSPacketIn packet)
        {
            int result2;

            if (player.PlayerCharacter.HasBagPassword && player.PlayerCharacter.IsLocked)
            {
                player.Out.SendMessage(eMessageType.Normal, LanguageMgr.GetTranslation("Bag.Locked", new object[0]));
                result2 = 0;
            }
            else
            {
                StringBuilder payGoods = new StringBuilder();
                int           count    = packet.ReadInt();
                bool          istips   = true;
                for (int i = 0; i < count; i++)
                {
                    eBageType bag     = (eBageType)packet.ReadByte();
                    int       place   = packet.ReadInt();
                    int       goodsID = packet.ReadInt();
                    int       type    = (int)packet.ReadByte();
                    bool      isDress = packet.ReadBoolean();
                    if (bag == eBageType.MainBag || bag == eBageType.PropBag || bag == eBageType.Bank)
                    {
                        ItemInfo item = player.GetItemAt(bag, place);
                        if (item != null && item.ValidDate != 0 && !item.IsValidItem() && (bag == eBageType.MainBag || (bag == eBageType.PropBag && item.TemplateID == 10200)))
                        {
                            int          gold          = 0;
                            int          money         = 0;
                            int          offer         = 0;
                            int          gifttoken     = 0;
                            int          oldDate       = item.ValidDate;
                            int          oldCount      = item.Count;
                            bool         isValid       = item.IsValidItem();
                            List <int>   needitemsinfo = new List <int>();
                            ShopItemInfo shopitem      = ShopMgr.GetShopItemInfoById(goodsID);
                            needitemsinfo = ShopMgr.GetShopItemBuyConditions(shopitem, type, ref gold, ref money, ref offer, ref gifttoken);
                            int  icount = player.MainBag.GetItems().Count;
                            bool result = true;
                            for (int j = 0; j < needitemsinfo.Count; j += 2)
                            {
                                if (player.GetItemCount(needitemsinfo[j]) < needitemsinfo[j + 1])
                                {
                                    result = false;
                                }
                            }
                            if (!result)
                            {
                                eMessageType eMsg = eMessageType.ERROR;
                                string       msg  = "UserBuyItemHandler.NoBuyItem";
                                player.Out.SendMessage(eMsg, LanguageMgr.GetTranslation(msg, new object[0]));
                                result2 = 1;
                                return(result2);
                            }
                            if (gold <= player.PlayerCharacter.Gold && money <= player.PlayerCharacter.Money && offer <= player.PlayerCharacter.Offer && gifttoken <= player.PlayerCharacter.GiftToken)
                            {
                                player.RemoveMoney(money, LogMoneyType.Shop, LogMoneyType.Shop_Continue);
                                player.RemoveGold(gold);
                                player.RemoveOffer(offer);
                                player.RemoveGiftToken(gifttoken);
                                for (int j = 0; j < needitemsinfo.Count; j += 2)
                                {
                                    player.RemoveTemplate(needitemsinfo[j], needitemsinfo[j + 1], eItemRemoveType.ShoppingForContinue);
                                    payGoods.Append(needitemsinfo[j].ToString() + ":");
                                }
                                if (!isValid && item.ValidDate != 0)
                                {
                                    if (1 == type)
                                    {
                                        item.ValidDate = shopitem.AUnit;
                                        item.BeginDate = DateTime.Now;
                                        item.IsUsed    = true;
                                    }
                                    if (2 == type)
                                    {
                                        item.ValidDate = shopitem.BUnit;
                                        item.BeginDate = DateTime.Now;
                                        item.IsUsed    = true;
                                    }
                                    if (3 == type)
                                    {
                                        item.ValidDate = shopitem.CUnit;
                                        item.BeginDate = DateTime.Now;
                                        item.IsUsed    = true;
                                    }
                                }
                                if (bag == eBageType.MainBag)
                                {
                                    player.MainBag.UpdateItem(item);
                                }
                                else
                                {
                                    if (bag == eBageType.PropBag)
                                    {
                                        player.PropBag.UpdateItem(item);
                                    }
                                    else
                                    {
                                        player.StoreBag.UpdateItem(item);
                                    }
                                }
                                //LogMgr.LogMoneyAdd(LogMoneyType.Shop, LogMoneyType.Shop_Continue, player.PlayerCharacter.ID, money, gold, gifttoken, offer, "", item.TemplateID, 6, item.Count);
                            }
                            else
                            {
                                if (money <= player.PlayerCharacter.Money)
                                {
                                    istips         = false;
                                    item.ValidDate = oldDate;
                                    item.Count     = oldCount;
                                    player.Out.SendMessage(eMessageType.Normal, LanguageMgr.GetTranslation("UserItemContineueHandler.NoMoney", new object[0]));
                                }
                                else
                                {
                                    if (gifttoken <= player.PlayerCharacter.GiftToken)
                                    {
                                        istips         = false;
                                        item.ValidDate = oldDate;
                                        item.Count     = oldCount;
                                        player.Out.SendMessage(eMessageType.Normal, LanguageMgr.GetTranslation("UserItemContineueHandler.NoMoney", new object[0]));
                                    }
                                }
                            }
                        }
                    }
                }
                if (istips)
                {
                    player.Out.SendMessage(eMessageType.Normal, LanguageMgr.GetTranslation("UserItemContineueHandler.Success", new object[0]));
                }
                result2 = 0;
            }
            return(result2);
        }
예제 #28
0
        public override int HandlePacket(GamePlayer player, GSPacketIn packet)
        {
            int  bagType       = packet.ReadInt();
            int  place         = packet.ReadInt();
            int  goodsID       = packet.ReadInt();
            int  type          = packet.ReadInt();
            bool ignoreBagLock = packet.ReadBoolean();
            int  result;

            if (player.PlayerCharacter.HasBagPassword && player.PlayerCharacter.IsLocked && !ignoreBagLock)
            {
                player.Out.SendMessage(eMessageType.Normal, LanguageMgr.GetTranslation("Bag.Locked", new object[0]));
                result = 0;
            }
            else
            {
                ItemInfo item;
                string   msg;
                if (place == -1)
                {
                    int          gold      = 0;
                    int          money     = 0;
                    int          offer     = 0;
                    int          gifttoken = 0;
                    ShopItemInfo info      = ShopMgr.GetShopItemInfoById(goodsID);
                    if (null == info)
                    {
                        result = 1;
                        return(result);
                    }
                    List <int> payGoods = ShopMgr.GetShopItemBuyConditions(info, type, ref gold, ref money, ref offer, ref gifttoken);
                    if (offer > 0 || payGoods.Count > 0)
                    {
                        result = 1;
                        return(result);
                    }
                    item = ShopMgr.CreateItem(info, 102, type, "", "", true);
                    if (item == null)
                    {
                        result = 1;
                        return(result);
                    }
                    player.RemoveMoney(money, LogMoneyType.Shop, LogMoneyType.Shop_Card);
                    player.RemoveGold(gold);
                    player.RemoveOffer(offer);
                    player.RemoveGiftToken(gifttoken);
                    //LogMgr.LogMoneyAdd(LogMoneyType.Shop, LogMoneyType.Shop_Card, player.PlayerCharacter.ID, money, gold, 0, 0, "", item.TemplateID, 1, item.Count);
                    msg = "CardUseHandler.Success";
                }
                else
                {
                    item = player.PropBag.GetItemAt(place);
                    msg  = "CardUseHandler.Success";
                }
                if (item != null)
                {
                    string msg2 = string.Empty;
                    if (item.Template.Property1 != 21)
                    {
                        AbstractBuffer buffer = BufferList.CreateBuffer(item.Template, item.ValidDate);
                        if (buffer != null)
                        {
                            buffer.Start(player);
                            if (place != -1)
                            {
                                player.OnUsingItem(item.TemplateID);
                                player.PropBag.RemoveItem(item, eItemRemoveType.Use);
                            }
                        }
                        player.Out.SendMessage(eMessageType.Normal, LanguageMgr.GetTranslation(msg, new object[0]));
                    }
                    else
                    {
                        if (item.IsValidItem())
                        {
                            player.AddGpDirect(item.Template.Property2);
                            player.OnUsingItem(item.TemplateID);
                            player.RemoveItem(item, eItemRemoveType.Use);
                            msg2 = "GPDanUser.Success";
                        }
                        player.Out.SendMessage(eMessageType.Normal, LanguageMgr.GetTranslation(msg2, new object[]
                        {
                            item.Template.Property2
                        }));
                    }
                }
                result = 0;
            }
            return(result);
        }
예제 #29
0
    /// <summary>
    /// Awake is called when the script instance is being loaded.
    /// </summary>
    void Awake()
    {
        LoadPrefab();
        heightCell = 256;
        IAP.main.SetObjectInfo(this.gameObject.name, "IAPCallBack");


        InitAd();
        //bg
        TextureUtil.UpdateImageTexture(imageBg, AppCommon.IMAGE_SETTING_BG, true);

        textAd.text = Language.main.GetString("STR_SHOP_TIP_AD");
        textAd.gameObject.SetActive(false);

        //    topBarOffsetYNormal = objTopBar.GetComponent<RectTransform>().offsetMax.y;
        // textAdOffsetYNormal = textAd.GetComponent<RectTransform>().offsetMax.y;
        // heightTobBarNormal = objTopBar.GetComponent<RectTransform>().rect.height;
        // heightTextAdNormal = textAd.GetComponent<RectTransform>().rect.height;
        // rctranTableviewNoarml = objTableViewTemplate.GetComponent<RectTransform>();

        //item
        listItem = new List <object>();
        int idx = 0;

        {
            ShopItemInfo info = new ShopItemInfo();
            info.gold   = GOLD_VIDEO;
            info.title  = Language.main.GetReplaceString("STR_SHOP_GOLD_VIDEO_TITLE", AppCommon.STR_LANGUAGE_REPLACE, info.gold.ToString());
            info.artist = Language.main.GetString("STR_SHOP_IAP_BTN_BUY_TITLE0");
            info.tag    = idx++;
            info.id     = ID_GOLD_VIDEO;//Common.GetAppPackage() + ".gold0";
            info.isIAP  = false;
            listItem.Add(info);
        }
        {
            ShopItemInfo info = new ShopItemInfo();
            info.gold   = GOLD_COMMENT;
            info.title  = Language.main.GetReplaceString("STR_SHOP_GOLD_COMMENT_TITLE", AppCommon.STR_LANGUAGE_REPLACE, info.gold.ToString());
            info.artist = Language.main.GetString("STR_SHOP_IAP_BTN_BUY_TITLE0");
            info.tag    = idx++;
            info.id     = ID_GOLD_COMMENT;
            info.isIAP  = false;
            listItem.Add(info);
        }
        if (Config.main.isHaveShare)
        {
            ShopItemInfo info = new ShopItemInfo();
            info.gold   = GOLD_SHARE;
            info.title  = Language.main.GetReplaceString("STR_SHOP_GOLD_SHARE_TITLE", AppCommon.STR_LANGUAGE_REPLACE, info.gold.ToString());
            info.artist = Language.main.GetString("STR_SHOP_IAP_BTN_BUY_TITLE0");
            info.tag    = idx++;
            info.id     = ID_GOLD_SHARE;//Common.GetAppPackage() + ".gold0";
            info.isIAP  = false;
            listItem.Add(info);
        }

        if (Config.main.isHaveIAP)
        {
            if (AppVersion.appCheckHasFinished)
            {
                textAd.gameObject.SetActive(true);
            }

            {
                ShopItemInfo info = new ShopItemInfo();
                info.title  = Language.main.GetString("STR_SHOP_IAP_TITLE0");
                info.artist = Language.main.GetString("STR_SHOP_IAP_BTN_BUY_TITLE0");
                info.tag    = idx++;
                string product = Config.main.GetIAPProduct("IAP_PRODUCT0");
                if (Common.BlankString(product))
                {
                    product = "gold0";
                }
                info.id    = product;//Common.GetAppPackage() + ".gold0";
                info.gold  = GET_BUY_GOLD0;
                info.isIAP = true;
                listItem.Add(info);
            }
            {
                ShopItemInfo info = new ShopItemInfo();
                info.title  = Language.main.GetString("STR_SHOP_IAP_TITLE1");
                info.artist = Language.main.GetString("STR_SHOP_IAP_BTN_BUY_TITLE1");
                info.tag    = idx++;
                string product = Config.main.GetIAPProduct("IAP_PRODUCT1");
                if (Common.BlankString(product))
                {
                    product = "gold1";
                }
                info.id    = product;
                info.gold  = GET_BUY_GOLD1;
                info.isIAP = true;
                listItem.Add(info);
            }
            {
                ShopItemInfo info = new ShopItemInfo();
                info.title  = Language.main.GetString("STR_SHOP_IAP_TITLE2");
                info.artist = Language.main.GetString("STR_SHOP_IAP_BTN_BUY_TITLE2");
                info.tag    = idx++;
                string product = Config.main.GetIAPProduct("IAP_PRODUCT2");
                if (Common.BlankString(product))
                {
                    product = "gold2";
                }
                info.id    = product;
                info.gold  = GET_BUY_GOLD2;
                info.isIAP = true;
                listItem.Add(info);
            }
        }

        oneCellNum = 1;
        totalItem  = listItem.Count;
        numRows    = listItem.Count;
    }
예제 #30
0
        public int HandlePacket(GameClient client, GSPacketIn packet)
        {
            int gold      = 0;       //表示金币
            int money     = 0;       //表示点券
            int offer     = 0;       //表示功勋
            int gifttoken = 0;       //表示礼劵
            int medal     = 0;
            //StringBuilder payGoods = new StringBuilder();          //表示支付物品ID
            int GoodsID = packet.ReadInt();                        //商品
            int type    = 1;                                       //购买类型



            ShopItemInfo shopItem = Bussiness.Managers.ShopMgr.GetShopItemInfoById(GoodsID);                   //获取商品信息

            if (shopItem == null)                                                                              //商品不存在
            {
                return(0);
            }

            ItemTemplateInfo prop = Bussiness.Managers.ItemMgr.FindItemTemplate(shopItem.TemplateID);         //获取物品模

            ItemInfo.SetItemType(shopItem, type, ref gold, ref money, ref offer, ref gifttoken, ref medal);   //获取购买价格及需要物品

            //eMessageType eMsg = eMessageType.Normal;
            //string msg = "UserBuyItemHandler.Success";

            if (prop.CategoryID == 10)
            {
                PlayerInfo pi = client.Player.PlayerCharacter;
                //未开始
                if (client.Player.PlayerCharacter.HasBagPassword && client.Player.PlayerCharacter.IsLocked && (money > 0 || offer > 0 || gifttoken > 0 || medal > 0))//GoodsID == 11408))
                {
                    client.Out.SendMessage(eMessageType.Normal, LanguageMgr.GetTranslation("Bag.Locked"));
                    return(0);
                }

                /*/////////////////////////////////////////////////////////////////////////////////////
                 * //玩家背包中是否有兑换物品所需要的物品
                 * int icount = client.Player.MainBag.GetItems().Count;       //获取个数
                 * bool result = true;
                 * for (int j = 0; j < needitemsinfo.Count; j += 2)
                 * {
                 *  if (client.Player.GetItemCount(needitemsinfo[j]) < needitemsinfo[j + 1])
                 *  {
                 *      result = false;
                 *  }
                 * }
                 *
                 * if (!result)
                 * {
                 *  eMsg = eMessageType.ERROR;
                 *  msg = "UserBuyItemHandler.NoBuyItem";
                 *  client.Out.SendMessage(eMsg,LanguageMgr.GetTranslation(msg));
                 *  return 1;
                 * }
                 * ////////////////////////////////////////////////////////////*/

                if (gold <= pi.Gold && money <= (pi.Money < 0 ? 0 : pi.Money) && offer <= pi.Offer && gifttoken <= pi.GiftToken && medal <= pi.medal)
                {
                    ItemInfo info = ItemInfo.CreateFromTemplate(prop, 1, (int)ItemAddType.Buy);

                    ////////////////////////////////////////////////////////////////////////////////////////////////////
                    //判断有限期
                    if (0 == shopItem.BuyType)                              //时间购买类型
                    {
                        if (1 == type)
                        {
                            info.ValidDate = shopItem.AUnit;
                        }
                        if (2 == type)
                        {
                            info.ValidDate = shopItem.BUnit;
                        }
                        if (3 == type)
                        {
                            info.ValidDate = shopItem.CUnit;
                        }
                    }
                    else                                                  //数量购买类型
                    {
                        if (1 == type)
                        {
                            info.Count = shopItem.AUnit;
                        }
                        if (2 == type)
                        {
                            info.Count = shopItem.BUnit;
                        }
                        if (3 == type)
                        {
                            info.Count = shopItem.CUnit;
                        }
                    }
                    ////////////////////////////////////////////////////////////////////////////////////////////////////////

                    if (client.Player.FightBag.AddItem(info, 0))
                    {
                        client.Player.RemoveGold(gold);
                        client.Player.RemoveMoney(money);
                        client.Player.RemoveOffer(offer);
                        client.Player.RemoveGiftToken(gifttoken);
                        client.Player.RemoveMedal(medal);

                        /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////
                         * //从玩家背包中删除兑换所需要的物品
                         * for (int j = 0; j < needitemsinfo.Count; j += 2)
                         * {
                         *  client.Player.RemoveTemplate(needitemsinfo[j], needitemsinfo[j + 1]);
                         *  payGoods.Append(needitemsinfo[j].ToString() + ":");
                         * }
                         * ////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
                        LogMgr.LogMoneyAdd(LogMoneyType.Shop, LogMoneyType.Shop_Buy, client.Player.PlayerCharacter.ID, money, client.Player.PlayerCharacter.Money, gold, 0, 0, 0, "牌子编号", prop.TemplateID.ToString(), type.ToString());
                    }
                }
                else
                {
                    client.Out.SendMessage(eMessageType.ERROR, LanguageMgr.GetTranslation("PropBuyHandler.NoMoney"));
                }
            }
            return(0);
        }
예제 #31
0
    public void destroy(bool doubleResource)
    {
        destroyedByMine = true;

        int planetExplosionNumber = Random.Range(1, 3);

        FindObjectOfType <AudioManager>().PlayIfNotPlaying("PlanetExplosion" + planetExplosionNumber);
        if (inHomeSystem)
        {
            // do something to show everything that it is gone (messes up the UI)
            FindObjectOfType <Player>().HomePlanetDestroyed(this);
            GetComponent <HomePlanet>().clearInventory();
            FindObjectOfType <Home>().homePlanets[FindObjectOfType <Home>().homePlanets.IndexOf(this)]    = null;
            FindObjectOfType <Home>().planetInfo[FindObjectOfType <Home>().planetInfo.IndexOf(this.info)] = null;


            float cheeperMultiplier = 1f;
            if (ShopManager.isCheaper)
            {
                cheeperMultiplier = FindObjectOfType <ShopManager>().expCheeperShopMultiplier;
            }


            if (FindObjectOfType <Home>().numberOfHomePlanets == ShopManager.maxHomePlanets)
            {
                ShopItemInfo shopItem = new ShopItemInfo();
                shopItem.name = "Add Rock Planet";
                shopItem.cost = (int)MaxItemsManager.priceOfPlanet;
                FindObjectOfType <canvas>().mainBuyShop.addShopItem(shopItem);
            }



            FindObjectOfType <canvas>().mainBuyShop.GetComponent <Shop>().changePrice("Add Rock Planet", (int)(MaxItemsManager.priceOfPlanet / FindObjectOfType <ShopManager>().upgradeAmount / .98f / cheeperMultiplier));
            //FindObjectOfType<Home>().numberOfHomePlanets--;
        }

        GameObject exp = Instantiate(planetExplosion);

        exp.transform.position = new Vector3(gameObject.transform.position.x, gameObject.transform.position.y, gameObject.transform.position.z);

        int doubleChance = Random.Range(0, 100);

        if (doubleChance >= 50 && doubleResource)
        {
            GameObject resource = Instantiate(planetResource);
            planetResource.tag          = "resource";
            resource.transform.position = new Vector2(gameObject.transform.position.x, gameObject.transform.position.y);
            Vector2 velocityDirection = new Vector2(Random.Range(-2.5f, 2.5f), Random.Range(-2.5f, 2.5f));

            while ((velocityDirection.x < .5f && velocityDirection.x > -.5f) && (velocityDirection.y < .5f && velocityDirection.y > -.5f))
            {
                velocityDirection = new Vector2(Random.Range(-2.5f, 2.5f), Random.Range(-2.5f, 2.5f));
            }

            resource.GetComponent <Rigidbody2D>().velocity        = velocityDirection;
            resource.GetComponent <Rigidbody2D>().angularVelocity = 720;

            GameObject resource2 = Instantiate(planetResource);
            planetResource.tag           = "resource";
            resource2.transform.position = new Vector2(gameObject.transform.position.x, gameObject.transform.position.y);
            Vector2 velocityDirection2 = new Vector2(Random.Range(-2, 2), Random.Range(-2, 2));

            while ((velocityDirection2.x < .5f && velocityDirection2.x > -.5f) && (velocityDirection2.y < .5f && velocityDirection2.y > -.5f))
            {
                velocityDirection2 = new Vector2(Random.Range(-2, 2), Random.Range(-2, 2));
            }

            resource2.GetComponent <Rigidbody2D>().velocity        = velocityDirection2;
            resource2.GetComponent <Rigidbody2D>().angularVelocity = 720;
        }
        else
        {
            GameObject resource = Instantiate(planetResource);
            planetResource.tag          = "resource";
            resource.transform.position = new Vector2(gameObject.transform.position.x, gameObject.transform.position.y);
            Vector2 velocityDirection = new Vector2(Random.Range(-2, 2), Random.Range(-2, 2));

            while ((velocityDirection.x < .5f && velocityDirection.x > -.5f) && (velocityDirection.y < .5f && velocityDirection.y > -.5f))
            {
                velocityDirection = new Vector2(Random.Range(-2, 2), Random.Range(-2, 2));
            }

            resource.GetComponent <Rigidbody2D>().velocity        = velocityDirection;
            resource.GetComponent <Rigidbody2D>().angularVelocity = 720;
        }

        FindObjectOfType <planetGenerator>().destroyPlanet(this);
    }