void MakeItem()
    {
        int targetId = int.Parse(makingTipButton [1].gameObject.name);

        foreach (int key in LoadTxt.MatDic[targetId].combReq.Keys)
        {
            if (_gameData.CountInHome(key) < LoadTxt.MatDic [targetId].combReq [key])
            {
                _floating.CallInFloating("Insufficient Material!", 1);
                return;
            }
            _gameData.ConsumeItemInHome(key, LoadTxt.MatDic [targetId].combReq [key]);
        }

        bool  isKitchen = LoadTxt.MatDic [targetId].makingType == "Kitchen";
        float discount  = isKitchen ? GameData._playerData.CookingTimeDiscount : GameData._playerData.BlackSmithTimeDiscount;

        _gameData.ChangeTime((int)(LoadTxt.MatDic [targetId].makingTime * 60 * discount));


        int combGet = LoadTxt.MatDic [targetId].combGet;

        if (isKitchen)
        {
            float r = Random.Range(1f, GameData._playerData.CookingIncreaseRate);
            combGet = (int)(combGet * r);
        }
        _gameData.AddItem(GenerateItemId(targetId), combGet);
        _floating.CallInFloating(LoadTxt.MatDic [targetId].name + " +" + combGet, 0);


        SetMakingTipDesc(LoadTxt.MatDic[targetId]);

        //Achievement
        if (isKitchen)
        {
            this.gameObject.GetComponent <AchieveActions> ().CookFood(targetId);
        }

        switch (LoadTxt.MatDic [targetId].type)
        {
        case 3:
            this.gameObject.GetComponent <AchieveActions> ().CollectMeleeWeapon(targetId);
            break;

        case 4:
            this.gameObject.GetComponent <AchieveActions> ().CollectRangedWeapon(targetId);
            break;

        case 5:
            this.gameObject.GetComponent <AchieveActions> ().CollectMagicWeapon(targetId);
            break;

        default:
            break;
        }
    }
    public void StoreMemory()
    {
        int num = 0;

        if (GameData._playerData.bp.ContainsKey(22020000))
        {
            num = GameData._playerData.bp[22020000];
        }

        if (num < GameConfigs.SoulStoneForStoreMem)
        {
            return;
        }
        _gameData.ConsumeItemInHome(2202, GameConfigs.SoulStoneForStoreMem);
        _gameData.StoreMemmory();
        UpdateAltar();
        _floating.CallInFloating("Memmory Stored!", 0);
    }
Пример #3
0
    public void Capture()
    {
        if (enemy.canCapture == 0 || (enemy.hp / enemyMaxHp > 0.5f) || captureFailTime >= 3)
        {
            return;
        }
        if (_gameData.GetUsedPetSpace() + enemy.canCapture > GameData._playerData.PetsOpen * 10)
        {
            _floating.CallInFloating("Insufficient Pet Space!", 1);
            return;
        }

        myNextTurn++;
        SetPoint();
        float rate = 0.2f - enemy.level / 100 * 0.5f;

        rate *= GameData._playerData.CaptureRate;
        int i = Algorithms.GetIndexByRange(0, 10000);

        if (i < (int)(rate * 10000))
        {
            Pet p = new Pet();
            p.monsterId = enemy.monsterId;
            p.state     = 0;
            p.alertness = enemy.level;
            p.speed     = (int)enemy.speed;
            p.name      = enemy.name;
            _gameData.AddPet(p);
            AddLog("New Pet: " + enemy.name, 0);

            //Achievement
            this.gameObject.GetComponentInParent <AchieveActions> ().CapturePet();
            //战斗结束。。
            StartCoroutine(WaitAndCheck());
        }
        else
        {
            captureFailTime++;
            AddLog("You tried to capture " + enemy.name + ", but failed.", 0);
            if (captureFailTime >= 3)
            {
                AddLog("Can not capture over 3 times.", 0);
            }
            CheckEnemyAction();
        }
    }
Пример #4
0
    public void ChargeCrop(int index)
    {
        Dictionary <int, int> r = new Dictionary <int, int> ();
        Plants p = LoadTxt.GetPlant(GameData._playerData.Farms [index].plantType);
        int    num;

        switch (p.plantType)
        {
        case 0:
            foreach (int key in p.plantObtain.Keys)
            {
                num = (int)(p.plantObtain [key] * Algorithms.GetIndexByRange(80, 120) / 100 * GameData._playerData.HarvestIncrease);
                if (num > 0)
                {
                    r.Add(key, num);
                }
            }
            break;

        default:
            foreach (int key in p.plantObtain.Keys)
            {
                num = (int)(p.plantObtain [key] * Algorithms.GetIndexByRange(75, 125) / 100 * GameData._playerData.OenologyIncrease);
                if (num > 0)
                {
                    r.Add(key, num);
                }
            }
            break;
        }

        foreach (int key in r.Keys)
        {
            _gameData.AddItem(key * 10000, r [key]);
            _floating.CallInFloating(LoadTxt.MatDic [key].name + " +" + r [key], 0);
        }
        GameData._playerData.Farms [index].plantTime = 0;
        _gameData.StoreData("Farms", _gameData.GetStrFromFarmState(GameData._playerData.Farms));
        UpdateFarm();
    }
Пример #5
0
    public void DefeatEnemy(int monsterId)
    {
        Achievement a = new Achievement();

        if (monsterId == 1)
        {
            //Ghost
            GameData._playerData.ghostKill++;
            _gameData.StoreData("GhostKill", GameData._playerData.ghostKill);
            a = LoadTxt.GetAchievement(2);
            if (GameData._playerData.Achievements[2] == 0)
            {
                if (GameData._playerData.ghostKill >= a.req)
                {
                    StoreAchievement(2);
                    _floating.CallInFloating("Achievement:" + a.name, 0);
                    _log.AddLog("Achievement:" + a.name, true);
                }
            }
        }
        else if (monsterId == 2)
        {
            //GhostBoss
            GameData._playerData.ghostBossKill++;
            _gameData.StoreData("GhostBossKill", GameData._playerData.ghostBossKill);
            a = LoadTxt.GetAchievement(3);
            if (GameData._playerData.Achievements[3] == 0)
            {
                if (GameData._playerData.ghostBossKill >= a.req)
                {
                    StoreAchievement(3);
                    _floating.CallInFloating("Achievement:" + a.name, 0);
                    _log.AddLog("Achievement:" + a.name, true);
                }
            }
        }
        else if (monsterId == 3)
        {
            //GhostKing
            GameData._playerData.ghostKingKill++;
            _gameData.StoreData("GhostKingKill", GameData._playerData.ghostKingKill);
            a = LoadTxt.GetAchievement(4);
            if (GameData._playerData.Achievements[4] == 0)
            {
                if (GameData._playerData.ghostKingKill >= a.req)
                {
                    StoreAchievement(4);
                    _floating.CallInFloating("Achievement:" + a.name, 0);
                    _log.AddLog("Achievement:" + a.name, true);
                }
            }
        }
        else if (monsterId == 1801 || monsterId == 1802 || monsterId == 1803)
        {
            //Dragon
            GameData._playerData.dragonKilled++;
            _gameData.StoreData("DragonKilled", GameData._playerData.dragonKilled);
            a = LoadTxt.GetAchievement(32);
            if (GameData._playerData.Achievements[32] == 0)
            {
                if (GameData._playerData.dragonKilled >= a.req)
                {
                    StoreAchievement(32);
                    _floating.CallInFloating("Achievement:" + a.name, 0);
                    _log.AddLog("Achievement:" + a.name, true);
                }
            }
        }
        else if (monsterId == 3008 || monsterId == 3108 || monsterId == 3208 || monsterId == 3308 || monsterId == 3408)
        {
            if (GameData._playerData.Achievements[39] == 1)
            {
                return;
            }

            if (monsterId == 3008)
            {
                GameData._playerData.orderCamp = 1;
                _gameData.StoreData("OrderCamp", 1);
            }
            else if (monsterId == 3108)
            {
                GameData._playerData.truthCamp = 1;
                _gameData.StoreData("TruthCamp", 1);
            }
            else if (monsterId == 3208)
            {
                GameData._playerData.lifeCamp = 1;
                _gameData.StoreData("LifeCamp", 1);
            }
            else if (monsterId == 3308)
            {
                GameData._playerData.chaosCamp = 1;
                _gameData.StoreData("ChaosCamp", 1);
            }
            else
            {
                GameData._playerData.deathCamp = 1;
                _gameData.StoreData("DeathCamp", 1);
            }

            a = LoadTxt.GetAchievement(39);
            if (ReconizeCamp() >= a.req)
            {
                StoreAchievement(39);
                _floating.CallInFloating("Achievement:" + a.name, 0);
                _log.AddLog("Achievement:" + a.name, true);
                PlaceActions p = this.GetComponentInChildren <PlaceActions> ();
                p.CallInComplete(2);
            }
        }

        GameData._playerData.monsterKilled++;
        _gameData.StoreData("MonsterKilled", GameData._playerData.monsterKilled);
        a = LoadTxt.GetAchievement(16);
        if (GameData._playerData.Achievements [16] == 0)
        {
            if (GameData._playerData.monsterKilled >= a.req)
            {
                StoreAchievement(16);
                _floating.CallInFloating("Achievement:" + a.name, 0);
                _log.AddLog("Achievement:" + a.name, true);
            }
        }
    }