예제 #1
0
        private void StealItem(BattleEnemy enemy, Int32 itemIndex)
        {
            Byte itemId = enemy.StealableItems[itemIndex];

            if (itemId == Byte.MaxValue)
            {
                UiState.SetBattleFollowFormatMessage(BattleMesages.CouldNotStealAnything);
                return;
            }

            enemy.StealableItems[itemIndex] = Byte.MaxValue;
            GameState.Thefts++;

            BattleItem.AddToInventory(itemId);
            UiState.SetBattleFollowFormatMessage(BattleMesages.Stole, FF9TextTool.ItemName(itemId));
            if (_v.Caster.HasSupportAbility(SupportAbility2.Mug))
            {
                _v.Target.Flags   |= CalcFlag.HpAlteration;
                _v.Target.HpDamage = (Int16)(GameRandom.Next16() % (_v.Caster.Level * _v.Target.Level >> 1));
            }

            if (_v.Caster.HasSupportAbility(SupportAbility1.StealGil))
            {
                GameState.Gil += (UInt32)(GameRandom.Next16() % (1 + _v.Caster.Level * _v.Target.Level / 4));
            }
        }
예제 #2
0
        public void CheckReference(BattlePlayer player, BattleEnemy enemy)
        {
            if (player != null && _player != player)
            {
                _player = player;

                if (Settings.RecordPlayerCard)
                {
                    _hasMulligan    = false;
                    _hasPlayerDrawn = false;

                    _player.OnAddHandCardEvent += Player_OnAddHandCardEvent;
                    _player.OnAddPlayCardEvent += Player_OnAddPlayCardEvent;
                    _player.OnAddBanishEvent   += Player_OnAddBanishEvent;
                    _player.OnAddCemeteryEvent += Player_OnAddCemeteryEvent;
                }
                if (Settings.ShowCountdown)
                {
                    _player.OnPlayerActive += Player_OnPlayerActive;
                    _player.OnSendTurnEnd  += Player_OnSendTurnEnd;
                }
            }
            if (enemy != null && _enemy != enemy && Settings.RecordEnemyCard)
            {
                _enemy = enemy;

                _enemy.OnAddDeckEvent     += Enemy_OnAddDeckEvent;
                _enemy.OnAddHandCardEvent += Enemy_OnAddHandCardEvent;
                _enemy.OnAddPlayCardEvent += Enemy_OnAddPlayCardEvent;
                _enemy.OnSpellPlayEvent   += Enemy_OnSpellPlayEvent;
            }
        }
예제 #3
0
    private BattleEnemy DrawBattleEnemy(Rect position, BattleEnemy current)
    {
        if (current == null)
        {
            current = new BattleEnemy();
        }

        EditorGUI.TextField(new Rect(position.x, position.y, 200, position.height), current.Data.ActorName);
        if (GUI.Button(new Rect(position.x + 200, position.y, 60, position.height), "Select"))
        {
            var window = EditorWindow.GetWindow <EnemyUI>();
            window.Selected = true;
            window.Initialize(ref current.Data);
            window.Show();
        }

        float maxX = current.Data.Image != null ? (Constant.BackgroundWidth / 2) - current.Data.Image.textureRect.width : Constant.BackgroundWidth / 2;
        float maxY = current.Data.Image != null ? (Constant.BackgroundHeight / 2) - current.Data.Image.textureRect.height : Constant.BackgroundHeight / 2;

        EditorGUI.LabelField(new Rect(position.x + 280, position.y, 20, position.height), "X: ");
        current.EnemyPosition.x = EditorGUI.Slider(new Rect(position.x + 300, position.y, 200, position.height), current.EnemyPosition.x, -Constant.BackgroundWidth / 2, maxX);
        EditorGUI.LabelField(new Rect(position.x + 520, position.y, 20, position.height), "Y: ");
        current.EnemyPosition.y = EditorGUI.Slider(new Rect(position.x + 540, position.y, 200, position.height), current.EnemyPosition.y, -maxY, (Constant.BackgroundHeight / 2));

        return(current);
    }
예제 #4
0
    /// <summary>
    /// Raycasts from mouse
    /// </summary>
    /// <returns>The tile</returns>
    private GameObject MouseRaycast(List <Node> movementRange)
    {
        Ray ray = raycastCamera.ScreenPointToRay(Input.mousePosition);

        Vector3 rayDirection = Input.mousePosition - raycastCamera.transform.position;
        //Ray ray = new Ray(raycastCamera.transform.position, rayDirection);
        RaycastHit hit;

        Physics.Raycast(ray, out hit, Mathf.Infinity);

        if (hit.collider != null && !EventSystem.current.IsPointerOverGameObject())
        {
            Tile        tile  = hit.collider.gameObject.GetComponent <Tile>();
            BattleEnemy enemy = hit.collider.gameObject.GetComponent <BattleEnemy>();

            //For movement
            if (tile != null && !Attacking && movementRange.Contains(GetTargetNode(tile)))
            {
                return(hit.collider.gameObject);
            }
            //For attacking
            else if (enemy != null && Pathfinding.GetRange(Nodes, friendlies[0].nodeParent, lastSelectedAttack.Range).Contains(enemy.nodeParent))
            {
                return(hit.collider.gameObject);
            }
        }
        return(null);
    }
예제 #5
0
        public void CreatePhysics()
        {
            var w   = new World();
            var obj = new BattleEnemy();

            obj.CreatePhysics(w);
            Assert.AreEqual(1, w.BodyList.Count);
        }
예제 #6
0
 void Start()
 {
     if (isAttackGen)
     {
         battleEnemy = FindObjectOfType <BattleEnemy>();
     }
     objectCounter = 0;
 }
예제 #7
0
    // Update is called once per frame
    void Update()
    {
        if (bc.enemyBattleStart != null)
        {
            name = bc.enemyBattleStart.name;
            bc.enemyBattleStart.gameObject.SetActive(false);
        }

        if (enemyHealth == null)
        {
            enemyHealth = FindObjectOfType <BattleEnemy>();
            expToGive   = enemyHealth.expToGive;
        }



        //  healthBar.maxValue = playerHealth.playerMaxHealth;
        //  healthBar.value = playerHealth.playerCurrentHealth;
        //  HPText.text = "HP: "+playerHealth.playerCurrentHealth+" / "+playerHealth.playerMaxHealth;

        //  expBar.maxValue = playerStats.toLevelUp[playerStats.currentLevel];
        //  expBar.value = playerStats.currentExp;
        //  EXPText.text = "EXP: "+playerStats.currentExp+" / "+playerStats.toLevelUp[playerStats.currentLevel];

        //    LVLText.text= "LVL: "+playerStats.currentLevel;

        enemyHealthBar.maxValue = enemyHealth.maxHP;


        enemyHealthBar.value = enemyHealth.HP;

        if (FindObjectOfType <UIManager>() != null)
        {
            if (FindObjectOfType <UIManager>().invActive)
            {
                enemyHealthBar.gameObject.SetActive(false);
            }
            else
            {
                enemyHealthBar.gameObject.SetActive(true);
            }
        }
        else
        {
            enemyHealthBar.gameObject.SetActive(true);
        }

        if (enemyHealthBar.value <= 0)
        {
            endBattle(expToGive);
            //  FindObjectOfType<PlayerController>().EnemyDestroyer.SetActive(true);
        }
        else if (FindObjectOfType <ShipPlayerController>().GetComponent <PlayerHealthManager>().playerCurrentHealth <= 0)
        {
            endBattleLoss();
        }
    }
예제 #8
0
    void Start()
    {
        sfxMan = FindObjectOfType <SFXManager>();
        rb     = GetComponent <Rigidbody2D>();

        SS = FindObjectOfType <ShotShooter>();

        rb.velocity = new Vector3(Random.Range(SS.lowSpeed, SS.highSpeed), 0, 0);
        battleEnemy = FindObjectOfType <BattleEnemy>();
    }
예제 #9
0
    // Update is called once per frame
    void Update()
    {
        if (battleEnemy == null)
        {
            battleEnemy    = FindObjectOfType <BattleEnemy>();
            enemyName.text = FindObjectOfType <BattleEnemy>().enemyName;

            //  FindObjectOfType<MusicController>().switchTrack(battleEnemy.song);
        }
    }
예제 #10
0
    /// <summary>
    /// Creates a new BattleEnemy and gives it its data
    /// </summary>
    /// <param name="name">Name as EnemyName</param>
    /// <returns></returns>
    public static BattleEnemy MakeNewBattleEnemy(EnemyName name)
    {
        // Create data
        BattleEnemy orig = Data[name];
        // Create enemy using data
        BattleEnemy newEnemy = new BattleEnemy(name, orig.Stats);

        newEnemy.HealAll();
        return(newEnemy);
    }
예제 #11
0
    // Use this for initialization
    void Start()
    {
        members = new List <BattleEnemy>();
        //手动添加敌人
        BattleEnemy be1 = new BattleEnemy();

        be1.Setup(120, 12, 3);
        be1.SetBattleTex("Assassin.png");

        members.Add(be1);
    }
예제 #12
0
    public void changeOption()
    {
        if (isAttackGen && battleEnemy == null)
        {
            battleEnemy = FindObjectOfType <BattleEnemy>();
        }


        System.Random random = new System.Random();
        currentOption = random.Next(0, battleEnemy.attacks.Length);
    }
예제 #13
0
 void Start()
 {
     bEnemy = FindObjectOfType <BattleEnemy>();
     //EnemyGameObject=Enemy.BattleEnemy;
     //  bEnemy=EnemyGameObject.GetComponent<BattleEnemy>();
     spawnTime    = bEnemy.spawnTime;
     spawnCount   = bEnemy.spawnCount;
     lowSpeed     = bEnemy.lowSpeed;
     highSpeed    = bEnemy.highSpeed;
     spawnCounter = 0;
 }
예제 #14
0
        public void DestroyPhysics(int count)
        {
            var w = new World();

            for (var i = 0; i < count; i++)
            {
                var obj = new BattleEnemy();
                obj.CreatePhysics(w);
                PhysicsBodyRemover.Add(obj.Body, obj.Fixtures);
            }
            w.StepWithDelete(0.1f, 1, 1);
            Assert.AreEqual(0, w.BodyList.Count);
        }
예제 #15
0
 private void DrawEnemy(BattleEnemy obj)
 {
     if (obj != null)
     {
         if (obj.Data.Image != null)
         {
             GUI.DrawTextureWithTexCoords(new Rect(obj.EnemyPosition.x + previewX, -obj.EnemyPosition.y + previewY, obj.Data.Image.textureRect.width, obj.Data.Image.textureRect.height),
                                          obj.Data.Image.texture,
                                          Constant.GetTextureCoordinate(obj.Data.Image)
                                          );
         }
     }
 }
예제 #16
0
    void Start()
    {
        battleEnemy = FindObjectOfType <BattleEnemy>();

        Enemy            = FindObjectOfType <EnemyBattleStart>();
        EnemyGameObject  = Enemy.BattleEnemy;
        enemyBattleStart = FindObjectOfType <EnemyBattleStart>().gameObject;
        //Destroy(enemyBattleStart);
        EnemyGameObject.SetActive(true);

        Instantiate(EnemyGameObject, new Vector3(6f, -2.5f, 0f), Quaternion.identity);
        enemyBattleStart = FindObjectOfType <EnemyBattleStart>().gameObject;
    }
예제 #17
0
        private static Boolean HasStealableItems(BattleEnemy enemy)
        {
            Boolean hasStealableItems = false;

            for (Int16 index = 0; index < 4; ++index)
            {
                if (enemy.StealableItems[index] != Byte.MaxValue)
                {
                    hasStealableItems = true;
                }
            }
            return(hasStealableItems);
        }
예제 #18
0
    /*
     * 初期化
     * プレイヤーと敵を生成
     * カメラの設定
     * 後々テーブルで敵の数などを決めれるようにする
     */
    void Start()
    {
        // プレイヤーの生成
        player = Instantiate(playerPrefab, new Vector3(PLAYER_POSITION, 0.0f, 0.0f), Quaternion.Euler(0, 90, 0)) as BattlePlayer;
        PlayerStatesData stateData = GlobalDataManager.GetGlobalData().LoadPlayerStatesData();

        if (stateData == null)
        {
            player.STATES = GlobalDataManager.GetGlobalData().GetDataBase().GetPlayerStates(1);
            player.HP     = player.STATES.HP;
        }
        else
        {
            player.STATES     = GlobalDataManager.GetGlobalData().GetDataBase().GetPlayerStates(stateData.LV);
            player.STATES.HP  = stateData.HP;
            player.HP         = stateData.HP;
            player.STATES.MP  = stateData.MP;
            player.STATES.EXP = stateData.EXP;
        }
        canvasManager.CreateStatesUI(player, true);

        // エネミーの生成
        EnemyTable table     = GlobalDataManager.GetGlobalData().GetEnemyTable().GetEnemyTable((int)Table.LEVEL.EASY);
        int        enemy_num = table.NUM;

        for (int i = 0; i < enemy_num; i++)
        {
            BattleEnemy enemy = Instantiate(enemyPrefab, new Vector3((i * 0.3f) + 0.3f, 0.0f, 0.0f), Quaternion.Euler(0, 270, 0)) as BattleEnemy;
            enemy.STATES  = GlobalDataManager.GetGlobalData().GetDataBase().GetSkeletonStates(table.LEVEL);
            enemy.HP      = enemy.STATES.HP;
            enemy.Manager = this;
            enemy.Player  = player;
            enemy.ID      = i;
            enemyList.Add(enemy);
            //canvasManager.CreateStatesUI(enemy);
            targetList.Add(i);
        }

        player.Manager = this;
        player.Enemy   = enemyList[player.TargetID];

        // カメラ位置の設定
        centerPoint.Player      = player.transform;
        centerPoint.TargetEnemy = enemyList[player.TargetID].transform;

        // ターゲットポインター
        targetPointer        = Instantiate(targetPointerPrefab);
        targetPointer.Target = player.Enemy;

        StartCoroutine(GameStart());
    }
예제 #19
0
    private void initEnemy(int enemy_id)
    {
        if (m_BattleDispEnemy != null && m_MasterDataParamEnemys != null)
        {
            //MasterDataParamEnemy enemy_master = searchEnemy(enemy_id);
            int index = searchEnemyIndex(enemy_id);
            MasterDataParamEnemy enemy_master = m_MasterDataParamEnemys[index];

            if (enemy_master != null)
            {
                MasterDataParamChara chara_master = MasterFinder <MasterDataParamChara> .Instance.Find((int)enemy_master.chara_id);

                if (chara_master != null)
                {
                    MasterDataParamEnemy wrk_enemy_master = new MasterDataParamEnemy();
                    wrk_enemy_master.Copy(enemy_master); //元のマスターデータに影響が出ないようにコピーを作成
                    BattleEnemy battle_enemy = null;
                    {
                        battle_enemy = new BattleEnemy();
                        battle_enemy.setMasterData(wrk_enemy_master, chara_master);
                        battle_enemy.m_EnemyAttack        = enemy_master.status_pow;
                        battle_enemy.m_EnemyDefense       = enemy_master.status_def;
                        battle_enemy.m_EnemyHP            = enemy_master.status_hp;
                        battle_enemy.m_EnemyHPMax         = enemy_master.status_hp;
                        battle_enemy.m_EnemyDrop          = 0;
                        battle_enemy.m_StatusAilmentChara = new StatusAilmentChara(StatusAilmentChara.OwnerType.ENEMY);
                        battle_enemy.setAcquireDropUnit(false);
                    }
                    m_CurrentBattleEnemy   = battle_enemy;
                    m_CurrentEnemyDispInfo = m_EnemyDispInfos[index];

                    setInfoToInteface();
                    setInfoToWorkMaster();

                    m_BattleEnemys    = new BattleEnemy[1];
                    m_BattleEnemys[0] = battle_enemy;

                    m_BattleDispEnemy.instanceObject(m_BattleEnemys);

                    m_BattleDispEnemy.gameObject.SetLayerRecursively(LayerMask.NameToLayer("BATTLE")); // レイヤーを設定し直し

                    m_BattleDispEnemy.showTargetCursor(0);                                             // ターゲットカーソルを表示
                }
            }
            else
            {
                m_BattleDispEnemy.instanceObject(null);
            }
        }
    }
예제 #20
0
 /*
  * ターゲットしている敵に攻撃
  */
 public void PlayerAttackEnemy(int atk, BattleEnemy enemy)
 {
     enemy.Damage(atk);// とりあえず1
     if (enemy.IsDead())
     {
         totalEXP += enemy.STATES.EXP;
         for (int i = 0; i < targetList.Count; i++)
         {
             if (enemy.ID == targetList[i])
             {
                 targetList.RemoveAt(i);
             }
         }
         ChangeTargetEnemy();
     }
 }
예제 #21
0
        public static BattleEnemy ReadBattleEnemy(object id, List <Enemy> enemiesData, List <PassiveSkill> pSkillsData)
        {
            BattleEnemy battleEnemy;

            using (var conn0 = Connect())
            {
                conn0.Open();
                using (var data0 = Read(conn0, "SELECT * FROM BattleEnemy WHERE BattleEnemy_ID = " + id))
                {
                    data0.Read();
                    battleEnemy = new BattleEnemy(data0, enemiesData, pSkillsData);
                }
                conn0.Close();
            }
            return(battleEnemy);
        }
예제 #22
0
    private IEnumerator Starting()
    {
        //Setup enemy
        BattleEnemy battleEnemyPrefab = Array.Find(enemyPrefabs, data => data.id == DataManager.Instance.battleEnemyData.id);

        currentEnemy           = Instantiate(battleEnemyPrefab, spawnPos.position, spawnPos.rotation);
        currentEnemy.enemyData = DataManager.Instance.battleEnemyData;
        enemyNameText.text     = currentEnemy.enemyData.name;
        //Setup player
        player.hp = DataManager.Instance.playerHP;
        yield return(new WaitForSeconds(8));

        enemyHPIndicator.characterData = currentEnemy.enemyData;
        enemyHPIndicator.gameObject.SetActive(true);
        hpIndicator.gameObject.SetActive(true);
    }
예제 #23
0
    private void OnEntityDeath(BattleEntity entity)
    {
        BattleEnemy enemy = entity as BattleEnemy;

        if (enemy != null)
        {
            enemies.Remove(enemy);
        }
        else
        {
            friendlies.Remove(entity);
        }
        Destroy(entity.gameObject);

        BattleStatus status = CheckBattleStatus();

        ProcessBattleStatus(status);
    }
예제 #24
0
    public BattleEnemyGroup(Summary1 s1)
    {
        set1(s1);

        for (int t1 = 0; t1 < max(); t1++)
        {
            battle_enemy[t1] = new BattleEnemy(s1, t1);
        }

        {
            image_save_enemy = new ImageSaveEnemy(s1);
            image_save_enemy.init1();
        }

        battle_enemy_appear_control = new BattleEnemyAppearControl(s1);

        battle_enemy_ai = new BattleEnemyAI(s1);
    }
예제 #25
0
    public static void outputEnemyParty(BattleEnemy[] enemy_party)
    {
        for (int idx_enemy = 0; idx_enemy < enemy_party.Length; idx_enemy++)
        {
            BattleEnemy battle_enemy = enemy_party[idx_enemy];
            DebugBattleLog.writeText(DebugBattleLog.StrOpe + "敵情報(" + idx_enemy.ToString() + ")"
                                     + " EnemyFixID:" + battle_enemy.getMasterDataParamEnemy().fix_id.ToString()
                                     + " CharaFixID:" + battle_enemy.getMasterDataParamChara().fix_id.ToString()
                                     + " 属性:" + battle_enemy.getMasterDataParamChara().element.ToString()
                                     + " 種族1:" + battle_enemy.getMasterDataParamChara().kind.ToString()
                                     + " 種族2:" + battle_enemy.getMasterDataParamChara().sub_kind.ToString()
                                     + " [" + battle_enemy.getMasterDataParamChara().name + "]"
                                     );

            uint[] enemy_abilitys = battle_enemy.getEnemyAbilitys();
            for (int idx_ability = 0; idx_ability < enemy_abilitys.Length; idx_ability++)
            {
                uint ability_fix_id = enemy_abilitys[idx_ability];
                if (ability_fix_id != 0)
                {
                    string ability_name = "";
                    MasterDataEnemyAbility ability_master = BattleParam.m_MasterDataCache.useEnemyAbility(ability_fix_id);
                    if (ability_master != null)
                    {
                        ability_name = ability_master.name;
                    }
                    DebugBattleLog.writeText(DebugBattleLog.StrOpe + "     特性" + (idx_ability + 1).ToString()
                                             + "(FixId:" + ability_fix_id.ToString() + "):"
                                             + ability_name
                                             );
                }
            }

            DebugBattleLog.writeText(DebugBattleLog.StrOpe + "  "
                                     + " HP:" + battle_enemy.m_EnemyHP.ToString() + "/" + battle_enemy.m_EnemyHPMax.ToString()
                                     + " SkillTurn:" + battle_enemy.m_EnemyTurn.ToString() + "/" + battle_enemy.m_EnemyTurnMax.ToString()
                                     );

            // 状態変化
            StatusAilmentChara ailment = battle_enemy.m_StatusAilmentChara;
            outputAilment(ailment);
        }
    }
예제 #26
0
    private void changeEnemySelection(GameObject cursor, Vector3[] positionArr, BattleState stateToChangeTo)
    {
        /// THIS FUNCTION IS FOR CHANGING THE POSITION OF THE CURSOR THAT SELECTS THE ENEMY TO ATTACK...
        /// THE CURSOR IS JUST FOR SHOW, BUT THE UP AND DOWN ARROWS CHANGE THE ACTION THAT IS SELECTED.

        /// MOVE CURSOR UP OR DOWN //////
        if (Input.GetKeyUp(KeyCode.UpArrow))
        {
            buttonSelectIndex--;
            if (buttonSelectIndex < 0)
            {
                buttonSelectIndex = positionArr.Length - 1;
            }
            cursor.transform.position = positionArr[buttonSelectIndex];
        }
        else if (Input.GetKeyUp(KeyCode.DownArrow))
        {
            buttonSelectIndex++;
            if (buttonSelectIndex == positionArr.Length)
            {
                buttonSelectIndex = 0;
            }
            cursor.transform.position = positionArr[buttonSelectIndex];
        }
        ////////////////////////////////////////////////////////
        // ONCE ENTER IS PRESSED THE CURSOR WILL BE DESTROYED //
        // AND THE ENEMY WILL BE SELECTED                     //
        ////////////////////////////////////////////////////////
        else if (Input.GetKeyUp(KeyCode.Return))
        {
            state                  = stateToChangeTo;
            enemyChosen            = enemy.GetComponent <SpanEnemies>().getEnemy(buttonSelectIndex);
            enemyChosen_properties = enemyChosen.GetComponent <BattleEnemy>();
            travel_to              = enemyChosen.transform.position;
            travel_to              = new Vector3(travel_to.x, travel_to.y + 2.5f);
            enemyChosenIndex       = buttonSelectIndex;
            buttonSelectIndex      = 0;
            Destroy(cursor);
            Destroy(abilityList);
        }
        /////////////////////////////////////////////////////////
    }
예제 #27
0
        public void CheckReference(BattlePlayer player, BattleEnemy enemy)
        {
            if (player != null && _player != player)
            {
                _player         = player;
                _hasMulligan    = false;
                _hasPlayerDrawn = false;

                _player.OnAddHandCardEvent += Player_OnAddHandCardEvent;
                _player.OnAddPlayCardEvent += Player_OnAddPlayCardEvent;
            }
            if (enemy != null && _enemy != enemy)
            {
                _enemy = enemy;

                _enemy.OnAddHandCardEvent += Enemy_OnAddHandCardEvent;
                _enemy.OnAddPlayCardEvent += Enemy_OnAddPlayCardEvent;
                _enemy.OnSpellPlayEvent   += Enemy_OnSpellPlayEvent;
            }
        }
예제 #28
0
        public void Initialize(System.Data.SQLite.SQLiteDataReader data, List <Environment> environmentsData, List <Enemy> enemiesData, List <PassiveSkill> pSkillsData,
                               List <Skill> skillsData, List <Item> itemsData, List <Weapon> weaponsData, List <State> statesData)
        {
            Initialize(data);
            int numberOfEnemies = Int(data["NumberOfEnemies"]);

            for (int i = 1; i <= numberOfEnemies; i++)
            {
                object      beId          = data["BattleEnemy" + i];
                BattleEnemy b             = ReadBattleEnemy(beId, enemiesData, pSkillsData);
                Enemy       enemyInBattle = b.Enemy;
                enemyInBattle.SetAllStats(b.Level, b.HPMultiplier);
                enemyInBattle.MoveToPosition(b.GridPositionZ, b.GridPositionX);
                if (b.PassiveSkill1 != null)
                {
                    enemyInBattle.AddPassiveSkill(pSkillsData, b.PassiveSkill1.Id);
                }
                if (b.PassiveSkill2 != null)
                {
                    enemyInBattle.AddPassiveSkill(pSkillsData, b.PassiveSkill2.Id);
                }
                List <EnemyTool <Skill> >  enemySkills  = ReadEnemyTools(beId, skillsData, statesData);
                List <EnemyTool <Item> >   enemyItems   = ReadEnemyTools(beId, itemsData, statesData);
                List <EnemyTool <Weapon> > enemyWeapons = ReadEnemyTools(beId, weaponsData, statesData);
                foreach (var et in enemySkills)
                {
                    enemyInBattle.AddSkill(skillsData, et.Tool.Id);
                }
                foreach (var et in enemyItems)
                {
                    enemyInBattle.AddItem(itemsData, et.Tool.Id);
                }
                foreach (var et in enemyWeapons)
                {
                    enemyInBattle.AddWeapon(weaponsData, et.Tool.Id);
                }
                enemyInBattle.MaxHPSP();
                Enemies.Add(enemyInBattle);
            }
        }
예제 #29
0
    public static void cacheBattleUnitTexture()
    {
        if (BattleParam.m_PlayerParty != null)
        {
            CharaOnce[] player_party_members = BattleParam.m_PlayerParty.getPartyMembers(CharaParty.CharaCondition.EXIST);
            for (int idx = 0; idx < player_party_members.Length; idx++)
            {
                CharaOnce player_party_member = player_party_members[idx];
                BattleUnitTextureCache.Instance.loadTexture((int)player_party_member.m_CharaMasterDataParam.fix_id, false);
                if (player_party_member.m_LinkParam != null &&
                    player_party_member.m_LinkParam.m_cCharaMasterDataParam != null
                    )
                {
                    BattleUnitTextureCache.Instance.loadTexture((int)player_party_member.m_LinkParam.m_cCharaMasterDataParam.fix_id, false);
                }
            }
        }

        if (BattleParam.m_EnemyParam != null)
        {
            for (int idx = 0; idx < BattleParam.m_EnemyParam.Length; idx++)
            {
                BattleEnemy battle_enemy = BattleParam.m_EnemyParam[idx];
                if (battle_enemy != null)
                {
                    MasterDataParamChara enemy_chara = battle_enemy.getMasterDataParamChara();
                    if (enemy_chara != null)
                    {
                        BattleUnitTextureCache.Instance.loadTexture((int)enemy_chara.fix_id, false);
                    }
                }
            }
        }

        // 主人公の画像をキャッシュ
        int current_hero_id = (int)MasterDataUtil.GetCurrentHeroID();

        BattleUnitTextureCache.Instance.loadTexture(-current_hero_id, false);
    }
예제 #30
0
        public void Perform()
        {
            BattleEnemy enemy = BattleEnemy.Find(_v.Target);

            if (!HasStealableItems(enemy))
            {
                UiState.SetBattleFollowFormatMessage(BattleMesages.DoesNotHaveAnything);
                return;
            }

            if (!_v.Caster.HasSupportAbility(SupportAbility2.Bandit))
            {
                _v.Context.HitRate = (Int16)(_v.Caster.Level + _v.Caster.Will);
                _v.Context.Evade   = _v.Target.Level;

                if (GameRandom.Next16() % _v.Context.HitRate < GameRandom.Next16() % _v.Context.Evade)
                {
                    UiState.SetBattleFollowFormatMessage(BattleMesages.CouldNotStealAnything);
                    return;
                }
            }

            if (enemy.StealableItems[3] != Byte.MaxValue)
            {
                StealItem(enemy, 3);
            }
            else if (enemy.StealableItems[2] != Byte.MaxValue)
            {
                StealItem(enemy, 2);
            }
            else if (enemy.StealableItems[1] != Byte.MaxValue)
            {
                StealItem(enemy, 1);
            }
            else
            {
                StealItem(enemy, 0);
            }
        }