/// [NEW FOR ASSESSMENT 4]
/// <summary>
/// Sets the attacker.
/// also handles actions that need to happen when the attacker changes
/// </summary>
void setAttacker(CombatCharacter character)
{
if (attacker == character)
{
return;
}
attacker = character;
float val = Random.value;
Debug.Log(val);
if (val < attacker.attackFriendlyChance)
{
//select a random alive friendly character
List <int> options = new List <int> ();
for (int i = 0; i < frendlyChars.Count; i++)
{
if (frendlyChars [i].health > 0)
{
options.Add(i);
}
}
int toAttack = options [Random.Range(0, options.Count - 1)];
//attack them
attackTargets = new List <CombatCharacter> ();
attackTargets.Add(frendlyChars [toAttack]);
attack = attacker.basicAttack;
attacker.updateEntityAnimation("move");
currentStage = turnStages.moving;
}
}
public static CombatCharacter MakeCharacter(CombatCharacterPresets characterType)
{
CombatCharacter newCharacter = null;
int characterMaxHealth = GetCharacterMaxhealth(characterType);
int characterMaxEnergy = GetCharacterMaxEnergy(characterType);
CombatAbility basicAttack = getCharacterBasicAttack(characterType);
switch (characterType)
{
case CombatCharacterPresets.BobbyBard:
newCharacter = new CombatCharacter(characterMaxHealth, characterMaxHealth / 2, characterMaxEnergy, characterMaxEnergy, basicAttack);
break;
default:
newCharacter = new CombatCharacter(characterMaxHealth, characterMaxHealth, characterMaxEnergy, characterMaxEnergy, basicAttack);
break;
}
List <CombatAbility> abilities = GetCharacterAbilities(characterType);
foreach (CombatAbility ability in abilities)
{
newCharacter.AddAbility(ability);
}
newCharacter.combatSprites = getCharacterSprites(characterType);
newCharacter.Name = GetCharacterName(characterType);
return(newCharacter);
}
//called in update() if the current stage is the selection stage
void selectionStage()
{
if (!frendlyAttacking)
{
//TODO write better enemy combat logic
int toAttack = CombatCharacter.getFirstAlive(defendChars);
if (toAttack == -1)
{
lose();
}
else
{
attackTargets = new List <CombatCharacter> ();
attackTargets.Add(defendChars [toAttack]);
attack = attacker.basicAttack;
attacker.updateEntityAnimation("move");
currentStage = turnStages.moving;
}
}
else
{
selectorRen.enabled = true;
selectorObj.transform.position = attacker.entity.transform.position;
}
}
public static void SetCombatAblility(this Ped ped, CombatAbility ability)
{
Function.Call((Hash) - 4079649877180351064L, new InputArgument[2]
{
InputArgument.op_Implicit(((Entity)ped).get_Handle()),
InputArgument.op_Implicit((int)ability)
});
}
public static void SetCombatAblility(this Ped ped, CombatAbility ability)
{
Function.Call(GTA.Native.Hash.SET_PED_COMBAT_ABILITY, (InputArgument[])new InputArgument[2]
{
ped.Handle,
(int)ability
});
}
// function called when an abililty button on abilities panel is pressed
/// <summary>
/// [changes] - check that character has sufficient mana before launching attack
/// - this fixes error from crashing due to no mana
/// </summary>
void selectAbility(CombatAbility ability)
{
if (attacker.energy >= ability.energyCost)
{
attack = ability;
currentStage = turnStages.targetSelection;
targetsRemaining = attack.maxTargets;
}
}
// function to be called when the "attack" button is hit
public void doAttack()
{
if (currentStage == turnStages.selecting && frendlyAttacking)
{
attack = attacker.basicAttack;
currentStage = turnStages.targetSelection;
targetsRemaining = attack.maxTargets;
}
}
public void UpdateAbilities()
{
currentEvasionAbility = persistance.ReadData("currentEvasionAbility", EvasionAbility.None);
currentCombatAbility = persistance.ReadData("currentCombatAbility", CombatAbility.None);
purchasedEvasionAbilities = persistance.ReadData("purchasedEvasionAbilities", new List <EvasionAbility>());
purchasedCombatAbilities = persistance.ReadData("purchasedCombatAbilities", new List <CombatAbility>());
if (OnAbilitiesUpdated != null)
{
OnAbilitiesUpdated();
}
}
public CombatEffect(effectType type, int turnsRemaining, CombatAbility ability = null, string damageType = "", float modifier = 0f)
{
this.turnsRemaining = turnsRemaining;
this.type = type;
if (type == effectType.abilityPerTurn)
{
this.ability = ability;
}
if (type == effectType.damageDealtModifier || type == effectType.damageTakenModifier)
{
this.damageType = damageType;
this.modifier = modifier;
}
}
public CombatAttack AttackByAbility(Combatant attacker, CombatAbility abilityAttack)
{
var attack = new CombatAttack(0, abilityAttack.damageType);
var cl = new StringBuilder();
float sourceDamage = abilityAttack.damageMag * abilityAttack.damageMod;
cl.AppendLine("Source Damage: " + sourceDamage.ToString());
float stattedDamage = attacker.CombatantStats.CalculateStatMod(sourceDamage, abilityAttack);
cl.AppendLine("Statted Damage: " + stattedDamage.ToString());
attack.SetAttackDamage(stattedDamage);
return(attack);
}
public float CalculateStatMod(float sourceDamage, CombatAbility attack)
{
float stattedDamage = sourceDamage;
switch (attack.damageType)
{
case DamageType.Physical:
stattedDamage += AttackPower;
break;
case DamageType.Magic:
stattedDamage += MagicPower;
break;
}
return(stattedDamage);
}
public void OnConnect(PlayerAbilityController ownAbilities)
{
_uiIcons = FindObjectsOfType <AbilitySlot>();
HotKeys = _uiIcons.Select(icon => icon.Key).ToArray();
for (int i = 0; i < _uiIcons.Length; i++)
{
AbilitySlot slot = _uiIcons[i];
if (ownAbilities.AvailableAbilities.Length > i)
{
CombatAbility ability = ownAbilities.AvailableAbilities[i];
_equippedAbilities.Add(slot.Key, ability);
ability.AbilityCast += _uiIcons[i].ResetLoadingProgress;
slot.SetIcon(ability.Icon);
slot.SetCooldown(ability.Cooldown);
}
}
}
/// <summary>
/// [CHANGE] - Remove feature setting Bobby Bard to half health and beta testers found it confusing and wasn't necessary to
/// distinguish his character type
/// </summary>
public static CombatCharacter MakeCharacter(CombatCharacterPresets characterType)
{
CombatCharacter newCharacter = null;
int characterMaxHealth = GetCharacterMaxhealth(characterType);
int characterMaxEnergy = GetCharacterMaxEnergy(characterType);
CombatAbility basicAttack = getCharacterBasicAttack(characterType);
newCharacter = new CombatCharacter(characterMaxHealth, characterMaxHealth, characterMaxEnergy, characterMaxEnergy, basicAttack);
List <CombatAbility> abilities = GetCharacterAbilities(characterType);
foreach (CombatAbility ability in abilities)
{
newCharacter.AddAbility(ability);
}
newCharacter.combatSprites = getCharacterSprites(characterType);
return(newCharacter);
}
// function called when the abilities button is pressed
public void doAbilities()
{
if (currentStage != turnStages.selecting)
{
return; // do nothing
}
//clear old buttons
if (abilityButtonObjs != null)
{
foreach (GameObject button in abilityButtonObjs)
{
GameObject.Destroy(button);
}
}
abilityButtonObjs = new List <GameObject> ();
abilitiesPanel.SetActive(true);
GameObject referenceButton = abilitiesPanel.transform.Find("ReferenceButton").gameObject;
Vector2 newButtonPosMin = ((RectTransform)referenceButton.transform).offsetMin;
Vector2 newButtonPosMax = ((RectTransform)referenceButton.transform).offsetMax;
float buttonSeparation = 45; // distance apart the tops of the buttons should be in pixels
foreach (CombatAbility a in attacker.abilities)
{
GameObject newButtonObj = Instantiate(referenceButton, abilitiesPanel.transform);
UnityEngine.UI.Button newButton = newButtonObj.GetComponent <UnityEngine.UI.Button> ();
abilityButtonObjs.Add(newButtonObj);
((RectTransform)newButtonObj.transform).offsetMin = newButtonPosMin;
((RectTransform)newButtonObj.transform).offsetMax = newButtonPosMax;
newButtonPosMin.y -= buttonSeparation;
newButtonPosMax.y -= buttonSeparation;
newButtonObj.SetActive(true);
newButtonObj.transform.Find("NameText").gameObject.GetComponent <UnityEngine.UI.Text> ().text = a.abilityName;
newButtonObj.transform.Find("CostText").gameObject.GetComponent <UnityEngine.UI.Text> ().text = a.energyCost.ToString();
CombatAbility tempValue = a; // necessary to deal with weird scoping
newButton.onClick.AddListener(delegate { selectAbility(tempValue); });
if (attacker.energy < tempValue.energyCost)
{
newButton.interactable = false;
}
}
}
public CombatCharacter(int maxHealth, int health, int maxEnergy, int energy, CombatAbility basicAttack = null)
{
this.maxHealth = maxHealth;
this.health = health;
this.maxEnergy = maxEnergy;
this.energy = energy;
if (basicAttack == null)
{
this.basicAttack = new SimpleAttack(8, 10, "melee");
}
else
{
this.basicAttack = basicAttack;
}
abilities = new List <CombatAbility> ();
effectList = new List <CombatEffect> ();
}
private void ClearEquipment()
{
WeaponAbility.GetComponent <WeaponAbility>().GetItem(null, null);
HealingAbility.GetComponent <HealingAbility>().GetItem(null, null);
CombatAbility.GetComponent <CombatAbility>().GetItem(null, null);
}
private void UpdateEquipment()
{
WeaponAbility.GetComponent <WeaponAbility>().GetItem(activeCharacter, pivotCharacter);
HealingAbility.GetComponent <HealingAbility>().GetItem(activeCharacter, pivotCharacter);
CombatAbility.GetComponent <CombatAbility>().GetItem(activeCharacter, pivotCharacter);
}
protected override void OnRawDataUpdated()
{
ShipInfo rInfo;
if (!KanColleGame.Current.MasterInfo.Ships.TryGetValue(RawData.ShipID, out rInfo))
{
Info = ShipInfo.Dummy;
}
else
{
if (Info?.ID != RawData.ShipID)
{
r_EquipmentIDs = null;
r_Slots = null;
}
Info = rInfo;
OnPropertyChanged(nameof(Info));
}
HP.Set(RawData.HPMaximum, RawData.HPCurrent);
Fuel.Set(Info.MaxFuelConsumption, RawData.Fuel);
Bullet.Set(Info.MaxBulletConsumption, RawData.Bullet);
Speed = RawData.Speed;
Range = RawData.Range;
Condition = RawData.Condition;
if (KanColleGame.Current.Sortie != null && r_Port.EvacuatedShipIDs.Contains(ID))
{
State |= ShipState.Evacuated;
}
else
{
State &= ~ShipState.Evacuated;
}
if (r_Port.RepairDocks.Values.Any(r => r.Ship == this))
{
State |= ShipState.Repairing;
}
else
{
State &= ~ShipState.Repairing;
UpdateAnchorageRepairStatus(OwnerFleet?.AnchorageRepair?.IsBeingAnchorageRepair(this));
}
if (RawData.ModernizedStatus?.Length >= 5)
{
Status.Update(Info, RawData);
}
if (RawData.Equipment != null)
{
UpdateSlots();
}
CombatAbility.Update();
IsLocked = RawData.IsLocked;
OnPropertyChanged(nameof(Level));
OnPropertyChanged(nameof(ExperienceToNextLevel));
OnPropertyChanged(nameof(Status));
}
public void AddAbility(CombatAbility ability)
{
abilities.Add(ability);
}
public void AddPurchasedCombatAbility(CombatAbility c)
{
purchasedCombatAbilities.Add(c);
persistance.WriteData("purchasedCombatAbilities", purchasedCombatAbilities);
}
// function called when an abililty button on abilities panel is pressed
void selectAbility(CombatAbility ability)
{
attack = ability;
currentStage = turnStages.targetSelection;
targetsRemaining = attack.maxTargets;
}
