public static bool mod_ShowOnSpellBar(GenericAbility ability, CharacterStats stats, int spellLevel)
{
if (ability.Passive)
{
return false;
}
GenericSpell genericSpell = ability as GenericSpell;
GenericCipherAbility genericCipherAbility = ability as GenericCipherAbility;
if (!genericSpell)
{
return genericCipherAbility && (spellLevel <= 0 || genericCipherAbility.SpellLevel == spellLevel);
}
if (genericSpell.SpellClass != stats.CharacterClass && spellLevel > 0 && genericSpell.SpellLevel == spellLevel && IEModOptions.HideAnticlassSpells)
{
return true;
}
if (genericSpell.SpellClass != stats.CharacterClass || (spellLevel > 0 && genericSpell.SpellLevel != spellLevel))
{
return false;
}
if (stats.CharacterClass != CharacterStats.Class.Wizard || !genericSpell.NeedsGrimoire)
{
return true;
}
Equipment component = stats.GetComponent<Equipment>();
if (component == null || component.CurrentItems == null || component.CurrentItems.Grimoire == null)
{
return false;
}
Grimoire component2 = component.CurrentItems.Grimoire.GetComponent<Grimoire>();
return !(component2 == null) && component2.HasSpell(genericSpell);
}
// Use this for initialization
void Start()
{
P1 = GameObject.FindGameObjectWithTag("Player1");
P2 = GameObject.FindGameObjectWithTag ("Player2");
playerHealth1 = P1.GetComponent<CharacterStats> ();
playerHealth2 = P2.GetComponent<CharacterStats> ();
}
public override ControllState handleInput(BThirdPerson controller, CharacterStats stats)
{
Vector3 mousePoint = Vector3.zero;
stats.healthRegenerationRate = 0f;
stats.enduranceRegenerationRate = 0f;
if(controller.stateTime < 0.1){
controller.turnToReferenceObject();
controller.controller.slotRightHand.GetComponent<OWeapon>().enable();
shot = false;
}
if(Random.Range(1,10) < 3){
shot = true;
}
if(controller.stateTime > 0.22f){
if(shot){
return ControllerZombie._ZombieATTACKB;
}
else{
controller.controller.slotRightHand.GetComponent<OWeapon>().disable();
return ControllerZombie._ZombieIDLE;
}
}
return this;
}
public override ControllState handleInput(BThirdPerson controller, CharacterStats stats)
{
Vector3 mousePoint = Vector3.zero;
stats.healthRegenerationRate = 0f;
stats.enduranceRegenerationRate = 0f;
if(controller.stateTime < 0.1){
controller.controller.slotRightHand.GetComponent<OWeapon>().enable();
shot = false;
Vector2 inputVector = new Vector2(Input.GetAxis("Horizontal"),Input.GetAxis("Vertical"));
Vector3 inputVectorTransformed = new Vector3(inputVector.x,0,-inputVector.y);
Vector3 lookTarget = controller.position + (ControllerCamera.hingeUp.transform.rotation*inputVectorTransformed);
controller.turn(lookTarget);
}
if(Input.GetButtonDown("attack") && stats.reduceEndurance(7) && !shot){
shot = true;
}
if(controller.stateTime > 0.22f){
if(shot){
return ControllerKnight._KnightATTACKB;
}
else{
controller.controller.slotRightHand.GetComponent<OWeapon>().disable();
return ControllerKnight._KnightIDLE;
}
}
return this;
}
public static Character Slime()
{
var character = new Character();
var baseStats = new CharacterStats();
baseStats.SetStat(Const.Stats.MaxHp, 700d);
baseStats.SetStat(Const.Stats.MaxMp, 150d);
baseStats.SetStat(Const.Stats.Attack, 300d);
baseStats.SetStat(Const.Stats.Defense, 150d);
baseStats.SetStat(Const.Stats.Wisdom, 70d);
baseStats.SetStat(Const.Stats.Agility, 100d);
baseStats.SetStat(Const.Stats.Mind, 50d);
baseStats.SetStat(Const.Stats.Critical, 0.05d);
baseStats.SetStat(Const.Stats.Accuracy, 0.8d);
baseStats.SetStat(Const.Stats.Evasion, 0.1d);
character.Name = "Slime";
character.BaseStats = baseStats;
character.PortraitPath = "Characters/Slime/portrait";
character.ModelPath = "Characters/Slime/model";
character.AttackDistance = 2.5f;
character.SizeOffset = 1.5f;
character.Skills.Add(Skill.MeleeAttack());
character.Movement = 2;
character.PatternShape = Pattern.Single();
return character;
}
void Awake()
{
anim = GetComponent<Animator>();
cc = this.GetComponent<CharacterController>();
car = GetComponent<CharacterStats>();
shot = GetComponent<Shooting>();
}
public override ControllState handleInput(BThirdPerson controller, CharacterStats stats)
{
if(controller.stateTime > 5.625){
}
return this;
}
public void mod_SetButtonsAnticlassSpells(CharacterStats stats)
{
this.Label = null;
int num = 0;
foreach (GenericAbility current in stats.Abilities)
{
if (current is GenericSpell)
{
CharacterStats.Class spellClass = ((GenericSpell)current).SpellClass;
if (spellClass != stats.CharacterClass || !CharacterStats.IsPlayableClass(spellClass))
{
if ((stats.CharacterClass == CharacterStats.Class.Wizard ||
stats.CharacterClass == CharacterStats.Class.Priest ||
stats.CharacterClass == CharacterStats.Class.Druid ||
stats.CharacterClass == CharacterStats.Class.Chanter ||
stats.CharacterClass == CharacterStats.Class.Cipher) && IEModOptions.HideAnticlassSpells)
{
}
else
{
this.SetButton(num, current.gameObject, UIAbilityBarButtonSet.AbilityButtonAction.CAST_SPELL_ABILITY, current.Icon);
num++;
}
}
}
}
this.HideButtons(num);
this.m_DoRefresh = true;
}
public virtual void Start()
{
characterStats = gameObject.GetCharacterStats();
inventory = gameObject.GetInventory();
playerMotor = gameObject.GetPlayerMotor();
characterStats.Died += characterStats_Died;
}
void Start(){
playerControls = gameObject.GetComponent<PlayerControls> ();
charStats = playerControls.characterStats;
normalName = playerControls.controllerType+"Normal";
specialName = playerControls.controllerType+"Special";
horName = playerControls.controllerType+"Horizontal";
verName = playerControls.controllerType+"Vertical";
}
public void SubtractStats(CharacterStats statsToSubtract)
{
swagger -= statsToSubtract.swagger;
strength -= statsToSubtract.strength;
agility -= statsToSubtract.agility;
mind -= statsToSubtract.mind;
health -= statsToSubtract.health;
}
public void AddStats(CharacterStats statsToAdd)
{
swagger += statsToAdd.swagger;
strength += statsToAdd.strength;
agility += statsToAdd.agility;
mind += statsToAdd.mind;
health += statsToAdd.health;
}
void Start()
{
anim = GetComponent<Animator>();
playerController = GetComponent<PlayerMovementController>();
characterStats = GetComponent<CharacterStats>();
colliderr = GetComponent<CapsuleCollider>();
characterControlInterface = GetComponent<CharacterControlInterface>();
}
void Awake()
{
stats = GetComponentInParent<CharacterStats>();
if (stats == null)
{
Debug.LogError("Can not found CharacterStats! " + this.gameObject.name);
}
}
//private Text text;
void Start()
{
characterStats = character.GetComponent<CharacterStats>();
HPBarRectTransform = HPBarImage.GetComponent<RectTransform>();
originalSize = HPBarRectTransform.sizeDelta;
originalLocalPosition = HPBarRectTransform.localPosition;
//text = HPBarText.GetComponent<Text>();
}
void Start()
{
characterStats = GetComponent<CharacterStats>();
characterStats.HPScaler *= hpScale;
characterStats.MovingSpeedModifier += movingSpeedModifier;
transform.localScale *= sizeScale;
}
public CharacterStats Clone()
{
var clone = new CharacterStats();
foreach (var key in this._stats.Keys)
{
clone._stats[key] = this._stats[key];
}
return clone;
}
public float GetCurrentBonusMultiplierNew(CharacterStats stats, GenericAbility abilityOrigin)
{
if (stats == null)
{
return 1f;
}
float bonus = 0f;
if (IEModOptions.NPCDispositionFix || (GameState.s_playerCharacter != null && stats.gameObject == GameState.s_playerCharacter.gameObject)) // added ((Mod_GameOptions_GameMode)GameState.Mode).NPCDispositionFix ||
{
float single = 1f;
if (abilityOrigin != null)
{
single = single * abilityOrigin.GatherAbilityModProduct(AbilityMod.AbilityModType.NegativeReligiousTraitMultiplier);
}
if (stats.CharacterClass == CharacterStats.Class.Priest)
{
global::Religion.DeityData deityDatum = this.FindDeityData(stats.Deity);
if (deityDatum != null)
{
bonus = bonus + this.GetBonus(deityDatum.PositiveTrait[0], this.PositiveTraitBonus);
bonus = bonus + this.GetBonus(deityDatum.PositiveTrait[1], this.PositiveTraitBonus);
bonus = bonus + this.GetBonus(deityDatum.NegativeTrait[0], this.NegativeTraitBonus) * single;
bonus = bonus + this.GetBonus(deityDatum.NegativeTrait[1], this.NegativeTraitBonus) * single;
}
}
else if (stats.CharacterClass == CharacterStats.Class.Paladin)
{
global::Religion.PaladinOrderData paladinOrderDatum = this.FindPaladinOrderData(stats.PaladinOrder);
if (paladinOrderDatum != null)
{
/* patching in dis/favored dispositions for Pallegina's order */
if (stats.PaladinOrder == PaladinOrder.FrermasMesCancSuolias)
{
var favored1 = IEModOptions.PalleginaFavored1;
var favored2 = IEModOptions.PalleginaFavored2;
var disfavored1 = IEModOptions.PalleginaDisfavored1;
var disfavored2 = IEModOptions.PalleginaDisfavored2;
paladinOrderDatum.PositiveTrait = new Disposition.Axis[2];
paladinOrderDatum.PositiveTrait[0] = favored1;
paladinOrderDatum.PositiveTrait[1] = favored2;
paladinOrderDatum.NegativeTrait = new Disposition.Axis[2];
paladinOrderDatum.NegativeTrait[0] = disfavored1;
paladinOrderDatum.NegativeTrait[1] = disfavored2;
}
/**************************************************************************************/
bonus = bonus + this.GetBonus(paladinOrderDatum.PositiveTrait[0], this.PositiveTraitBonus);
bonus = bonus + this.GetBonus(paladinOrderDatum.PositiveTrait[1], this.PositiveTraitBonus);
bonus = bonus + this.GetBonus(paladinOrderDatum.NegativeTrait[0], this.NegativeTraitBonus) * single;
bonus = bonus + this.GetBonus(paladinOrderDatum.NegativeTrait[1], this.NegativeTraitBonus) * single;
}
}
}
bonus = bonus + 1f;
return bonus;
}
Vector3 greenPos; //Position of the health bar relative to the character
#endregion Fields
#region Methods
void Awake()
{
//loads enemy health value from healthScript
healthScript = transform.parent.gameObject.GetComponent<CharacterStats>();
curHealth = healthScript.health;
maxHealth = healthScript.maxHealth;
//stores two health values, will come in later
}
void Start()
{
if (gameManager == null) {
gameManager = Camera.main.GetComponent<GameManager>();
}
characterStats = GetComponent<CharacterStats>();
previousHP = characterStats.MaxHP;
}
public static CharacterStats Copy(CharacterStats original)
{
CharacterStats copy = new CharacterStats();
copy.agility = original.agility;
copy.strength = original.strength;
copy.health = original.health;
copy.mind = original.mind;
copy.swagger = original.swagger;
return copy;
}
// Use this for initialization
void Start () {
ownColor = gameObject.GetComponent<SpriteRenderer>().color;
_myStats = new CharacterStats(gameObject.tag.ToString());
if( _myStats.load() ){
hp = _myStats.getHp();
exp = _myStats.getExp();
coin = _myStats.getCoin();
max_hp = hp;
}
}
public static void onHit(BThirdPerson controller, Collider collider, CharacterStats stats)
{
OStroke stroke = collider.gameObject.GetComponent<OStroke>();
if(stroke){
controller.hitBack(stroke.strokeForce, collider.gameObject);
stats.reduceHealthImpact(stroke.strength);
}
else{
stats.reduceHealthImpact(5f);
}
}
void Start()
{
characterStats = GetComponent<CharacterStats>();
for (int i = 0; i < transform.childCount; ++i) {
Renderer targetRenderer = transform.GetChild(i).GetComponent<Renderer>();
if (targetRenderer != null) {
targetRenderer.material.color = Color.green;
}
}
}
//for testing...
private CharacterStats GetRandomStats()
{
CharacterStats stats = new CharacterStats();
stats.agility = Random.Range(5, 18);
stats.health = Random.Range(5, 18);
stats.mind = Random.Range(5, 18);
stats.strength = Random.Range(5, 18);
stats.swagger = Random.Range(5, 18);
return stats;
}
public static void SaveCharacterStats(GameObject player) {
if (player.GetComponent<PlayerControls> () != null) {
SaveCharStats.playerStats = player.GetComponent<PlayerControls> ().characterStats;
BinaryFormatter bf = new BinaryFormatter ();
FileStream file = File.Create (Application.persistentDataPath + "/" + player.name + ".pfgon");
bf.Serialize (file, SaveCharStats.playerStats);
file.Close ();
} else {
Debug.Log ("Michael! You're and idiot! This doesn't have a CharacterStats!");
}
}
// Use this for initialization
void Start()
{
player = GetComponent<Transform>();
animator = GetComponent<Animator>();
weaponColliders = GetComponentsInChildren<BoxCollider>();
playerCollider = GetComponent<CapsuleCollider>();
playerStats = GetComponent<CharacterStats>();
foreach (Collider weaponCollider in weaponColliders)
{
Physics.IgnoreCollision(weaponCollider, playerCollider);
}
}
void Start()
{
characterStats = GetComponent<CharacterStats>();
characterStats.MovingSpeedModifier += movingSpeedModifier;
for (int i = 0; i < transform.childCount; ++i) {
Renderer targetRenderer = transform.GetChild(i).GetComponent<Renderer>();
if (targetRenderer != null) {
targetRenderer.material.color = Color.red;
}
}
}
// Use this for initialization
void Start()
{
if (Stats == null)
{
Stats = FindObjectOfType<CharacterStats>();
}
BarsMaterials = new Material[2];
BarsMaterials[0] = new Material(Bars[0].GetComponent<Image>().material);
BarsMaterials[1] = new Material(Bars[1].GetComponent<Image>().material);
Bars[0].GetComponent<Image>().material = BarsMaterials[0];
Bars[1].GetComponent<Image>().material = BarsMaterials[1];
}
void SelectedChar()
{
_characterStats = characterSelected.GetComponent<CharacterStats>();
if(_characterSelected.character1Selected == true){
characterSelected = Characters[0];
}
if(_characterSelected.character2Selected == true){
characterSelected = Characters[1];
}
if(_characterSelected.character3Selected == true){
characterSelected = Characters[2];
}
}
void Start()
{
myStats = GetComponent <CharacterStats>();
}
/// <summary>
/// Determines how a card action takes effect
///
/// More description/complexity will be required
/// </summary>
/// <param name="effect"></param>
/// <param name="caster">Stats of the casting character</param>
/// <param name="target">Stats of the target character</param>
void ApplyAction(CardAction casterEffect, CardAction targetEffect, CharacterStats caster, CharacterStats target)
{
int damage = casterEffect.damageVal;
int cardHeal = casterEffect.healVal;
damage -= targetEffect.defenseVal;
if (damage < 0)
{
damage = 0;
}
//TODO: Change to an actual UI
Debug.Log(caster.charName + " played " + casterEffect.cardName + ", dealing " + damage + " damage and healing " + cardHeal);
caster.changeHP(-cardHeal);
target.changeHP(damage);
}
//Initialize components
void Start()
{
myStats = GetComponent <CharacterStats>();
playerMotor = Player.instance.GetComponent <PlayerMotor2>();
playerManager = PlayerManager.instance;
}
void OnTriggerEnter(Collider collider)
{
//Reduce life by amount specified in enemyStrength
CharacterStats.ReduceLife(enemyStrength);
}
public virtual void Attack(CharacterStats targetStats)
{
}
void Start()
{
_stats = GetComponent <CharacterStats>();
_thisTransform = GetComponent <Transform>();
}
public void DealDamage(CharacterStats _target)
{
_target.TakeDamage(m_physicalDamage, m_attackType);
// Debug.Log(transform.name + " Is dealing damage.");
}
public static bool Prefix(CharacterStats __instance)
{
Character _c = __instance.GetComponent <Character>();
if ((!(bool)CustomGameStats.PlayerConfig.GetValue(Settings.ToggleSwitch) &&
!(bool)CustomGameStats.AIConfig.GetValue(Settings.ToggleSwitch)) ||
NetworkLevelLoader.Instance.IsGameplayLoading ||
!_c.IsLateInitDone)
{
return(true);
}
if (!PhotonNetwork.isNonMasterClientInRoom)
{
if (!_c.IsAI)
{
if ((bool)CustomGameStats.PlayerConfig.GetValue(Settings.ToggleSwitch))
{
Instance.ApplyCustomStats(_c, CustomGameStats.PlayerConfig, Settings.PlayerStats, true);
}
else
{
Instance.ApplyCustomStats(_c, CustomGameStats.PlayerConfig, Settings.PlayerStats, false);
}
}
else
{
if ((bool)CustomGameStats.AIConfig.GetValue(Settings.ToggleSwitch))
{
Instance.ApplyCustomStats(_c, CustomGameStats.AIConfig, Settings.AIStats, true);
}
else
{
Instance.ApplyCustomStats(_c, CustomGameStats.AIConfig, Settings.AIStats, false);
}
}
}
else
{
if (!Instance._playerSyncInit || !Instance._aiSyncInit)
{
Instance.RequestSync();
}
if (!_c.IsAI)
{
if (Instance.CurrentPlayerSyncInfo != null && Instance._playerSyncInit)
{
if ((bool)Instance.CurrentPlayerSyncInfo.GetValue(Settings.ToggleSwitch))
{
Instance.ApplyCustomStats(_c, Instance.CurrentPlayerSyncInfo, Settings.PlayerStats, true);
}
else
{
Instance.ApplyCustomStats(_c, Instance.CurrentPlayerSyncInfo, Settings.PlayerStats, false);
}
}
}
else
{
if (Instance.CurrentAISyncInfo != null && Instance._aiSyncInit)
{
if ((bool)Instance.CurrentAISyncInfo.GetValue(Settings.ToggleSwitch))
{
Instance.ApplyCustomStats(_c, Instance.CurrentAISyncInfo, Settings.AIStats, true);
}
else
{
Instance.ApplyCustomStats(_c, Instance.CurrentAISyncInfo, Settings.AIStats, false);
}
}
}
}
return(false);
}
void Start()
{
EneemyManager = PlayerManager.instance;
myStats = GetComponent <CharacterStats>();
parti.Stop();
}
private void ClearCustomStat(CharacterStats stats, Tag statTag, string stackSource, bool mult)
{
stats.RemoveStatStack(statTag, stackSource, !mult);
stats.RemoveStatStack(statTag, stackSource, mult);
}
// monster switch statement ahead...
private void SetCustomStat(CharacterStats stats, string stackSource, Tag statTag, float value, bool mult, ModConfig config)
{
ClearCustomStat(stats, statTag, stackSource, mult);
stats.RefreshVitalMaxStat();
Stat[] _dmg = (Stat[])AT.GetValue(typeof(CharacterStats), stats, "m_damageTypesModifier");
Stat[] _pro = (Stat[])AT.GetValue(typeof(CharacterStats), stats, "m_damageProtection");
Stat[] _res = (Stat[])AT.GetValue(typeof(CharacterStats), stats, "m_damageResistance");
switch (statTag.TagName)
{
case "MaxHealth":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, AT.GetCharacterStat(stats, "m_maxHealthStat"), value, CharacterStats.MIN_MAXHEALTH_LIMIT, config)), mult);
break;
case "HealthRegen":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, AT.GetCharacterStat(stats, "m_healthRegen"), value, Settings.Minimum, config)), mult);
break;
case "HealthBurn":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, AT.GetCharacterStat(stats, "m_burntHealthModifier"), value, Settings.MinimumMod, config)), mult);
break;
case "MaxStamina":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, AT.GetCharacterStat(stats, "m_maxStamina"), value, CharacterStats.MIN_MAXSTAMINA_LIMIT, config)), mult);
break;
case "StaminaRegen":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, AT.GetCharacterStat(stats, "m_staminaRegen"), value, Settings.MinimumMod, config)), mult);
break;
case "StaminaUse":
case "StaminaCostReduction":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, AT.GetCharacterStat(stats, "m_staminaUseModifiers"), value, Settings.Minimum, config)), mult);
break;
case "StaminaBurn":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, AT.GetCharacterStat(stats, "m_burntStaminaModifier"), value, Settings.MinimumMod, config)), mult);
break;
case "MaxMana":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, AT.GetCharacterStat(stats, "m_maxManaStat"), value, Settings.Minimum, config)), mult);
break;
case "ManaRegen":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, AT.GetCharacterStat(stats, "m_manaRegen"), value, Settings.Minimum, config)), mult);
break;
case "ManaUse":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, AT.GetCharacterStat(stats, "m_manaUseModifiers"), value, Settings.Minimum, config)), mult);
break;
case "ManaBurn":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, AT.GetCharacterStat(stats, "m_burntManaModifier"), value, Settings.MinimumMod, config)), mult);
break;
case "Impact":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, AT.GetCharacterStat(stats, "m_impactModifier"), value, Settings.Minimum, config)), mult);
break;
case "AllDamages":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, AT.GetCharacterStat(stats, "m_damageModifiers"), value, Settings.Minimum, config)), mult);
break;
case "PhysicalDamage":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, _dmg[0].CurrentValue, value, Settings.Minimum, config)), mult);
break;
case "EtherealDamage":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, _dmg[1].CurrentValue, value, Settings.Minimum, config)), mult);
break;
case "DecayDamage":
case "DarkDamage":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, _dmg[2].CurrentValue, value, Settings.Minimum, config)), mult);
break;
case "ElectricDamage":
case "LightDamage":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, _dmg[3].CurrentValue, value, Settings.Minimum, config)), mult);
break;
case "FrostDamage":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, _dmg[4].CurrentValue, value, Settings.Minimum, config)), mult);
break;
case "FireDamage":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, _dmg[5].CurrentValue, value, Settings.Minimum, config)), mult);
break;
case "DamageProtection":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, AT.GetCharacterStat(stats, "m_allDamageProtection"), value, Settings.Minimum, config)), mult);
break;
case "PhysicalProtection":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, _pro[0].CurrentValue, value, Settings.Minimum, config)), mult);
break;
case "EtherealProtection":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, _pro[1].CurrentValue, value, Settings.Minimum, config)), mult);
break;
case "DecayProtection":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, _pro[2].CurrentValue, value, Settings.Minimum, config)), mult);
break;
case "ElectricProtection":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, _pro[3].CurrentValue, value, Settings.Minimum, config)), mult);
break;
case "FrostProtection":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, _pro[4].CurrentValue, value, Settings.Minimum, config)), mult);
break;
case "FireProtection":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, _pro[5].CurrentValue, value, Settings.Minimum, config)), mult);
break;
case "DarkProtection":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, _pro[6].CurrentValue, value, Settings.Minimum, config)), mult);
break;
case "LightProtection":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, _pro[7].CurrentValue, value, Settings.Minimum, config)), mult);
break;
case "AllResistances":
case "DamageResistance":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, AT.GetCharacterStat(stats, "m_resistanceModifiers"), value, Settings.Minimum, config)), mult);
break;
case "PhysicalResistance":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, _res[0].CurrentValue, value, Settings.Minimum, config)), mult);
break;
case "EtherealResistance":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, _res[1].CurrentValue, value, Settings.Minimum, config)), mult);
break;
case "DecayResistance":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, _res[2].CurrentValue, value, Settings.Minimum, config)), mult);
break;
case "ElectricResistance":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, _res[3].CurrentValue, value, Settings.Minimum, config)), mult);
break;
case "FrostResistance":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, _res[4].CurrentValue, value, Settings.Minimum, config)), mult);
break;
case "FireResistance":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, _res[5].CurrentValue, value, Settings.Minimum, config)), mult);
break;
case "DarkResistance":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, _res[6].CurrentValue, value, Settings.Minimum, config)), mult);
break;
case "LightResistance":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, _res[7].CurrentValue, value, Settings.Minimum, config)), mult);
break;
case "ImpactResistance":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, AT.GetCharacterStat(stats, "m_impactResistance"), value, Settings.Minimum, config)), mult);
break;
case "StabilityRegen":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, AT.GetCharacterStat(stats, "m_stabilityRegen"), value, Settings.MinimumMod, config)), mult);
break;
case "EnvColdProtection":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, AT.GetCharacterStat(stats, "m_coldProtection"), value, Settings.Minimum, config)), mult);
break;
case "EnvHeatProtection":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, AT.GetCharacterStat(stats, "m_heatProtection"), value, Settings.Minimum, config)), mult);
break;
case "ColdRegen":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, AT.GetCharacterStat(stats, "m_coldRegenRate"), value, Settings.MinimumMod, config)), mult);
break;
case "HeatRegen":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, AT.GetCharacterStat(stats, "m_heatRegenRate"), value, Settings.MinimumMod, config)), mult);
break;
case "Waterproof":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, AT.GetCharacterStat(stats, "m_waterproof"), value, Settings.Minimum, config)), mult);
break;
case "CorruptionResistance":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, AT.GetCharacterStat(stats, "m_corruptionResistance"), value, Settings.Minimum, config)), mult);
break;
case "TemperatureModifier":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, AT.GetCharacterStat(stats, "m_temperatureModifier"), value, Settings.Minimum, config)), mult);
break;
case "MovementSpeed":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, AT.GetCharacterStat(stats, "m_movementSpeed"), value, Settings.MinimumMod, config)), mult);
break;
case "Speed":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, AT.GetCharacterStat(stats, "m_speedModifier"), value, Settings.MinimumMod, config)), mult);
break;
case "AttackSpeed":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, AT.GetCharacterStat(stats, "m_attackSpeedModifier"), value, Settings.MinimumMod, config)), mult);
break;
case "DodgeInvulnerabilityModifier":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, AT.GetCharacterStat(stats, "m_dodgeInvulneratiblityModifier"), value, Settings.MinimumMod, config)), mult);
break;
case "Detectability":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, AT.GetCharacterStat(stats, "m_detectability"), value, Settings.Minimum, config)), mult);
break;
case "VisualDetectability":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, AT.GetCharacterStat(stats, "m_visualDetectability"), value, Settings.Minimum, config)), mult);
break;
case "PouchCapacity":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, AT.GetCharacterStat(stats, "m_pouchCapacity"), value, Settings.Minimum, config)), mult);
break;
case "FoodEffectEfficiency":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, AT.GetCharacterStat(stats, "m_foodEffectEfficiency"), value, Settings.Minimum, config)), mult);
break;
case "SkillCooldownModifier":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, AT.GetCharacterStat(stats, "m_skillCooldownModifier"), value, Settings.MinimumMod, config)), mult);
break;
case "BuyModifier":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, AT.GetCharacterStat(stats, "m_buyModifier"), value, Settings.MinimumMod, config)), mult);
break;
case "SellModifier":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, AT.GetCharacterStat(stats, "m_sellModifier"), value, Settings.MinimumMod, config)), mult);
break;
case "FoodDepleteRate":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, AT.GetPlayerStat(stats.GetComponent <PlayerCharacterStats>(), "m_foodDepletionRate"), value, Settings.MinimumMod, config)), mult);
break;
case "DrinkDepleteRate":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, AT.GetPlayerStat(stats.GetComponent <PlayerCharacterStats>(), "m_drinkDepletionRate"), value, Settings.MinimumMod, config)), mult);
break;
case "SleepDepleteRate":
stats.AddStatStack(statTag, new StatStack(stackSource, Modify(mult, AT.GetPlayerStat(stats.GetComponent <PlayerCharacterStats>(), "m_sleepDepletionRate"), value, Settings.MinimumMod, config)), mult);
break;
}
}
public abstract AbilityCaster Initialize(CharacterStats caster);
/// <summary>
/// Given a card and stats for both a player and enemy, apply those effects to each other simultaneously
/// </summary>
/// <param name="playerCard"></param>
/// <param name="playerStats"></param>
/// <param name="enemyCard"></param>
/// <param name="enemyStats"></param>
public void BattleCalculations(CardAction playerCard, CharacterStats playerStats, CardAction enemyCard, CharacterStats enemyStats)
{
//apply card effects to both characters
ApplyAction(playerCard, enemyCard, playerStats, enemyStats);
ApplyAction(enemyCard, playerCard, enemyStats, playerStats);
}
private void Start()
{
playerManager = PlayerManager.instance;
myStats = GetComponent <CharacterStats>();
}
public override void ApplyEffect(CharacterStats stats)
{
stats.Heal(10);
}
void Start()
{
stats = GetComponent <Player>().characterStats;
}
private void Start()
{
spawnProjectile = transform.Find("ProjectileSpawn");
characterStats = GetComponent <CharacterStats>();
}
private void Awake()
{
stats = GetComponent <CharacterStats>();
}
public void Consume(CharacterStats stat)
{
throw new System.NotImplementedException();
}
IEnumerator PickUp(Collider other)
{
gameObject.GetComponent <MeshRenderer>().enabled = false;
gameObject.GetComponent <Collider>().enabled = false;
gameObject.GetComponent <ParticleSystem>().Stop();
CharacterStats stats = other.GetComponent <CharacterStats>();
Axe axe = other.GetComponentInChildren <Axe>();
Sword sword = other.GetComponentInChildren <Sword>();
Spell spell = other.GetComponentInChildren <Spell>();
if (charBoost != null)
{
Destroy(Instantiate(charBoost.pickUpEffect, gameObject.transform.position, Quaternion.identity), 3f);
Destroy(Instantiate(charBoost.pickUpSound, gameObject.transform.position, Quaternion.identity), 3f);
Destroy(Instantiate(charBoost.pickUpText, gameObject.transform.position, Quaternion.identity), 5f);
powerUpDuration = charBoost.boostDuration;
if (powerUpDuration > 20f)
{
powerUpDuration = 20f;
}
stats.maxHealth += charBoost.healthBoost;
stats.maxMana += charBoost.manaBoost;
stats.moveSpeed += charBoost.speedBoost;
stats.jumpForce += charBoost.jumpForceBoost;
stats.replenishH += charBoost.healthRegenBoost;
stats.replenishM += charBoost.manaRegenBoost;
}
else if (axeBoost != null)
{
Destroy(Instantiate(axeBoost.pickUpEffect, gameObject.transform.position, Quaternion.identity), 3f);
Destroy(Instantiate(axeBoost.pickUpSound, gameObject.transform.position, Quaternion.identity), 3f);
Destroy(Instantiate(axeBoost.pickUpText, gameObject.transform.position, Quaternion.identity), 3f);
powerUpDuration = axeBoost.boostDuration;
if (powerUpDuration > 20f)
{
powerUpDuration = 20f;
}
axe.axeMultiShot = axeBoost.multiShooter;
axe.axeConeSize = axeBoost.shotSpread;
axe.axeShotgunAmount = axeBoost.shotMultiply;
for (int i = 0; i < axe.axeStats.Length; i++)
{
//Debug.Log("BOOSTED BY " + axeBoost.GetAxeBoostArray()[i]);
if (axeBoost.GetAxeBoostArray()[i] > 0)
{
axe.axeStats[i] *= axeBoost.GetAxeBoostArray()[i];
}
//Debug.Log("AFTER BOOST VALUE " + axe.axeStats[i]);
}
}
else if (swordBoost != null)
{
Destroy(Instantiate(swordBoost.pickUpEffect, gameObject.transform.position, Quaternion.identity), 3f);
Destroy(Instantiate(swordBoost.pickUpSound, gameObject.transform.position, Quaternion.identity), 3f);
Destroy(Instantiate(swordBoost.pickUpText, gameObject.transform.position, Quaternion.identity), 3f);
powerUpDuration = swordBoost.boostDuration;
if (powerUpDuration > 20f)
{
powerUpDuration = 20f;
}
sword.swordMultiShot = swordBoost.multiShooter;
sword.swordConeSize = swordBoost.shotSpread;
sword.swordShotgunAmount = swordBoost.shotMultiply;
for (int i = 0; i < sword.swordStats.Length; i++)
{
//Debug.Log("BOOSTED BY " + swordBoost.GetSwordBoostArray()[i]);
if (swordBoost.GetSwordBoostArray()[i] > 0)
{
sword.swordStats[i] *= swordBoost.GetSwordBoostArray()[i];
}
//Debug.Log("AFTER BOOST VALUE " + sword.swordStats[i]);
}
}
else if (spellBoost != null)
{
Destroy(Instantiate(spellBoost.pickUpEffect, gameObject.transform.position, Quaternion.identity), 3f);
Destroy(Instantiate(spellBoost.pickUpSound, gameObject.transform.position, Quaternion.identity), 3f);
Destroy(Instantiate(spellBoost.pickUpText, gameObject.transform.position, Quaternion.identity), 3f);
powerUpDuration = spellBoost.boostDuration;
if (powerUpDuration > 20f)
{
powerUpDuration = 20f;
}
spell.spellMultiShot = spellBoost.multiShooter;
spell.spellConeSize = spellBoost.shotSpread;
spell.spellShotgunAmount = spellBoost.shotMultiply;
for (int i = 0; i < spell.spellStats.Length; i++)
{
//Debug.Log("BOOSTED BY " + spellBoost.GetSpellBoostArray()[i]);
if (spellBoost.GetSpellBoostArray()[i] > 0)
{
spell.spellStats[i] *= spellBoost.GetSpellBoostArray()[i];
}
//Debug.Log("AFTER BOOST VALUE " + spell.spellStats[i]);
}
}
yield return(new WaitForSeconds(powerUpDuration));
if (axeBoost != null)
{
axe.LoadAxeStats();
axe.axeMultiShot = false;
}
else if (swordBoost != null)
{
sword.LoadSwordStats();
sword.swordMultiShot = false;
}
else if (spellBoost != null)
{
spell.LoadSpellStats();
spell.spellMultiShot = false;
}
else if (charBoost != null)
{
stats.maxHealth -= charBoost.healthBoost;
stats.maxMana -= charBoost.manaBoost;
stats.moveSpeed -= charBoost.speedBoost;
stats.jumpForce -= charBoost.jumpForceBoost;
stats.replenishH -= charBoost.healthRegenBoost;
stats.replenishM -= charBoost.manaRegenBoost;
}
Destroy(gameObject);
}
public Weapon(int a)
{
base.itemDD = a;
if (a == 0)
{
base.name = "Axe of the Celestial Battalion";
base.Description = "battleaxe forged by master dwarven and poladar blacksmiths and blessed \n" +
"by a great sorcerer, it was made for a poladar chief.\n ";
base.cost = 20;
base.isDestroyed = false;
base.Part = "Weapon";
base.Type = "Axe";
CharacterStats temp = new CharacterStats();
temp.setCHA(0);
temp.setCON(1);
temp.setINT(0);
temp.setDEX(2);
temp.setSTR(0);
temp.setWIS(0);
base.bonus = temp;
}
else
{
if (a == 1)
{
base.name = "Elven Blade";
base.Description = "This sword (like the other eleven) has a generic metallic colored blade and a black hilt.\n" +
"There is a small white symbol (See Symbol below) etched in on side of the black hilt.";
base.cost = 40;
base.isDestroyed = false;
base.Part = "Weapon";
base.Type = "Sword";
CharacterStats temp = new CharacterStats();
temp.setCHA(1);
temp.setCON(0);
temp.setINT(1);
temp.setDEX(1);
temp.setSTR(0);
temp.setWIS(1);
base.bonus = temp;
}
else
{
if (a == 2)
{
base.name = "Warlord’s Bow";
base.Description = "This mithral elements of bow allows the shooter \nto attract and lead a number of followers ";
base.cost = 60;
base.isDestroyed = false;
base.Part = "Weapon";
base.Type = "Bow";
CharacterStats temp = new CharacterStats();
temp.setCHA(4);
temp.setCON(0);
temp.setINT(1);
temp.setDEX(1);
temp.setSTR(0);
temp.setWIS(0);
base.bonus = temp;
}
else
{
if (a == 3)
{
base.name = "Demon Blade";
base.Description = "This blade is fashioned to make the warrior appear \n" +
"to be a demon. The pictures on the blades shows a horned demon head";
base.cost = 20;
base.isDestroyed = false;
base.Part = "Weapon";
base.Type = "Blade";
CharacterStats temp = new CharacterStats();
temp.setCHA(1);
temp.setCON(0);
temp.setINT(0);
temp.setDEX(1);
temp.setSTR(3);
temp.setWIS(0);
base.bonus = temp;
}
else
{
if (a == 5)
{
base.name = "Dragonskin hook";
base.Description = "This hook is crafted from the hide of a great wyrm dragon.\n" +
" At the warrior's command, the hook sprouts enormous dragon wings, \n" +
"giving warrior more mobility .";
base.cost = 60;
base.isDestroyed = false;
base.Part = "Weapon";
base.Type = "Hook";
CharacterStats temp = new CharacterStats();
temp.setCHA(0);
temp.setCON(0);
temp.setINT(1);
temp.setDEX(4);
temp.setSTR(1);
temp.setWIS(0);
base.bonus = temp;
}
else
{
if (a == 4)
{
base.name = "Dagger of Luck";
base.Description = "This dagger gives wearer a lot of bonuses ";
base.cost = 40;
base.isDestroyed = false;
base.Part = "Weapon";
base.Type = "Dagger";
CharacterStats temp = new CharacterStats();
temp.setCHA(1);
temp.setCON(1);
temp.setINT(1);
temp.setDEX(1);
temp.setSTR(0);
temp.setWIS(1);
base.bonus = temp;
}
}
}
}
}
}
}
// takes in the stats of the character that we want to attack
//public void Attack (CharacterStats targetStats, Animator anim)
//{
// if (attackCooldown < 0f)
// {
// anim.SetTrigger("Hit1");
// StartCoroutine(DoDamage(targetStats, damageDelay));
// if (OnAttack != null)
// {
// OnAttack();
// }
// //play animation
// // the greater the attack speed the faster the cooldown
// attackCooldown = 1f / attackSpeed;
// }
//}
IEnumerator DoDamage(CharacterStats stats, float delay)
{
yield return(new WaitForSeconds(delay));
stats.TakeDamage(myStats.damage.GetValue());
}
public override void Equip(CharacterStats cs)
{
base.Equip(cs);
}
public static bool ItemTransferValidNew(InventoryItem invitem, UIInventoryGridItem from, UIInventoryGridItem to,
out string error, bool alreadyHeld = false)
{
UIInventoryItemZone owner;
error = string.Empty;
if (invitem == null || invitem.baseItem == null)
{
return(true);
}
if (from == to && UIGlobalInventory.Instance.DragOwnerIsSame())
{
return(true);
}
InventoryItem inventoryItem = invitem;
UIInventoryGridItem uIInventoryGridItem = from;
if (!to)
{
owner = null;
}
else
{
owner = to.Owner;
}
if (!UIInventoryGridItem.ItemTransferValid(inventoryItem, uIInventoryGridItem, owner, out error, alreadyHeld))
{
return(false);
}
if (!UIInventoryGridItem.ItemTakeValid(to, out error))
{
return(false);
}
//!+ ADDED CODE
// this is to disallow items TO
if (IEModOptions.UnlockCombatInv && GameState.InCombat &&
(to.EquipmentSlot == Equippable.EquipmentSlot.Armor || ForbiddenToMoveItems.Contains(invitem.BaseItem.Name)))
{
// doesn't allow equipping/unequipping armor during combat, as well as summoned magical items such as druid cat claws
error = GUIUtils.GetText(0xd7);
return(false);
}
//!+ END ADD
if (to && (to.Locked || to.Blocked || !to.EquipmentModifyValid()))
{
return(false);
}
if (to && to.EquipmentSlot != Equippable.EquipmentSlot.None)
{
error = GUIUtils.GetText(217);
Equippable equippable = invitem.baseItem as Equippable;
EquipmentSoulbind component = invitem.baseItem.GetComponent <EquipmentSoulbind>();
if (!equippable)
{
return(false);
}
if (!equippable.CanUseSlot(to.EquipmentSlot))
{
return(false);
}
if (to.WeaponSetBuddy != null && !to.WeaponSetBuddy.Empty)
{
if (equippable.BothPrimaryAndSecondarySlot)
{
error = GUIUtils.GetText(1737);
return(false);
}
Equippable invItem = to.WeaponSetBuddy.InvItem.baseItem as Equippable;
if (invItem && invItem.BothPrimaryAndSecondarySlot)
{
error = GUIUtils.GetText(1737);
return(false);
}
}
Equipment selectedEquipment = UIInventoryManager.Instance.Equipment.SelectedEquipment;
if (selectedEquipment && selectedEquipment.IsSlotLocked(to.EquipmentSlot))
{
return(false);
}
Equippable.CantEquipReason cantEquipReason = equippable.WhyCantEquip(UIInventoryManager.Instance.SelectedCharacter.gameObject);
if (cantEquipReason != Equippable.CantEquipReason.None)
{
CharacterStats selectedCharacter = UIInventoryManager.Instance.SelectedCharacter;
switch (cantEquipReason)
{
case Equippable.CantEquipReason.EquipmentLocked:
{
object[] name = new object[] { invitem.baseItem.Name, CharacterStats.Name(selectedCharacter) };
error = GUIUtils.Format(1003, name);
break;
}
case Equippable.CantEquipReason.ClassMismatch:
{
error = GUIUtils.Format(1003, new object[] { invitem.baseItem.Name, GUIUtils.GetClassString(selectedCharacter.CharacterClass, selectedCharacter.Gender) });
break;
}
case Equippable.CantEquipReason.SoulboundToOther:
{
error = GUIUtils.Format(2038, new object[] { equippable.Name, CharacterStats.Name(component.BoundGuid) });
break;
}
default:
{
goto case Equippable.CantEquipReason.EquipmentLocked;
}
}
return(false);
}
}
if (from.EquipmentSlot != Equippable.EquipmentSlot.None)
{
Equipment equipment = UIInventoryManager.Instance.Equipment.SelectedEquipment;
if (equipment && to && equipment.IsSlotLocked(to.EquipmentSlot))
{
return(false);
}
}
if (to && to.EquipmentSlot == Equippable.EquipmentSlot.Grimoire && UIInventoryManager.Instance.SelectedCharacter.EffectDisablesSpellcasting)
{
error = GUIUtils.GetText(1738);
return(false);
}
if (to && to.RestrictByFilter != UIInventoryFilter.ItemFilterType.NONE && (invitem.baseItem.FilterType & to.RestrictByFilter) == UIInventoryFilter.ItemFilterType.NONE)
{
if (to.OrAllowEquipment == Equippable.EquipmentSlot.None || !(invitem.baseItem is Equippable) || !(invitem.baseItem as Equippable).CanUseSlot(to.OrAllowEquipment))
{
return(false);
}
}
return(true);
}
public override void Unequip(CharacterStats cs)
{
base.Unequip(cs);
}
private void Start()
{
characterStats = GetComponentInParent <CharacterStats>();
}
private void Select(Transform target)
{
_target = target;
_targetStats = _target.GetComponent <CharacterStats>();
}
public CharacterView(ContentManager content, string assetName, int frameWidth, int frameHeight, float xPos, float yPos, CharacterStats stats)
: base(content, assetName, frameWidth, frameHeight, xPos, yPos)
{
this.stats = stats;
}
public abstract void Cast(CharacterStats onTarget);
private void Unselect()
{
_target = null;
_targetStats = null;
}
