public Character GetNextEnemy(CharacterProperties.Team tempPlayer, float currentPosition, CharacterProperties.AttackType tempAttackType, float tempAttackRange, CharacterProperties.UnitType tempUnitType)
    {
        if (!GlobalManager.gameover)
        {
            if (tempUnitType == CharacterProperties.UnitType.HEALER)
            {
                enemies = tempPlayer == CharacterProperties.Team.LEFT ? Character.characterLeft : Character.characterRight;
            }
            else
            {
                enemies = tempPlayer == CharacterProperties.Team.LEFT ? Character.characterRight : Character.characterLeft;
            }

            for (int i = enemies.Count - 1; i >= 0; i--)
            {
                if (enemies[i].MovementState != CharacterProperties.CharacterState.DEAD)
                {
                    float distance = tempPlayer == CharacterProperties.Team.LEFT ? enemies[i].transform.localPosition.x - currentPosition : currentPosition - enemies[i].transform.localPosition.x;
                    //Debug.Log(distance);
                    if (distance <= tempAttackRange && distance > 0)
                    {
                        //enemyTarget = enemies[i];
                        //status = "attacking";

                        bool willAttack = false;

                        Character charObj = enemies[i].gameObject.GetComponent <Character>();
                        if (charObj)
                        {
                            if (tempAttackType == CharacterProperties.AttackType.AIR && charObj.PositionType == CharacterProperties.PositionType.AIR)
                            {
                                willAttack = true;
                            }
                            else if (tempAttackType == CharacterProperties.AttackType.GROUND && charObj.PositionType == CharacterProperties.PositionType.GROUND)
                            {
                                willAttack = true;
                            }
                            else if (tempAttackType == CharacterProperties.AttackType.GROUND_AND_AIR && (charObj.PositionType == CharacterProperties.PositionType.GROUND || charObj.PositionType == CharacterProperties.PositionType.AIR))
                            {
                                willAttack = true;
                            }
                        }
                        else
                        {
                            willAttack = true;
                        }

                        if (willAttack)
                        {
                            return(enemies[i]);

                            break;
                        }
                    }
                }
            }
        }

        return(null);
    }
    private IEnumerator DelayCharacterSpawn(int amt, int i, int j)
    {
        for (int k = 0; k < amt; k++)
        {
            int tempCardNum   = settings.area[areaNum].subStage[stageNum].stageSettings[i].unitSettings[j].unitCardNum;
            int tempCardLevel = settings.area[areaNum].subStage[stageNum].stageSettings[i].unitSettings[j].unitLevel;
            CharacterProperties.UnitType tempUnitType;
            team = settings.area[areaNum].subStage[stageNum].stageSettings[i].unitSettings[j].unitTeam;

            if (tempCardNum > 0)
            {
                tempUnitType = GetUnitTypeByCardNumber(tempCardNum);
            }
            else
            {
                CharacterProperties.UnitType tempUnitType2 = settings.area[areaNum].subStage[stageNum].stageSettings[i].unitSettings[j].unitType;
                int tempRarity           = settings.area[areaNum].subStage[stageNum].stageSettings[i].unitSettings[j].rarity;
                CharacterProperties prop = GetUnitByClassAndRarity(tempUnitType2, tempRarity);

                tempCardNum  = characterSettings.characterProperties.IndexOf(prop) + 1;
                tempUnitType = prop.unitType;
            }

            defObj.SpawnCharacter(damageApplyDeck, tempCardNum, tempCardLevel, tempUnitType, team);

            yield return(new WaitForSeconds(Random.Range(0.3f, 1f)));
        }
    }
Ejemplo n.º 3
0
    public void SpawnCharacter(int cardNum, CharacterProperties.UnitType unit)
    {
        CharacterProperties.Team           tempOwner = CharacterProperties.Team.LEFT;
        CharacterProperties.CategoryColour colour    = GlobalManager.GameSettings.csObj.characterProperties[cardNum].category;
        int rankLevel = cardNum;

        if (unit != CharacterProperties.UnitType.DRAGON)
        {
            GameObject go = Instantiate(characterPrefab, Vector3.zero, Quaternion.identity) as GameObject;
            go.transform.parent     = this.transform.Find("Holder/Character Unit Holder").transform;
            go.transform.localScale = Vector3.one * 10;
            Vector3 pos = Vector3.zero;
            pos.y = 36f;
            go.transform.localPosition = pos;
            go.rigidbody2D.isKinematic = true;
            go.collider2D.enabled      = false;

            switch (unit)
            {
            case CharacterProperties.UnitType.ARCHER:
            case CharacterProperties.UnitType.CANNON:
                Archer rangeObj = go.AddComponent <Archer>();
                rangeObj.characterSettings = GlobalManager.GameSettings.csObj;
                rangeObj.rank        = rankLevel;
                rangeObj.Category    = colour;
                rangeObj.UnitType    = unit;
                rangeObj.Team        = tempOwner;
                rangeObj.DisplayUnit = true;
                break;

            case CharacterProperties.UnitType.ONE_HANDED_WARRIOR:
            case CharacterProperties.UnitType.TWO_HANDED_WARRIOR:
            case CharacterProperties.UnitType.SPEAR_WARRIOR:
                Warrior meleeObj = go.AddComponent <Warrior>();
                meleeObj.characterSettings = GlobalManager.GameSettings.csObj;
                meleeObj.rank        = rankLevel;
                meleeObj.Category    = colour;
                meleeObj.UnitType    = unit;
                meleeObj.Team        = tempOwner;
                meleeObj.DisplayUnit = true;
                break;

            case CharacterProperties.UnitType.HEALER:
                Healer healerObj = go.AddComponent <Healer>();
                healerObj.characterSettings = GlobalManager.GameSettings.csObj;
                healerObj.rank        = rankLevel;
                healerObj.Category    = colour;
                healerObj.UnitType    = unit;
                healerObj.Team        = tempOwner;
                healerObj.DisplayUnit = true;
                break;
            }
        }
        else if (unit == CharacterProperties.UnitType.DRAGON)
        {
            GameObject go = Instantiate(dragonPrefab, Vector3.zero, Quaternion.identity) as GameObject;
            go.transform.parent     = this.transform.Find("Holder/Character Unit Holder").transform;
            go.transform.localScale = Vector3.one * 6;
            Vector3 pos = Vector3.zero;
            pos.y = 20f;
            go.transform.localPosition = pos;
            go.rigidbody2D.isKinematic = true;
            go.collider2D.enabled      = false;

            go.GetComponent <DragonRider>().characterSettings = GlobalManager.GameSettings.csObj;
            go.GetComponent <DragonRider>().rank        = rankLevel;
            go.GetComponent <DragonRider>().Category    = colour;
            go.GetComponent <DragonRider>().Team        = tempOwner;
            go.GetComponent <DragonRider>().DisplayUnit = true;
        }
    }
 public void SpawnSkill(int type, CharacterProperties.Team playerNumber)
 {
 }
    public void SpawnCharacter(int[] damageDeck, int cardNum, int cardLevel, CharacterProperties.UnitType unit, CharacterProperties.Team tempOwner = CharacterProperties.Team.LEFT)
    {
        Vector3 spawnPosition = tempOwner == CharacterProperties.Team.LEFT ? spawnPointLeft.transform.position : spawnPointRight.transform.position;

        CharacterProperties.CategoryColour colour = characterSettingsObj.characterProperties[cardNum].category;
        CharacterProperties.SkillType      skill  = characterSettingsObj.characterProperties[cardNum].skillType;
        int rankLevel = cardNum;

        if (unit != CharacterProperties.UnitType.DRAGON)
        {
            GameObject go = Instantiate(characterPrefab, spawnPosition, Quaternion.identity) as GameObject;
            go.transform.parent     = defenseParent.transform;
            go.transform.localScale = Vector3.one * 1000;

            switch (unit)
            {
            case CharacterProperties.UnitType.ARCHER:
            case CharacterProperties.UnitType.CANNON:
                Archer rangeObj = go.AddComponent <Archer>();
                rangeObj.characterSettings  = characterSettingsObj;
                rangeObj.skillSettings      = skillSettingsObj;
                rangeObj.indicatorPrefab    = indicatorPrefab;
                rangeObj.damageEffectPrefab = damageEffectPrefab;
                rangeObj.bonusDamageDeck    = damageDeck;
                rangeObj.unitLevel          = cardLevel;
                rangeObj.rank           = rankLevel;
                rangeObj.Category       = colour;
                rangeObj.SkillType      = skill;
                rangeObj.UnitType       = unit;
                rangeObj.Team           = tempOwner;
                rangeObj.effectSettings = skillEffects;
                break;

            case CharacterProperties.UnitType.ONE_HANDED_WARRIOR:
            case CharacterProperties.UnitType.TWO_HANDED_WARRIOR:
            case CharacterProperties.UnitType.SPEAR_WARRIOR:
                Warrior meleeObj = go.AddComponent <Warrior>();
                meleeObj.characterSettings  = characterSettingsObj;
                meleeObj.skillSettings      = skillSettingsObj;
                meleeObj.indicatorPrefab    = indicatorPrefab;
                meleeObj.damageEffectPrefab = damageEffectPrefab;
                meleeObj.bonusDamageDeck    = damageDeck;
                meleeObj.unitLevel          = cardLevel;
                meleeObj.rank           = rankLevel;
                meleeObj.Category       = colour;
                meleeObj.SkillType      = skill;
                meleeObj.UnitType       = unit;
                meleeObj.Team           = tempOwner;
                meleeObj.effectSettings = skillEffects;
                break;

            case CharacterProperties.UnitType.HEALER:
                Healer healerObj = go.AddComponent <Healer>();
                healerObj.characterSettings  = characterSettingsObj;
                healerObj.skillSettings      = skillSettingsObj;
                healerObj.indicatorPrefab    = indicatorPrefab;
                healerObj.damageEffectPrefab = damageEffectPrefab;
                healerObj.bonusDamageDeck    = damageDeck;
                healerObj.unitLevel          = cardLevel;
                healerObj.rank           = rankLevel;
                healerObj.Category       = colour;
                healerObj.SkillType      = skill;
                healerObj.UnitType       = unit;
                healerObj.Team           = tempOwner;
                healerObj.effectSettings = skillEffects;
                break;
            }
        }
        else if (unit == CharacterProperties.UnitType.DRAGON)
        {
            GameObject go = Instantiate(riderPrefab, spawnPosition, Quaternion.identity) as GameObject;
            go.transform.parent = defenseParent.transform;
            go.GetComponent <DragonRider>().characterSettings  = characterSettingsObj;
            go.GetComponent <DragonRider>().skillSettings      = skillSettingsObj;
            go.GetComponent <DragonRider>().indicatorPrefab    = indicatorPrefab;
            go.GetComponent <DragonRider>().damageEffectPrefab = damageEffectPrefab;
            go.GetComponent <DragonRider>().bonusDamageDeck    = damageDeck;
            go.GetComponent <DragonRider>().unitLevel          = cardLevel;
            go.GetComponent <DragonRider>().rank           = rankLevel;
            go.GetComponent <DragonRider>().Category       = colour;
            go.GetComponent <DragonRider>().SkillType      = skill;
            go.GetComponent <DragonRider>().Team           = tempOwner;
            go.GetComponent <DragonRider>().effectSettings = skillEffects;
        }
    }