warscript 0.0.1-dev.91da42b → 0.0.1-dev.9381e62

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.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

@@ -88,7 +88,7 @@ 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;

package/engine/object-field.lua

@@ -403,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
@@ -426,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

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