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");
}
/// <summary>
/// 効果範囲が範囲のスキルの対象を決定します
/// </summary>
/// <returns>対象のキャラクターのリスト</returns>
/// <param name="useSkill">使用するスキル</param>
private FieldPosition decideHostileAreaTarget(IActiveSkill useSkill)
{
int range = ActiveSkillSupporter.searchRange(useSkill, user);
Dictionary <FieldPosition, int> areaDangerLevelTable = BattleManager.getInstance().getRawAreaDangerLevelTableInRange(user, range);
var keys = areaDangerLevelTable.Keys;
int sumDangerLevel = 0;
foreach (FieldPosition pos in keys)
{
sumDangerLevel += areaDangerLevelTable[pos];
}
//最終判定：レベルが高いところへ
int rand = UnityEngine.Random.Range(0, sumDangerLevel);
foreach (FieldPosition pos in keys)
{
if (areaDangerLevelTable[pos] <= rand)
{
return(pos);
}
else
{
rand -= areaDangerLevelTable[pos];
}
}
throw new InvalidOperationException("cannot decide areaTarget");
}
/// <summary>
/// 自分から出すターゲットラインを更新します
/// </summary>
private void updateTargetLine()
{
if (tasks.Count <= 0)
{
return;
}
BattleTask task = tasks[0];
if (task.getIsSkill())
{
IActiveSkill useSkill = task.getSkill();
if (ActiveSkillSupporter.isAffectSkill(useSkill))
{
List <IBattleable> targets = task.getTargets();
drawTargetingLine(player, targets, useSkill.getName(), useSkill.isFriendly());
}
}
else
{
List <IBattleable> targets = task.getTargets();
var item = task.getItem();
drawTargetingLine(player, targets, item.getName(), true);
}
}
/// <summary>
/// 効果範囲が単体のスキルの対象を決定します
/// </summary>
/// <returns>対象となったキャラクター</returns>
/// <param name="useSkill">使用するスキル</param>
private IBattleable decideHostileSingleTarget(IActiveSkill useSkill)
{
//レベルを合計する
int sumLevel = 0;
List <IBattleable> hostalityTargets = new List <IBattleable>();
var targets = BattleManager.getInstance().getCharacterInRange(user, ActiveSkillSupporter.searchRange(useSkill, user));
foreach (IBattleable target in targets)
{
if (target.isHostility(user.getFaction()))
{
hostalityTargets.Add(target);
sumLevel += target.getLevel();
}
}
//最終判定：計算可能な形式の変数にする
Dictionary <int, int> levelTable = new Dictionary <int, int>();
for (int i = 0; i < hostalityTargets.Count; i++)
{
levelTable.Add(i, hostalityTargets[i].getLevel());
}
return(hostalityTargets[MathHelper.getRandomKeyLowerOrderProbality(levelTable)]);
throw new InvalidOperationException("Cannot decideHostileSingleTarget.");
}
/// <summary>
/// 移動が存在する場合のコンストラクタ
/// </summary>
/// <param name="uniqueId">タスクの実行者のユニークID</param>
/// <param name="skill">タスクが実行するスキル</param>
/// <param name="move">移動量</param>
/// <param name="id">タスクID</param>
public BattleTask(long uniqueId, IActiveSkill skill, int move, long id)
{
this.OWNER_UNIQUEID = uniqueId;
this.skill = skill;
this.NAME = skill.getName();
this.move = move;
this.ID = id;
isSkill = true;
}
public BattleTask(long uniqueId, IActiveSkill skill, FieldPosition targetPos, long id)
{
this.OWNER_UNIQUEID = uniqueId;
this.skill = skill;
this.NAME = skill.getName();
this.ID = id;
this.targetPos = targetPos;
isSkill = true;
}
/// <summary>
/// ターゲットが存在する場合のコンストラクタ
/// </summary>
/// <param name="uniqueId">タスクの実行者のユニークID</param>
/// <param name="skill">タスクが実行するスキル</param>
/// <param name="id">タスクID</param>
public BattleTask(long uniqueId, IActiveSkill skill, List <IBattleable> targets, long id)
{
this.OWNER_UNIQUEID = uniqueId;
this.skill = skill;
this.NAME = skill.getName();
this.ID = id;
this.targets = targets;
isSkill = true;
}
public void addSkill(IActiveSkill skill)
{
if (skill != null || !activeSkills.Contains(skill))
{
activeSkills.Add(skill);
}
else
{
throw new ArgumentException("invalid activeSkill");
}
}
/// <summary>
/// タスクを追加します
/// </summary>
/// <param name="addedTask">Add task.</param>
private void addTask(BattleTask addedTask)
{
Debug.Log("added " + addedTask.getName());
tasks.Add(addedTask);
listView.setTask(addedTask);
battletaskIdCount++;
chosenActiveSkill = null;
inputActiveSkillList();
}
/// <summary>
/// 友好的なスキルの対象を決定します
/// </summary>
/// <returns>スキルの対象のリスト</returns>
/// <param name="useSkill">使用するスキル</param>
private IBattleable decideFriendlySingleTarget(IActiveSkill useSkill)
{
switch (useSkill.getActiveSkillType())
{
case ActiveSkillType.HEAL:
return(decideHealSingleTarget((HealSkill)useSkill));
case ActiveSkillType.BUF:
return(decideBufSingleTarget((BufSkill)useSkill));
}
throw new ArgumentException("invalid type of skill");
}
private FieldPosition decideAreaFriendlyTarget(IActiveSkill useSkill)
{
switch (useSkill.getActiveSkillType())
{
case ActiveSkillType.HEAL:
return(decideAreaHealTarget((HealSkill)useSkill));
case ActiveSkillType.BUF:
return(decideAreaBufTarget((BufSkill)useSkill));
}
throw new ArgumentException("invalid type of skill");
}
/// <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);
}
/// <summary>
/// 渡されたIActiveSkillからmoveを検出します
/// </summary>
/// <returns> 検出したmove</returns>
/// <param name="skill"> 検索したいIActiveSkill </param>
public static int searchMove(IActiveSkill skill, IBattleable actoiner)
{
if (skill.getActiveSkillType() == ActiveSkillType.MOVE)
{
MoveSkill moveSkill = (MoveSkill)skill;
return(moveSkill.getMove(actoiner));
}
else
{
throw new ArgumentException("invalid skill " + skill);
}
}
public Archer(
string id,
string name,
int healthPoints,
int manaPoints,
IDamage damage,
IActiveSkill activeSkill)
: base(id, name, healthPoints, damage)
{
_activeAttackModule = new DefaultAttackModule(activeSkill);
ManaPoints = manaPoints;
ActiveSkill = activeSkill;
}
/// <summary>
/// BattleTaskを生成します
/// </summary>
/// <returns>生成したタスク</returns>
private BattleTask creatTask()
{
if (!isReady)
{
throw new InvalidOperationException("manager hasn't readied yet");
}
IActiveSkill skill = ai.decideSkill();
if (ActiveSkillSupporter.isAffectSkill(skill))
{
Extent extent = ActiveSkillSupporter.searchExtent(skill);
BattleTask returnTask;
//効果範囲に応じてタスクを生成
switch (extent)
{
case Extent.SINGLE:
IBattleable target = ai.decideSingleTarget(skill);
List <IBattleable> singleTargetList = new List <IBattleable>()
{
target
};
returnTask = new BattleTask(user.getUniqueId(), skill, singleTargetList, battletaskIdCount);
break;
case Extent.AREA:
FieldPosition pos = ai.decideAreaTarget(skill);
returnTask = new BattleTask(user.getUniqueId(), skill, pos, battletaskIdCount);
break;
case Extent.ALL:
List <IBattleable> allTargetList = BattleManager.getInstance().getJoinedBattleCharacter();
returnTask = new BattleTask(user.getUniqueId(), skill, allTargetList, battletaskIdCount);
break;
default: throw new NotSupportedException("unkonwn extent");
}
battletaskIdCount++;
return(returnTask);
}
else if (skill.getActiveSkillType() == ActiveSkillType.MOVE)
{
MoveSkill moveSkill = (MoveSkill)skill;
int move = ai.decideMove(moveSkill);
BattleTask returnTask = new BattleTask(user.getUniqueId(), skill, move, battletaskIdCount);
battletaskIdCount++;
return(returnTask);
}
throw new InvalidOperationException("unknown skillType");
}
public ArcherCaptain(
string id,
string name,
int healthPoints,
int manaPoints,
IDamage damage,
IActiveSkill activeSkill,
IArmor armor)
: base(id, name, healthPoints, manaPoints, damage, activeSkill)
{
AttackHandlers.Add(armor);
ArmorPoints = armor.ArmorPoints;
}
public FieldPosition decideAreaTarget(IActiveSkill useSkill)
{
if (!ActiveSkillSupporter.isAffectSkill(useSkill))
{
throw new ArgumentException("the skill " + useSkill + " dosen't has to decide target.");
}
if (ActiveSkillSupporter.searchExtent(useSkill) != Extent.AREA)
{
throw new ArgumentException("the skill " + useSkill + " isn't a skill for single");
}
if (useSkill.isFriendly())
{
return(this.decideAreaFriendlyTarget(useSkill));
}
else
{
return(this.decideHostileAreaTarget(useSkill));
}
}
/// <summary>
/// スキルの対象を決定します
/// </summary>
/// <returns>対象のリスト</returns>
/// <param name="useSkill">使用するスキル</param>
public IBattleable decideSingleTarget(IActiveSkill useSkill)
{
if (!ActiveSkillSupporter.isAffectSkill(useSkill))
{
throw new ArgumentException("the skill " + useSkill + " dosen't has to decide target.");
}
if (ActiveSkillSupporter.searchExtent(useSkill) != Extent.SINGLE)
{
throw new ArgumentException("the skill " + useSkill + " isn't a skill for single");
}
if (useSkill.isFriendly())
{
return(this.decideFriendlySingleTarget(useSkill));
}
else
{
return(this.decideHostileSingleTarget(useSkill));
}
}
/// <summary>
/// skillNodeが選択された時の処理
/// </summary>
/// <param name="chosenSkill">選択されたIActiveSkill</param>
public void skillChose(IActiveSkill chosenSkill)
{
this.chosenActiveSkill = chosenSkill;
if (ActiveSkillSupporter.isAffectSkill(chosenSkill))
{
Extent extent = ActiveSkillSupporter.searchExtent(chosenSkill);
int range = ActiveSkillSupporter.searchRange(chosenSkill, player);
inputTargetList(extent, range);
}
else if (chosenSkill.getActiveSkillType() == ActiveSkillType.MOVE)
{
int move = ActiveSkillSupporter.searchMove(chosenSkill, player);
inputMoveAreaList(move);
}
else
{
throw new NotSupportedException("Unkonwn skillType");
}
}
/// <summary>
/// 与えられたIActiveSkillからExtentプロパティを取得します
/// </summary>
/// <returns> 検出したExtent ない場合はNONEを返します </returns>
/// <param name="skill"> 検索したいIActiveSkill </param>
public static Extent searchExtent(IActiveSkill skill)
{
switch (skill.getActiveSkillType())
{
case ActiveSkillType.ATTACK:
AttackSkill attackSkill = (AttackSkill)skill;
return(attackSkill.getExtent());
case ActiveSkillType.HEAL:
HealSkill healSkill = (HealSkill)skill;
return(healSkill.getExtent());
case ActiveSkillType.BUF:
BufSkill bufSkill = (BufSkill)skill;
return(bufSkill.getExtent());
case ActiveSkillType.DEBUF:
DebufSkill debufSkill = (DebufSkill)skill;
return(debufSkill.getExtent());
}
throw new ArgumentException("invalid skill " + skill);
}
/// <summary>
/// ステートがACTIONの時に毎フレーム行う処理
/// </summary>
private void actionState()
{
BattleTask runTask = tasks[0];
Debug.Log("run " + runTask.getName());
if (runTask.getIsSkill())
{
IActiveSkill runSkill = runTask.getSkill();
runSkill.action(player, runTask);
if (ActiveSkillSupporter.isAffectSkill(runSkill))
{
Debug.Log("into isAffect");
deleteTargetingLine(player);
}
}
else
{
IItem runItem = runTask.getItem();
player.getInventory().useItem(runItem, player);
}
tasks.Remove(runTask);
battleState = BattleState.IDLE;
}
/// <summary>
/// 与えられたAffectSkillが、その使用者によって対象に使用できるかを判定します
/// </summary>
/// <returns><c>true</c>, 使用可能, <c>false</c> 使用不可</returns>
/// <param name="actioner">スキル使用者</param>
/// <param name="targets">スキル対象</param>
/// <param name="skill">使用するスキル AffectSkillである必要があります</param>
public static bool canUseAffectSkill(IBattleable actioner, List <IBattleable> targets, IActiveSkill skill)
{
if (!isAffectSkill(skill))
{
throw new ArgumentException("gave skill isn't an affectSkill");
}
//スキル使用者のMPが足りるか
if (actioner.getMp() < skill.getCost())
{
return(false);
}
//スキル使用対象はちゃんと存在するか
if (targets.Count <= 0)
{
return(false);
}
//スキル使用対象まで射程が届くか
int actionerPos = (int)BattleManager.getInstance().searchCharacter(actioner);
int targetPos = (int)BattleManager.getInstance().searchCharacter(targets[0]);
int distance = (actionerPos < targetPos) ? targetPos - actionerPos : actionerPos - targetPos;
if (distance > searchRange(skill, actioner))
{
return(false);
}
//以上が満たされればtrue
return(true);
}
public IActiveSkill decideSkill()
{
//ボーナス値のテーブルです。最終的に足されます。
Dictionary <ActiveSkillCategory, int> probalityBonus = new Dictionary <ActiveSkillCategory, int>()
{
{ ActiveSkillCategory.NORMAL, 0 },
{ ActiveSkillCategory.CAUTION, 0 },
{ ActiveSkillCategory.DANGER, 0 },
{ ActiveSkillCategory.POWER, 0 },
{ ActiveSkillCategory.FULL_POWER, 0 },
{ ActiveSkillCategory.SUPPORT, 0 },
{ ActiveSkillCategory.HEAL, 0 },
{ ActiveSkillCategory.MOVE, 0 }
};
//div0を防ぐための処理
int maxMp = (user.getMaxMp() > 0) ? user.getMaxMp() : 1;
//HPが50%以下の場合、caution可能性値を+20します
if (this.user.getHp() / maxMp <= 0.5f)
{
probalityBonus[ActiveSkillCategory.CAUTION] += 20;
}
//HPが20%以下の場合、danger可能性値を+30します
if (this.user.getHp() / maxMp <= 0.2f)
{
probalityBonus[ActiveSkillCategory.DANGER] += 30;
}
//HPが70%以下の場合、攻撃する可能性値を-5、移動する可能性を+10します
if (this.user.getHp() / maxMp <= 0.7f)
{
probalityBonus[ActiveSkillCategory.NORMAL] -= 5;
probalityBonus[ActiveSkillCategory.POWER] -= 5;
probalityBonus[ActiveSkillCategory.FULL_POWER] -= 5;
probalityBonus[ActiveSkillCategory.MOVE] += 10;
}
List <ActiveSkillCategory> categories = new List <ActiveSkillCategory>(probalityBonus.Keys);
//スキルの射程内に何もいない、またはコスト外の時、ボーナス値を使って可能性値を0にします。
foreach (ActiveSkillCategory category in categories)
{
IActiveSkill categorySkill = activeSkills.getSkillFromSkillCategory(category);
if (!ActiveSkillSupporter.isAffectSkill(categorySkill))
{
continue;
}
int range = ActiveSkillSupporter.searchRange(categorySkill, user);
bool isInRange = BattleManager.getInstance().sumFromAreaTo(user, range) > 0;
bool canUse = categorySkill.getCost() <= user.getMp();
if (!isInRange || !canUse)
{
probalityBonus[category] = -1 * probalityTable[category];
}
}
//基礎値 + ボーナス値が負の値の場合、可能性値が0になるように設定し直します
foreach (ActiveSkillCategory category in categories)
{
if (probalityTable[category] + probalityBonus[category] < 0)
{
probalityBonus[category] = -1 * probalityTable[category];;
}
}
//可能性値を合計します
int sum = 0;
foreach (ActiveSkillCategory category in categories)
{
sum += probalityTable[category] + probalityBonus[category];
}
//合計が0の場合、攻撃不可と判断して移動します
if (sum <= 0)
{
return(activeSkills.getSkillFromSkillCategory(ActiveSkillCategory.MOVE));
}
//乱数でスキルを選択します
int choose = UnityEngine.Random.Range(0, sum);
foreach (ActiveSkillCategory category in categories)
{
int probality = probalityTable[category] + probalityBonus[category];
if (choose < probality)
{
return(activeSkills.getSkillFromSkillCategory(category));
}
choose -= probalityTable[category] + probalityBonus[category];
}
throw new InvalidOperationException("exception state");
}
/// <summary>
/// 初期設定をします
/// </summary>
/// <param name="manager"> 情報を取得するPlayerBattleTaskManager </param>
/// <param name="skill"> 担当するスキル </param>
public void setState(PlayerBattleTaskManager manager, IActiveSkill skill)
{
this.manager = manager;
this.skill = skill;
textObject.text = skill.getName();
}
// Constructor
public PlayerViewModel(IBasePoints basePoints, IPlayerStat playerStat)
{
this.BasePoints = basePoints;
this.PlayerStat = playerStat;
this.Skills = new ObservableCollection <IActiveSkill>();
this.Advantages = new ObservableCollection <IActiveAdvantage>();
this.Disadvantages = new ObservableCollection <IActiveDisadvantage>();
AddAttributeCommand = new DelegateCommand(PlayerStat.AddAttribute, null);
SubAttributeCommand = new DelegateCommand(PlayerStat.SubAttribute, null);
Scope = IoCContainer.Container.BeginLifetimeScope();
AddSkillCommand = new DelegateCommand(
x => {
Skills.Add(Scope.Resolve <IActiveSkill>());
AddSkillCommand.OnCanExecuteChanged();
},
x => AddSkillCanExecute()
);
RemoveSkillCommand = new DelegateCommand(
x => {
var SelectedItem = Scope.Resolve <ISelectedItem>();
IActiveSkill z = Skills.First(p => p.Skill.Name == SelectedItem.SelectedSkillRemove.Skill.Name);
BasePoints.UsedPoints -= z.Cost;
RemoveSkillCommand.OnCanExecuteChanged();
Skills.Remove(SelectedItem.SelectedSkillRemove);
},
x => Scope.Resolve <ISelectedItem>().SelectedSkillRemove != null);
AddAdvantageCommand = new DelegateCommand(
x => {
IActiveAdvantage z = Scope.Resolve <IActiveAdvantage>();
if (z.Advantage.PtPerLvl > BasePoints.UnspentPoints)
{
return;
}
Advantages.Add(z);
BasePoints.UsedPoints += z.Advantage.PtPerLvl;
AddAdvantageCommand.OnCanExecuteChanged();
},
x => AddAdvantageCanExecute()
);
RemoveAdvantageCommand = new DelegateCommand(
x => {
var SelectedItem = Scope.Resolve <ISelectedItem>();
IActiveAdvantage z = Advantages.First(p => p.Advantage.Name == SelectedItem.SelectedAdvantageRemove.Advantage.Name);
BasePoints.UsedPoints -= z.Cost;
RemoveAdvantageCommand.OnCanExecuteChanged();
Advantages.Remove(SelectedItem.SelectedAdvantageRemove);
},
x => Scope.Resolve <ISelectedItem>().SelectedAdvantageRemove != null
);
AddDisadvantageCommand = new DelegateCommand(
x => {
IActiveDisadvantage z = Scope.Resolve <IActiveDisadvantage>();
if ((z.Disadvantage.PtCost + BasePoints.UsedDisadvantagePoints) < BasePoints.MaxDisadvantagePoints)
{
return;
}
Disadvantages.Add(z);
BasePoints.UsedDisadvantagePoints += z.Disadvantage.PtCost;
AddDisadvantageCommand.OnCanExecuteChanged();
},
x => AddDisadvantageCanExecute()
);
RemoveDisadvantageCommand = new DelegateCommand(
x => {
var SelectedItem = Scope.Resolve <ISelectedItem>();
IActiveDisadvantage z = Disadvantages.First(p => p.Disadvantage.Name == SelectedItem.SelectedDisadvantageRemove.Disadvantage.Name);
BasePoints.UsedDisadvantagePoints -= z.Cost;
RemoveDisadvantageCommand.OnCanExecuteChanged();
Disadvantages.Remove(SelectedItem.SelectedDisadvantageRemove);
},
x => Scope.Resolve <ISelectedItem>().SelectedDisadvantageRemove != null
);
}
