/// <summary>
/// Display a String for the Enums
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public static string ToMessage(this AbilityEnum value)
{
// Default String
var Message = "None";
switch (value)
{
case AbilityEnum.SpeedAbility:
Message = "Speed boost";
break;
case AbilityEnum.StrengthAbility:
Message = "Strength boost";
break;
case AbilityEnum.ThiccnessAbility:
Message = "Stamina boost";
break;
case AbilityEnum.StaminaAbility:
Message = "Stamina boost";
break;
case AbilityEnum.Unknown:
default:
break;
}
return(Message);
}
/// <summary>
/// Converts the ability enum to the corrosponding ability
/// </summary>
/// <param name="ability"></param>
/// <returns>Returns the ability</returns>
public Ability GetAbilityFromEnum(AbilityEnum ability)
{
switch (ability)
{
case AbilityEnum.Str:
return(Strength);
case AbilityEnum.Dex:
return(Dexterity);
case AbilityEnum.Con:
return(Constitution);
case AbilityEnum.Int:
return(Intelligence);
case AbilityEnum.Wis:
return(Wisdom);
case AbilityEnum.Cha:
return(Charisma);
default: return(Strength);
}
}
static public AbilityBehavior CreateAbilityBehavior(string abilityString)
{
AbilityEnum parsed_enum = (AbilityEnum)System.Enum.Parse(typeof(AbilityEnum), abilityString);
switch (parsed_enum)
{
case AbilityEnum.normal:
return(new NormalBallAbility());
case AbilityEnum.fireBall:
return(new FireBallAbility());
case AbilityEnum.lightningBall:
return(new LightningBallAbility());
case AbilityEnum.waterBall:
return(new WaterBallAbility());
case AbilityEnum.thiefBall:
return(new ThiefBallAbility());
case AbilityEnum.lifeBall:
return(new LifeBallAbility());
case AbilityEnum.goldBall:
return(new GoldBallAbility());
case AbilityEnum.strongBall:
return(new StrongBallAbility());
case AbilityEnum.loveBall:
return(new LoveBallAbility());
}
return(new NormalBallAbility());
}
internal int ApplyEffectsToAbilityBaseModifier(AbilityEnum ability, int baseModifier)
{
// 1. find worst replacing effect first, and apply if any
var worseReplacingEffect = this._appliedCharacterEffects.Values.Where(e =>
e.GetType().Implements(typeof(IAbilityBonusTargettedCharacterEffect)) &&
((IAbilityBonusTargettedCharacterEffect)e).AffectedAbility == ability &&
((IAbilityBonusTargettedCharacterEffect)e).EffectVector == EffectVectorEnum.Replace)
.OrderBy(e => e.Value)
.FirstOrDefault();
if (worseReplacingEffect != null)
{
return((int)worseReplacingEffect.Value);
}
// 2. get all other effects - will sum final efefct later
var otherApplyingEffects = this._appliedCharacterEffects.Values.Where(e =>
e.GetType().Implements(typeof(IAbilityBonusTargettedCharacterEffect)) &&
((IAbilityBonusTargettedCharacterEffect)e).AffectedAbility == ability &&
((IAbilityBonusTargettedCharacterEffect)e).EffectVector != EffectVectorEnum.Replace);
foreach (var otherEffect in otherApplyingEffects)
{
if (((IAbilityBonusTargettedCharacterEffect)otherEffect).EffectVector == EffectVectorEnum.Positive)
{
baseModifier += (int)otherEffect.Value;
}
else
{
baseModifier -= (int)otherEffect.Value;
}
}
return(baseModifier);
}
/// <summary>
/// Looks in the list for a specific Ability and returns a copy of that instance.
/// TODO: Make sure that the returned Ability is a copy and not a reference.
/// </summary>
/// <param name="ability">Enum name of the Ability to find</param>
/// <returns></returns>
public Ability GetAbilityFromList(AbilityEnum ability)
{
// Call the method that gets the Ability from name after looking up the name
// from the provided enum.
Ability toReturn = GetAbilityFromList(GetAbilityNameByEnum(ability));
return(toReturn);
}
/// <summary>
/// Called to start casting fireball
/// </summary>
public void StartFireball()
{
if (actionPoints > 0 && this.hasFireball)
{
this.playerActing = true;
this.currentAction = AbilityEnum.FIREBALL;
uiController.setVisibility(true);
}
}
/// <summary>
/// Called to start movement
/// </summary>
public void StartMove()
{
//Start actions
if (actionPoints > 0)
{
//Start action
this.playerActing = true;
this.currentAction = AbilityEnum.MOVE_PLAYER;
uiController.setVisibility(true);
}
}
/// <summary>
/// Converts an Enum to a name for looking up.
/// If the name is not found, it returns Generic Ability.
/// </summary>
/// <param name="ability"></param>
/// <returns></returns>
private string GetAbilityNameByEnum(AbilityEnum ability)
{
switch (ability)
{
case AbilityEnum.GenericAbility:
return("GenericAbility");
case AbilityEnum.GenericChanneled:
return("GenericChanneled");
default:
return("GenericAbility");
}
}
/// <summary>
/// Display a String for the Enums
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public static string ToMessage(this AbilityEnum value)
{
// Default String
var Message = "None";
switch (value)
{
case AbilityEnum.Bandage:
Message = "Apply Bandages";
break;
case AbilityEnum.Nimble:
Message = "React Quickly";
break;
case AbilityEnum.Toughness:
Message = "Toughen Up";
break;
case AbilityEnum.Focus:
Message = "Mental Focus";
break;
case AbilityEnum.Quick:
Message = "Anticipate";
break;
case AbilityEnum.Barrier:
Message = "Barrier Defense";
break;
case AbilityEnum.Curse:
Message = "Shout Curse";
break;
case AbilityEnum.Heal:
Message = "Heal Self";
break;
case AbilityEnum.None:
case AbilityEnum.Unknown:
default:
break;
}
return(Message);
}
/// <summary>
/// Mark if an ability is available
/// </summary>
/// <param name="ability"></param>
/// <returns></returns>
public bool IsAbilityAvailable(AbilityEnum ability)
{
var avaible = AbilityTracker.TryGetValue(ability, out int remaining);
if (avaible == false)
{
// does not exist
return(false);
}
if (remaining < 1)
{
// out of tries
return(false);
}
return(true);
}
/// <summary>
/// Use the Ability
/// </summary>
/// <param name="Attacker"></param>
/// <returns></returns>
public bool UseAbility(AbilityEnum ability)
{
var avaible = AbilityTracker.TryGetValue(ability, out int remaining);
if (avaible == false)
{
// does not exist
return(false);
}
if (remaining < 1)
{
// out of tries
return(false);
}
switch (ability)
{
case AbilityEnum.Heal:
case AbilityEnum.Bandage:
BuffHealth();
break;
case AbilityEnum.Toughness:
case AbilityEnum.Barrier:
BuffDefense();
break;
case AbilityEnum.Curse:
case AbilityEnum.Focus:
BuffAttack();
break;
case AbilityEnum.Quick:
case AbilityEnum.Nimble:
BuffSpeed();
break;
}
// Reduce the count
AbilityTracker[ability] = remaining - 1;
return(true);
}
internal uint?ApplyEffectsToAbilityScore(AbilityEnum affectedAbility, uint?score)
{
// Characters without Ability score will also ignore any Ability modifiers that would normally apply to it
if (score == null)
{
return(null);
}
// 1. find worst replacing effect first, and apply if any
var worseReplacingEffect = this._appliedCharacterEffects.Values.Where(e =>
e.GetType().Implements(typeof(IAbilityTargettedCharacterEffect)) &&
((IAbilityTargettedCharacterEffect)e).AffectedAbility == affectedAbility &&
((IAbilityTargettedCharacterEffect)e).EffectVector == EffectVectorEnum.Replace)
.OrderBy(e => e.Value)
.FirstOrDefault();
if (worseReplacingEffect != null)
{
return((uint)worseReplacingEffect.Value);
}
// 2. get all other effects - will sum final efefct later
var otherApplyingEffects = this._appliedCharacterEffects.Values.Where(e =>
e.GetType().Implements(typeof(IAbilityTargettedCharacterEffect)) &&
((IAbilityTargettedCharacterEffect)e).AffectedAbility == affectedAbility &&
((IAbilityTargettedCharacterEffect)e).EffectVector != EffectVectorEnum.Replace);
foreach (var otherEffect in otherApplyingEffects)
{
if (((IAbilityTargettedCharacterEffect)otherEffect).EffectVector == EffectVectorEnum.Positive)
{
score += (uint)otherEffect.Value;
}
else
{
score -= (uint)otherEffect.Value;
}
}
return(score);
}
/// <summary>
/// Unity's Update() function called once per step
/// </summary>
void Update()
{
//Get player position. Different in VR
if (vrActive)
{
int[] hexCoords = HexConst.CoordToHexIndex(new Vector3(transform.position.x, uiController.transform.position.y, transform.position.z));
q = hexCoords[0];
r = hexCoords[1];
h = hexCoords[2];
}
else
{
int[] hexCoords = HexConst.CoordToHexIndex(new Vector3(transform.position.x, transform.position.y, transform.position.z));
q = hexCoords[0];
r = hexCoords[1];
h = hexCoords[2];
}
//If player presses "m" to start acting, isn't yet acting, and has enough action points to do so
if (Input.GetKeyUp("m") && actionPoints > 0)
{
//Start action
this.playerActing = true;
this.currentAction = AbilityEnum.MOVE_PLAYER;
uiController.setVisibility(true);
}
if (Input.GetKeyUp(KeyCode.Alpha1) && actionPoints > 0)
{
this.playerActing = true;
this.currentAction = AbilityEnum.FIREBALL;
uiController.setVisibility(true);
}
//Cancel abilities
if (Input.GetKeyUp(KeyCode.Escape))
{
this.playerActing = false;
this.currentAction = AbilityEnum.NOT_USING_ABILITIES;
uiController.setVisibility(false);
}
}
/// <summary>
/// Display a String for the Enums
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public static string ToMessage(this AbilityEnum value)
{
// Default String
var Message = "Unknown";
switch (value)
{
case AbilityEnum.ExtraCredit:
Message = "Extra credit";
break;
case AbilityEnum.Extension:
Message = "Extension";
break;
case AbilityEnum.FlashGenius:
Message = "Flash of genius";
break;
case AbilityEnum.Bribes:
Message = "Bribes";
break;
case AbilityEnum.PayTuition:
Message = "Pay tuition";
break;
case AbilityEnum.None:
Message = "None";
break;
case AbilityEnum.Unknown:
default:
break;
}
return(Message);
}
public AbilityDrainedCharacterEffect(BaseEffectBuilder effectBuilder, AbilityEnum affectedAbility, uint newDamagedPoints) : base(effectBuilder)
{
this._affectedAbility = affectedAbility;
this.Value = (int)newDamagedPoints;
}
public Ability(AbilityEnum name, int score, bool isProficient = false)
{
Name = name;
Score = score;
IsProficient = isProficient;
}
public AbilityDamagedCharacterEffect(BaseEffectBuilder effectBuilder, AbilityEnum affectedAbility, uint newDamagedPoints) : base(effectBuilder)
{
this._affectedAbility = affectedAbility;
this.ReplacePrevious = false;
this.Value = (int)newDamagedPoints;
}
/// <summary>
/// Each ability will have a modifier. The modifier can be calculated using this formula:
/// (ability/2) -5 [round result down]
/// The modifier is the number you add to or subtract from the die roll when your character tries to do something related to that ability.
/// A positive modifier is called a bonus, and a negative modifier is called a penalty.
/// </summary>
/// <param name="ability"></param>
/// <returns></returns>
public int GetAbilityModifier(AbilityEnum ability)
{
// TODO: take into account also temporary effects
return(this._character.Effects.ApplyEffectsToAbilityBaseModifier(ability, GlobalOperators.Round((this._scoreArray[(int)ability] ?? 0) / 2m - 5m)));
}
/// <summary>
/// Fireball ability
/// </summary>
/// <returns>True once fireball has been cast</returns>
public bool Fireball()
{
//If the player is standing on a hex (not falling, jumping)
if (levelController[q, r, h] != null)
{
//Get the area around the current hex
uiController.ShowValidTopDownRadius(q, r, h, 5, true);
}
UICellObj hitObj = null;
//Non VR Movement
if (!vrActive)
{
//Get the cell the player is looking at
Vector3 lineOfSight = playerCamera.transform.forward * 1000;
RaycastHit hit;
if (Physics.Raycast(playerCamera.transform.position, lineOfSight, out hit))
{
//Get the UI hex cell the player is looking at
hitObj = hit.transform.gameObject.GetComponent <UICellObj>() as UICellObj;
}
//VR Specific movement
}
else
{
hitObj = VRHitObj;
}
//if it isn't null
if (hitObj != null)
{
//get the selected cell; if it's within 5 units of the starting cell show the ability AoE
PathCell lookedCell = aiController[hitObj.q, hitObj.r, hitObj.h];
PathCell startCell = aiController[q, r, h];
//if this is in the right range to cast this, it's a valid move.
if (aiController.DistBetween(lookedCell, startCell) <= 5)
{
uiController.ShowValidTopDownRadius(hitObj.q, hitObj.r, hitObj.h, 1, true, TargetingMaterial.TARGETED_ZONE);
//If the player presses the mouse button
if (Input.GetMouseButtonUp(0) || vrPressUp)
{
PathCell targetedCell = aiController[hitObj.q, hitObj.r, hitObj.h];
//kill any monsters on the cells you target
foreach (Monster m in aiController.monsters)
{
PathCell monsterLoc = aiController.pathGrid[m.CurrentCell[0], m.CurrentCell[1], m.CurrentCell[2]];
if (aiController.DistBetween(targetedCell, monsterLoc) <= 1)
{
m.gameObject.GetComponent <MonsterStats>().Health -= 9001;
}
}
//now turn the remaining tiles extra crispy
PathCell[] surroundingCells = aiController.pathGrid.GetRadius(hitObj.q, hitObj.r, hitObj.h, 1, -1, true);
foreach (PathCell cell in surroundingCells)
{
HexCellData cellData = levelController.levelGrid[cell.q, cell.r, cell.h];
cellData.hexCellObject.gameObject.GetComponent <Renderer>().material = this.burntTileMaterial;
}
actionPoints -= 1;
uiController.ClearCells();
uiController.setVisibility(false);
currentAction = AbilityEnum.NOT_USING_ABILITIES;
return(true);
}
}
}
//Not finished casting
return(false);
}
public PenalizeAbilityBasedSkillsEffectBuilder(AbilityEnum affectedAbility, EffectTimeFrameEnum timeFrame, int penaltyScore)
: base(timeFrame, EffectStackModeEnum.Stackable)
{
throw new NotImplementedException();
}
public void ReportCharacterAbilityRestored(Character character, AbilityEnum affectedAbility)
{
throw new NotImplementedException();
}
public static EffectGroup Parse(string s)
{
string[] tmp = s.Split(new char[] { '|' });
EffectGroup effects = new EffectGroup();
foreach (string t in tmp)
{
string[] tmp2 = t.Split(new char[] { '$' });
string value = tmp2[1].Trim();
int v;
NumericEffect numEff = null;
switch (tmp2[0].Trim())
{
case "Mode":
effects.Mode = (Effect.ModeEnum)Enum.Parse(typeof(Effect.ModeEnum), tmp2 [1]);
break;
case "Affected":
effects.Affected = Target.ParseTargets(value);
break;
case "GainControl":
effects.Add(new Effect(EffectType.GainControl));
break;
case "Description":
break;
case "AddKeyword":
AbilityEnum ae = AbilityEnum.Unset;
if (Enum.TryParse(value, true, out ae))
{
effects.Add(new AbilityEffect(new Ability(ae)));
break;
}
switch (value)
{
case "Double Strike":
effects.Add(new AbilityEffect(new Ability(AbilityEnum.DoubleStrike)));
break;
default:
Debug.WriteLine("unknown AddKeyword in effect: " + value);
break;
}
break;
case "Condition":
break;
case "AddAbility":
break;
case "AddPower":
numEff = new NumericEffect(EffectType.AddPower);
if (int.TryParse(value, out v))
{
numEff.Amount = v;
}
else
{
SVarToResolve.RegisterSVar(value, numEff, numEff.GetType().GetField("Amount"));
}
effects.Add(numEff);
numEff = null;
break;
case "AddToughness":
numEff = new NumericEffect(EffectType.AddTouchness);
if (int.TryParse(value, out v))
{
numEff.Amount = v;
}
else
{
SVarToResolve.RegisterSVar(value, numEff, numEff.GetType().GetField("Amount"));
}
effects.Add(numEff);
numEff = null;
break;
case "SetPower":
if (!int.TryParse(value, out v))
{
break;
}
effects.Add(new NumericEffect
{
TypeOfEffect = EffectType.SetPower,
Amount = v,
});
break;
case "SetToughness":
if (!int.TryParse(value, out v))
{
break;
}
effects.Add(new NumericEffect
{
TypeOfEffect = EffectType.SetTouchness,
Amount = v,
});
break;
case "EffectZone":
break;
case "CharacteristicDefining":
break;
case "AddType":
break;
case "References":
break;
case "ValidCard":
break;
case "AddHiddenKeyword":
switch (value)
{
case "CARDNAME can't attack or block.":
effects.Add(EffectType.CantAttack);
effects.Add(EffectType.CantBlock);
break;
default:
Debug.WriteLine("Unkwnown HiddenKeyword: " + value);
break;
}
break;
case "CheckSVar":
break;
case "SVarCompare":
break;
case "AffectedZone":
break;
case "Activator":
break;
case "Type":
break;
case "Color":
break;
case "Amount":
break;
case "SetColor":
break;
case "Caster":
break;
case "OpponentAttackedWithCreatureThisTurn":
break;
case "AddColor":
break;
case "AddSVar":
break;
case "Spell":
break;
case "SetMaxHandSize":
break;
case "AddTrigger":
break;
case "RemoveKeyword":
break;
case "GlobalRule":
break;
case "Attacker":
break;
case "Cost":
break;
case "Player":
break;
case "Phases":
break;
case "Target":
break;
case "Optional":
break;
case "AILogic":
break;
case "CheckSecondSVar":
break;
case "SecondSVarCompare":
break;
case "RemoveSubTypes":
break;
case "RemoveAllAbilities":
break;
case "AddStaticAbility":
break;
case "SharedKeywordsZone":
break;
case "SharedRestrictions":
break;
case "MaxDamage":
break;
case "Source":
break;
case "RemoveCreatureTypes":
break;
case "TopCardOfLibraryIs":
break;
case "NonMana":
break;
case "GainsAbilitiesOf":
break;
case "GainsAbilitiesOfZones":
break;
case "RemoveCardTypes":
break;
case "CombatDamage":
break;
case "ValidTarget":
break;
case "RemoveType":
break;
case "ValidSource":
break;
case "RaiseMaxHandSize":
break;
case "Origin":
break;
case "MinMana":
break;
case "ValidSpellTarget":
break;
case "TapAbility":
break;
case "KeywordMultiplier":
break;
case "CheckThirdSVar":
break;
case "CheckFourthSVar":
break;
case "AddReplacementEffects":
break;
case "OnlySorcerySpeed":
break;
default:
break;
}
}
return(effects);
}
public Skill(SkillEnum skill, AbilityEnum ability, Proficiency proficiency)
{
SkillName = skill;
BaseAbility = ability;
Proficiency = proficiency;
}
public DisableAbilityBonusCharacterEffect(BaseEffectBuilder effectBuilder, AbilityEnum affectedAbility, int penaltyRounds) : base(effectBuilder)
{
this.AffectedAbility = affectedAbility;
this.Value = 0;
}
public void CancelAction()
{
this.playerActing = false;
this.currentAction = AbilityEnum.NOT_USING_ABILITIES;
uiController.setVisibility(false);
}
/// <summary>
/// Update the UI for player movement and item usage
/// </summary>
/// <returns>Returns true when movement has happened</returns>
public bool MovePlayer()
{
//Check to see if the player is standing on a hex; if so show all valid moves on the minimap.
//If the player is standing on a hex (not falling, jumping)
if (levelController[q, r, h] != null)
{
//Get the neighbors of the current hex
movable = aiController.ReachableInSteps(new int[] { q, r, h }, 2, actionPoints);
//Give all valid neighbors the neighbor material
uiController.ShowValidMoves(movable);
//Give the current hex the current hex material
uiController[q, r, h].gameObject.GetComponent <Renderer>().material = currenthexmaterial;
}
UICellObj hitObj = null;
//Non VR Movement
if (!vrActive)
{
//Get the cell the player is looking at
Vector3 lineOfSight = playerCamera.transform.forward * 1000;
RaycastHit hit;
if (Physics.Raycast(playerCamera.transform.position, lineOfSight, out hit))
{
//Get the UI hex cell the player is looking at
hitObj = hit.transform.gameObject.GetComponent <UICellObj>() as UICellObj;
}
//VR Specific movement
}
else
{
hitObj = VRHitObj;
}
//if it isn't null
if (hitObj != null)
{
//get the selected cell
PathCell lookedCell = aiController[hitObj.q, hitObj.r, hitObj.h];
PathCell startCell = aiController[q, r, h];
//loop through all cells we're close enough to reach
for (int i = 0; i < movable.Count; i++)
{
foreach (PathCell m in movable[i])
{
if (lookedCell.Equals(m) && !lookedCell.Equals(startCell))
{
//set the material
hitObj.gameObject.GetComponent <Renderer>().material = highlightMaterial;
GameObject thisUICell = uiController [lookedCell.q, lookedCell.r, lookedCell.h].gameObject;
uiController.playerFigure.transform.position = thisUICell.transform.position + new Vector3(0, thisUICell.GetComponent <Renderer>().bounds.size.y / 2, 0);
//If the player clicked the mouse
if (Input.GetMouseButtonUp(0) || vrPressUp)
{
//Move the player
transform.parent.position = levelController[hitObj.q, hitObj.r, hitObj.h].centerPos;
//If the target has a goal
if (levelController[hitObj.q, hitObj.r, hitObj.h].hasGoal)
{
//Update the goal
levelController.numOfGoals -= 1;
levelController[hitObj.q, hitObj.r, hitObj.h].goal.GetComponent <Goal>().Accomplished();
}
//Reduce number of player action points remaining
actionPoints -= i + 1;
//Clear the UI controller
uiController.ClearCells();
uiController.setVisibility(false);
currentAction = AbilityEnum.NOT_USING_ABILITIES;
return(true);
}
}
}
}
}
//Movement not finished
return(false);
}
public int GetAbilityModifier(AbilityEnum ability)
{
var ab = Abilities.First(a => a.Name == ability);
return(ab.IsProficient ? ab.Modifier + ProficiencyBonus : ab.Modifier);
}
public AbilityDamagedEffectBuilder(AbilityEnum affectedAbility, uint newDamagedPoints) : base(EffectTimeFrameEnum.Restorable, EffectStackModeEnum.Stackable)
{
this._affectedAbility = affectedAbility;
this._newDamagedPoints = newDamagedPoints;
}
/// <summary>
/// Each ability will have a modifier. The modifier can be calculated using this formula:
/// (ability/2) -5 [round result down]
/// The modifier is the number you add to or subtract from the die roll when your character tries to do something related to that ability.
/// A positive modifier is called a bonus, and a negative modifier is called a penalty.
/// </summary>
/// <param name="ability"></param>
/// <returns></returns>
/// <remarks>CORE modifier does not take into account temporary modifiers, it's usefull for character advancement routines.</remarks>
public int GetCoreAbilityModifier(AbilityEnum ability)
{
// even cybernetics only give effects, though "permanent")
return(GlobalOperators.Round((this._scoreArray[(int)ability] ?? 0) / 2m - 5m));
}
