Beispiel #1
0
        /// <summary>
        /// コンスラクタ
        /// </summary>
        /// <param name="datas">csvによるstring配列</param>
        public ActiveSkillSetBuilder(string[] datas)
        {
            id   = int.Parse(datas[0]);
            name = datas [1];

            normalSkillId   = int.Parse(datas [2]);
            normalSkillType = (ActiveSkillType)Enum.Parse(typeof(ActiveSkillType), datas[3]);

            cautionSkillId   = int.Parse(datas[4]);
            cautionSkillType = (ActiveSkillType)Enum.Parse(typeof(ActiveSkillType), datas [5]);

            dangerSkillId   = int.Parse(datas[6]);
            dangerSkillType = (ActiveSkillType)Enum.Parse(typeof(ActiveSkillType), datas[7]);

            powerSkillId   = int.Parse(datas [8]);
            powerSkillType = (ActiveSkillType)Enum.Parse(typeof(ActiveSkillType), datas[9]);

            fullPowerSkillId   = int.Parse(datas[10]);
            fullPowerSkillType = (ActiveSkillType)Enum.Parse(typeof(ActiveSkillType), datas[11]);

            supportSkillId   = int.Parse(datas[12]);
            supportSkillType = (ActiveSkillType)Enum.Parse(typeof(ActiveSkillType), datas [13]);

            healSkillId   = int.Parse(datas[14]);
            healSkillType = (ActiveSkillType)Enum.Parse(typeof(ActiveSkillType), datas [15]);

            moveSkillId   = int.Parse(datas[16]);
            moveSkillType = (ActiveSkillType)Enum.Parse(typeof(ActiveSkillType), datas[17]);
        }
Beispiel #2
0
        /// <summary>
        /// コンストラクタ
        /// </summary>
        /// <param name="parameters">csvによるstring配列データ</param>
        public Job(string[] parameters)
        {
            ID    = int.Parse(parameters[0]);
            NAME  = parameters [1];
            LEVEL = int.Parse(parameters[2]);
            MFT   = int.Parse(parameters[3]);
            FFT   = int.Parse(parameters[4]);
            MGP   = int.Parse(parameters[5]);
            PHY   = int.Parse(parameters[6]);
            AGI   = int.Parse(parameters[7]);
            DEX   = int.Parse(parameters[8]);
            SPC   = int.Parse(parameters[9]);

            DESCRIPTION = parameters[10];
            FLAVOR_TEXT = parameters[11];

            int index = 12;

            for (; parameters[index] != "end"; index += 2)
            {
                ActiveSkillType type    = (ActiveSkillType)Enum.Parse(typeof(ActiveSkillType), parameters[index]);
                var             skillId = int.Parse(parameters[index + 1]);
                activeSkillIds.Add(new KeyValuePair <ActiveSkillType, int>(type, skillId));
            }
            index++;

            for (; parameters[index] != "end"; index++)
            {
                var id = int.Parse(parameters[index]);
                reactionSkillIds.Add(id);
            }
        }
Beispiel #3
0
                          public void activateSkill(IPlayable player)
                          {
                              if (SKILL_TYPE == "NONE")
                              {
                                  return;
                              }

                              var activeNames = Enum.GetNames(typeof(ActiveSkillType));

                              foreach (string name in activeNames)
                              {
                                  if (name == SKILL_TYPE)
                                  {
                                      ActiveSkillType type  = (ActiveSkillType)Enum.Parse(typeof(ActiveSkillType), SKILL_TYPE);
                                      IActiveSkill    skill = ActiveSkillSupporter.getActiveSkill(type, SKILL_ID);
                                      player.addSkill(skill);
                                      return;
                                  }
                              }

                              if (SKILL_TYPE == "REACTION")
                              {
                                  player.addSkill(ReactionSkillMasterManager.getInstance().getReactionSkillFromId(SKILL_ID));
                                  return;
                              }

                              throw new InvalidProgramException("SkillType " + SKILL_TYPE + "wan't found");
                          }
Beispiel #4
0
        public bool hasActiveSkill(int id, ActiveSkillType activeType)
        {
            var skills = player.getActiveSkills();

            switch (activeType)
            {
            case ATTACK:
                var targetAttackSkill = AttackSkillMasterManager.getInstance().getAttackSkillFromId(id);
                return(skills.Contains(targetAttackSkill));

            case BUF:
                var targetBufSkill = BufSkillMasterManager.getInstance().getBufSkillFromId(id);
                return(skills.Contains(targetBufSkill));

            case DEBUF:
                var targetDebufSkill = DebufSkillMasterManager.getInstance().getDebufSkillFromId(id);
                return(skills.Contains(targetDebufSkill));

            case HEAL:
                var targetHealSkill = HealSkillMasterManager.getInstance().getHealSkillFromId(id);
                return(skills.Contains(targetHealSkill));

            case MOVE:
                var targetMoveSkill = MoveSkillMasterManager.getInstance().getMoveSkillFromId(id);
                return(skills.Contains(targetMoveSkill));
            }

            throw new NotSupportedException("unkown activeSkillType");
        }
        /// <summary>
        /// 対象がAffectSkillかを判定します
        /// AffectSkillとは、IActiveSkillの中でも、スキル対象が存在するスキルをさします
        /// 例えば、MoveSkillは対象が存在しないため、AffectSkillではありません
        /// </summary>
        /// <returns><c>true</c>, AffectSkill <c>false</c> AffectSkillでない</returns>
        /// <param name="skill">判定したいスキル</param>
        public static bool isAffectSkill(IActiveSkill skill)
        {
            ActiveSkillType type        = skill.getActiveSkillType();
            bool            needsTarget = (
                type == ActiveSkillType.ATTACK ||
                type == ActiveSkillType.BUF ||
                type == ActiveSkillType.DEBUF ||
                type == ActiveSkillType.HEAL
                );

            return(needsTarget);
        }
Beispiel #6
0
 public SkillBook(SkillBookBuilder builder)
 {
     SKILL_ID         = builder.SkillId;
     SKILL_TYPE       = builder.SkillType;
     NAME             = builder.Name;
     DESCRIPTION      = builder.Description;
     FLAVOR_TEXT      = builder.FlavorText;
     ITEM_VALUE       = builder.ItemValue;
     MASS             = builder.Mass;
     IS_REACTIONSKILL = builder.IsReactionSkill;
     LEVEL            = builder.Level;
 }
Beispiel #7
0
 public SkillBook getActiveSkillBookFromTypeAndId(int id, ActiveSkillType skillType)
 {
     foreach (var builder in dataTable)
     {
         if (!builder.IsReactionSkill)
         {
             if (builder.SkillType == skillType && builder.SkillId == id)
             {
                 return(builder.build());
             }
         }
     }
     throw new System.ArgumentException("actionSkill you want couldn't be found");
 }
Beispiel #8
0
        /// <summary>
        /// 与えられたデータからIActiveSkillを探して返します
        /// </summary>
        /// <returns> 結果 </returns>
        /// <param name="id"> スキルのID </param>
        /// <param name="type"> スキルの種別 </param>
        private IActiveSkill searchAndGetBuilder(int id, ActiveSkillType type)
        {
            switch (type)
            {
            case ActiveSkillType.ATTACK:
                return(AttackSkillMasterManager.getInstance().getAttackSkillFromId(id));

            case ActiveSkillType.BUF:
                return(BufSkillMasterManager.getInstance().getBufSkillFromId(id));

            case ActiveSkillType.DEBUF:
                return(DebufSkillMasterManager.getInstance().getDebufSkillFromId(id));

            case ActiveSkillType.HEAL:
                return(HealSkillMasterManager.getInstance().getHealSkillFromId(id));

            case ActiveSkillType.MOVE:
                return(MoveSkillMasterManager.getInstance().getMoveSkillFromId(id));
            }
            throw new NotSupportedException("Unkonwn SkillType");
        }
Beispiel #9
0
    public SkillBookBuilder(ISkill skill)
    {
        skillId     = skill.getId();
        name        = skill.getName() + "のスキル書";
        description = name + "の知識が書かれた魔法の書";
        flavorText  = skill.getFlavorText();

        itemValue = skill.getLevel() * 30;
        mass      = skill.getLevel() / 5 + 1;
        level     = skill.getLevel();

        if (skill is ReactionSkill)
        {
            isReactionSkill = true;
        }
        else
        {
            var activeSkill = (IActiveSkill)skill;
            skillType       = activeSkill.getActiveSkillType();
            isReactionSkill = false;
        }
    }
        public static IActiveSkill getActiveSkill(ActiveSkillType type, int id)
        {
            switch (type)
            {
            case ActiveSkillType.ATTACK:
                return(AttackSkillMasterManager.getInstance().getAttackSkillFromId(id));

            case ActiveSkillType.BUF:
                return(BufSkillMasterManager.getInstance().getBufSkillFromId(id));

            case ActiveSkillType.DEBUF:
                return(DebufSkillMasterManager.getInstance().getDebufSkillFromId(id));

            case ActiveSkillType.HEAL:
                return(HealSkillMasterManager.getInstance().getHealSkillFromId(id));

            case ActiveSkillType.MOVE:
                return(MoveSkillMasterManager.getInstance().getMoveSkillFromId(id));

            default: throw new NotSupportedException("unkonwn skillType " + type);
            }
        }