Exemple #1
0
 public void Register(SkillContainer skill)
 {
     if (skills.Exists(p => p.skillId == skill.skillId) == false)
     {
         skills.Add(skill);
     }
 }
 public Player(Player copy)
 {
     this.playerSkill = copy.playerSkill;
     silenced = copy.silenced;
     score = copy.score;
     gameTime = copy.gameTime;
 }
    public void SelectSkill(int index)
    {
        if (!processingCommand)
        {
            return;
        }
        if (GameManager.instance.tasks.Count > 0)
        {
            return;
        }
        if (IsAimingSkill)
        {
            return;
        }
        if (index < 0 || index >= skillContainers.Count)
        {
            return;
        }
        SkillContainer s = skillContainers[index];

        if (!s.IsCastable)
        {
            return;
        }
        aimingSkill = s;
        GameManager.instance.TilesInRangeSkill(tile, s.skill.range, this, s.skill);
        GameManager.instance.cursor.transform.localScale = new Vector3((1 + s.skill.aoe * 2), 1, (1 + s.skill.aoe * 2));
    }
 void CommitSkillTarget()
 {
     if (!IsAimingSkill)
     {
         return;
     }
     if (GameManager.instance.selected == null ||
         !aimingSkill.skill.IsInRange(this, GameManager.instance.selected))
     {
         GameManager.instance.TilesInRangeSkill(tile, aimingSkill.skill.range, this, aimingSkill.skill);
         return;
     }
     if (aimingSkill.skill.aoe <= 0 && !aimingSkill.skill.ValidTile(this, GameManager.instance.selected))
     {
         GameManager.instance.TilesInRangeSkill(tile, aimingSkill.skill.range, this, aimingSkill.skill);
         //GameManager.instance.cursor.transform.localScale = new Vector3((1 + aimingSkill.skill.aoe * 2), 1, (1 + aimingSkill.skill.aoe * 2));
         return;
     }
     GameManager.instance.cursor.transform.localScale = Vector3.one;
     GameManager.instance.ProcessCommand(() =>
     {
         aimingSkill.skill.Perform(this, GameManager.instance.selected);
         aimingSkill.cooldown = aimingSkill.skill.cooldown;
         aimingSkill          = null;
     });
 }
    public Dictionary <int, Skill> GetDict()
    {
        XElement sc = SkillContainer.Load(path);

        SkillInfos = sc.Element("Skills").Elements("Skill").Select(c => new Skill().Set(c)).ToDictionary(info => info.id);

        return(SkillInfos);
    }
Exemple #6
0
 public void AbortCast()
 {
     wait          = null;
     nowCastTime   = 0;
     castTime      = 0;
     target        = Vector3.zero;
     startPosition = Vector3.zero;
     isCast        = false;
     skill         = null;
 }
Exemple #7
0
    private void GrabSkill(GameObject item)
    {
        SkillContainer container = item.GetComponent <SkillContainer>();

        if (container != null)
        {
            skillsManager.AddSkill(container.getSkill(), gameObject.transform.parent.gameObject.transform.parent.gameObject);
        }

        item.SetActive(false);
    }
 public GameState(GameState copy)
 {
     field = new Field<Route>(copy.field);
     turn = copy.turn;
     activePlayer = copy.activePlayer;
     globalSkillCap = copy.globalSkillCap;
     placedPieces = copy.placedPieces;
     player[0] = new Player(copy.player[0]);
     player[1] = new Player(copy.player[1]);
     skillsUsed = copy.skillsUsed;
 }
 //the GameState is assumed to be the playing game state
 public GameState()
 {
     field = new Field<Route>(Route.empty);
     turn = 0;
     activePlayer = 0;
     placedPieces = 0;
     globalSkillCap = 0;
     player[0] = new Player();
     player[1] = new Player();
     skillsUsed = new SkillContainer();
 }
Exemple #10
0
 public void Populate(PCEvent pc)
 {
     this.pc = pc;
     Clear();
     for (int i = 0; i < pc.activeBook.spells.Count; i += 1)
     {
         SkillContainer container = Instantiate(containerPrefab);
         container.transform.SetParent(transform, false);
         container.Populate(pc, i);
     }
 }
Exemple #11
0
    void Awake()
    {
        manager = this;
        DontDestroyOnLoad(gameObject);
        SkillIds = new List <int> ();
        skills   = SkillContainer.Load(Path.Combine(Application.dataPath, "Data.xml"));

        foreach (GameObject g in GameObject.FindGameObjectsWithTag("Agent"))
        {
            g.GetComponent <TemplateAgent> ().enabled = true;
        }
    }
Exemple #12
0
 public void SkillUse(int id, Vector3 _target, Vector3 _startPosition, int playerId)
 {
     if (wait != null && wait.id == id)
     {
         return;
     }
     skill         = SkillManager.singleton.getSkill(id);
     wait          = (new SkillWait(id, skill.spoperties.castTime));
     castTime      = wait.time;
     nowCastTime   = wait.time;
     isCast        = true;
     target        = _target;
     startPosition = _startPosition;
 }
 public void StopAimingSkill()
 {
     GameManager.instance.cursor.transform.localScale = Vector3.one;
     if (!IsAimingSkill)
     {
         return;
     }
     aimingSkill = null;
     if (!hasMoved)
     {
         CalculateReachableTiles();
     }
     else
     {
         GameManager.instance.TilesInRange(tile, 0, this);
     }
 }
Exemple #14
0
    public bool Upgrade(int skillId)
    {
        SkillContainer temp = getSkill(skillId);

        if (temp == null)
        {
            Debug.LogError("Error");
            return(false);
        }
        SkillProperties tempP = temp.spoperties;

        if (tempP == null)
        {
            return(false);
        }
        temp.spoperties = tempP.UpdateNextLevel();
        return(true);
    }
    public void calculateAttack()
    {
        Unit enemy = GameManager.instance.GetNearestEnemy(this, true);

        if (enemy == null)
        {
            GameManager.instance.ProcessCommand(() => { });
            return;
        }

        List <SkillContainer> castableMoves = new List <SkillContainer>();

        foreach (SkillContainer sc in skillContainers)
        {
            if (sc.IsCastable && sc.skill.targetType == Skill.TargetType.ENEMY && sc.skill.IsInRange(this, enemy.tile))
            {
                castableMoves.Add(sc);
            }
        }

        if (castableMoves.Count <= 0)
        {
            GameManager.instance.ProcessCommand(() => { });
            return;
        }

        SkillContainer move = castableMoves[Random.Range(0, castableMoves.Count)];

        GameManager.instance.ProcessCommand(() => {
            move.skill.Perform(this, enemy.tile);
            move.cooldown = move.skill.cooldown;
        });


        /*
         * if (SkillFactory.GetSnipe().IsInRange(this, enemy.tile))
         *  GameManager.instance.ProcessCommand(() =>
         *  {
         *      SkillFactory.GetSnipe().Perform(this, enemy.tile);
         *  });
         * else
         *  GameManager.instance.ProcessCommand(() => { });
         */
    }
 public void ManipulatePlayerSkills(SkillContainer skillContainer)
 {
     if (skillContainer == null)
     {
         _playerSkillsHolder.SwitchSkill(_playerStats.PlayerSkill);
         UpdateCurrentSkill();
     }
     else
     {
         if (_playerStats.SkillHolderCapacity > _playerSkillsHolder.GetPlayerSkillsCount())
         {
             _playerSkillsHolder.AddNewSkill(skillContainer.PlayerSkill);
         }
         else
         {
             CreateDroppedSkillItem(_playerSkillsHolder.SwapCurrentSkill(_playerStats.PlayerSkill, skillContainer.PlayerSkill), skillContainer.SkillGameObject);
             UpdateCurrentSkill();
         }
     }
 }
    void SetButton(int index, SkillContainer sc)
    {
        if (index >= buttons.Length)
            return;
        buttons[index].enabled = sc.IsCastable;
        buttons[index].image.color = sc.IsCastable ? Color.white : Color.grey;
        buttons[index].image.sprite = sc.skill.icon;
        buttons[index].transform.GetChild(0).GetComponent<Text>().text = sc.skill.name+"\n"+sc.skill.manaCost(unit);
        buttons[index].onClick.RemoveAllListeners();
        buttons[index].onClick.AddListener(() => {
            unit.StopAimingSkill();
            unit.SelectSkill(index);
            buttons[index].image.color = Color.white;
        });

        //set cooldown here
        //sc.cooldownproportion or whatever i called it gives you the amount to fill.
        buttons[index].transform.GetChild(1).GetComponent<Image>().fillAmount = 1 - sc.CooldownProportion;
        //buttons[index].transform.GetChild(0).GetComponent<Text>().color = sc.skill.CanCast(sc.user) ? Color.white : Color.red;
    }
    void SetButton(int index, SkillContainer sc)
    {
        if (index >= buttons.Length)
        {
            return;
        }
        buttons[index].enabled      = sc.IsCastable;
        buttons[index].image.color  = sc.IsCastable ? Color.white : Color.grey;
        buttons[index].image.sprite = sc.skill.icon;
        buttons[index].transform.GetChild(0).GetComponent <Text>().text = sc.skill.name + "\n" + sc.skill.manaCost(unit);
        buttons[index].onClick.RemoveAllListeners();
        buttons[index].onClick.AddListener(() => {
            unit.StopAimingSkill();
            unit.SelectSkill(index);
            buttons[index].image.color = Color.white;
        });

        //set cooldown here
        //sc.cooldownproportion or whatever i called it gives you the amount to fill.
        buttons[index].transform.GetChild(1).GetComponent <Image>().fillAmount = 1 - sc.CooldownProportion;
        //buttons[index].transform.GetChild(0).GetComponent<Text>().color = sc.skill.CanCast(sc.user) ? Color.white : Color.red;
    }
    public void Init()
    {
        XElement sc = SkillContainer.Load(path);

        SkillInfos = sc.Element("Skills").Elements("Skill").Select(c => new Skill().Set(c)).ToDictionary(info => info.id);
    }
Exemple #20
0
 void CommitSkillTarget()
 {
     if (!IsAimingSkill)
         return;
     if (GameManager.instance.selected == null ||
         !aimingSkill.skill.IsInRange(this, GameManager.instance.selected))
     {
         GameManager.instance.TilesInRangeSkill(tile, aimingSkill.skill.range, this, aimingSkill.skill);
         return;
     }
     if (aimingSkill.skill.aoe <= 0 && !aimingSkill.skill.ValidTile(this, GameManager.instance.selected)) {
         GameManager.instance.TilesInRangeSkill(tile, aimingSkill.skill.range, this, aimingSkill.skill);
         //GameManager.instance.cursor.transform.localScale = new Vector3((1 + aimingSkill.skill.aoe * 2), 1, (1 + aimingSkill.skill.aoe * 2));
         return;
     }
     GameManager.instance.cursor.transform.localScale = Vector3.one;
     GameManager.instance.ProcessCommand(() =>
     {
         aimingSkill.skill.Perform(this, GameManager.instance.selected);
         aimingSkill.cooldown = aimingSkill.skill.cooldown;
         aimingSkill = null;
     });
 }
Exemple #21
0
 public void StopAimingSkill()
 {
     GameManager.instance.cursor.transform.localScale = Vector3.one;
     if (!IsAimingSkill)
         return;
     aimingSkill = null;
     if (!hasMoved)
         CalculateReachableTiles();
     else
         GameManager.instance.TilesInRange(tile, 0, this);
 }
Exemple #22
0
 public void SelectSkill(int index)
 {
     if (!processingCommand)
         return;
     if (GameManager.instance.tasks.Count > 0)
         return;
     if (IsAimingSkill)
         return;
     if (index < 0 || index >= skillContainers.Count)
         return;
     SkillContainer s = skillContainers[index];
     if (!s.IsCastable)
         return;
     aimingSkill = s;
     GameManager.instance.TilesInRangeSkill(tile, s.skill.range,this, s.skill);
     GameManager.instance.cursor.transform.localScale = new Vector3((1 + s.skill.aoe*2), 1, (1 + s.skill.aoe*2));
 }
Exemple #23
0
 private void OnTriggerExit2D(Collider2D other)
 {
     _nearestPlayerSkill = null;
 }
Exemple #24
0
 private void OnTriggerEnter2D(Collider2D other)
 {
     _nearestPlayerSkill = other.GetComponent <SkillContainer>();
 }