warscript 0.0.1-dev.989e1a3 → 0.0.1-dev.9a5718b

package/engine/object-field/ability.lua

@@ -519,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.d.ts

@@ -46,6 +46,7 @@ export declare abstract class ObjectField<ObjectDataEntryType extends ObjectData
     private modifiersByInstance?;
     getValue(entry: ObjectDataEntryType | InstanceType, includeModifiers?: boolean): ValueType;
     setValue(entry: ObjectDataEntryType | InstanceType, value: ValueType): boolean;
+    updateActualValue(instance: InstanceType): void;
     applyModifier(instance: InstanceType, modifier: ObjectFieldModifier<InstanceType, ValueType>): void;
     removeModifier(instance: InstanceType, modifier: ObjectFieldModifier<InstanceType, ValueType>): boolean;
     removeValue(entry: ObjectDataEntryType): boolean;
@@ -87,8 +88,9 @@ export declare abstract class ObjectLevelField<ObjectDataEntryType extends Objec
     protected abstract getNativeFieldValue(instance: InstanceType, level: number): ValueType;
     protected abstract setNativeFieldValue(instance: InstanceType, level: number, value: ValueType): boolean;
     protected abstract getLevelCount(entry: ObjectDataEntryType | InstanceType): number;
-    getValue<LevelType extends [number] | []>(entry: ObjectDataEntryType | InstanceType, ...[level]: LevelType): LevelType extends [number] ? ValueType : ValueType[];
+    getValue<LevelType extends [number, boolean?] | [boolean?]>(entry: ObjectDataEntryType | InstanceType, ...[level, includeModifiers]: LevelType): LevelType extends [number, boolean?] ? ValueType : ValueType[];
     setValue(entry: ObjectDataEntryType | InstanceType, ...[levelOrValue, value]: [value: ObjectDataEntryLevelFieldValueSupplier<InputValueType, ValueType>] | [level: number, value: InputValueType]): boolean;
+    updateActualValue(instance: InstanceType, level?: number): void;
     applyModifier(instance: InstanceType, modifier: ObjectLevelFieldModifier<InstanceType, ValueType>): void;
     removeModifier(instance: InstanceType, modifier: ObjectLevelFieldModifier<InstanceType, ValueType>): boolean;
     trySetValue(entry: ObjectDataEntryType | InstanceType, levelOrValue: number | unknown, value?: unknown): boolean;

package/engine/object-field.lua

@@ -139,7 +139,7 @@ function ObjectField.prototype.setValue(self, entry, value)
                 return true
             end
             originalValueByInstance[entry] = value
-            value = self:calculateActualValue(entry)
+            value = (self:calculateActualValue(entry))
         end
     end
     local previousValue = self:setActualValue(entry, value)
@@ -163,6 +163,12 @@ function ObjectField.prototype.setValue(self, entry, value)
     end
     return true
 end
+function ObjectField.prototype.updateActualValue(self, instance)
+    local actualValue, hasModifiers = self:calculateActualValue(instance)
+    if hasModifiers then
+        self:setActualValue(instance, actualValue)
+    end
+end
 function ObjectField.prototype.applyModifier(self, instance, modifier)
     local modifiersByInstance = self.modifiersByInstance
     if modifiersByInstance == nil then
@@ -182,10 +188,7 @@ function ObjectField.prototype.applyModifier(self, instance, modifier)
             ____originalValueByInstance_instance_3 = self:getActualValue(instance)
         end
         ____originalValueByInstance_4[____instance_5] = ____originalValueByInstance_instance_3
-        self:setActualValue(
-            instance,
-            self:calculateActualValue(instance)
-        )
+        self:setActualValue(instance, (self:calculateActualValue(instance)))
     end
 end
 function ObjectField.prototype.removeModifier(self, instance, modifier)
@@ -193,10 +196,7 @@ function ObjectField.prototype.removeModifier(self, instance, modifier)
     if modifiersByInstance ~= nil then
         local modifiers = modifiersByInstance[instance]
         if modifiers ~= nil and modifiers:remove(modifier) then
-            self:setActualValue(
-                instance,
-                self:calculateActualValue(instance)
-            )
+            self:setActualValue(instance, (self:calculateActualValue(instance)))
             return true
         end
     end
@@ -283,10 +283,11 @@ function ObjectField.prototype.calculateActualValue(self, instance)
             for modifier in pairs(modifiers) do
                 value = modifier(instance, value, originalValue)
             end
+            return value, true
         end
-        return value
+        return value, false
     end
-    return self.defaultValue
+    return self.defaultValue, false
 end
 function ObjectField.prototype.invokeValueChangeEvent(self, ...)
     self:invokeValueChangeEventRecursive(
@@ -402,12 +403,12 @@ ____exports.ObjectLevelField = __TS__Class()
 local ObjectLevelField = ____exports.ObjectLevelField
 ObjectLevelField.name = "ObjectLevelField"
 __TS__ClassExtends(ObjectLevelField, ObjectFieldBase)
-function ObjectLevelField.prototype.getValue(self, entry, level)
+function ObjectLevelField.prototype.getValue(self, entry, level, includeModifiers)
     if level == nil then
         local result = {}
         local levelCount = self:getLevelCount(entry)
         for i = 0, levelCount - 1 do
-            result[i + 1] = self:getValue(entry, i)
+            result[i + 1] = self:getValue(entry, i, includeModifiers)
         end
         return result
     end
@@ -425,11 +426,13 @@ function ObjectLevelField.prototype.getValue(self, entry, level)
         end
         return self.defaultValue
     end
-    local ____opt_22 = self.originalValueByLevelByInstance
-    local ____opt_20 = ____opt_22 and ____opt_22[entry]
-    local originalValue = ____opt_20 and ____opt_20[level]
-    if originalValue ~= nil then
-        return originalValue
+    if not includeModifiers then
+        local ____opt_22 = self.originalValueByLevelByInstance
+        local ____opt_20 = ____opt_22 and ____opt_22[entry]
+        local originalValue = ____opt_20 and ____opt_20[level]
+        if originalValue ~= nil then
+            return originalValue
+        end
     end
     return self:getActualValue(entry, level)
 end
@@ -512,6 +515,27 @@ function ObjectLevelField.prototype.setValue(self, entry, levelOrValue, value)
     end
     return true
 end
+function ObjectLevelField.prototype.updateActualValue(self, instance, level)
+    local modifiersByInstance = self.modifiersByInstance
+    if modifiersByInstance == nil then
+        return
+    end
+    local modifiers = modifiersByInstance[instance]
+    if modifiers == nil or modifiers.size == 0 then
+        return
+    end
+    if level == nil then
+        for i = 0, self:getLevelCount(instance) - 1 do
+            self:updateActualValue(instance, i)
+        end
+        return
+    end
+    self:setActualValue(
+        instance,
+        level,
+        self:calculateActualValue(instance, level)
+    )
+end
 function ObjectLevelField.prototype.applyModifier(self, instance, modifier)
     local modifiersByInstance = self.modifiersByInstance
     if modifiersByInstance == nil then

package/engine/random.d.ts

@@ -18,3 +18,4 @@ export declare const random: {
     <T>(element: T, ...elements: T[]): T;
     <T>(...elements: T[]): T | undefined;
 };
+export declare const shuffle: (array: unknown[]) => void;

package/engine/random.lua

@@ -28,4 +28,12 @@ ____exports.random = function(...)
         ...
     ))
 end
+____exports.shuffle = function(array)
+    for i = #array - 1, 1 do
+        local j = getRandomInt(0, i)
+        local value = array[i + 1]
+        array[i + 1] = array[j + 1]
+        array[j + 1] = value
+    end
+end
 return ____exports