public void setInfoLabel(MyLabel label, Rune check_rune)
{
StatSum statsum = (check_rune != null) ? check_rune.GetStats(Get.isSpecial(label.effect_type)) : null;
StatBit statbit = (statsum != null) ? statsum.GetStatBit(label.effect_type) : null;
if (label.text != null)
{
label.text.text = "";
}
if (label.image_labels.Length > 0)
{
label.image_labels[0].setLabel("", 0);
}
if (statbit != null && statbit.hasStat())
{
int lvl = check_rune.getLevel(label.effect_type);
if (label.text != null)
{
label.text.text = (lvl > 0) ? lvl.ToString() : "";
}
if (label.image_labels.Length > 0)
{
label.image_labels[0].setLabel("", lvl);
}
}
}
public override void Activate(StatBit skill)
{
float[] _stats = skill.getStats();
level = skill.level;
am_active = true;
my_firearm = Peripheral.Instance.getHeroFirearm(RuneType.Airy);
my_line.gameObject.SetActive(true);
collider.enabled = true;
StatBit[] sb = new StatBit[2];
sb[0] = new StatBit(EffectType.Speed, _stats[0], 1, false);
sb[0].effect_sub_type = EffectSubType.Freeze;
sb[0].very_dumb = true;
sb[0].dumb = true;
sb[1] = new StatBit(EffectType.Force, _stats[1], 1, false);
sb[1].very_dumb = true;
sb[1].dumb = true;
Debug.Log("Activating Quicksand! Speed " + _stats[0] + " force " + _stats[1] + "\n");
if (Monitor.Instance != null)
{
Monitor.Instance.my_spyglass.DisableByDragButton(true);
}
stats = new StatSum(3, 0, sb, RuneType.Airy);
//stats doesn't have a factor because of speed
bullets = Mathf.CeilToInt(_stats[3]);
stats.factor = 1;
lava_life = _stats[2];
lava_size = _stats[5];
my_line.clearLine();
}
public override void Activate(StatBit skill)
{
float[] _stats = skill.getStats();
level = skill.level;
my_firearm = Peripheral.Instance.getHeroFirearm(RuneType.Sensible);
am_active = true;
collider.enabled = true;
speed = _stats[2];
lava_size = _stats[4];
lava_life = _stats[1];// / 5f;
StatBit[] sb = new StatBit[2];
sb[0] = new StatBit(EffectType.Force, _stats[0], 1, false);
sb[0].very_dumb = true;
sb[0].dumb = true;
sb[1] = new StatBit(EffectType.Stun, speed, 1, false);
sb[1].very_dumb = true;
sb[1].dumb = true;
if (Monitor.Instance != null)
{
Monitor.Instance.my_spyglass.DisableByDragButton(true);
}
stats = new StatSum(1, 0, sb, RuneType.Sensible);
stats.factor = 1;
}
public void DoTheThing(Firearm firearm, StatSum stats)
{
if (!is_active)
{
return;
}
if (am_hidden)
{
return;
}
//Laser
if (my_hitme == null)
{
Debug.Log("No hitme\n"); return;
}
if (stats == null)
{
Debug.Log("No stats\n");
}
if (firearm == null)
{
Debug.Log("No firearm\n");
}
if (firearm.current_arrow_name == null)
{
Debug.Log("No current arrow now\n");
}
try
{
my_hitme.HurtMe(stats, firearm, EffectTypeOverride(firearm.current_arrow_name.type));
}catch (NullReferenceException e)
{
Debug.LogError($"Something is null: stats {stats == null} firearm {firearm == null} my_hitme {my_hitme == null} firearm.current_arrow_name {firearm?.current_arrow_name == null}");
}
}
public void Init(EffectType primary_effecttype, int primary_level, StatSum stats, float lifespan, bool auto_return, Firearm firearm)
{
if (!locationSet)
{
SetLocation(null, this.transform.position, 1, Quaternion.identity);
}
this.my_stats = stats;
this.primary_effecttype = primary_effecttype;
this.lifespan = lifespan;
this.auto_return = auto_return;
this.primary_level = primary_level;
foreach (StatBit s in stats.stats)
{
if (primary_effecttype != EffectType.Diffuse && !s.dumb)
{
Debug.LogError("Lava " + this.gameObject.name + " is using a smart StatBit!\n");
}
s.dumb = true;
}
am_enabled = true;
my_firearm = firearm;
monsters = null;
every_so_often = Get.lava_damage_frequency;
//CancelInvoke();
//InvokeRepeating("GetVictims", 0f, every_so_often);
TIME = 0f;
time_to_next_lava_damage = 0f;
}
public override void Activate(StatBit skill)
{
float[] _stats = skill.getStats();
level = skill.level;
am_active = true;
my_firearm = Peripheral.Instance.getHeroFirearm(RuneType.Sensible);
my_line.gameObject.SetActive(true);
collider.enabled = true;
StatBit[] sb = new StatBit[1];
//sb[0] = new StatBit(EffectType.Force, _stats[0], 1, false);
sb[0] = new StatBit(EffectType.Force, _stats[0], 1, false);
lava_life = _stats[1];// / 5f;
sb[0].very_dumb = true;
bullets = Mathf.CeilToInt(_stats[2]);
if (Monitor.Instance != null)
{
Monitor.Instance.my_spyglass.DisableByDragButton(true);
}
stats = new StatSum(1, 0, sb, RuneType.Sensible);
stats.factor = 1;// / (lava_life * lava_size);
// Debug.Log("Activating Air Attack! Damage " + _stats[0] + " factor " + stats.factor + " bullets " + bullets + " lava_life " + lava_life + "\n");
my_line.clearLine();
}
void UpgradeTargetGhosts()
{
if (child_toys.Count == 0)
{
return;
}
StatSum my_stats = rune.GetStats(false);
float tower_force = rune.getLevel(EffectType.TowerForce);
float tower_range = rune.getLevel(EffectType.TowerRange);
foreach (Toy f in child_toys)
{
int i = 0;
while (f.rune.getLevel(EffectType.Force) < tower_force && i < 10)
{
f.rune.Upgrade(EffectType.Force, false);
// Debug.Log(f.name + "am force level " + f.rune.getLevel(EffectType.Force) + " want to be level " + tower_force + "\n");
i++;
}
i = 0;
while (f.rune.getLevel(EffectType.Range) < tower_range && i < 10)
{
Debug.Log(f.name + "am range level " + f.rune.getLevel(EffectType.Range) + " want to be level " + tower_range + "\n");
f.rune.Upgrade(EffectType.Range, false);
i++;
}
}
}
public void UpdateStats()
{
// Debug.Log("Updating stats " + stats.Length + "\n");
int actives = 0;
int special_actives = 0;
if (stats == null)
{
return;
}
for (int i = 0; i < stats.Length; i++)
{
bool special = Get.isSpecial(stats[i].effect_type);
stats[i].checkFinisher();
if (stats[i].active && special)
{
special_actives++;
}
if (stats[i].active && !special)
{
actives++;
}
}
int my_i = 0;
int my_special_i = 0;
StatBit[] my_stats = new StatBit[actives];
StatBit[] my_special_stats = new StatBit[special_actives];
float current_time_bonus = StaticRune.GetTimeBonus(runetype, toy_type);
for (int i = 0; i < stats.Length; i++)
{
stats[i].setModifier(current_time_bonus, distance_bonus);
if (!stats[i].active)
{
continue;
}
bool special = Get.isSpecial(stats[i].effect_type);
if (special)
{
my_special_stats[my_special_i] = stats[i];
my_special_i++;
}
else
{
my_stats[my_i] = stats[i];
my_i++;
}
}
stat_sum = new StatSum(level, xp, my_stats, runetype);
special_stat_sum = new StatSum(level, xp, my_special_stats, runetype);
}
public void setInfo(bool show)
{
info = false;
info_panel.SetActive(show);
if (show)
{
StatSum statsum = parent.rune.GetStats(false);
for (int i = 0; i < labels.Count; i++)
{
//Debug.Log("Checking label " + labels[i].effect_type + "\n");
StatBit statbit = statsum.GetStatBit(labels[i].effect_type);
if (Get.isGeneric(statbit.effect_type) && statbit.hasStat())
{
if (labels[i].type.Equals("info"))
{
labels[i].text.text = statbit.getDetailStats()[0].toString();
info = true;
// Debug.Log("updating text for " + labels[i].effect_type + "\n");
}
else
{
labels[i].gameObject.SetActive(true);
info = true;
//Debug.Log("updating image for " + labels[i].effect_type + "\n");
}
}
else
if (statbit.hasStat())
{
if (labels[i].type.Equals("info"))
{
labels[i].text.text = statbit.getDetailStats()[0].toString();
info = true;
labels[i].gameObject.SetActive(true);
// Debug.Log("updating text for " + labels[i].effect_type + "\n");
}
else
{
labels[i].gameObject.SetActive(true);
info = true;
// Debug.Log("updating image for " + labels[i].name + " " + labels[i].effect_type + "\n");
}
}
else
{
labels[i].gameObject.SetActive(false);
}
}
}
}
void SetEverythingOnFire(float[] stats) /// DOT FINISHER
{
my_lava = Zoo.Instance.getObject(lava_name, false).GetComponent <Lava>();
//my_lava.SetLocation(this.transform, this.transform.position, stats[1], Quaternion.identity);
StatBit[] lava_statbits = new StatBit[1];
lava_statbits[0] = new StatBit(EffectType.Fear, stats[0], 1, true);
StatSum lava_stats = new StatSum(1, 0, lava_statbits, RuneType.Vexing);
my_lava.SetLocation(my_hitme.transform, my_hitme.transform.position, stats[1], Quaternion.identity);
my_lava.Init(EffectType.DOT, 2, lava_stats, duration, true, null);
my_lava.gameObject.SetActive(true);
}
public void initStats(StatBit skill, int ID)
{
float[] stats = skill.getStats();
bullets = Mathf.RoundToInt(stats[0]);
fire_time = stats[1];
// if (!am_firing) {
my_statsum = new StatSum();
my_statsum.towerID = ID;
my_statsum.runetype = RuneType.Sensible;
StatBit[] statbits;
float finisher_percent = (stats.Length == StaticStat.StatLength(EffectType.Sparkles, true)) ? stats[3] : 0;
if (finisher_percent > 0 && UnityEngine.Random.Range(0, 1) < finisher_percent)
{
statbits = new StatBit[3];
statbits[2] = new StatBit();
statbits[2].effect_type = EffectType.Sparkles;
statbits[2].Base_stat = stats[4];
statbits[2].level = skill.level;
}
else
{
statbits = new StatBit[2];
}
statbits[0] = new StatBit();
statbits[0].effect_type = EffectType.Force;
statbits[1] = new StatBit();
statbits[1].effect_type = EffectType.Range;
statbits[1].Base_stat = 1.5f + skill.level / 2f;
my_statsum.stats = statbits;
// }
//lets_make_sparkles = false;
my_statsum.stats[0].Base_stat = stats[2];
my_statsum.stats[0].dumb = true;
my_statsum.stats[0].very_dumb = true;
my_statsum.stats[0].level = skill.level;
//this works like a lava
am_firing = true;
is_active = true;
if (colors == null)
{
InitColors();
}
}
void CauseMassPanic(float[] stats)
{
my_lava = Zoo.Instance.getObject(lava_name, false).GetComponent <Lava>();
StatBit[] lava_statbits = new StatBit[1];
lava_statbits[0] = new StatBit(EffectType.Fear, stats[0], 0, true);
StatSum lava_stats = new StatSum(1, 0, lava_statbits, RuneType.Vexing);
my_lava.SetLocation(my_ai.transform, my_ai.transform.position, stats[1], Quaternion.identity);
my_lava.lifespan = stats[0];
//not ideal, level is whaaaat
my_lava.Init(EffectType.Fear, 2, lava_stats, lifetime, true, null);
my_lava.gameObject.SetActive(true);
}
void GetVictims()
{
// Debug.Log("Getting victims\n");
if (monsters == null)
{
monsters = Peripheral.Instance.targets;
}
List <HitMe> targets = new List <HitMe>();
for (int i = 0; i < monsters.max_count; i++)
{
HitMe enemy = monsters.array[i];
if (enemy == null || enemy.amDying() || !enemy.gameObject.activeSelf)
{
continue;
}
if (Vector2.Distance(enemy.transform.position, this.transform.position) < radius)
{
targets.Add(enemy);
}
}
if (targets.Count == 0)
{
return;
}
StatSum type = null;
type = arrow.myFirearm.toy.rune.GetStats(false);
type.factor = 0.9f;
StatSum explode_statsum = type.getSubStatSum(EffectType.Explode_Force);
for (int i = 0; i < targets.Count; i++)
{
arrow.myFirearm.addXp(targets[i].HurtMe(explode_statsum, null, EffectType.Null), true);
float mass = targets[i].my_rigidbody.mass;
//Vector3 dir3 = targets[i].transform.position - from;
Vector3 dir3 = this.transform.position - from;
Vector2 dir = Vector3.Normalize(new Vector2(dir3.x, dir3.y));
//float dist = Vector2.Distance(targets[i].transform.position, from);
float adjust = targets[i].my_ai.speed;
targets[i].my_rigidbody.AddForce(adjust * strength * dir * mass, ForceMode2D.Impulse);
}
}
public void initStats(Firearm _firearm)
{
// setFirearm(_firearm);
statsum = _firearm.toy.rune.GetStats(false);
statsum.towerID = this.gameObject.GetInstanceID();
//float strength = statsum.GetStatBit(EffectType.Laser).stat;
// Debug.Log("Initializing laser with strength " + strength + "\n");
// float times = 6;
ammo_frequency = statsum.getReloadTime(false);
damage_frequency = Get.laser_damage_frequency;
statsum.factor = Get.laser_damage_factor;
initLaser();
}
public override void Activate(StatBit skill)
{
float[] _stats = skill.getStats();
level = skill.level;
collider.enabled = true;
my_firearm = Peripheral.Instance.getHeroFirearm(RuneType.Vexing); //only used for bees right now
if (start_from == Vector3.zero)
{
Firearm f = Peripheral.Instance.getHero(rune_type);
if (f == null)
{
Peripheral.Instance.my_skillmaster.CancelSkill(skill_effect_type);
Noisemaker.Instance.Click(ClickType.Error);
Debug.Log("Cannot use Sentient Cloud skill " + skill_effect_type + " " + rune_type + ", no appropriate hero found\n");
return;
}
start_from = f.transform.position;
}
am_active = true;
StatBit[] sb = new StatBit[1];
how_many = Mathf.FloorToInt(_stats[0]);
sb[0] = new StatBit();
sb[0].effect_type = lava_effect_type;
sb[0].updateStat(_stats[1]);
sb[0].dumb = true;
sb[0].very_dumb = true;
//range = -s.stat * 2;
range = _stats[2];
lava_life = _stats[3];
//bullets = 0, damage = 1, range = 2, lava kife = 3
stats = new StatSum(1, 0, sb, rune_type);
Tracker.Log(PlayerEvent.SpecialSkillUsed, true,
customAttributes: new Dictionary <string, string>()
{
{ "attribute_1", EffectType.Bees.ToString() }
},
customMetrics: new Dictionary <string, double>()
{
{ "metric_1", level }
});
}
public void initStats(Firearm _firearm)
{
my_firearm = _firearm;
StatSum statsum = my_firearm.toy.rune.GetStats(false);
//period = statsum.getReloadTime(false);
//duration = period * duration_factor;
time_between_pulses = statsum.getReloadTime(false);
pulse_length = time_between_pulses * duration_factor;
type = statsum;
previous_status = false;
// retry_time = 0f;
monsters = Peripheral.Instance.targets;
if (tileSize < 0)
{
tileSize = Peripheral.Instance.tileSize;
}
/*
* if (duration > period) {
* period = -1;
* duration = -1;
* }//lol what
*/
if (pulse_length > time_between_pulses)
{
time_between_pulses = -1;
pulse_length = -1;
}
halo_active = false;
if (halo == null)
{
halo = Zoo.Instance.getObject("Surfaces/Units/toy_halo", true);
halo.transform.SetParent(transform);
halo.transform.position = this.transform.position;
updateHaloSize();
}
ShowHalo(false);
// StopAllCoroutines();
// StartCoroutine(RunMe());
}
public void InitArrow(StatSum statsum, Vector3 target, float _speed, Firearm _firearm)
{
// Debug.Log(this.gameObject.GetInstanceID() + " BORN\n");
if (_speed > 0)
{
speed = _speed;
}
type = (arrow_type == ArrowType.RapidFire) ? statsum.clone() : statsum;
if (rb == null)
{
rb = GetComponent <Rigidbody2D> ();
}
if (init_mass == -1)
{
init_mass = rb.mass;
}
if (statsum.runetype == RuneType.Sensible)
{
rb.mass = init_mass * type.getPrimary();
}
alive = true;
myStaticTarget = target;
myFirearm = _firearm;
if (my_peripheral == null)
{
my_peripheral = Peripheral.Instance;
}
Color c = sprite_renderer.color;
c.a = 1f;
sprite_renderer.color = c;
if (arrow_type == ArrowType.Sparkle)
{
lifetime = 3f; //meh
}
if (diffuse != null)
{
statsum.factor = diffuse.Init(statsum);
}
}
public void MakeDiffuse(Vector3 pos)
{
// Debug.Log("Diffuse doing diffusion\n");
//force
StatBit diffuse_statbit = stats.GetStatBit(EffectType.Diffuse);
//StatSum lava_statsum_old = stats.cloneAndRemoveStat(EffectType.Diffuse);
float[] stat_floats = diffuse_statbit.getStats();
StatSum lava_statsum = new StatSum();
lava_statsum.runetype = RuneType.Sensible;
lava_statsum.stats = new StatBit[1];
StatBit lava_statbit = new StatBit();
lava_statbit.effect_type = EffectType.Force;
lava_statbit.base_stat = stat_floats[5];
lava_statbit.rune_type = RuneType.Sensible;
lava_statbit.dumb = true;
lava_statbit.very_dumb = true;
lava_statsum.stats[0] = lava_statbit;
float range = stat_floats[0];
float lifespan = stat_floats[1];
float factor = stat_floats[2];
//this statbit is not dumb. Diffuse just diffuses whatever Vexing force the arrow has.
//get your own lava since lavas live for much longer than arrows, arrows get reused much faster.
//each arrow does not have its own lava
lava = Zoo.Instance.getObject("Wishes/diffuse_lava", false).GetComponent <Lava>();
lava.SetLocation(null, pos, range, Quaternion.identity);
lava.gameObject.SetActive(true);
// Debug.Log("Diffuse lava lifetime " + lifespan + "\n");
lava.Init(EffectType.Diffuse, diffuse_statbit.level, lava_statsum, lifespan, true, arrow.myFirearm);
lava.SetFactor(factor);
arrow.MakeMeDie(false);
}
void SetUpgrade()
{
InitUpgradeVisual();
if (parent.building.construction_in_progress)
{
if (parent.building.tower_visual)
{
parent.building.tower_visual.setUpgrade(false);
}
return;
}
if (!parent.building.tower_visual || !parent.building.tower_visual.haveUpgrades)
{
return;
}
//if (upgrade == null){ return;}
// Debug.Log("rune_buttons Checking upgrades " + this.parent.name + "\n");
bool ok = false;
StatSum sum = parent.rune.GetStats(false);
for (int i = 0; i < sum.stats.Length; i++)
{
if (parent.rune.CanUpgrade(sum.stats[i].effect_type, parent.rune.runetype) == StateType.Yes)
{
ok = true;
}
}
//if (ok == upgrade.gameObject.activeSelf) return;
//setXPFull(false);
SetXP();
parent.building.tower_visual.setUpgrade(ok);
//Show.SetAlpha(upgrade, 1);
//upgrade.gameObject.SetActive(ok);
// Debug.Log("Enabled upgrage visual\n");
}
public override void Activate(StatBit skill)
{
float[] _stats = skill.getStats();
level = skill.level;
am_active = true;
collider.enabled = true;
StatBit[] sb = new StatBit[1];
sb[0] = new StatBit();
sb[0].effect_type = effect_type;
sb[0].updateStat(_stats[0]);
sb[0].dumb = true;
//range = -s.stat * 2;
range = _stats[1];
lava_life = _stats[3];
if (Monitor.Instance != null)
{
Monitor.Instance.my_spyglass.DisableByDragButton(true);
}
stats = new StatSum(1, 0, sb, rune_type);
}
private static Arrow _MakeArrow(ArrowName type, Vector3 origin, StatSum arrow_stats, float speed, Firearm _firearm, bool play_sound)
{
GameObject newMissile = Peripheral.Instance.zoo.getObject(type.name, false);
// Debug.Log("Making arrow " + arrow_name + "\n");
origin.z = 0f;
newMissile.transform.position = origin;
newMissile.transform.SetParent(Peripheral.Instance.arrows_transform);
newMissile.tag = "PlayerArrow";
Arrow arrow = newMissile.GetComponent <Arrow>();
arrow.arrow_type = type.type;
if (play_sound && Noisemaker.Instance != null)
{
Noisemaker.Instance.Play("arrow_fired");
}
return(arrow);
}
public override void Activate(StatBit skill)
{
float[] _stats = skill.getStats();
level = skill.level;
my_firearm = Peripheral.Instance.getHeroFirearm(RuneType.Vexing);
am_active = true;
collider.enabled = true;
StatBit[] sb = new StatBit[1];
sb[0] = new StatBit();
sb[0].effect_type = EffectType.Teleport;
sb[0].updateStat(_stats[0]);
sb[0].dumb = true;
range = _stats[1];
if (Monitor.Instance != null)
{
Monitor.Instance.my_spyglass.DisableByDragButton(true);
}
stats = new StatSum(1, 0, sb, RuneType.Vexing);
}
public void Prepare(StatBit bit, Firearm firearm, EffectType type)
{
StatSum stats = firearm.toy.rune.GetStats(false);
float[] calamity_stats = bit.getStats();
if (TIME < next_time_to_make_new_lava || (my_lava != null && my_lava.gameObject.activeSelf))
{
return;
}
//2 =make new timer, 3 = lava life
next_time_to_disable_lava = TIME + calamity_stats[3];
next_time_to_make_new_lava = TIME + calamity_stats[2];
StatBit[] sb = new StatBit[1];
if (type == EffectType.Foil) //Foil summons EMP lava, EMP does the thing
{
sb[0] = new StatBit(EffectType.Foil, calamity_stats[3], 1, false);
}
else
{
sb[0] = new StatBit(EffectType.Force, calamity_stats[0], 1, false);
}
sb[0].very_dumb = true;
lava_stats = new StatSum(1, 0, sb, RuneType.Airy);
lava_timer = calamity_stats[3];
lava_stats.factor = 1;
// lava_size = (type == EffectType.Calamity) ? stats.getRange() * calamity_stats[1] / 2f : stats.getRange() * calamity_stats[1];
//this shit should be handled by StatBit, the lazy bum
lava_size = calamity_stats[1];
}
public void InitArrow(StatSum statsum, Transform target, float _speed, Firearm _firearm)
{
myTarget = target;
InitArrow(statsum, target.transform.position, _speed, _firearm);
}
void FireProjectile()
{
if (myTarget == null)
{
return;
}
incrementNextFireTime();
arrow_count++;
if (!ammo_by_time)
{
UseAmmo();
}
else
{
start_ammo_by_time = true;
}
Vector3 firefrom = transform.position;
if (arrow_origin != null)
{
firefrom = arrow_origin.position;
}
StatSum statsum = toy.rune.GetStats(false);
statsum.towerID = this.gameObject.GetInstanceID();
float arrow_speed = -1;
Arrow arrow = null;
if (current_arrow_name.type == ArrowType.RapidFire || current_arrow_name.type == ArrowType.Slow)
{
getTargetPosition();
arrow = Get.MakeArrow(current_arrow_name, firefrom, myTargetPosition, statsum, arrow_speed, this, true);
}
else
{
myTargetPosition.x = myTarget.position.x;
myTargetPosition.y = myTarget.position.y;
arrow = Get.MakeArrow(current_arrow_name, firefrom, myTarget, statsum, arrow_speed, this, true);//focus has to aim for an actual moving target, nobody else cares though
}
CalcAimPosition(myTarget.position);
//modifiers on regular arrows
if (current_arrow_name.type == ArrowType.RapidFire)
{
//StatBit force = statsum.GetStatBit(EffectType.VexingForce);
// force.updateStat(rapid_fire.GetMass());
rapid_fire.modifyArrow(arrow);
}
toy.my_tower_stats.Shots_fired++;
arrow.gameObject.SetActive(true);
if (!EnemyInRange(myTarget))
{
myTarget = null;
}
// incrementNextFireTime(); should be first
}
//1 is fully defended
public float HurtMe(StatSum statsum, Firearm firearm, EffectType primary_effecttype, int primary_level)
{
if (dying)
{
return(0);
}
if (checkIfWasKilled())
{
return(0);
}
float factor = statsum.factor;//does anybody know what this is for? laser?
float defense;
float xp = 0f;
StatBit[] statbits = statsum.stats;
for (int i = 0; i < statbits.Length; i++)
{
StatBit skill_stats = statbits[i];
if (statbits[i].effect_type == EffectType.Range)
{
continue;
}
if (statbits[i].effect_type == EffectType.ReloadTime)
{
continue;
}
switch (statsum.runetype)
{
case RuneType.Sensible:
bool is_laser = (statsum.GetStatBit(EffectType.Laser) != null);
if (is_laser)
{
defense = Get.GetDefense(defenses, EffectType.Force);
if (statbits[i].effect_type == EffectType.Laser && defense < 1)
{
float add = stats.getXp(ForceMe(skill_stats.getModifiedStats(factor, defense)));
xp += add;
assignXp(add, firearm, primary_effecttype, EffectType.Laser, primary_level, skill_stats.level);
}
}
else
{
if (statbits[i].effect_type == EffectType.Stun)
{
float add = StunMe(skill_stats.getModifiedStats(factor, 0)) / 10f;
xp += add;
assignXp(add, firearm, primary_effecttype, EffectType.Stun, primary_level,
skill_stats.level);
}
if (statbits[i].effect_type == EffectType.Transform)
{
defense = Get.GetDefense(defenses, EffectType.Transform);
//applied with diffuse, which has a factor. this is not susceptible to that factor
if (defense < 1)
{
TransformMe(skill_stats.getModifiedStats(factor, defense), factor);
}
}
float force_defense = Get.GetDefense(defenses, EffectType.Force);
if (force_defense < 1)
{
if (statbits[i].effect_type == EffectType.Force)
{
// Debug.Log("factor " + statsum.factor + "\n");
float add = stats.getXp(ForceMe(statsum.getModifiedPrimaryStats(force_defense)));
xp += add;
assignXp(add, firearm, primary_effecttype, EffectType.Force, primary_level, skill_stats.level);
}
if (statbits[i].effect_type == EffectType.Explode_Force)
{
float add = stats.getXp(ForceMe(skill_stats.getModifiedStats(factor, force_defense)));
xp += add;
assignXp(add, firearm, primary_effecttype, EffectType.Explode_Force, primary_level, skill_stats.level);
}
}
if (statbits[i].effect_type == EffectType.Speed && statbits[i].effect_sub_type == EffectSubType.Ultra)
{
float add = SpeedMe(skill_stats.getModifiedStats(factor, 0), statbits[i].effect_type, statbits[i].effect_sub_type);
xp += add * (1 + firearm.toy.rune.level * 0.5f);
assignXp(add, firearm, primary_effecttype, EffectType.Meteor, primary_level, skill_stats.level);
}
}
break;
case RuneType.Airy:
if (statbits[i].effect_type == EffectType.Weaken)
{
defense = (statbits[i].effect_sub_type == EffectSubType.Null) ? Get.GetDefense(defenses, EffectType.Weaken) : 0;
if (defense < 1)
{
float add = WeakenMe(skill_stats.getModifiedStats(factor, defense));
xp += add;
assignXp(add, firearm, primary_effecttype, EffectType.Weaken, primary_level, skill_stats.level);
}
}
float speed_defense = Get.GetDefense(defenses, EffectType.Speed) / 2f; //otherwise they seem like they are very resistant to speed
if (statbits[i].effect_type == EffectType.Speed && speed_defense < 1)
{
float add = SpeedMe(skill_stats.getModifiedStats(factor, speed_defense), statbits[i].effect_type, statbits[i].effect_sub_type); //this xp factor is to balance out xp to match other towers that do more damage
xp += add;
assignXp(add, firearm, primary_effecttype, EffectType.Speed, primary_level, skill_stats.level);
}
if (statbits[i].effect_type == EffectType.Speed && statbits[i].effect_sub_type == EffectSubType.Freeze)
{
float add = SpeedMe(skill_stats.getModifiedStats(factor, 0), statbits[i].effect_type, statbits[i].effect_sub_type);
// Debug.Log("timefreeze factor is " + factor + "\n");
xp += add;
assignXp(add, firearm, primary_effecttype, EffectType.Frost, primary_level, skill_stats.level);
}
float hey_defense = Get.GetDefense(defenses, EffectType.Force);
if (statbits[i].effect_type == EffectType.Force && speed_defense < 1)
{
float add = stats.getXp(ForceMe(skill_stats.getModifiedStats(factor, hey_defense)));
xp += add;
assignXp(add, firearm, primary_effecttype, EffectType.Force, primary_level, skill_stats.level);
}
if (statbits[i].effect_type == EffectType.DirectDamage)
{
float add = stats.getXp(ForceMe(skill_stats.getModifiedStats(factor, 0)));
xp += add;
assignXp(add, firearm, primary_effecttype, EffectType.DirectDamage, primary_level, skill_stats.level);
}
//SSkill
if (statbits[i].effect_type == EffectType.EMP)
{
EMPMe(skill_stats.getModifiedStats(factor, 0), false);
}
//Regular Skill: Foil -> Foil Lava -> summons EMP
if (primary_effecttype == EffectType.Foil && statbits[i].effect_type == EffectType.Foil)
{
EMPMe(skill_stats.getModifiedStats(factor, 0), true);
}
break;
case RuneType.Vexing:
float vf_defense = Get.GetDefense(defenses, EffectType.VexingForce);
if ((primary_effecttype != EffectType.Focus && statbits[i].effect_type == EffectType.VexingForce) ||
(primary_effecttype == EffectType.Focus && primary_effecttype == statbits[i].effect_type)) // for Focus, use focus statbits, not VF
{
if (vf_defense < 1)
{
float add = stats.getXp(ForceMe(statsum.getModifiedPrimaryStats(vf_defense)));
xp += add;
assignXp(add, firearm, primary_effecttype, EffectType.VexingForce, primary_level, skill_stats.level);
}
}
if (statbits[i].effect_type == EffectType.DOT)
{
DOTMe(skill_stats.getModifiedStats(factor, vf_defense), firearm, skill_stats.level);
//does damage through an invoke which can't get back to this
//invoke calls MassMe, which assigns XP
}
if (statbits[i].effect_type == EffectType.Critical)
{
float critical_factor = firearm.critical.getCriticalForce(); //so that we can do correct xp attribution for it
if (critical_factor > 0)
{
float new_defense = vf_defense / (1 + critical_factor);
float[] new_stats = statsum.getModifiedPrimaryStats(vf_defense / (1 + critical_factor));
float add = stats.getXp(ForceMe(new_stats));
xp += add;
assignXp(add, firearm, EffectType.Critical, EffectType.Critical, primary_level, skill_stats.level);
}
}
if (statbits[i].effect_type == EffectType.Teleport)
{
defense = Get.GetDefense(defenses, EffectType.Teleport);
if (defense >= 1)
{
return(xp);
}
float add = TeleportMe(skill_stats.getModifiedStats(factor, defense));
xp += add;
assignXp(add, firearm, primary_effecttype, EffectType.Teleport, primary_level, skill_stats.level);
}
if (statbits[i].effect_type == EffectType.Fear)
{
defense = Get.GetDefense(defenses, EffectType.Fear);
if (defense < 1)
{
FearMe(skill_stats.getModifiedStats(factor, defense));
}
}
break;
case RuneType.Time:
if (statbits[i].effect_type == EffectType.Speed && statbits[i].effect_sub_type == EffectSubType.Ultra)
{
defense = Get.GetDefense(defenses, StaticRune.getPrimaryDamageType(statsum.runetype));
if (defense >= 1)
{
return(xp);
}
float add = SpeedMe(skill_stats.getModifiedStats(factor, defense), EffectType.Speed, statbits[i].effect_sub_type);
xp += add;
assignXp(add, firearm, primary_effecttype, EffectType.Speed, primary_level, skill_stats.level);
}
break;
case RuneType.Fast:
case RuneType.Slow:
if (statbits[i].effect_type == EffectType.Force)
{
defense = Get.GetDefense(defenses, StaticRune.getPrimaryDamageType(statsum.runetype));
if (defense >= 1)
{
return(xp);
}
float add = stats.getXp(ForceMe(skill_stats.getModifiedStats(factor, defense)));
Debug.Log($"Night tower {Sun.Instance.GetCurrentTime()} {firearm.gameObject.name} {this.gameObject.name} defense {defense} xp {add} primary effect {primary_effecttype}\n");
xp += add;
assignXp(add, firearm, primary_effecttype, EffectType.Force, primary_level, skill_stats.level);
}
break;
default:
if (statbits[i].effect_type == EffectType.Force)
{
defense = Get.GetDefense(defenses, EffectType.Force);
if (defense >= 1)
{
return(xp);
}
float add = stats.getXp(ForceMe(skill_stats.getModifiedStats(factor, defense)));
xp += add;
assignXp(add, firearm, primary_effecttype, EffectType.Force, primary_level, skill_stats.level);
}
break;
}
}
// Debug.Log("Total xp " + xp + "\n");
return(xp);
}
public UpdateEquipmentCommandHandler(IFFDbContext context)
: base(context)
{
this.statSum = new StatSum();
}
public float Init(HitMe _hitme, float[] stats, EffectType type, EffectSubType sub_type)
{
if (_hitme.my_body.amHidden())
{
return(0);
}
my_ai = _hitme.my_ai;
// Debug.Log("Stats " + stats[0] + " " + stats[1] + " " + stats[2] + "\n");
my_time = 0;
start = false;
bool was_already_active = is_active;
is_active = true;
float xp = 0f;
if (orig_rotation_inverse_speed_factor == -1)
{
orig_rotation_inverse_speed_factor = my_ai.rotation_inverse_speed_factor;
}
float aff = Get.getPercent(stats[0]);
// Debug.Log("SPEED AFF " + stats[0] + " -> " + aff + "\n");
float original_aff = aff;
if (aff < 0)
{
aff = 0;
}
if (aff > 0.99f)
{
aff = 0.99f;
}
bool froze = false;
if (sub_type == EffectSubType.Freeze)
{
float pct_freeze = stats[3];
float roll = UnityEngine.Random.Range(0f, 100f);
if (roll < pct_freeze)
{
Debug.Log("FREEZING " + my_ai.gameObject.name + " for " + stats[5] + "\n");
aff = 0f;
froze = true;
StatBit[] sb = new StatBit[1];
lifetime = stats[5];
time_to_normal = stats[5];
sb[0] = new StatBit(EffectType.Weaken, stats[4], 1, false);
sb[0].effect_sub_type = EffectSubType.Freeze;
sb[0].very_dumb = true;
sb[0].dumb = true;
StatSum weaken = new StatSum(3, 0, sb, RuneType.Airy);
_hitme.HurtMe(weaken, null, EffectType.Null);
}
}
if (froze)
{
_hitme.EnableVisuals(MonsterType.Freeze, lifetime);
}
else
{
_hitme.EnableVisuals(MonsterType.Speed, lifetime);
}
//Speed
lifetime = stats[2];
time_to_normal = stats[1];
float final = my_ai.speed * aff;
/* this makes speed lavas ineffective
* if (was_already_active)
* {
* float current_speed_factor = my_ai.current_speed / my_ai.speed;
* float new_factor = (2 * aff + current_speed_factor) / 3f;
* final = new_factor * my_ai.speed;
* Debug.Log("Speed acting again, current speed factor " + current_speed_factor + " new_factor " + new_factor + " instead of " + aff + "\n");
* }*/
// Debug.Log(my_ai.gameObject.name + " SETTING SPEED FROM (" + original_aff + ") " + my_ai.speed + " TO " + final + " AFF " + aff + " FOR " + lifetime + "\n");
my_ai.Stunned = true;
my_ai.current_speed = final;
xp = lifetime * (my_ai.speed - my_ai.current_speed) / my_ai.speed;
// Debug.Log(stats[0] + " " + aff + " time to normal " + time_to_normal + "\n");
//Debug.Log("stat " + stats[0] + " aff " + aff + " xp " + xp + " lifetime " + lifetime + " speed " + my_ai.speed + " current_speed " + my_ai.current_speed + "\n");
return(xp / 5f);
//return 0;
}
public float HurtMe(StatSum statsum, Firearm firearm, EffectType primary_effecttype)
{
return(HurtMe(statsum, firearm, primary_effecttype, -1));
}
void GetVictims()
{
if (monsters == null)
{
monsters = Peripheral.Instance.targets;
}
HitMe closest_target = null;
float closest_distance = 999f;
bool previous_status = halo_active;
List <HitMe> targets = new List <HitMe>();
// Debug.Log("Potential targets " + monsters.Count + " range is " + range + " tilesize " + tileSize + "\n");
for (int i = 0; i < monsters.max_count; i++)
{
HitMe enemy = monsters.array[i];
if (enemy == null || enemy.amDying() || !enemy.gameObject.activeSelf)
{
continue;
}
float distance = Vector2.Distance(enemy.transform.position, transform.position);
if (distance < closest_distance)
{
closest_target = enemy;
closest_distance = distance;
}
if (distance < my_firearm.getCurrentRange() * tileSize)
{
targets.Add(enemy);
halo_active = true;
}
}
// Debug.Log("Got " + targets.Count + " victims, previous status is " + previous_status + "\n");
if (targets.Count > 0)
{
type = my_firearm.toy.rune.GetStats(false);
if (previous_status == false)
{
if (my_calamity != null)
{
StatBit bit = type.GetStatBit(EffectType.Calamity);
if (bit != null)
{
my_calamity.Init(bit, closest_target, my_firearm, EffectType.Calamity);
}
}
if (my_foil != null)
{
StatBit bit = type.GetStatBit(EffectType.Foil);
if (bit != null)
{
my_foil.Init(bit, closest_target, my_firearm, EffectType.Foil);
}
}
if (my_swarm != null)
{
StatBit bit = type.GetStatBit(EffectType.Swarm);
if (bit != null)
{
my_swarm.Init(bit, transform, my_firearm, EffectType.Swarm);
}
}
}
}
// Debug.Log("Gonna hurt " + targets.Count + " victims\n");
for (int i = 0; i < targets.Count; i++)
{
targets[i].HurtMe(type, my_firearm, EffectType.Null);
if (my_wish_catcher != null)
{
StatBit bit = type.GetStatBit(EffectType.WishCatcher);
if (bit != null)
{
my_wish_catcher.Init(targets[i], bit.getStats());
}
}
}
if (!previous_status && halo_active)
{
ShowHalo(true);
if (!previous_status)
{
my_firearm.UseAmmo();
}
if (previous_status == false)
{
}
}
}
