Index: binaries/data/mods/public/simulation/components/Heal.js
===================================================================
--- binaries/data/mods/public/simulation/components/Heal.js
+++ binaries/data/mods/public/simulation/components/Heal.js
@@ -1,4 +1,205 @@
-function Heal() {}
+class Heal
+{
+ Init()
+ {
+ this.target = INVALID_ENTITY;
+ }
+
+ GetTimers()
+ {
+ return {
+ "prepare": 1000,
+ "repeat": this.GetRate()
+ };
+ }
+
+ /**
+ * @return {number} - The amount of HitPoints regenerated per interval.
+ */
+ GetHP()
+ {
+ return ApplyValueModificationsToEntity("Heal/HP", +this.template.HP, this.entity);
+ }
+
+ GetRate()
+ {
+ return ApplyValueModificationsToEntity("Heal/Rate", +this.template.Rate, this.entity);
+ }
+
+ GetRange()
+ {
+ return {
+ "min": 0,
+ "max": ApplyValueModificationsToEntity("Heal/Range", +this.template.Range, this.entity)
+ };
+ }
+
+ GetUnhealableClasses()
+ {
+ return this.template.UnhealableClasses._string || "";
+ }
+
+ GetHealableClasses()
+ {
+ return this.template.HealableClasses._string || "";
+ }
+
+ GetRangeOverlays()
+ {
+ if (!this.template.RangeOverlay)
+ return [];
+
+ return [{
+ "radius": this.GetRange().max,
+ "texture": this.template.RangeOverlay.LineTexture,
+ "textureMask": this.template.RangeOverlay.LineTextureMask,
+ "thickness": +this.template.RangeOverlay.LineThickness
+ }];
+ }
+
+ /**
+ * Starts healing the specified target.
+ *
+ * @param {number} target - The target to heal.
+ * @return {Object} - The timers in the form { "prepare": {number}, "repeat": {number} }.
+ */
+ StartHealing(target)
+ {
+ if (!this.IsInRange(target))
+ {
+ this.StopHealing(false, true);
+ return;
+ }
+
+ // We were already healing!
+ if (this.target != INVALID_ENTITY)
+ this.StopHealing();
+
+ let timings = this.GetTimers();
+ let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
+
+ // If the repeat time since the last heal hasn't elapsed,
+ // delay the action to avoid healing too fast.
+ let prepare = timings.prepare;
+ if (this.lastHealed)
+ {
+ let repeatLeft = this.lastHealed + timings.repeat - cmpTimer.GetTime();
+ prepare = Math.max(prepare, repeatLeft);
+ }
+
+ let cmpVisual = Engine.QueryInterface(this.entity, IID_Visual);
+ if (cmpVisual)
+ {
+ cmpVisual.SelectAnimation("heal", false, 1.0);
+ cmpVisual.SetAnimationSyncRepeat(timings.repeat);
+ cmpVisual.SetAnimationSyncOffset(prepare);
+ }
+
+ // If using a non-default prepare time, re-sync the animation when the timer runs.
+ this.resyncAnimation = prepare != timings.prepare;
+ this.target = target;
+ this.healTimer = cmpTimer.SetInterval(this.entity, IID_Heal, "PerformHeal", prepare, timings.repeat, null);
+
+ return timings;
+ }
+
+ /**
+ * Stops healing.
+ * @param {boolean} healed - Whether we stopped because the target was healed.
+ * @param {boolean} outOfRange - Whether we stopped because the target got out of our range.
+ */
+ StopHealing(healed = false, outOfRange = false)
+ {
+ if (this.healTimer)
+ {
+ let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
+ cmpTimer.CancelTimer(this.healTimer);
+ delete this.healTimer;
+ }
+
+ let cmpVisual = Engine.QueryInterface(this.entity, IID_Visual);
+ if (cmpVisual)
+ cmpVisual.SelectAnimation("idle", false, 1.0);
+
+ if (this.target != INVALID_ENTITY)
+ this.target = INVALID_ENTITY;
+
+ Engine.PostMessage(this.entity, MT_HealingStopped, {
+ "healed": healed,
+ "outOfRange": outOfRange
+ });
+ }
+
+ /**
+ * Heal the target entity. This should only be called after a successful range
+ * check, and should only be called after GetTimers().repeat msec has passed
+ * since the last call to PerformHeal.
+ */
+ PerformHeal(data, lateness)
+ {
+ if (this.target == INVALID_ENTITY)
+ {
+ this.StopHealing(true);
+ return;
+ }
+ if (!this.IsInRange(this.target))
+ {
+ this.StopHealing(false, true);
+ return;
+ }
+
+ let cmpHealth = Engine.QueryInterface(this.target, IID_Health);
+ if (!cmpHealth || !cmpHealth.IsInjured())
+ {
+ this.StopHealing(true);
+ return;
+ }
+
+ let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
+ this.lastHealed = cmpTimer.GetTime() - lateness;
+
+ let targetState = cmpHealth.Increase(this.GetHP());
+
+ // Add experience points.
+ let cmpLoot = Engine.QueryInterface(this.target, IID_Loot);
+ let cmpPromotion = Engine.QueryInterface(this.entity, IID_Promotion);
+ if (targetState !== undefined && cmpLoot && cmpPromotion)
+ // HP healed * XP per HP
+ cmpPromotion.IncreaseXp((targetState.new - targetState.old) / cmpHealth.GetMaxHitpoints() * cmpLoot.GetXp());
+
+ // TODO we need a sound file.
+ // PlaySound("heal_impact", this.entity);
+
+ if (!cmpHealth.IsInjured())
+ {
+ this.StopHealing(true);
+ return;
+ }
+
+ if (this.resyncAnimation)
+ {
+ let cmpVisual = Engine.QueryInterface(this.entity, IID_Visual);
+ if (cmpVisual)
+ {
+ let repeat = this.GetTimers().repeat;
+ cmpVisual.SetAnimationSyncRepeat(repeat);
+ cmpVisual.SetAnimationSyncOffset(repeat);
+ }
+ this.resyncAnimation = false;
+ }
+ }
+
+ /**
+ * @param {number} - The entity ID of the target to check.
+ * @return {boolean} - Whether this entity is in range of its target.
+ */
+ IsInRange(target)
+ {
+ let range = this.GetRange();
+ let cmpObstructionManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_ObstructionManager);
+ return cmpObstructionManager.IsInTargetRange(this.entity, target, range.min, range.max, false);
+ }
+}
Heal.prototype.Schema =
"Controls the healing abilities of the unit." +
@@ -14,7 +215,7 @@
"Cavalry" +
"Support Infantry" +
"" +
- "" +
+ "" +
"