warscript 0.0.1-dev.c362181 → 0.0.1-dev.c47d565

package/engine/object-data/entry/upgrade.d.ts

@@ -1,9 +1,9 @@
 /** @noSelfInFile */
 import { TupleOf } from "../../../utility/types";
 import { TechTreeDependency, TechTreeDependencyInput } from "../auxiliary/tech-tree-dependency";
-import { ObjectDataEntry, ObjectDataEntryId, ObjectDataEntryLevelFieldValueSupplier } from "../entry";
+import { ObjectDataEntry, CustomObjectDataEntryId, ObjectDataEntryLevelFieldValueSupplier } from "../entry";
 import { AbilityTypeId } from "./ability-type";
-export type UpgradeId = ObjectDataEntryId & number & {
+export type UpgradeId = CustomObjectDataEntryId & number & {
     readonly __upgradeId: unique symbol;
 };
 export declare const enum UpgradeEffectType {

package/engine/object-data/entry.d.ts

@@ -1,9 +1,13 @@
 /** @noSelfInFile */
 import { AttachmentPreset, AttachmentPresetInput } from "./auxiliary/attachment-preset";
 import { MutableKeys } from "../../utility/types";
-export type ObjectDataEntryId = (number | string) & {
+import { StandardAbilityTypeId } from "../standard/entries/ability-type";
+import { StandardItemTypeId } from "../standard/entries/item-type";
+import { StandardLightningTypeId } from "../standard/entries/lightning-type";
+export type CustomObjectDataEntryId = (number | string) & {
     readonly __objectDataEntryId: unique symbol;
 };
+export type ObjectDataEntryId = CustomObjectDataEntryId | StandardAbilityTypeId | StandardItemTypeId | StandardLightningTypeId;
 export type ObjectDataEntryIdType<T extends ObjectDataEntry> = T extends ObjectDataEntry<infer Id> ? Id : never;
 export type ObjectDataEntryConstructor<T extends ObjectDataEntry> = OmitConstructor<typeof ObjectDataEntry> & (new (object: WarObject) => T);
 export type ObjectDataEntryAbstractConstructor<T extends ObjectDataEntry> = OmitConstructor<typeof ObjectDataEntry> & (abstract new (object: WarObject) => T);
@@ -38,6 +42,7 @@ export declare abstract class ObjectDataEntry<Id extends ObjectDataEntryId = Obj
     setFieldValue<This extends this, Args extends any[]>(this: This, field: {
         setValue(entry: This, ...args: Args): boolean;
     }, ...args: Args): void;
+    copyFrom(id: Id): void;
     protected getBooleanField(field: string): boolean;
     protected setBooleanField(field: string, value: boolean): void;
     protected getNumberField(field: string): number;

package/engine/object-data/entry.lua

@@ -181,6 +181,14 @@ end
 function ObjectDataEntry.prototype.setFieldValue(self, field, ...)
     check(field:setValue(self, ...))
 end
+function ObjectDataEntry.prototype.copyFrom(self, id)
+    local that = self.type:of(id)
+    if that == nil then
+        return
+    end
+    for ____, field in ipairs(self.object.all) do
+    end
+end
 function ObjectDataEntry.prototype.getBooleanField(self, field)
     return dataToBoolean(self.object:getField(field))
 end

package/engine/object-field/ability.d.ts

@@ -12,7 +12,7 @@ import { ReadonlyNonEmptyLinkedSet } from "../../utility/linked-set";
 export declare abstract class AbilityField<ValueType extends number | string | boolean = number | string | boolean, NativeFieldType extends jabilityfield = jabilityfield> extends ObjectField<AbilityType, Ability, ValueType, NativeFieldType> {
     protected get instanceClass(): typeof Ability;
     protected getObjectDataEntryId(instance: Ability): AbilityTypeId;
-    protected hasNativeFieldValue(instance: Ability): boolean;
+    protected hasNativeFieldValue(abilityTypeId: AbilityTypeId): boolean;
     static get valueChangeEvent(): ObjectFieldValueChangeEvent<ReadonlyObjectFieldType<AbilityField>>;
 }
 export declare class AbilityBooleanField extends AbilityField<boolean, jabilitybooleanfield> {
@@ -48,7 +48,7 @@ export declare class AbilityStringField extends AbilityField<string, jabilitystr
 export declare abstract class AbilityArrayField<ValueType extends number | string | boolean = number | string | boolean, NativeFieldType extends jabilityfield = jabilityfield> extends ObjectArrayField<AbilityType, Ability, ValueType, NativeFieldType> {
     protected get instanceClass(): typeof Ability;
     protected getObjectDataEntryId(instance: Ability): AbilityTypeId;
-    protected hasNativeFieldValue(instance: Ability): boolean;
+    protected hasNativeFieldValue(abilityTypeId: AbilityTypeId): boolean;
 }
 export declare class AbilityStringArrayField extends AbilityArrayField<string, jabilitystringlevelfield> {
     protected get defaultValue(): string;
@@ -68,7 +68,7 @@ export declare abstract class AbilityLevelField<ValueType extends number | strin
     protected get instanceClass(): typeof Ability;
     protected getLevelCount(entry: AbilityType | Ability): number;
     protected getObjectDataEntryId(instance: Ability): AbilityTypeId;
-    protected hasNativeFieldValue(instance: Ability): boolean;
+    protected hasNativeFieldValue(abilityTypeId: AbilityTypeId): boolean;
     static get valueChangeEvent(): ObjectLevelFieldValueChangeEvent<ReadonlyObjectLevelFieldType<AbilityLevelField>>;
 }
 export declare class AbilityBooleanLevelField extends AbilityLevelField<boolean, boolean, jabilityintegerlevelfield> {
@@ -117,7 +117,7 @@ export declare abstract class AbilityEnumLevelField<T extends number> extends Ab
     protected getNativeFieldById(id: number): jabilityintegerlevelfield;
     protected getNativeFieldValue(instance: Ability, level: number): T;
     protected setNativeFieldValue(instance: Ability, level: number, value: T): boolean;
-    static get valueChangeEvent(): ObjectLevelFieldValueChangeEvent<AbilityBooleanLevelField>;
+    static get valueChangeEvent(): ObjectLevelFieldValueChangeEvent<AbilityEnumLevelField<number>>;
 }
 export declare class AbilityBuffPolarityLevelField extends AbilityEnumLevelField<BuffPolarity> {
     protected values: ReadonlyNonEmptyLinkedSet<BuffPolarity>;

package/engine/object-field/ability.lua

@@ -7,6 +7,7 @@ local __TS__InstanceOf = ____lualib.__TS__InstanceOf
 local ____exports = {}
 local ____ability = require("engine.internal.ability")
 local Ability = ____ability.Ability
+local abilityTypeHasField = ____ability.abilityTypeHasField
 local ____object_2Dfield = require("engine.object-field")
 local ObjectArrayField = ____object_2Dfield.ObjectArrayField
 local ObjectField = ____object_2Dfield.ObjectField
@@ -29,8 +30,8 @@ __TS__ClassExtends(AbilityField, ObjectField)
 function AbilityField.prototype.getObjectDataEntryId(self, instance)
     return instance.typeId
 end
-function AbilityField.prototype.hasNativeFieldValue(self, instance)
-    return instance:hasField(self.nativeField)
+function AbilityField.prototype.hasNativeFieldValue(self, abilityTypeId)
+    return abilityTypeHasField(abilityTypeId, self.nativeField)
 end
 __TS__SetDescriptor(
     AbilityField.prototype,
@@ -197,8 +198,8 @@ __TS__ClassExtends(AbilityArrayField, ObjectArrayField)
 function AbilityArrayField.prototype.getObjectDataEntryId(self, instance)
     return instance.typeId
 end
-function AbilityArrayField.prototype.hasNativeFieldValue(self, instance)
-    return instance:hasField(self.nativeField)
+function AbilityArrayField.prototype.hasNativeFieldValue(self, abilityTypeId)
+    return abilityTypeHasField(abilityTypeId, self.nativeField)
 end
 __TS__SetDescriptor(
     AbilityArrayField.prototype,
@@ -269,8 +270,8 @@ end
 function AbilityLevelField.prototype.getObjectDataEntryId(self, instance)
     return instance.typeId
 end
-function AbilityLevelField.prototype.hasNativeFieldValue(self, instance)
-    return instance:hasField(self.nativeField)
+function AbilityLevelField.prototype.hasNativeFieldValue(self, abilityTypeId)
+    return abilityTypeHasField(abilityTypeId, self.nativeField)
 end
 __TS__SetDescriptor(
     AbilityLevelField.prototype,
@@ -518,9 +519,9 @@ __TS__SetDescriptor(
 )
 ____exports.resolveCurrentAbilityDependentValue = function(ability, value)
     if __TS__InstanceOf(value, ____exports.AbilityField) then
-        return value:getValue(ability)
+        return value:getValue(ability, true)
     elseif __TS__InstanceOf(value, ____exports.AbilityLevelField) then
-        return value:getValue(ability, ability.level)
+        return value:getValue(ability, ability.level, true)
     elseif type(value) == "function" then
         return value(ability)
     else

package/engine/object-field/item.d.ts

@@ -0,0 +1,22 @@
+/** @noSelfInFile */
+import { ObjectField } from "../object-field";
+import { Item } from "../internal/item";
+import { ItemType, ItemTypeId } from "../object-data/entry/item-type";
+export declare abstract class ItemField<ValueType extends number | string | boolean = number | string | boolean, NativeFieldType = any> extends ObjectField<ItemType, Item, ValueType, NativeFieldType> {
+    protected get instanceClass(): typeof Item;
+    protected getObjectDataEntryId(instance: Item): ItemTypeId;
+}
+export declare class ItemBooleanField extends ItemField<boolean, jitembooleanfield> {
+    protected get defaultValue(): boolean;
+    protected getNativeFieldById(id: number): jitembooleanfield;
+    protected hasNativeFieldValue(): boolean;
+    protected getNativeFieldValue(instance: Item): boolean;
+    protected setNativeFieldValue(instance: Item, value: boolean): boolean;
+}
+export declare class ItemIntegerField extends ItemField<number, jitemintegerfield> {
+    protected get defaultValue(): number;
+    protected getNativeFieldById(id: number): jitemintegerfield;
+    protected hasNativeFieldValue(): boolean;
+    protected getNativeFieldValue(instance: Item): number;
+    protected setNativeFieldValue(instance: Item, value: number): boolean;
+}

package/engine/object-field/item.lua

@@ -0,0 +1,118 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local __TS__SetDescriptor = ____lualib.__TS__SetDescriptor
+local ____exports = {}
+local ____object_2Dfield = require("engine.object-field")
+local ObjectField = ____object_2Dfield.ObjectField
+local ____item = require("engine.internal.item")
+local Item = ____item.Item
+local ____lua_2Dsets = require("utility.lua-sets")
+local luaSetOf = ____lua_2Dsets.luaSetOf
+local convertItemBooleanField = ConvertItemBooleanField
+local convertItemIntegerField = ConvertItemIntegerField
+local getItemBooleanField = BlzGetItemBooleanField
+local getItemIntegerField = BlzGetItemIntegerField
+local isItemPawnable = IsItemPawnable
+local isItemPowerup = IsItemPowerup
+local setItemBooleanField = BlzSetItemBooleanField
+local setItemDropOnDeath = SetItemDropOnDeath
+local setItemDroppable = SetItemDroppable
+local setItemPawnable = SetItemPawnable
+local setItemIntegerField = BlzSetItemIntegerField
+____exports.ItemField = __TS__Class()
+local ItemField = ____exports.ItemField
+ItemField.name = "ItemField"
+__TS__ClassExtends(ItemField, ObjectField)
+function ItemField.prototype.getObjectDataEntryId(self, instance)
+    return instance.typeId
+end
+__TS__SetDescriptor(
+    ItemField.prototype,
+    "instanceClass",
+    {get = function(self)
+        return Item
+    end},
+    true
+)
+local nativeItemBooleanFieldIds = luaSetOf(
+    fourCC("ipaw"),
+    fourCC("iusa")
+)
+____exports.ItemBooleanField = __TS__Class()
+local ItemBooleanField = ____exports.ItemBooleanField
+ItemBooleanField.name = "ItemBooleanField"
+__TS__ClassExtends(ItemBooleanField, ____exports.ItemField)
+function ItemBooleanField.prototype.getNativeFieldById(self, id)
+    return convertItemBooleanField(id)
+end
+function ItemBooleanField.prototype.hasNativeFieldValue(self)
+    return nativeItemBooleanFieldIds[self.id] ~= nil
+end
+function ItemBooleanField.prototype.getNativeFieldValue(self, instance)
+    return getItemBooleanField(instance.handle, self.nativeField)
+end
+function ItemBooleanField.prototype.setNativeFieldValue(self, instance, value)
+    if self.id == fourCC("iusa") then
+        local handle = instance.handle
+        local powerUp = isItemPowerup(handle)
+        local perishes = getItemBooleanField(handle, ITEM_BF_PERISHABLE)
+        local dropsOnDeath = getItemBooleanField(handle, ITEM_BF_DROPPED_WHEN_CARRIER_DIES)
+        local canBeDropped = getItemBooleanField(handle, ITEM_BF_CAN_BE_DROPPED)
+        local canBeSold = isItemPawnable(handle)
+        local result = setItemBooleanField(handle, ITEM_BF_ACTIVELY_USED, value)
+        setItemPawnable(handle, canBeSold)
+        setItemDroppable(handle, canBeDropped)
+        setItemDropOnDeath(handle, dropsOnDeath)
+        setItemBooleanField(handle, ITEM_BF_PERISHABLE, perishes)
+        setItemBooleanField(handle, ITEM_BF_USE_AUTOMATICALLY_WHEN_ACQUIRED, powerUp)
+        return result
+    end
+    return setItemBooleanField(instance.handle, self.nativeField, value)
+end
+__TS__SetDescriptor(
+    ItemBooleanField.prototype,
+    "defaultValue",
+    {get = function(self)
+        return false
+    end},
+    true
+)
+local nativeItemIntegerFieldIds = luaSetOf(
+    fourCC("ilev"),
+    fourCC("iuse"),
+    fourCC("icid"),
+    fourCC("ihtp"),
+    fourCC("ihpc"),
+    fourCC("ipri"),
+    fourCC("iarm"),
+    fourCC("iclr"),
+    fourCC("iclg"),
+    fourCC("iclb"),
+    fourCC("ical")
+)
+____exports.ItemIntegerField = __TS__Class()
+local ItemIntegerField = ____exports.ItemIntegerField
+ItemIntegerField.name = "ItemIntegerField"
+__TS__ClassExtends(ItemIntegerField, ____exports.ItemField)
+function ItemIntegerField.prototype.getNativeFieldById(self, id)
+    return convertItemIntegerField(id)
+end
+function ItemIntegerField.prototype.hasNativeFieldValue(self)
+    return nativeItemIntegerFieldIds[self.id] ~= nil
+end
+function ItemIntegerField.prototype.getNativeFieldValue(self, instance)
+    return getItemIntegerField(instance.handle, self.nativeField)
+end
+function ItemIntegerField.prototype.setNativeFieldValue(self, instance, value)
+    return setItemIntegerField(instance.handle, self.nativeField, value)
+end
+__TS__SetDescriptor(
+    ItemIntegerField.prototype,
+    "defaultValue",
+    {get = function(self)
+        return 0
+    end},
+    true
+)
+return ____exports

package/engine/object-field/unit.d.ts

@@ -1,16 +1,85 @@
 /** @noSelfInFile */
 import { Unit } from "../internal/unit";
-import { ObjectField } from "../object-field";
+import { ObjectField, ObjectFieldValueChangeEvent, ObjectLevelField, ObjectLevelFieldValueChangeEvent, ReadonlyObjectFieldType, ReadonlyObjectLevelFieldType } from "../object-field";
 import { UnitType, UnitTypeId } from "../object-data/entry/unit-type";
+import { ReadonlyNonEmptyLinkedSet } from "../../utility/linked-set";
+import { AttackType } from "../object-data/auxiliary/attack-type";
+import { UnitClassifications } from "../object-data/auxiliary/unit-classification";
+import { HealthRegenerationType } from "../object-data/auxiliary/health-regeneration-type";
 export declare abstract class UnitField<ValueType extends number | string | boolean = number | string | boolean, NativeFieldType = any> extends ObjectField<UnitType, Unit, ValueType, NativeFieldType> {
     protected get instanceClass(): typeof Unit;
     protected getObjectDataEntryId(instance: Unit): UnitTypeId;
+    protected hasNativeFieldValue(): boolean;
+    static get valueChangeEvent(): ObjectFieldValueChangeEvent<ReadonlyObjectFieldType<UnitField>>;
+}
+export declare class UnitBooleanField extends UnitField<boolean, junitbooleanfield> {
+    protected get defaultValue(): boolean;
+    protected getNativeFieldById(id: number): junitbooleanfield;
+    protected getNativeFieldValue(instance: Unit): boolean;
+    protected setNativeFieldValue(instance: Unit, value: boolean): boolean;
+    static get valueChangeEvent(): ObjectFieldValueChangeEvent<ReadonlyObjectFieldType<UnitBooleanField>>;
+}
+export declare class UnitFloatField extends UnitField<number, junitrealfield> {
+    protected get defaultValue(): number;
+    protected getNativeFieldById(id: number): junitrealfield;
+    protected getNativeFieldValue(instance: Unit): number;
+    protected setNativeFieldValue(instance: Unit, value: number): boolean;
+    static get valueChangeEvent(): ObjectFieldValueChangeEvent<ReadonlyObjectFieldType<UnitFloatField>>;
+}
+export declare class UnitIntegerField<T extends number = number> extends UnitField<T, junitintegerfield> {
+    protected get defaultValue(): T;
+    protected getNativeFieldById(id: number): junitintegerfield;
+    protected getNativeFieldValue(instance: Unit): T;
+    protected setNativeFieldValue(instance: Unit, value: T): boolean;
+    static get valueChangeEvent(): ObjectFieldValueChangeEvent<ReadonlyObjectFieldType<UnitIntegerField>>;
 }
 export declare class UnitStringField extends UnitField<string, junitstringfield> {
     protected get defaultValue(): string;
     protected getNativeFieldById(id: number): junitstringfield;
-    protected hasNativeFieldValue(): boolean;
     protected getNativeFieldValue(instance: Unit): string;
-    protected getObjectDataEntryId(instance: Unit): UnitTypeId;
     protected setNativeFieldValue(instance: Unit, value: string): boolean;
+    static get valueChangeEvent(): ObjectFieldValueChangeEvent<ReadonlyObjectFieldType<UnitStringField>>;
+}
+type junitweaponfield = junitweaponbooleanfield | junitweaponintegerfield | junitweaponrealfield | junitweaponstringfield;
+export declare abstract class UnitWeaponField<ValueType extends number | string | boolean = number | string | boolean, InputValueType extends ValueType = never, NativeFieldType extends junitweaponfield = junitweaponfield> extends ObjectLevelField<UnitType, Unit, ValueType, InputValueType, NativeFieldType> {
+    protected get instanceClass(): typeof Unit;
+    protected getLevelCount(): number;
+    protected getObjectDataEntryId(instance: Unit): UnitTypeId;
+    protected hasNativeFieldValue(): boolean;
+    static get valueChangeEvent(): ObjectLevelFieldValueChangeEvent<ReadonlyObjectLevelFieldType<UnitWeaponField>>;
+}
+export declare abstract class UnitNumberWeaponField<NativeFieldType extends junitweaponintegerfield | junitweaponrealfield = junitweaponintegerfield | junitweaponrealfield> extends UnitWeaponField<number, number, NativeFieldType> {
+    protected get defaultValue(): number;
+    static get valueChangeEvent(): ObjectLevelFieldValueChangeEvent<UnitNumberWeaponField>;
+}
+export declare abstract class UnitEnumWeaponField<T extends number> extends UnitWeaponField<T, T, junitweaponintegerfield> {
+    protected abstract values: ReadonlyNonEmptyLinkedSet<T>;
+    protected get defaultValue(): T;
+    protected getNativeFieldById(id: number): junitweaponintegerfield;
+    protected getNativeFieldValue(instance: Unit, index: number): T;
+    protected setNativeFieldValue(instance: Unit, index: number, value: T): boolean;
+    static get valueChangeEvent(): ObjectLevelFieldValueChangeEvent<UnitEnumWeaponField<number>>;
+}
+export declare class UnitAttackTypeWeaponField extends UnitEnumWeaponField<AttackType> {
+    protected values: ReadonlyNonEmptyLinkedSet<AttackType>;
+}
+export declare class UnitClassificationsField extends UnitField<UnitClassifications, junitintegerfield> {
+    protected get defaultValue(): UnitClassifications;
+    protected getNativeFieldById(id: number): junitintegerfield;
+    protected getNativeFieldValue(instance: Unit): UnitClassifications;
+    protected setNativeFieldValue(instance: Unit, value: UnitClassifications): boolean;
+}
+export declare class UnitFlyHeightField extends UnitFloatField {
+    protected getNativeFieldValue(instance: Unit): number;
+    protected setNativeFieldValue(instance: Unit, value: number): boolean;
+}
+export declare class UnitPropulsionWindowField extends UnitFloatField {
+    protected getNativeFieldValue(instance: Unit): number;
+    protected setNativeFieldValue(instance: Unit, value: number): boolean;
+}
+export declare class UnitHealthRegenerationTypeField extends UnitIntegerField<HealthRegenerationType> {
+}
+export declare class UnitScalingValueField extends UnitFloatField {
+    protected setNativeFieldValue(instance: Unit, value: number): boolean;
 }
+export {};