private static int getWeakness(FullCombatCharacter fcc)
{
int weakness = fcc.hp;
if (fcc.hp <= 0)
{
weakness = int.MaxValue;
}
if (ModificationsGeneration.BasicModificationsGeneration.hasMod(fcc, "Guard"))
{
weakness = weakness * 2;
}
if (ModificationsGeneration.BasicModificationsGeneration.hasMod(fcc, "Ranged"))
{
weakness = (int)(weakness * 3.5f);
}
if (ModificationsGeneration.BasicModificationsGeneration.hasMod(fcc, "Reckless"))
{
weakness = weakness / 4;
}
return(weakness);
}
private ProcessResult PreProcess(FullCombatCharacter source, List <FullCombatCharacter> target, CombatData combatData, List <IEffect> effects)
{
//Determine if it's a valid skill or on cooldown etc
if (source.classLevel < requiredClassLevel || combatData.hasCooldown(source.name, cooldown) || target.Count > maxTargets)
{
return(ProcessResult.EndTurn);
}
if (BasicModificationsGeneration.hasMod(source, "Ranged"))
{
damageCoefficient = damageCoefficient * .75f;
if (!ranged)
{
effects.Add(new Effect(EffectTypes.Message, 0, "Using a melee attack has removed the ranged advantage!", 0));
CombatCalculator.removeRanged(source);
}
}
if (oncePerRest != string.Empty && source.usedAbilities.Contains(oncePerRest))
{
return(ProcessResult.EndTurn);
}
return(ProcessResult.Normal);
}
private ProcessResult PostProcess(FullCombatCharacter source, List <FullCombatCharacter> target, CombatData combatData, List <IEffect> effects)
{
//Set next attack time etc.
if (cooldown != string.Empty)
{
combatData.cooldowns.Add(new CooldownModel
{
character = source.name,
name = cooldown,
time = (source.nextAttackTime + cooldownDuration)
});
}
GeneralProcessor.calculateNextAttackTime(source, attackTimeCoefficient, combatData);
if (oncePerRest != string.Empty)
{
source.usedAbilities.Add(oncePerRest);
}
if (mpCost != 0)
{
source.mp = source.mp - mpCost;
}
return(ProcessResult.Normal);
}
public List <ICommand> getClassCommands(FullCombatCharacter source, CombatData combatData)
{
List <ICommand> commands = new List <ICommand>();
int level = source.classLevel;
commands.Add(new Command(false, new List <ICommand>(), false, 0, 0, "Glance", false, 0, true, isDisabled("Glance", source, combatData)));
if (level >= 3)
{
commands.Add(new Command(false, new List <ICommand>(), false, 0, 0, "Guarded Strike", false, 0, true, isDisabled("Guarded Strike", source, combatData)));
}
if (level >= 5)
{
commands.Add(new Command(false, new List <ICommand>(), false, 0, 0, "Reckless Hit", false, 0, true, isDisabled("Reckless Hit", source, combatData)));
}
if (level >= 7)
{
commands.Add(new Command(false, new List <ICommand>(), false, 0, 0, "Guided Strike", false, 0, true, isDisabled("Guided Strike", source, combatData)));
}
if (level >= 9)
{
commands.Add(new Command(false, new List <ICommand>(), false, 0, 0, "Throw Rock", false, 0, true, isDisabled("Throw Rock", source, combatData)));
}
if (level >= 15)
{
commands.Add(new Command(false, new List <ICommand>(), false, 0, 0, "First Strike", false, 0, true, isDisabled("First Strike", source, combatData)));
}
return(commands);
}
public static bool isDisabled(string abilityName, FullCombatCharacter source, CombatData combatData)
{
if (processors.ContainsKey(source.className))
{
return(processors[source.className].isDisabled(abilityName, source, combatData));
}
return(false);
}
public static List <ICommand> getClassCommands(FullCombatCharacter source, CombatData combatData)
{
if (processors.ContainsKey(source.className))
{
return(processors[source.className].getClassCommands(source, combatData));
}
return(new List <ICommand>());
}
public static List <IEffect> getCommand(FullCombatCharacter source, List <FullCombatCharacter> targets, CombatData combatData)
{
if (source.className == "Goblin")
{
return(Goblins.GoblinAbilityProcessing.getCommand(source, targets, combatData));
}
return(new List <IEffect>());
}
private ProcessResult processFunction(Func <FullCombatCharacter, List <FullCombatCharacter>, CombatData, List <IEffect>, AbilityInfo, ProcessResult> executingFunction,
FullCombatCharacter source,
List <FullCombatCharacter> targets,
CombatData combatData,
List <IEffect> effects)
{
if (executingFunction != null)
{
return(executingFunction(source, targets, combatData, effects, this));
}
return(ProcessResult.Normal);
}
public bool isDisabled(string abilityName, FullCombatCharacter source, CombatData combatData)
{
if (abilityName == "First Strike")
{
if (!combatData.isFirstTurn(source.name))
{
return(true);
}
}
return(false);
}
public static bool hasMod(FullCombatCharacter fcc, string modName)
{
foreach (CombatModificationsModel cmm in fcc.mods)
{
if (cmm.name == modName)
{
return(true);
}
}
return(false);
}
//Basic Goblin, only attacks
public static List <IEffect> getCommand(FullCombatCharacter source, List <FullCombatCharacter> targets, CombatData combatData)
{
List <IEffect> effects = new List <IEffect>();
FullCombatCharacter target = BasicAbilityProcessing.identifyWeakestTarget(targets);
int dmg = (int)((source.strength * 5 / target.vitality));
target.inflictDamage(ref dmg);
effects.Add(new Effect(EffectTypes.DealDamage, target.combatUniq, string.Empty, dmg));
effects.Add(new Effect(EffectTypes.Message, 0, source.name + " has attacked " + target.name + " for " + dmg.ToString() + " damage!", 0));
GeneralProcessor.calculateNextAttackTime(source, 1.0f);
return(effects);
}
public static FullCombatCharacter identifyWeakestTarget(List <FullCombatCharacter> characters)
{
FullCombatCharacter currentCharacter = characters[0];
foreach (FullCombatCharacter fcc in characters)
{
if (fcc.hp < currentCharacter.hp)
{
currentCharacter = fcc;
}
}
return(currentCharacter);
}
private ProcessResult Process(FullCombatCharacter source, List <FullCombatCharacter> target, CombatData combatData, List <IEffect> effects)
{
//Deal damage etc.
foreach (FullCombatCharacter t in target)
{
int dmg = 0;
if (damageType == DamageType.Physical)
{
dmg = (int)((CombatCalculator.getNormalAttackValue(source) * damageCoefficient * damageMultiplier / t.vitality));
for (int i = 0; i < hits; i++)
{
if (t.inflictDamage(ref dmg) == FullCombatCharacter.HitEffect.Unbalance)
{
attackTimeCoefficient = attackTimeCoefficient * 2;
}
}
effects.Add(new Effect(EffectTypes.DealDamage, t.combatUniq, string.Empty, dmg));
string newMessage = message.Replace("{Name}", source.name)
.Replace("{Target}", t.name)
.Replace("{Damage}", dmg.ToString())
.Replace("{HitCount}", hits.ToString());
if (newMessage != string.Empty)
{
effects.Add(new Effect(EffectTypes.Message, 0, newMessage, 0));
}
}
else if (damageType == DamageType.Magical)
{
dmg = (int)((CombatCalculator.getMagicAttackValue(source) * damageCoefficient * damageMultiplier / t.wisdom));
for (int i = 0; i < hits; i++)
{
t.inflictDamage(ref dmg);
}
effects.Add(new Effect(EffectTypes.DealDamage, t.combatUniq, string.Empty, dmg));
string newMessage = message.Replace("{Name}", source.name)
.Replace("{Target}", t.name)
.Replace("{Damage}", dmg.ToString())
.Replace("{HitCount}", hits.ToString());
if (newMessage != string.Empty)
{
effects.Add(new Effect(EffectTypes.Message, 0, newMessage, 0));
}
}
}
return(ProcessResult.Normal);
}
public static FullCombatCharacter identifyWeakestTarget(List <FullCombatCharacter> characters)
{
FullCombatCharacter currentCharacter = characters[0];
int currentWeakLevel = getWeakness(currentCharacter);
foreach (FullCombatCharacter fcc in characters)
{
int newWeakLevel = getWeakness(fcc);
if (newWeakLevel < currentWeakLevel && fcc.hp > 0)
{
currentCharacter = fcc;
currentWeakLevel = newWeakLevel;
}
}
return(currentCharacter);
}
public static void removeRanged(FullCombatCharacter fcc)
{
CombatModificationsModel toRemove = null;
foreach (CombatModificationsModel mod in fcc.mods)
{
if (mod.name == "Ranged")
{
toRemove = mod;
}
}
if (toRemove != null)
{
fcc.mods.Remove(toRemove);
}
}
public static int getNormalAttackValue(FullCombatCharacter fcc)
{
int attackValue = fcc.strength;
if (fcc.className == "Brawler")
{
//Add bonus points for fist speciality
attackValue += ((int)(fcc.classLevel / 5) + 1);
}
if (ModificationsGeneration.BasicModificationsGeneration.hasMod(fcc, "Disarmed"))
{
attackValue = (int)(attackValue * .75);
}
return(attackValue);
}
public static List <IEffect> getCommand(FullCombatCharacter source, List <FullCombatCharacter> targets, CombatData combatData)
{
List <IEffect> effects = new List <IEffect>();
float coefficient = 1.0f;
FullCombatCharacter target = BasicAbilityProcessing.identifyWeakestTarget(targets);
int dmg = (int)((CombatCalculator.getNormalAttackValue(source) * 5 / target.vitality));
if (target.inflictDamage(ref dmg) == FullCombatCharacter.HitEffect.Unbalance)
{
coefficient = coefficient * 2;
}
effects.Add(new Effect(EffectTypes.Attack, source.combatUniq, string.Empty, 0));
effects.Add(new Effect(EffectTypes.DealDamage, target.combatUniq, string.Empty, dmg));
effects.Add(new Effect(EffectTypes.Message, 0, source.name + " has attacked " + target.name + " for " + dmg.ToString() + " damage!", 0));
GeneralProcessor.calculateNextAttackTime(source, coefficient, combatData);
return(effects);
}
public static void calculateNextAttackTime(FullCombatCharacter character, float abilityCoefficient, CombatData combatData)
{
int nextAttackTime;
if (combatData.doubleSelectionState != PlayerModels.CombatDataModels.CombatDataModel.DoubleSelectionState.None)
{
abilityCoefficient = abilityCoefficient * 1.5f;
}
if (BasicModificationsGeneration.hasMod(character, "Adrenaline"))
{
nextAttackTime = calculateNextAttackTime(character.nextAttackTime, abilityCoefficient / 3, character.agility);
}
else
{
nextAttackTime = calculateNextAttackTime(character.nextAttackTime, abilityCoefficient, character.agility);
}
if (combatData.doubleSelectionState == PlayerModels.CombatDataModels.CombatDataModel.DoubleSelectionState.None)
{
character.nextAttackTime = nextAttackTime;
}
else
{
if (combatData.doubleSelectionState == PlayerModels.CombatDataModels.CombatDataModel.DoubleSelectionState.First)
{
combatData.doubleSelectionDelay = nextAttackTime;
combatData.doubleSelectionState = PlayerModels.CombatDataModels.CombatDataModel.DoubleSelectionState.Second;
}
else
{
combatData.doubleSelectionDelay += (nextAttackTime - character.nextAttackTime);
character.nextAttackTime = combatData.doubleSelectionDelay;
combatData.doubleSelectionState = PlayerModels.CombatDataModels.CombatDataModel.DoubleSelectionState.None;
}
}
}
public static List <ICommand> getClassAbilities(FullCombatCharacter source, CombatData combatData)
{
return(GeneralProcessor.getClassCommands(source, combatData));
}
public static Func <List <FullCombatCharacter>, List <FullCombatCharacter>, CombatData, List <IEffect> > initialExecute(FullCombatCharacter source)
{
if (processors.ContainsKey(source.className))
{
return(processors[source.className].initialExecute(source));
}
return((List <FullCombatCharacter> allies, List <FullCombatCharacter> enemies, CombatData combatData) =>
{
return new List <IEffect>();
});
}
public static int getMagicAttackValue(FullCombatCharacter fcc)
{
int attackValue = fcc.intellect;
return(attackValue);
}
public Func <LiveImplementation.FullCombatCharacter, List <LiveImplementation.FullCombatCharacter>, LiveImplementation.CombatData, List <Interfaces.IEffect> > executeCommand(Interfaces.SelectedCommand command)
{
AbilityInfo ai;
switch (command.commandName)
{
case "Disarming Blow":
ai = new AbilityInfo()
{
name = "Disarming Blow",
message = "{Name} has dealt {Damage} damage to {Target} with a disarming blow.",
requiredClassLevel = 3,
damageMultiplier = 5,
damageType = AbilityInfo.DamageType.Physical,
cooldown = "Disarming Blow",
cooldownDuration = 60,
preExecute = ((FullCombatCharacter source, List <FullCombatCharacter> target, CombatData combatData, List <IEffect> effects, AbilityInfo abilityInfo) =>
{
foreach (FullCombatCharacter t in target)
{
if (!BasicModificationsGeneration.hasMod(t, "Disarmed"))
{
List <PlayerModels.CombatDataModels.CombatConditionModel> conditions = new List <PlayerModels.CombatDataModels.CombatConditionModel>();
conditions.Add(new PlayerModels.CombatDataModels.CombatConditionModel()
{
name = "Time",
state = (source.nextAttackTime + 60).ToString()
});
t.mods.Add(new PlayerModels.CombatDataModels.CombatModificationsModel()
{
name = "Disarmed",
conditions = conditions
});
}
}
return(AbilityInfo.ProcessResult.Normal);
})
};
return(ai.getCommand());
case "One-Two Punch":
ai = new AbilityInfo()
{
name = "One-Two Punch",
message = "{Name} has dealt {HitCount}x{Damage} damage to {Target} with a One-Two Punch.",
requiredClassLevel = 7,
damageMultiplier = 5,
damageCoefficient = 0.75f,
damageType = AbilityInfo.DamageType.Physical,
cooldown = "One-Two Punch",
cooldownDuration = 120,
hits = 2
};
return(ai.getCommand());
case "Sweep":
ai = new AbilityInfo()
{
name = "Sweep",
message = "{Name} dealt damage to all enemies with a sweeping blow!",
requiredClassLevel = 9,
maxTargets = 10,
damageMultiplier = 5,
damageCoefficient = 0.5f,
attackTimeCoefficient = 1.5f,
damageType = AbilityInfo.DamageType.Physical,
cooldown = "Sweep",
cooldownDuration = 180
};
return(ai.getCommand());
case "Preemptive Strike":
ai = new AbilityInfo()
{
name = "Preemptive Strike",
message = "{Name} dealt {Damage} damage to {Target} with a Preemptive Strike!",
requiredClassLevel = 13,
damageMultiplier = 5,
damageCoefficient = 1.5f,
damageType = AbilityInfo.DamageType.Physical,
cooldown = "Preemptive Strike",
cooldownDuration = 120,
preExecute = ((FullCombatCharacter source, List <FullCombatCharacter> target, CombatData combatData, List <IEffect> effects, AbilityInfo abilityInfo) =>
{
FullCombatCharacter currentTarget = target[0];
foreach (FullCombatCharacter t in target)
{
if (currentTarget.nextAttackTime > t.nextAttackTime)
{
currentTarget = t;
}
}
target.Clear();
target.Add(currentTarget);
return(AbilityInfo.ProcessResult.Normal);
})
};
return(ai.getCommand());
case "Vicious Blow":
ai = new AbilityInfo()
{
name = "Vicious Blow",
message = "{Name} dealt {Damage} damage to {Target} with a Vicious Blow!",
requiredClassLevel = 15,
damageMultiplier = 5,
damageCoefficient = 1.5f,
damageType = AbilityInfo.DamageType.Physical,
cooldown = "Vicious Blow",
cooldownDuration = 180,
preExecute = ((FullCombatCharacter source, List <FullCombatCharacter> target, CombatData combatData, List <IEffect> effects, AbilityInfo abilityInfo) =>
{
FullCombatCharacter currentTarget = target[0];
if (currentTarget.hp * 2 > currentTarget.maxHP)
{
abilityInfo.message = "{Name}'s vicious blow missed {Target}!";
abilityInfo.damageCoefficient = 0.0f;
}
return(AbilityInfo.ProcessResult.Normal);
})
};
return(ai.getCommand());
case "Adrenaline":
ai = new AbilityInfo()
{
name = "Adrenaline",
message = "Adrenaline pumps through {Name}!",
requiredClassLevel = 17,
oncePerRest = "Adrenaline",
preExecute = ((FullCombatCharacter source, List <FullCombatCharacter> target, CombatData combatData, List <IEffect> effects, AbilityInfo abilityInfo) =>
{
source.mods.Add(BasicModificationsGeneration.getAdrenalineModification((source.nextAttackTime + 60).ToString()));
return(AbilityInfo.ProcessResult.Normal);
})
};
return(ai.getCommand());
default:
return((FullCombatCharacter source, List <FullCombatCharacter> target, CombatData combatData) =>
{
List <IEffect> effects = new List <IEffect>();
return effects;
});
}
}
public Func <List <FullCombatCharacter>, List <FullCombatCharacter>, CombatData, List <IEffect> > initialExecute(FullCombatCharacter source)
{
return((List <FullCombatCharacter> allies, List <FullCombatCharacter> enemies, CombatData combatData) =>
{
List <IEffect> effects = new List <IEffect>();
if (source.className == "Adventurer" && source.classLevel >= 13)
{
foreach (FullCombatCharacter fcc in enemies)
{
if (!BasicModificationsGeneration.hasMod(fcc, "Glance"))
{
CombatModificationsModel cmm = new CombatModificationsModel();
cmm.name = "Glance";
cmm.conditions = new List <CombatConditionModel>();
fcc.mods.Add(cmm);
cmm = null;
}
}
effects.Add(new Effect(EffectTypes.Message, 0, "All enemies have been glanced by " + source.name + "'s Insight ability!", 0));
}
return effects;
});
}
