public Thief Thief; //!< Player's Thief ability
public Ability this[AbilityName ability] //!< Convenience property to index abilities by AbilityName enum
{
get
{
switch (ability)
{
case AbilityName.Immunity:
return Immunity;
case AbilityName.TreatsGalore:
return TreatsGalore;
case AbilityName.Fearless:
return Fearless;
case AbilityName.FatMouse:
return FatMouse;
case AbilityName.ScaryCat:
return ScaryCat;
case AbilityName.BeastlyBuffet:
return BeastlyBuffet;
case AbilityName.Thief:
return Thief;
default:
throw new ArgumentOutOfRangeException("ability", ability, "No such ability.");
}
}
}
/// <summary>
/// Method to set a player's ability to a certain level.
/// </summary>
/// <param name="ability">Ability to be changed</param>
/// <param name="level">New level</param>
public void SetAbility(AbilityName ability, int level)
{
switch (ability)
{
case AbilityName.Immunity:
Immunity = new Immunity(level);
break;
case AbilityName.TreatsGalore:
TreatsGalore = new TreatsGalore(level);
break;
case AbilityName.Fearless:
Fearless = new Fearless(level);
break;
case AbilityName.FatMouse:
FatMouse = new FatMouse(level);
break;
case AbilityName.ScaryCat:
ScaryCat = new ScaryCat(level);
break;
case AbilityName.BeastlyBuffet:
BeastlyBuffet = new BeastlyBuffet(level);
break;
case AbilityName.Thief:
Thief = new Thief(level);
break;
default:
throw new ArgumentOutOfRangeException("ability", ability, "No such ability.");
}
}
public void UpdateAbilityScoreBaseValue(AbilityName abilityName, int NewValue)
{
switch (abilityName)
{
case AbilityName.Intelligence:
IntBase = NewValue;
IntBaseMod = GetAbilityModifier(IntBase);
return;
case AbilityName.Wisdom:
WisBase = NewValue;
WisBaseMod = GetAbilityModifier(WisBase);
return;
case AbilityName.Strength:
StrBase = NewValue;
StrBaseMod = GetAbilityModifier(StrBase);
return;
case AbilityName.Dexterity:
DexBase = NewValue;
DexBaseMod = GetAbilityModifier(DexBase);
return;
case AbilityName.Charisma:
ChaBase = NewValue;
ChaBaseMod = GetAbilityModifier(ChaBase);
return;
case AbilityName.Constitution:
ConBase = NewValue;
ConBaseMod = GetAbilityModifier(ConBase);
return;
}
}
/// <summary>
/// Calculates the overall competency score of a player in one particular ability.
/// The overall score is derived from finding the weighted average subscore in the specific ability.
/// </summary>
/// <param name="aName">The ability in question's name.</param>
/// <returns>The player's overall score in this ability.</returns>
/// <remarks>The returned score ≥ 0.</remarks>
public static int CalculateOverallScoreForOneAbility(AbilityName aName)
{
int sumOfWeightedScores = 0;
double sumOfWeight = 0.001;
// Get a list of abilities that are being measured
List <AbilityName> measuredAbilities = subScoreSeq.Select(s => s.AbilityName).ToList();
// If aName exists in measuredAbilities
if (measuredAbilities.Contains(aName))
{
// Iterate through subScoreSeq and find the average score for aName
foreach (var subScore in subScoreSeq)
{
if (subScore.AbilityName == aName)
{
sumOfWeightedScores += (subScore.Score * subScore.Weight);
sumOfWeight += subScore.Weight;
}
}
int overallScore = (int)Math.Ceiling(sumOfWeightedScores / sumOfWeight);
return(overallScore);
}
else // aName is not measured; return -1
{
return(-1);
}
}
public Skill(AbilityName ability, bool armorPenalty, bool untrained, bool hidden = false, bool isClass = false, int rank = 0)
{
this.ability = ability;
this.armorPenalty = armorPenalty;
this.untrained = untrained;
this.hidden = hidden;
this.rank = rank;
this.isClass = isClass;
}
public Skill(AbilityName ability, bool armorPenalty, bool untrained, bool hidden = false, bool isClass = false, int rank = 0)
{
this.ability = ability;
this.armorPenalty = armorPenalty;
this.untrained = untrained;
this.hidden = hidden;
this.rank = rank;
this.isClass = isClass;
}
public ModifyAbility(
EffectName name,
AbilityName abilityToModify,
AbilityName modifiedAbility,
IList <Validator>?validators = null) : base(name, $"{nameof(Effect)}.{nameof(ModifyAbility)}", validators ?? new List <Validator>())
{
AbilityToModify = abilityToModify;
ModifiedAbility = modifiedAbility;
}
public static void SetAbilityEnabled(AbilityName abilityName, bool enabled)
{
if (!abilities.ContainsKey(abilityName))
{
Debug.Log("ability " + abilityName + " does not exist");
return;
}
abilities[abilityName].abilityEnabled = enabled;
}
public IEnumerator WHEN_AbilityNameSet_THEN_AbilityNameGetFunctionWorks()
{
testOverallScoreStorage = new OverallScoreStorage();
testOverallScoreStorage.AbilityName = AbilityName.VISUOSPATIAL_SKETCHPAD;
AbilityName expectedAbilityName = AbilityName.VISUOSPATIAL_SKETCHPAD;
yield return(null);
Assert.AreEqual(expectedAbilityName, testOverallScoreStorage.AbilityName);
}
public IEnumerator WHEN_AbilityNameSet_THEN_NameGetFunctionWorks()
{
testSubscoreStorage = new SubscoreStorage();
testSubscoreStorage.AbilityName = AbilityName.INHIBITION;
AbilityName expectedAbilityName = AbilityName.INHIBITION;
yield return(null);
Assert.AreEqual(expectedAbilityName, testSubscoreStorage.AbilityName);
}
/// <summary>
/// Get the overallScoreStorage object for the specified input ability from the overallScoreSeq.
/// </summary>
/// <param name="abilityName"></param>
/// <returns></returns>
private OverallScoreStorage GetOverallScoreStorageForOneAbility(AbilityName abilityName)
{
OverallScoreStorage result = new OverallScoreStorage();
foreach (OverallScoreStorage overallScore in overallScoreSeq)
{
if (overallScore.AbilityName == abilityName)
{
result = overallScore;
break;
}
}
return(result);
}
private void Start()
{
AN = FindObjectOfType <AbilityName>();
player = FindObjectOfType <PlayerStats>();
settings = FindObjectOfType <Settings>();
input.onValueChange.AddListener(delegate { ValueChangeCheck(input.text); });
system = FindObjectOfType <BattleSystem>();
AB = FindObjectOfType <AudioBox>();
AS = FindObjectOfType <AbilitySelect>();
if (FindObjectOfType <Settings>())
{
autoMode = FindObjectOfType <Settings>().autoMode;
}
}
public static void ConfigAbility(AbilityConfig config)
{
AbilityName abilityName = (AbilityName)System.Enum.Parse(typeof(AbilityName), StringOperation.ToFirstUpper(config.abilityName));
if (!abilities.ContainsKey(abilityName))
{
Debug.Log("ability " + abilityName + " does not exist");
return;
}
AbilityBehaviour ability = abilities[abilityName];
ability.abilityEnabled = config.enabled;
ability.isChargeMode = config.isChargeMode;
ability.chargeCount = config.chargeCount;
}
public AbilityDefinition(AbilityName ability, string description, string[] provides, string[] requires) : this()
{
this.aname = ability;
this.name = ability.ToString().ToUpperInvariant();
this.description = description;
if (provides != null)
{
foreach (string provide in provides)
{
this.Provide(provide);
}
}
if (requires != null)
{
foreach (string require in requires)
{
this.Provide(require);
}
}
}
public void SetAbility(AbilityName ab)
{
switch (ab)
{
case AbilityName.FLAME:
setActive(0);
break;
case AbilityName.GRENADE:
setActive(1);
break;
case AbilityName.KB:
setActive(2);
break;
case AbilityName.RG:
setActive(3);
break;
}
}
public AbilityDefinition(AbilityName ability, string description, string[] provides, string[] requires)
: this()
{
this.aname = ability;
this.name = ability.ToString().ToUpperInvariant();
this.description = description;
if (provides != null)
{
foreach (string provide in provides)
{
this.Provide(provide);
}
}
if (requires != null)
{
foreach (string require in requires)
{
this.Provide(require);
}
}
}
public int GetAbilityScoreBaseValue(AbilityName abilityName)
{
switch (abilityName)
{
case AbilityName.Intelligence:
return(IntBase);
case AbilityName.Wisdom:
return(WisBase);
case AbilityName.Strength:
return(StrBase);
case AbilityName.Dexterity:
return(DexBase);
case AbilityName.Charisma:
return(ChaBase);
case AbilityName.Constitution:
return(ConBase);
}
return(-100);
}
public List <AbilityName> RetrieveSpecificAbilityName(IDbConnection connection, int ability_id)
{
List <AbilityName> abilityNames = new List <AbilityName>();
using (IDbCommand command = database.CreateCommand()) {
command.Connection = connection;
command.CommandText = Query.GetSpecificAbilityName;
command.Prepare();
command.AddWithValue("@ability_id", ability_id);
using (IDataReader reader = command.ExecuteReader()) {
while (reader.Read())
{
AbilityName abilityName = new AbilityName {
LocalLanguage = new Language {
Id = reader.CheckValue <int>("local_language_id")
},
Name = reader.CheckObject <string>("name")
};
abilityNames.Add(abilityName);
}
}
} // Command
return(abilityNames);
}
public int GetAbilityModValue(AbilityName abilityName)
{
switch (abilityName)
{
case AbilityName.Intelligence:
return(IntMod);
case AbilityName.Wisdom:
return(WisMod);
case AbilityName.Strength:
return(StrMod);
case AbilityName.Dexterity:
return(DexMod);
case AbilityName.Charisma:
return(ChaMod);
case AbilityName.Constitution:
return(ConMod);
}
return(-100);
}
public int this[AbilityName abilityName]
{
get { return(values[abilityName]); }
set { values [abilityName] = value; }
}
/// <summary>
/// Improves one of the player's abilities. Does nothing if the ability level is already at maximum.
/// </summary>
/// <param name="ability"></param>
public void ImproveAbility(AbilityName ability)
{
if (player.PAbilities[ability].Level >= player.PAbilities[ability].MaxLevel) return;
player.PAbilities.SetAbility(ability, player.PAbilities[ability].Level + 1);
abilityUi.UpdateAbilityLevelOnButton(ability);
abilityPoints--;
NewGameMessage("Improved " + player.PAbilities[ability].Name + "!");
}
/// <summary>
/// To be called by the Player script
/// to activate the ability based on
/// the tapped icon
/// </summary>
/// <param name="ability"></param>
public void ActivateAbility(AbilityName ability)
{
switch (ability)
{
case AbilityName.Immunity:
ActivateImmunity();
abilityUi.Countdowns[ability].text = player.PAbilities[AbilityName.Immunity]
.Duration.ToString();
abilityUi.Countdowns[ability].gameObject.SetActive(true);
break;
case AbilityName.TreatsGalore:
ActivateTreatsGalore();
abilityUi.Countdowns[ability].text = player.PAbilities[AbilityName.TreatsGalore]
.Duration.ToString();
abilityUi.Countdowns[ability].gameObject.SetActive(true);
break;
case AbilityName.Fearless:
ActivateFearless();
abilityUi.Countdowns[ability].text = player.PAbilities[AbilityName.Fearless]
.Duration.ToString();
abilityUi.Countdowns[ability].gameObject.SetActive(true);
break;
case AbilityName.FatMouse:
ActivateFatMouse();
abilityUi.Countdowns[ability].text = player.PAbilities[AbilityName.FatMouse]
.Duration.ToString();
abilityUi.Countdowns[ability].gameObject.SetActive(true);
break;
case AbilityName.ScaryCat:
ActivateScaryCat();
break;
case AbilityName.BeastlyBuffet:
ActivateBeastlyBuffet();
break;
case AbilityName.Thief:
ActivateThief();
abilityUi.Countdowns[ability].text = player.PAbilities[AbilityName.Thief]
.Duration.ToString();
abilityUi.Countdowns[ability].gameObject.SetActive(true);
break;
default:
throw new ArgumentOutOfRangeException("ability", ability, null);
}
}
// Function to check if an ability is still active using the specified duration.
private bool IsStillActive(AbilityName ability, int duration)
{
if (abilityLastActivatedTimes.ContainsKey(ability))
{
var timeSinceLastActivation = DateTime.Now.Subtract(abilityLastActivatedTimes[ability]).Seconds;
return timeSinceLastActivation < duration;
}
else return false;
}
/// <summary>
/// Remove an ability from the player's list
/// </summary>
/// <param name="ability"></param>
public void removeAbility(AbilityName ability)
{
if (PAbilities[ability].Level > 0)
PAbilities.SetAbility(ability, 0);
else
Debug.LogWarning("PLayer doesn't have the ability you are trying to remvoe");
}
public int this[AbilityName abilityName]
{
get { return values[abilityName]; }
set { values [abilityName] = value; }
}
private void InstantiateButton(float yOffset, AbilityName ability)
{
var button = Instantiate(abilityButtonPrefab) as GameObject;
// Set sprite, parent object and rectTransform anchors
button.GetComponent<Image>().sprite = abilitySpritesDict[ability];
button.transform.SetParent(canvas.transform, false);
RectTransform buttonRectTransform = button.GetComponent<RectTransform>();
Vector2 pos = buttonRectTransform.anchoredPosition;
buttonRectTransform.anchoredPosition = new Vector2(pos.x, pos.y - yOffset);
button.GetComponentInChildren<Text>().text = localPlayer.PAbilities[ability].Level.ToString();
button.GetComponent<Button>().onClick.AddListener(() => abilityController.ActivateAbility(ability));
var plusButton = button.transform.Find("PlusButton").gameObject;
plusButton.GetComponent<Button>().onClick.AddListener(() => abilityController.ImproveAbility(ability));
AbilityButtons[ability] = button;
abilityUpgradeButtons[ability] = plusButton;
}
public void Update()
{
if (DevMode.devMode)
{
curHealCooldown = 0;
curEnhancedDashCooldown = 0;
curPlayerEnchanceCooldown = 0;
curTimeStopCooldown = 0;
}
CheckCooldown();
//Player Color Change
if (Input.GetButtonDown("NextAbility"))
{
if ((int)curAbility == (int)AbilityName.PlayerHeal)
{
curAbility = AbilityName.PlayerEnhancedDash;
}
else
{
curAbility++;
}
}
if (Input.GetButtonDown("PrevAbility"))
{
if (curAbility == (int)AbilityName.PlayerEnhancedDash)
{
curAbility = AbilityName.PlayerHeal;
}
else
{
curAbility--;
}
}
switch (curAbility)
{
case AbilityName.PlayerEnhancedDash:
GameManager.instance.uiMan.BorderReset();
GameManager.instance.uiMan.playerDashBorder.enabled = true;
break;
case AbilityName.PlayerEnhance:
GameManager.instance.uiMan.BorderReset();
GameManager.instance.uiMan.playerEnhanceBorder.enabled = true;
break;
case AbilityName.PlayerHeal:
GameManager.instance.uiMan.BorderReset();
GameManager.instance.uiMan.playerHealBorder.enabled = true;
break;
}
//Actual Ability
if (Input.GetButtonDown("Fire3"))
{
switch (curAbility)
{
case AbilityName.PlayerEnhancedDash:
EnhancedDash();
break;
case AbilityName.PlayerEnhance:
PlayerEnhance();
break;
case AbilityName.PlayerHeal:
PlayerHeal();
break;
}
}
}
private AbilityResult PerformAbility(AbilityName ability, Ship invokator)
{
var coords = GetShipCoordinates(invokator);
return _abilities[ability].Perform(this, coords);
}
public bool IsActive(AbilityName ability)
{
switch (ability)
{
case AbilityName.Immunity:
return mouseIsImmune;
case AbilityName.TreatsGalore:
return treatsGaloreIsActive;
case AbilityName.Fearless:
return mouseIsFearless;
case AbilityName.FatMouse:
return mouseIsFat;
case AbilityName.ScaryCat:
return false;
case AbilityName.BeastlyBuffet:
return beastlyBuffetIsActive;
case AbilityName.Thief:
return mouseIsThief;
default:
throw new ArgumentOutOfRangeException("ability", ability, null);
}
}
/// <summary>
/// Add an ability to the player's list
/// </summary>
/// <param name="ability"></param>
public void addAbility(AbilityName ability)
{
if (PAbilities[ability].Level == 0)
PAbilities.SetAbility(ability, 1);
else
Debug.LogWarning("Player already has an ability that you are trying to add");
}
private int TimeLeft(AbilityName ability)
{
if (abilityLastActivatedTimes.ContainsKey(ability))
{
var timeSinceLastActivation = DateTime.Now.Subtract(abilityLastActivatedTimes[ability]).Seconds;
return player.PAbilities[ability].Duration - timeSinceLastActivation;
}
else return -1;
}
/// <summary>
/// Checks if player has the ability indicated
/// </summary>
/// <param name="ability"></param>
/// <returns></returns>
public bool hasAbility(AbilityName ability)
{
if (PAbilities[ability].Level > 0)
return true;
return false;
}
public AbilityAdjustment(AbilityName abilityName, int adjustment)
{
this.AbilityName = abilityName;
this.Adjustment = adjustment;
}
public bool CheckIfMaxed(AbilityName ability)
{
return abilityController.player.PAbilities[ability].Level == abilityController.player.PAbilities[ability].MaxLevel;
}
/// <summary>
/// Callback when ability icons are clicked
/// </summary>
public void OnAbilityDetail()
{
audio.PlayOneShot(SoundButton);
// Get selected ability
GameObject selectedAbilityObj = EventSystem.current.currentSelectedGameObject;
selectedAbility = (AbilityName)Enum.Parse(typeof(AbilityName), selectedAbilityObj.name);
// Check if player already has selecte ability and set choose ability button sprite
if (player.hasAbility(selectedAbility))
{
alreadyChosenText.SetActive(false);
chooseAbilityButton.gameObject.SetActive(true);
(chooseAbilityButton.targetGraphic as Image).sprite = cancelSelectionSprite;
}
else
{
// Check if player already has two abilities and disable choose ability button
if (player.getAbilities().Count == 2)
{
alreadyChosenText.SetActive(true);
chooseAbilityButton.gameObject.SetActive(false);
}
else
{
alreadyChosenText.SetActive(false);
chooseAbilityButton.gameObject.SetActive(true);
}
(chooseAbilityButton.targetGraphic as Image).sprite = confirmSelectionSprite;
}
// Change UI
introText.SetActive(false);
abilityIconUI.SetActive(false);
readyButtonObject.SetActive(false);
// Set detail UI to selected ability
selectedAbilityIcon.sprite = abilityIconSpritesDict[selectedAbility];
selectedAbilityTitle.text = abilityTitles[selectedAbility];
selectedAbilityDescription.text = abilityDescription[selectedAbility];
selectedAbilityLevelHeader.text = abilityLevelDetails[selectedAbility][0].level;
selectedAbilityLevelHappiness.text = abilityLevelDetails[selectedAbility][0].happiness;
selectedAbilityLevelDuration.text = abilityLevelDetails[selectedAbility][0].duration;
selectedAbilityLevelDetail.text = abilityLevelDetails[selectedAbility][0].description;
currentLevelIndex = 0;
abilityDetailUI.SetActive(true);
}
public void UpdateAbilityLevelOnButton(AbilityName abilityName)
{
AbilityButtons[abilityName].GetComponentInChildren<Text>().text = localPlayer.PAbilities[abilityName].Level.ToString();
}
/// <summary>
/// Saves the Ability object.
/// </summary>
/// <returns>Ability Object</returns>
public Ability SaveAbility()
{
SqlDataReader result;
DatabaseConnection dbconn = new DatabaseConnection();
SqlCommand command = new SqlCommand();
SqlConnection connection = new SqlConnection(dbconn.SQLSEVERConnString);
try
{
connection.Open();
command.Connection = connection;
command.CommandType = CommandType.StoredProcedure;
command.CommandText = "InsertUpdate_Ability";
command.Parameters.Add(dbconn.GenerateParameterObj("@AbilityID", SqlDbType.Int, AbilityID.ToString(), 0));
command.Parameters.Add(dbconn.GenerateParameterObj("@AbilityName", SqlDbType.VarChar, AbilityName.ToString(), 100));
command.Parameters.Add(dbconn.GenerateParameterObj("@SortOrder", SqlDbType.Int, SortOrder.ToString(), 0));
result = command.ExecuteReader();
result.Read();
SetReaderToObject(ref result);
}
catch
{
Exception e = new Exception();
this._insertUpdateOK = false;
this._insertUpdateMessage.Append(e.Message.ToString());
throw e;
}
finally
{
command.Dispose();
connection.Close();
}
return(this);
}
