Exemple #1
0
 public void DamageBattler(int dmg, Battler btl, bool critical)
 {
     btl.hp -= dmg;
     // topboard.UpdateString("The " + btl.name + " took " + dmg.ToString() + " damage!");
     if (btl.hp > 0)
     {
         btl.StartShake();
     }
     else
     {
         btl.Launch();
         earnedEXP += math.max((btl.lvl * 10 - math.max((player.lvl - btl.lvl), 0) * 5), 0);
         battlerQueue.Remove(btl);
         playerControlledBattlers.Remove(btl);
         enemies.Remove(btl);
         if (enemies.Count < 1)
         {
             topboard.UpdateString("You won!");
             currstate = states.battlewon;
         }
         else if (playerControlledBattlers.Count < 1)
         {
             topboard.UpdateString("You lost...");
             currstate = states.dead;
         }
     }
     audio.PlayOneShot((AudioClip)Resources.Load("Sounds/Hit"));
     //btl.StartFlashing(3.0f);
     btl.sprite.GetComponent <ParticleSystem>().Emit(dmg);
     CreateDamageText(dmg, btl.sprite, critical);
 }
    //Overwritten in Player for enemy heuristics
    //the hurtbox was collided with (this is called from a child's hurtbox script)
    public override void OnHurtboxCollision(Collider2D collision)
    {
        //check if collider is of tag hitbox

        if (collision.gameObject.CompareTag("Hitbox"))
        {
            //get the battler associated with the hit
            Battler attacker = (Battler)collision.transform.parent.gameObject.GetComponent <Battler>();
            if (attacker.currentState != BattlerState.dead)
            {
                TakeDamage(attacker.GetDamage());
                //start knockback (these are from the parent)
                if (currentState != BattlerState.dead)
                {
                    StartCoroutine(KnockCo(attacker.transform, attacker));
                }

                //if I was attacked by an enemy then increment their damage dealt to player
                //by there baseAttack

                if (attacker as Enemy != null)
                {
                    ((Enemy)attacker).incrementDamageDealt();
                }
            }
        }
    }
Exemple #3
0
        public void Initialize()
        {
            Global.camera.X = 0;
            Global.camera.Y = 0;
            //the first two indices are obviously x and y, although the third is NOT z!
            //the third stores any number of tiles when z can be queryed.
            //Note that this is not inefficient for the GraphicsCard since
            //the TileMap takes the three-dimensional and skips the null cells
            //when copying the vertices.
            TileMapParser mapLoader = new TileMapParser();
            TileMap       demoMap   = mapLoader.LoadMap("DemoMap");

            demoMap.player = new OWPlayer("Images/Characters/nickOW", new int[3] {
                1, 1, 0
            }, Tile.Direction.SOUTH);
            demoMap.Initialize();
            tileMaps.Add("DemoMap", demoMap);
            TileMap stairMap = mapLoader.LoadMap("StairMap");

            tileMaps.Add("StairMap", stairMap);
            tileMap = demoMap;

            battleMaps = new Dictionary <string, BattleMap>();
            Battler[] battlers = new Battler[1];
            battlers[0] = new Battler("Images/Characters/nickBattle", new Vector3(0, 0, 0));
            BattleMap testMap = new BattleMap("Ice_Path", battlers, 0);

            testMap.Initialize();
            battleMaps.Add("Ice_Path", testMap);
            battleMap = testMap;

            dialog = new Dialog();
            dialog.Initialize();
        }
Exemple #4
0
 public void DamageBattlerNoSound(int dmg, Battler btl, bool critical)
 {
     btl.hp -= dmg;
     // topboard.UpdateString("The " + btl.name + " took " + dmg.ToString() + " damage!");
     btl.sprite.GetComponent <ParticleSystem>().Emit(dmg);
     CreateDamageText(dmg, btl.sprite, critical);
 }
Exemple #5
0
 void ChangeControl()
 {
     if (GameObject.FindGameObjectWithTag("Player").GetComponent <Battler>())
     {
         inControl = GameObject.FindGameObjectWithTag("Player").GetComponent <Battler>();
     }
 }
Exemple #6
0
    void MakeRandomAction(Battler actor)
    {
        int selectedAttack = Random.Range(0, actor.creature.Attacks.Count);

        Player sideTargeted = Player.Player1;

        switch (actor.creature.Attacks[selectedAttack].Nature)
        {
        case AttackNature.Helpful:
            sideTargeted = Player.Player2;
            break;

        case AttackNature.Harmful:
            sideTargeted = Player.Player1;
            break;
        }

        Command setCom = new Command();

        setCom.moveToUse      = selectedAttack;
        setCom.targetSide     = sideTargeted;
        setCom.targetPosition = Random.Range(0, 2);

        actor.CommitCommand(setCom);
    }
 void ChangeControl()
 {
     if (GameObject.FindGameObjectWithTag("Player").GetComponent<Battler>())
     {
         inControl = GameObject.FindGameObjectWithTag("Player").GetComponent<Battler>();
     }
 }
Exemple #8
0
    public override void selectTargets(Tile[,] tiles, List <Tile> targets, Battler user, int startX, int startY)
    {
        for (int i = 1; i <= lineLen; i++)
        {
            if (startX == user.curTile.x && startY != user.curTile.y)//up || down
            {
                int x = user.curTile.x;
                int y = user.curTile.y + (startY > user.curTile.y ? i : -i);

                if (x < tiles.GetLength(0) && x >= 0 &&
                    y < tiles.GetLength(1) && y >= 0)
                {
                    targets.Add(tiles[x, y]);
                }
            }

            else if (startY == user.curTile.y && startX != user.curTile.x)//left || right
            {
                int x = user.curTile.x + (startX > user.curTile.x ? i : -i);
                int y = user.curTile.y;

                if (x < tiles.GetLength(0) && x >= 0 &&
                    y < tiles.GetLength(1) && y >= 0)
                {
                    targets.Add(tiles[x, y]);
                }
            }
        }
    }
Exemple #9
0
    public void RemoveBattler(Battler battler)
    {
        if (!_spawnedBattlers.Contains(battler))
        {
            GD.PrintErr($"{battler} is not currently spawned");
            return;
        }

        _spawnedBattlers.Remove(battler);

        if (_onBossWave)
        {
            this.PostNotification(WaveCompleteNotification);
            _onBossWave = false;
            return;
        }

        if (_spawnedBattlers.Count == 0)
        {
            foreach (var point in _spawnPoints)
            {
                if (point.IsBoss)
                {
                    point.Start(1);
                    _onBossWave = true;
                }
            }
        }
    }
Exemple #10
0
    void InstantiateBattlers()
    {
        Battler[] battlers = FindObjectsOfType <Battler>();
        foreach (Battler battler in battlers)
        {
            DestroyImmediate(battler.gameObject);
        }

        GameObject playerStart = GameObject.Find("PlayerStart");
        GameObject enemyStart  = GameObject.Find("EnemyStart");

        GameObject playerBattler = Instantiate(player.gameObject, playerStart.transform.position, playerStart.transform.rotation);
        GameObject enemyBattler  = Instantiate(enemy.gameObject, enemyStart.transform.position, enemyStart.transform.rotation);

        GameObject battlerHolder = GameObject.Find("Battlers");
        GameObject playerHolder  = battlerHolder.transform.Find("Players").gameObject;

        playerBattler.transform.SetParent(playerHolder.transform);

        GameObject enemyHolder = battlerHolder.transform.Find("Enemies").gameObject;

        enemyBattler.transform.SetParent(enemyHolder.transform);


        player            = playerBattler.GetComponent <Battler>();
        enemy             = enemyBattler.GetComponent <Battler>();
        player.mainCamera = battleCamera;
        enemy.mainCamera  = battleCamera;
        player.entity     = playerEntity;
        enemy.entity      = enemyEntity;


        player.OnDodgeComplete.AddListener(DisplayDodge);
        enemy.OnDodgeComplete.AddListener(DisplayDodge);
    }
Exemple #11
0
 public void OnApply(Battler battler)
 {
     if (battler is CharacterBattler characterBattler)
     {
         characterBattler.Aggro += AggroModifier;
     }
 }
Exemple #12
0
    bool SubTurnStep_Interrupt_AllyHit(Battler bat, Battler[] bats)
    {
        BattlerAction action     = BattlerAction.None;
        bool          tryToCutIn = false;

        for (int i = 0; i < bats.Length; i++)
        {
            if (bats[i].isValidTarget && bats[i].incomingHit && bats[i] != bat)
            {
                tryToCutIn = true;
                break;
            }
        }
        if (tryToCutIn)
        {
            action = bat.GetInterruptAction(BattlerActionInterruptType.OnAllyHit);
            if (action != BattlerAction.None)
            {
                currentActingBattler = bat;
                if (bat.isEnemy)
                {
                    bat.AttackWith(validPlayerTargets, validEnemyTargets, action);
                }
                else
                {
                    bat.AttackWith(validEnemyTargets, validPlayerTargets, action);
                }
            }
        }
        return(action != BattlerAction.None);
    }
Exemple #13
0
    private void RebuildAllBattlersArray()
    {
        _forceAllBattlersRegen = false;
        Battler[] longAllBattlers = new Battler[playerParty.Length + enemyParty.Length];
        int       i2 = 0;

        for (int i = 0; i < playerParty.Length; i++)
        {
            if (playerParty[i].isValidTarget)
            {
                longAllBattlers[i2] = playerParty[i];
                i2++;
            }
        }
        for (int i = 0; i < enemyParty.Length; i++)
        {
            if (enemyParty[i].isValidTarget)
            {
                longAllBattlers[i2] = enemyParty[i];
                i2++;
            }
        }
        allBattlers = new Battler[i2];
        for (int i = 0; i < allBattlers.Length; i++)
        {
            allBattlers[i] = longAllBattlers[i];
        }
    }
 public float RestorMPBattler(float _amount, Battler _target)
 {
     _target.MP += _amount;
     SpawnDamageText(_target.transform.position, _amount.ToString(), Color.blue);
     //_target.aura.Add(_element, _amount);
     return(_amount);
 }
Exemple #15
0
    IEnumerator <float> HandleAheadOfStandardActions()
    {
        if (turn == 0)
        {
            for (int i = 0; i < turnOrderList.Count; i++)
            {
                Battler bat = turnOrderList[turnOrderList.Keys[i]];
                if (!bat.isValidTarget)
                {
                    continue;
                }
                if (SubTurnStep_Interrupt_BattleStart(bat))
                {
                    theater.ProcessAction();
                    while (theater.processing)
                    {
                        yield return(0f);
                    }
                    yield return(Timing.WaitForSeconds(battleStepLength));

                    if (CheckIfBattleResolved())
                    {
                        yield break;
                    }
                }
            }
        }
    }
 public float HealBattler(float _amount, Battler _target)
 {
     _target.HP += _amount;
     SpawnDamageText(_target.transform.position, _amount.ToString(), Color.green);
     //_target.aura.Add(_element, _amount);
     return(_amount);
 }
 public void HurtBattler(float _amount, Battler _target, Element _element = Element.Physical)
 {
     _target.GetComponent <SpriteAnimator>().Play(_target.anims.Hurt);
     _target.HP -= _amount;
     SpawnDamageText(_target.transform.position, _amount.ToString(), Color.white);
     //_target.aura.Add(_element, _amount);
 }
    public float BattlerDamageOther(Battler _attacker, AttackDamageProperties _skill, Battler _defender)
    {
        float damageDone = 1;

        if (_skill.power > 0)
        {
            //Check Crit & Hit
            if (!CheckHit(_attacker, _skill, _defender))
            {
                SpawnDamageText(_defender.transform.position, "Miss", Color.grey);
                return(0);
            }
            bool crit = CheckCrit(_attacker, _skill, _defender);

            //Damage
            damageDone = Mathf.Floor(Calculator.DamageCalc(_attacker, _skill, _defender, crit));
            if (_defender.defending)
            {
                damageDone = Mathf.Floor(damageDone * 0.25f);
            }
            _defender.GetComponent <SpriteAnimator>().Play(_defender.anims.Hurt, true);
            _defender.HP -= damageDone;
            if (!crit)
            {
                SpawnDamageText(_defender.transform.position, damageDone.ToString(), Color.white);
            }
            else
            {
                SpawnDamageText(_defender.transform.position, "" + (damageDone).ToString(), Color.yellow);
            }
            //_other.aura.Add(_skill.element, damageDone);
        }
        return(damageDone);
    }
Exemple #19
0
 public TrumpBehavior(Battler parent)
 {
     WallPrefab = Resources.Load<GameObject>("Wall");
     CombPrefab = Resources.Load<GameObject>("Comb");
     Battler = parent;
     anim = parent.gameObject.GetComponent<Animator>();
 }
Exemple #20
0
    void Start()
    {
        map = FindObjectOfType <TileMap>();
        map.GenerateMap();

        var battleData = DataManager.LoadOnce <BattleData>(dataName);

        npcs   = new List <Battler>();
        allies = new List <Battler>();

        // add npcs to map
        foreach (var npc in battleData.npcs)
        {
            var npcData = battleData.npcData[npc.index];
            var tile    = map.TileAt(npc.row, npc.col);
            npcs.Add(Battler.Create(npcData, Alignment.Enemy, tile));
        }

        // add player characters to deploy points
        for (int i = 0; i < playerCharacters.Count && i < battleData.deployPoints.Length; i++)
        {
            var name     = playerCharacters[i];
            var coord    = battleData.deployPoints[i];
            var charData = DataManager.Fetch <Character>(name);
            var tile     = map.TileAt(coord.row, coord.col);
            allies.Add(Battler.Create(charData, Alignment.Ally, tile));
        }

        states = new StateMachine <Battle>(this, new PlayerTurn());
    }
Exemple #21
0
        public bool ActivatingSpell(Battler user, Spell spl, int splIndex)
        {
            BattleCardEventArgs args = new BattleCardEventArgs(user, GetOpponent(user), spl, splIndex);

            SpellActivate?.Invoke(this, args);

            if (args.DestroyTriggerer || (args.Cancel && spl.SpellType != CardEffectType.CONTINUOUS))
            {
                DestroyingSpell(args.NonTriggeringPlayer, args.TargetedCard, args.TriggeringCard, args.TargetedCardIndex, args.TriggeringCardIndex);
            }
            if (args.Cancel || args.DestroyTriggerer)
            {
                return(false);
            }


            Spell spell = (Spell)args.TriggeringCard;

            ShowText(args.TriggeringPlayer.Name + " activated " + args.TriggeringCard.Name + "!");
            spell.ResolveEffects(this, args.TriggeringCard);
            if (spell.SpellType == CardEffectType.INSTANT || spell.SpellType == CardEffectType.COUNTER)
            {
                RemovingSpell(args.TriggeringPlayer, spell, args.TriggeringCardIndex);
            }
            return(true);
        }
    public override void CommitAction(Battler _user, List <Battler> _targets)
    {
        BattleEffectsSpawner newEffects = GameObject.Instantiate(heldItem.useItem.effect.effects);

        newEffects.Init(BattleManager.main, _user, _targets, heldItem.useItem.effect);
        heldItem.stack--;
    }
Exemple #23
0
 public void ActiveBattler()
 {
     Debug.Log("ActiveBattler()");
     //code to determine next battler
     Battler tempbat = battlers[0];
     //BattleM_UI_Update(tempbat);
 }
Exemple #24
0
            protected internal override void Enter()
            {
                playerBattlerScript = Context.battlePlayer.GetComponent <Battler>();
                enemyBattlerScript  = Context.battleEnemy.GetComponent <Battler>();

                playerBattlerScript.ActionLeave();
            }
    public void PickBattler(Battler picked)
    {
        SelectedBattler = picked;
        CurrentStep     = PlayerControlSteps.PickAttack;

        Refresh();
    }
Exemple #26
0
 public BattleCardEventArgs(Battler turnplayer, Battler offturnplayer, Card triggeringcard, Card targetedcard, int triggeringcardindex, int targetedcardindex) : base(turnplayer, offturnplayer)
 {
     TriggeringCard      = triggeringcard;
     TargetedCard        = targetedcard;
     TriggeringCardIndex = triggeringcardindex;
     TargetedCardIndex   = targetedcardindex;
 }
Exemple #27
0
    /// <summary>
    /// Instantly performs battle initialization.
    /// This function does the following on the same frame:
    /// 1. Disables visibility of all UI.
    /// 2  Generates new battlers.
    /// 3. Starts music.
    /// 4. Makes battlers instantly summons new pokemon.
    /// 5. Loads Pokemon state UIs
    /// 6. Loads Move/Party UIs
    /// </summary>
    private IEnumerator InitializeBattleInstantly()
    {
        /* Initialize UI Settings */
        DialogueManager.SetTextVisibility(false);
        OptionManager.instance.SetPokeStates(false);
        OptionManager.instance.SetOptions(false);

        /* Generate Battlers */
        Battler1 = new Battler(spawn1);
        Battler2 = new Battler(spawn2);

        /* Start Music */
        SoundManager.PlayMusic(song);

        /* Instantly Summon Pokemon */
        Battler1.trainer.SummonInstant(0, Battler1.pokeSpawner.transform);
        Battler2.trainer.SummonInstant(0, Battler2.pokeSpawner.transform);
        Battler1.pokemon = Battler1.trainer.CurrentPokemon;
        Battler2.pokemon = Battler2.trainer.CurrentPokemon;

        /* Let Pokemon Awake/Start Calls Be Performed */
        yield return(null);

        /* Load Pokemon State UIs */
        OptionManager.instance.state1.LoadState(Battler1.pokemon);
        OptionManager.instance.state2.LoadState(Battler2.pokemon);

        /* Load Move/Party UIs */
        OptionManager.instance.LoadMoves(Battler1.pokemon);
        OptionManager.instance.LoadParty(Battler1.trainer);

        /* Start Options Loop */
        optionRoutine = StartCoroutine(SetOptionLoop());
    }
    public void CancelAll()
    {
        CurrentStep     = PlayerControlSteps.PickBattler;
        SelectedBattler = null;

        Refresh();
    }
Exemple #29
0
    void FinishChoosingAction()
    {
        choosingAction = false;

        if (playerTurnChooseAction)
        {
            playerTurnChooseAction = false; //reset

            activeBattlerIndex = 0;
            activeBattler      = battlers[activeBattlerIndex].GetComponent <Battler>();
            currentBattlePhase = BattlePhase.DoAction;

            for (int i = 0; i < battlers.Length; i++)
            {
                battlers[i].GetComponent <Battler>().StartRoundAction();
            }
        }
        else
        {
            activeBattlerIndex++;
            if (activeBattlerIndex < battlers.Length)
            {
                activeBattler = battlers[activeBattlerIndex].GetComponent <Battler>();

                if (activeBattler == playerBattler)
                {
                    playerTurnChooseAction = true;
                }
            }
            else //all non-player battlers have chosen their action
            {
                playerTurnChooseAction = true;
            }
        }
    }
Exemple #30
0
    protected float CalculateStandardDamage(Battler attackTarget)
    {
        float baseDamage = (float)(Math.Pow(battleState.level, 2d) + 19d) / 5f;

        float strengthFactor = (float)battleState.strength / (battleState.level * 2);

        int   equipmentDifference = battleState.attackRating - attackTarget.battleState.defenceRating;
        float equipmentFactor     = 3f / (float)Math.PI *
                                    (float)Math.Atan(0.075d * equipmentDifference - 0.57d) + 1.5f;

        float criticalHitFactor;
        float criticalHitChance = battleState.deadliness / 250f;

        System.Random r = new System.Random();
        if (criticalHitChance > r.NextDouble())
        {
            criticalHitFactor = 3f;
            StartCoroutine(CombatUI.Instance.DisplayMessage("Critical Hit!", 1f));
        }
        else
        {
            criticalHitFactor = 1f;
        }

        float randomFactor = (float)(1.1d - 0.2d * r.NextDouble());

        return(baseDamage * strengthFactor * equipmentFactor * criticalHitFactor * randomFactor);
    }
Exemple #31
0
        public override async Task PlaySkillAnimation(Battler source, IEnumerable <Battler> targets)
        {
            List <Task> Animations      = new List <Task>();
            var         leftoverObjects = new List <GameObject>();
            await source.QueueActionAndAwait(() =>
            {
                targets.ForEach(target =>
                {
                    var animationObject = GameObject.Instantiate(GameSettings.Instance.AnimationObject,
                                                                 BattleController.Instance.battleCanvas.transform);

                    leftoverObjects.Add(animationObject);

                    var animation = animationObject.GetComponent <AnimationObject>();
                    animation.transform.position = target.RectTransform.position;

                    ScaleAnimation(animation.transform as RectTransform);

                    Animations.Add(animation.PlayAndAwait(AnimationName, SoundInfo, SpeedMultiplier));
                });
            });

            await Task.WhenAll(Animations);

            await source.QueueActionAndAwait(() =>
            {
                foreach (var o in leftoverObjects)
                {
                    Object.Destroy(o);
                }
            });
        }
Exemple #32
0
        public bool StealingMana(Battler user, Monster mon, int monIndex)
        {
            BattleCardEventArgs args = new BattleCardEventArgs(user, GetOpponent(user), mon, monIndex);

            ManaSteal?.Invoke(this, args);

            if (args.DestroyTriggerer)
            {
                DestroyingMonster(args.TriggeringPlayer, (Monster)args.TriggeringCard, null, args.TriggeringCardIndex, -1);
            }
            if (args.Cancel || args.DestroyTriggerer)
            {
                return(false);
            }

            args.TriggeringPlayer.Mana    += mon.Level;
            args.NonTriggeringPlayer.Mana -= mon.Level;
            if (args.TriggeringCard is Monster)
            {
                ((Monster)args.TriggeringCard).CanAttack = false;
            }
            ShowText(args.TriggeringPlayer.Name + "'s " + args.TriggeringCard.Name + " stole " +
                     args.TriggeringCard.Level + " Mana from " + args.NonTriggeringPlayer.Name);
            args.TriggeringPlayer.HasMoved = true;

            return(true);
        }
Exemple #33
0
 public void RemoveFromInventory(Battler user)
 {
     Quantity--;
     if (Quantity <= 0)
     {
         user.Inventory.Remove(this);
     }
 }
Exemple #34
0
 //Only burn is implemented
 void BurnStatus(Battler battler)
 {
     if (battler == Character)
     {
         statusText.text = "Burn";
         statusText.color = new Color(1f, 0.25f, 0f);
     }
 }
Exemple #35
0
 public override void TakeDamage(Battler user, int baseDamage)
 {
     base.TakeDamage(user, baseDamage);
     if (!defending)
     {
         Battler.StartCoroutine(Anim());
     }
 }
Exemple #36
0
 //Implement a BattleBehavior.UseSP function
 public void UseSP(Battler user)
 {
     user.BattleBehavior.Stats.CurrentSP -= RequiredSP;
     if (user.BattleBehavior.Stats.CurrentSP < 0)
     {
         user.BattleBehavior.Stats.CurrentSP = 0;
     }
     user.BattleBehavior.SPEvent(user.BattleBehavior.Stats.CurrentSP, user.BattleBehavior.Stats.MaxSP);
 }
    private void SpawnBattler(int _prefabIndex, BattlerPosition _pos, Battler.Alliance _alliance)
    {
        GameObject spawn = MasterDatabase.MasterData.battlerPrefabs[_prefabIndex];

        GameObject.Instantiate(spawn);
        //spawn.GetComponent<Battler>().position = _pos;
        //spawn.GetComponent<Battler>().alliance = _alliance;
        //spawn.name = "Battler " + numberOfBattlers.ToString();
        numberOfBattlers++;
    }
Exemple #38
0
 public override IEnumerator StandardAttack(Battler user, Battler target)
 {
     Animator anim = user.GetComponent<Animator>();
     Vector3 startPos = user.gameObject.transform.position;
     anim.SetInteger("State", 1);
     yield return Move.MoveInFrontOfBattler(user, target, startPos, new Vector3(-2f, 0f, 0f), 50);
     anim.SetInteger("State", 2);
     int baseDamage = (user.BattleBehavior.Stats.Attack * 6) - (target.BattleBehavior.Stats.Defense * 3);
     baseDamage = new System.Random().Next((int)(baseDamage * 0.9), (int)(baseDamage * 1.1));
     yield return new WaitForSeconds(0.5f);
     target.BattleBehavior.TakeDamage(user, baseDamage);
     yield return new WaitForSeconds(0.3f);
     anim.SetInteger("State", 1);
     yield return Move.MoveBackFromBattler(user, target, startPos, new Vector3(-2f, 0f, 0f), 50);
     anim.SetInteger("State", 0);
 }
Exemple #39
0
 public static IEnumerator MoveInFrontOfBattler(Battler user, Battler target, Vector3 startPos, Vector3 offset, int duration)
 {
     Quaternion startRotation = user.transform.rotation;
     Vector3 targetPos = target.gameObject.transform.position + offset;
     targetPos.y = startPos.y;
     var heading = targetPos - startPos;
     var distance = heading.magnitude;
     var direction = heading / distance;
     user.transform.rotation = Quaternion.LookRotation(direction);
     for (int i = 0; i < duration; i++)
     {
         Vector3 newPos = startPos + (targetPos - startPos) * (float)i / duration;
         user.gameObject.transform.position = newPos;
         yield return 0;
     }
     user.transform.rotation = startRotation;
     user.transform.position = targetPos;
 }
Exemple #40
0
 public override IEnumerator Run(Battler user, Battler target, IList<Battler> allCharacters, IList<Battler> allEnemies, BattleController bc)
 {
     BattleBehavior.Battler.StartCoroutine(SpecialEffectsManager.SpecialName(Name));
     Animator anim = user.gameObject.GetComponent<Animator>();
     anim.SetInteger("State", 3);
     yield return new WaitForSeconds(2f);
     bc.StartCoroutine(CameraShake());
     yield return MakeWalls(target);
     yield return new WaitForSeconds(0.75f);
     anim.SetInteger("State", 0);
     int baseDamage = (int)(user.BattleBehavior.Stats.SpAttack * Power * 6) - (target.BattleBehavior.Stats.SpDefense * 3);
     if (baseDamage > 0)
         baseDamage = new System.Random().Next((int)(baseDamage * 0.9), (int)(baseDamage * 1.1));
     else
         baseDamage = 0;
     target.BattleBehavior.TakeDamage(user, baseDamage);
 }
Exemple #41
0
 IEnumerator MakeWalls(Battler target)
 {
     int count = 15;
     for (int i = 0; i < count; i++)
     {
         Vector3 pos = target.gameObject.transform.position;
         pos.x = 20 - (i * 3);
         GameObject wall = Instantiate(WallPrefab, pos, Quaternion.identity) as GameObject;
         yield return new WaitForSeconds(0.07f);
     }
 }
    IEnumerator PerformAction(Battler user, ActionType ActionType, Action action, int actionIndex, Battler target, IList<Battler> allCharacters, IList<Battler> allEnemies)
    {
        switch (ActionType)
        {
            case ActionType.Attack:
                yield return user.BattleBehavior.StandardAttack(user, target);
                break;

            case ActionType.Special:
                action.UseSP(user);
                yield return action.Run(user, target, allCharacters, allEnemies, this);
                break;

            case ActionType.Item:
                user.Inventory[actionIndex].RemoveFromInventory(user);
                user.Inventory[actionIndex].Use(user, target);
                break;

            case ActionType.Defend:
                Shield shield = Shields[user.BattlerIndex];
                user.BattleBehavior.Defending = true;
                shield.StartCoroutine(shield.Enter());
                break;
        }
    }
 public static void FireParticles(Battler battler)
 {
     Vector3 pos = battler.gameObject.transform.position;
     pos.y = 0f;
     GameObject fire = MonoBehaviour.Instantiate(FireParticlesPrefab, pos, Quaternion.Euler(-90f, 0f, 0f)) as GameObject;
     MonoBehaviour.Destroy(fire, 5f);
 }
 void HPText(Battler battler, int dHealth)
 {
     
     Vector3 position = Camera.main.WorldToScreenPoint(battler.gameObject.transform.position);
     position.y += 30f;
     GameObject num = Instantiate(DamageNumberPrefab) as GameObject;
     num.transform.SetParent(Canvas.transform);
     num.transform.position = position;
     DamageNumber dn = num.GetComponent<DamageNumber>();
     dn.Damage = Mathf.Abs(dHealth);
     if (dHealth > 0)
     {
         dn.Color = Color.green;
     }
 }
Exemple #45
0
 public SteveBehavior(Battler parent)
 {
     Battler = parent;
 }
Exemple #46
0
    public virtual void Use(Battler user, Battler recipient)
    {

    }
Exemple #47
0
 public CainaBehavior(Battler parent)
 {
     Battler = parent;
 }
Exemple #48
0
    public void CharacterTurn(Battler character)
    {
        //Only attack enemies that are alive
        allEnemies = allEnemies.Where(e => e.BattleBehavior.Status.StatusEffect != StatusEffect.Defeated).ToList();

        onTurn = true;
        cursorHover = false;
        gameObject.SetActive(true);
        currentCharacter = character;
        mainIndex = 0;
        specialIndex = 0;
        itemIndex = 0;
        charIndex = 0;
        enemyIndex = 0;
        MainMenu();
        UpdateMenu();
        UpdateCharacterName();
        Vector3 circlePos = currentCharacter.transform.position;
        circlePos.y = 0.25f;
        MagicCircle.transform.position = circlePos;//= currentCharacter.transform.position + new Vector3(0f, -2f, 0f);
        StartCoroutine(SpinCircle());
        StartCoroutine(CursorHover());
    }
 public static void DeathParticles2(Battler battler)
 {
     Vector3 pos = battler.gameObject.transform.position;
     pos.y = 0f;
     GameObject deathParticles = MonoBehaviour.Instantiate(DeathParticlesPrefab2, pos, Quaternion.identity) as GameObject;
     MonoBehaviour.Destroy(deathParticles, 3f);
 }
 public static IEnumerator DeathCircles(Battler battler)
 {
     int circleCount = 25;
     Vector3 circlePos = battler.gameObject.transform.position;
     circlePos.y = battler.GetComponentInChildren<Renderer>().bounds.center.y;
     for (int i = 0; i < circleCount; i++)
     {
         Vector3 dir = Random.insideUnitSphere;
         Quaternion facing = Quaternion.LookRotation(dir);
         MonoBehaviour.Instantiate(DeathCirclePrefab, circlePos, facing);
         yield return new WaitForSeconds(0.08f);
     }
 }
Exemple #51
0
 public override IEnumerator Run(Battler user, Battler target, IList<Battler> allCharacters, IList<Battler> allEnemies, BattleController battlecontroller)
 {
     Animator anim = user.gameObject.GetComponent<Animator>();
     BattleBehavior.Battler.StartCoroutine(SpecialEffectsManager.SpecialName(Name));
     Vector3 startPos = allCharacters[0].gameObject.transform.position;
     startPos.y = 2f;
     startPos.z = 10f;
     anim.SetInteger("State", 3);
     yield return new WaitForSeconds(2f);
     Instantiate(CombPrefab, startPos, Quaternion.identity);
     yield return new WaitForSeconds(2.4f);
     IList<Battler> liveCharacters = allCharacters.Where(c => c.BattleBehavior.Status.StatusEffect != StatusEffect.Defeated).ToList();
     foreach (Battler c in liveCharacters)
     {
         int baseDamage = (int)(user.BattleBehavior.Stats.SpAttack * Power * 6) - (c.BattleBehavior.Stats.SpDefense * 3);
         if (baseDamage > 0)
             baseDamage = new System.Random().Next((int)(baseDamage * 0.9), (int)(baseDamage * 1.1));
         else
             baseDamage = 0;
         c.BattleBehavior.TakeDamage(user, baseDamage);
     }
     anim.SetInteger("State", 0);
 }
Exemple #52
0
 public override IEnumerator Run(Battler user, Battler target, IList<Battler> allCharacters, IList<Battler> allEnemies, BattleController bc)
 {
     anim = user.GetComponent<Animator>();
     anim.SetInteger("State", 3);
     yield return new WaitForSeconds(1.4f);
     Camera.main.hdr = true;
     Light light = GameObject.FindGameObjectWithTag("Light").GetComponent<Light>();
     yield return new WaitForSeconds(0.3f);
     yield return Dim();
     for (int i = 0; i < starCount; i++)
     {
         CreateStar(user, target);
         yield return new WaitForSeconds(0.1f);
     }
     yield return new WaitForSeconds(3f);
     int baseDamage = (int)((user.BattleBehavior.Stats.SpAttack * 6 * Power) - (target.BattleBehavior.Stats.SpDefense * 3));
     baseDamage = new System.Random().Next((int)(baseDamage * 0.9), (int)(baseDamage * 1.1));
     target.BattleBehavior.TakeDamage(user, baseDamage);
     yield return Brighten();
     Camera.main.hdr = false;
     anim.SetInteger("State", 0);
 }
Exemple #53
0
 public override IEnumerator Run(Battler user, Battler target, IList<Battler> allCharacters, IList<Battler> allEnemies, BattleController battlecontroller)
 {
     Animator anim = user.gameObject.GetComponent<Animator>();
     BattleBehavior.Battler.StartCoroutine(SpecialEffectsManager.SpecialName(Name));
     anim.SetInteger("State", 3);
     yield return new WaitForSeconds(2f);
     SpecialEffectsManager.FireParticles(target);
     yield return new WaitForSeconds(1f);
     int baseDamage = (int)(user.BattleBehavior.Stats.SpAttack * Power * 6) - (target.BattleBehavior.Stats.SpDefense * 3);
     if (baseDamage > 0)
         baseDamage = new System.Random().Next((int)(baseDamage * 0.9), (int)(baseDamage * 1.1));
     else
         baseDamage = 0;
     target.BattleBehavior.TakeDamage(user, baseDamage);
     //50% chance of inflicting a burn
     target.BattleBehavior.AddStatusEffect(user, StatusEffect.Burn, 0.5f);
     anim.SetInteger("State", 0);
 }
Exemple #54
0
 void CreateStar(Battler user, Battler target)
 {
     float hue = Random.Range(0f, 1f);
     Color color = Color.HSVToRGB(hue, 1f, 1f);
     color *= 1.1f;
     Vector3 starPos = user.gameObject.transform.position;
     starPos.x -= 20f;
     starPos.y = 20f;
     starPos.z += Random.Range(-20f, 20f);
     Vector3 targetPos = target.gameObject.transform.position;
     targetPos.z = starPos.z;
     Quaternion angle = Quaternion.Euler(0f, 180f, 0f);
     GameObject star = Instantiate(StarPrefab, starPos, angle) as GameObject;
     Material starMaterial = star.GetComponent<MeshRenderer>().material;
     //Changes color to blue
     starMaterial.SetColor("_EmissionColor", color);//new Color(0f, 0f, 1.2f));
     Rigidbody rb = star.GetComponent<Rigidbody>();
     var heading = targetPos - starPos;
     var distance = heading.magnitude;
     var direction = heading / distance;
     rb.AddForce(direction * 1500f);
     Destroy(star, 5f);
 }
 void BurnText(Battler battler)
 {
     Vector3 position = Camera.main.WorldToScreenPoint(battler.gameObject.transform.position);
     position.x += 90f;
     position.y += 30f;
     GameObject text = Instantiate(BurnTextPrefab) as GameObject;
     text.transform.SetParent(Canvas.transform);
     text.transform.position = position;
 }
 public override IEnumerator Run(Battler user, Battler target, IList<Battler> allCharacters, IList<Battler> allEnemies, BattleController bc)
 {
     BattleBehavior.Battler.StartCoroutine(SpecialEffectsManager.SpecialName(Name));
     Animator anim = user.gameObject.GetComponent<Animator>();
     anim.SetInteger("State", 1);
     Vector3 startPos = user.gameObject.transform.position;
     yield return Move.MoveInFrontOfBattler(user, target, startPos, new Vector3(2f, 0f, 0f), 30);
     anim.SetInteger("State", 2);
     int baseDamage = (int)(user.BattleBehavior.Stats.SpAttack * Power * 6) - (target.BattleBehavior.Stats.SpDefense * 3);
     if (baseDamage > 0)
         baseDamage = new System.Random().Next((int)(baseDamage * 0.9), (int)(baseDamage * 1.1));
     else
         baseDamage = 0;
     yield return new WaitForSeconds(0.5f);
     target.BattleBehavior.TakeDamage(user, baseDamage);
     yield return new WaitForSeconds(0.3f);
     anim.SetInteger("State", 1);
     yield return Move.MoveBackFromBattler(user, target, startPos, new Vector3(2f, 0f, 0f), 30);
     anim.SetInteger("State", 0);
 }
Exemple #57
0
        public override IEnumerator Run(Battler user, Battler target, IList<Battler> allCharacters, IList<Battler> allEnemies, BattleController bc)
        {
            Animator anim = user.GetComponent<Animator>();
            anim.SetInteger("State", 3);
            yield return new WaitForSeconds(1.4f);
            int duration = 40;
            Material m = target.GetComponentInChildren<Renderer>().material;
            m.EnableKeyword("_EMISSION");

            SpecialEffectsManager.RestoreParticles(target);
            for (int i = 0; i < duration; i++)
            {
                m.SetColor("_EmissionColor", Color.white * 0.6f * Mathf.Sin((float) i / duration * Mathf.PI));
                yield return 0;
            }
            target.BattleBehavior.RestoreHP(user, 250);
            anim.SetInteger("State", 0);
            Debug.Log(user.BattleBehavior.Name + " restored 250 HP to " + target.BattleBehavior.Name);
        }
 public HyperRatBehavior(Battler parent)
 {
     Battler = parent;
     anim = parent.gameObject.GetComponent<Animator>();
 }
Exemple #59
0
 void MoveCursor(Battler character)
 {
     Renderer r = character.gameObject.GetComponentInChildren<Renderer>();
     CharacterCursor.transform.localPosition = character.gameObject.transform.position + new Vector3(0f, r.bounds.size.y + 1.5f + cursorY - character.gameObject.transform.position.y, 0f);
 }
 public static void RestoreParticles(Battler battler)
 {
     Vector3 pos = battler.gameObject.transform.position;
     pos.y = 0f;
     GameObject restoreParticles = MonoBehaviour.Instantiate(RestoreParticlesPrefab, pos, Quaternion.Euler(270f, 0f, 0f)) as GameObject;
     MonoBehaviour.Destroy(restoreParticles, 3f);
 }