warscript 0.0.1-dev.07e3832 → 0.0.1-dev.099f0af

package/engine/internal/unit/bonus.lua

@@ -21,6 +21,7 @@ local AUTO_ATTACK_DAMAGE_INCREASE_DUMMY_ABILITY_TYPE_ID = ____auto_2Dattack_2Dda
 local ____movement_2Dspeed_2Dincrease_2Dfactor = require("engine.internal.object-data.movement-speed-increase-factor")
 local MOVEMENT_SPEED_INCREASE_FACTOR_ABILITY_FIELD = ____movement_2Dspeed_2Dincrease_2Dfactor.MOVEMENT_SPEED_INCREASE_FACTOR_ABILITY_FIELD
 local MOVEMENT_SPEED_INCREASE_FACTOR_DUMMY_ABILITY_TYPE_ID = ____movement_2Dspeed_2Dincrease_2Dfactor.MOVEMENT_SPEED_INCREASE_FACTOR_DUMMY_ABILITY_TYPE_ID
+local damageFactorByUnit = {}
 local receivedDamageFactorByUnit = {}
 ____exports.UnitBonusType = {}
 local UnitBonusType = ____exports.UnitBonusType
@@ -46,13 +47,14 @@ do
         reduce = sum,
         initialValue = 0
     }
-    UnitBonusType.DAMAGE = {
+    UnitBonusType.AUTO_ATTACK_DAMAGE = {
         abilityTypeId = AUTO_ATTACK_DAMAGE_INCREASE_DUMMY_ABILITY_TYPE_ID,
         field = AUTO_ATTACK_DAMAGE_INCREASE_ABILITY_FIELD,
         integer = false,
         reduce = sum,
         initialValue = 0
     }
+    UnitBonusType.DAMAGE_FACTOR = {reduce = product, valueByUnit = damageFactorByUnit, initialValue = 1}
     UnitBonusType.RECEIVED_DAMAGE_FACTOR = {reduce = product, valueByUnit = receivedDamageFactorByUnit, initialValue = 1}
 end
 local bonusesByUnitByBonusType = {}
@@ -180,6 +182,9 @@ end
 Unit.onDamage:addListener(
     4,
     function(source, target, event)
+        if source ~= nil and damageFactorByUnit[source] ~= nil then
+            event.amount = event.amount * damageFactorByUnit[source]
+        end
         if receivedDamageFactorByUnit[target] ~= nil then
             event.amount = event.amount * receivedDamageFactorByUnit[target]
         end

package/engine/internal/unit/item.d.ts

@@ -0,0 +1,22 @@
+/** @noSelfInFile */
+import { Item } from "../item";
+export interface UnitItems extends ReadonlyArray<Item | undefined> {
+    readonly length: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    [0]: Item | undefined;
+    [1]: Item | undefined;
+    [2]: Item | undefined;
+    [3]: Item | undefined;
+    [4]: Item | undefined;
+    [5]: Item | undefined;
+}
+export declare class UnitItems {
+    constructor(handle: junit);
+    protected __newindex(slot: number, item: Item | undefined): void;
+    protected __index(key: string | number): unknown;
+    protected __len(): number;
+}
+declare module "../unit" {
+    interface Unit {
+        readonly items: UnitItems;
+    }
+}

package/engine/internal/unit/item.lua

@@ -0,0 +1,63 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__New = ____lualib.__TS__New
+local __TS__ObjectDefineProperty = ____lualib.__TS__ObjectDefineProperty
+local ____exports = {}
+local ____item = require("engine.internal.item")
+local Item = ____item.Item
+local ____unit = require("engine.internal.unit")
+local Unit = ____unit.Unit
+local rawset = _G.rawset
+local ____type = _G.type
+local isItemPowerup = IsItemPowerup
+local setItemBooleanField = BlzSetItemBooleanField
+local unitAddItem = UnitAddItem
+local unitDropItemSlot = UnitDropItemSlot
+local unitInventorySize = UnitInventorySize
+local unitItemInSlot = UnitItemInSlot
+local unitRemoveItemFromSlot = UnitRemoveItemFromSlot
+local handleByUnitItems = setmetatable({}, {__mode = "k"})
+____exports.UnitItems = __TS__Class()
+local UnitItems = ____exports.UnitItems
+UnitItems.name = "UnitItems"
+function UnitItems.prototype.____constructor(self, handle)
+    handleByUnitItems[self] = handle
+end
+function UnitItems.prototype.__newindex(self, slot, item)
+    local handle = handleByUnitItems[self]
+    if slot < 1 or slot > unitInventorySize(handle) then
+        return
+    end
+    unitRemoveItemFromSlot(handle, slot - 1)
+    if item ~= nil then
+        local itemHandle = item.handle
+        local isPowerup = isItemPowerup(itemHandle)
+        if isPowerup then
+            setItemBooleanField(itemHandle, ITEM_BF_USE_AUTOMATICALLY_WHEN_ACQUIRED, false)
+        end
+        unitAddItem(handle, itemHandle)
+        unitDropItemSlot(handle, itemHandle, slot - 1)
+        if isPowerup then
+            setItemBooleanField(itemHandle, ITEM_BF_USE_AUTOMATICALLY_WHEN_ACQUIRED, true)
+        end
+    end
+end
+function UnitItems.prototype.__index(self, key)
+    if ____type(key) == "number" then
+        return Item:of(unitItemInSlot(handleByUnitItems[self], key - 1))
+    end
+    return rawget(____exports.UnitItems.prototype, key)
+end
+function UnitItems.prototype.__len(self)
+    return unitInventorySize(handleByUnitItems[self])
+end
+__TS__ObjectDefineProperty(
+    Unit.prototype,
+    "items",
+    {get = function(self)
+        local items = __TS__New(____exports.UnitItems, self.handle)
+        rawset(self, "items", items)
+        return items
+    end}
+)
+return ____exports

package/engine/internal/unit+ability.lua

@@ -40,7 +40,7 @@ ItemAbility.onCreate:addListener(
         end
     end
 )
-Unit.onItemPickup:addListener(
+Unit.itemPickedUpEvent:addListener(
     0,
     function(unit, item)
         for ____, ability in ipairs(item.abilities) do
@@ -48,7 +48,7 @@ Unit.onItemPickup:addListener(
         end
     end
 )
-Unit.onItemDrop:addListener(
+Unit.itemDroppedEvent:addListener(
     4,
     function(unit, item)
         for ____, ability in ipairs(item.abilities) do

package/engine/internal/unit.d.ts

@@ -42,6 +42,7 @@ export interface DamagingEvent {
     damageType: jdamagetype;
     weaponType: jweapontype;
     readonly isAttack: boolean;
+    readonly originalAmount: number;
 }
 export type DamageEvent = DamagingEvent & {
     preventDeath<P extends any[]>(this: DamageEvent, callback: (this: void, ...parameters: P) => any, ...parameters: P): void;
@@ -322,9 +323,10 @@ export declare class Unit extends Handle<junit> {
     static readonly autoAttackStartEvent: UnitTriggerEvent<[Unit]>;
     static readonly onDamaging: Event<[source: Unit | undefined, target: Unit, event: DamagingEvent]>;
     static readonly onDamage: InitializingEvent<[source: Unit | undefined, target: Unit, event: DamageEvent], jtrigger>;
-    static onItemDrop: UnitTriggerEvent<[Item]>;
-    static onItemPickup: UnitTriggerEvent<[Item]>;
-    static onItemUse: UnitTriggerEvent<[Item]>;
+    static itemDroppedEvent: UnitTriggerEvent<[Item]>;
+    static itemPickedUpEvent: UnitTriggerEvent<[Item]>;
+    static itemUsedEvent: UnitTriggerEvent<[Item]>;
+    static itemStackedEvent: UnitTriggerEvent<[Item]>;
     static get onCreate(): EventDispatcher<[Unit], [Unit]>;
     static get destroyEvent(): EventDispatcher<[Unit], [Unit]>;
     getField(field: junitintegerfield | junitrealfield): number;

package/engine/internal/unit.lua

@@ -865,7 +865,7 @@ function Unit.prototype.dropItemSlot(self, item, slot)
     return UnitDropItemSlot(self.handle, item.handle, slot)
 end
 function Unit.prototype.itemInSlot(self, slot)
-    return Item:of(UnitItemInSlot(self.handle, slot))
+    return Item:of(unitItemInSlot(self.handle, slot))
 end
 function Unit.prototype.addAbility(self, abilityId)
     if unitAddAbility(self.handle, abilityId) then
@@ -2452,6 +2452,7 @@ Unit.onDamage = __TS__New(
                     damageType = BlzGetEventDamageType(),
                     weaponType = BlzGetEventWeaponType(),
                     isAttack = BlzGetEventIsAttack(),
+                    originalAmount = GetEventDamage(),
                     preventDeath = damageEventPreventDeath
                 }
                 local evData = setmetatable(
@@ -2502,7 +2503,7 @@ Unit.onDamage = __TS__New(
         DestroyTrigger(trigger)
     end
 )
-Unit.onItemDrop = __TS__New(
+Unit.itemDroppedEvent = __TS__New(
     ____exports.UnitTriggerEvent,
     EVENT_PLAYER_UNIT_DROP_ITEM,
     function()
@@ -2513,7 +2514,7 @@ Unit.onItemDrop = __TS__New(
         return IgnoreEvent
     end
 )
-Unit.onItemPickup = __TS__New(
+Unit.itemPickedUpEvent = __TS__New(
     ____exports.UnitTriggerEvent,
     EVENT_PLAYER_UNIT_PICKUP_ITEM,
     function()
@@ -2524,10 +2525,15 @@ Unit.onItemPickup = __TS__New(
         return IgnoreEvent
     end
 )
-Unit.onItemUse = __TS__New(
+Unit.itemUsedEvent = __TS__New(
     ____exports.UnitTriggerEvent,
     EVENT_PLAYER_UNIT_USE_ITEM,
-    function() return ____exports.Unit:of(GetTriggerUnit()), Item:of(GetManipulatedItem()) end
+    function() return ____exports.Unit:of(getTriggerUnit()), Item:of(getManipulatedItem()) end
+)
+Unit.itemStackedEvent = __TS__New(
+    ____exports.UnitTriggerEvent,
+    EVENT_PLAYER_UNIT_STACK_ITEM,
+    function() return ____exports.Unit:of(getTriggerUnit()), Item:of(getManipulatedItem()) end
 )
 __TS__ObjectDefineProperty(
     Unit,

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

@@ -45,4 +45,16 @@ export declare class ItemType extends ObjectDataEntry<ItemTypeId> {
     set tooltipText(tooltipText: string);
     get tooltipExtendedText(): string;
     set tooltipExtendedText(tooltipText: string);
+    get goldCost(): number;
+    set goldCost(goldCost: number);
+    get lumberCost(): number;
+    set lumberCost(lumberCost: number);
+    get activelyUsed(): boolean;
+    set activelyUsed(activelyUsed: boolean);
+    get perishable(): boolean;
+    set perishable(perishable: boolean);
+    get initialStackSize(): number;
+    set initialStackSize(initialStackSize: number);
+    get maximumStackSize(): number;
+    set maximumStackSize(maximumStackSize: number);
 }

package/engine/object-data/entry/item-type.lua

@@ -256,4 +256,82 @@ __TS__SetDescriptor(
     },
     true
 )
+__TS__SetDescriptor(
+    ItemType.prototype,
+    "goldCost",
+    {
+        get = function(self)
+            return self:getNumberField("igol")
+        end,
+        set = function(self, goldCost)
+            self:setNumberField("igol", goldCost)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    ItemType.prototype,
+    "lumberCost",
+    {
+        get = function(self)
+            return self:getNumberField("ilum")
+        end,
+        set = function(self, lumberCost)
+            self:setNumberField("ilum", lumberCost)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    ItemType.prototype,
+    "activelyUsed",
+    {
+        get = function(self)
+            return self:getBooleanField("iusa")
+        end,
+        set = function(self, activelyUsed)
+            self:setBooleanField("iusa", activelyUsed)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    ItemType.prototype,
+    "perishable",
+    {
+        get = function(self)
+            return self:getBooleanField("iper")
+        end,
+        set = function(self, perishable)
+            self:setBooleanField("iper", perishable)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    ItemType.prototype,
+    "initialStackSize",
+    {
+        get = function(self)
+            return self:getNumberField("iuse")
+        end,
+        set = function(self, initialStackSize)
+            self:setNumberField("iuse", initialStackSize)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    ItemType.prototype,
+    "maximumStackSize",
+    {
+        get = function(self)
+            return self:getNumberField("ista")
+        end,
+        set = function(self, maximumStackSize)
+            self:setNumberField("ista", maximumStackSize)
+        end
+    },
+    true
+)
 return ____exports

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

@@ -6,6 +6,9 @@ import { ObjectDataEntryId } from "../object-data/entry";
 import { LightningTypeId } from "../object-data/entry/lightning-type";
 import { CombatClassifications } from "../object-data/auxiliary/combat-classification";
 import { UnitTypeId } from "../object-data/entry/unit-type";
+import { BuffResistanceType } from "../object-data/auxiliary/buff-resistance-type";
+import { BuffPolarity } from "../object-data/auxiliary/buff-polarity";
+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;
@@ -107,6 +110,20 @@ export declare class AbilityAbilityTypeIdLevelField extends AbilityObjectDataEnt
 }
 export declare class AbilityUnitTypeIdLevelField extends AbilityObjectDataEntryIdLevelField<UnitTypeId> {
 }
+export declare abstract class AbilityEnumLevelField<T extends number> extends AbilityLevelField<T, T, jabilityintegerlevelfield> {
+    protected abstract values: ReadonlyNonEmptyLinkedSet<T>;
+    protected get defaultValue(): T;
+    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>;
+}
+export declare class AbilityBuffPolarityLevelField extends AbilityEnumLevelField<BuffPolarity> {
+    protected values: ReadonlyNonEmptyLinkedSet<BuffPolarity>;
+}
+export declare class AbilityBuffResistanceTypeLevelField extends AbilityEnumLevelField<BuffResistanceType> {
+    protected values: ReadonlyNonEmptyLinkedSet<BuffResistanceType>;
+}
 export declare class AbilityCombatClassificationsLevelField extends AbilityLevelField<CombatClassifications, CombatClassifications, jabilityintegerlevelfield> {
     protected get defaultValue(): CombatClassifications;
     protected getNativeFieldById(id: number): jabilityintegerlevelfield;

package/engine/object-field/ability.lua

@@ -13,6 +13,8 @@ local ObjectField = ____object_2Dfield.ObjectField
 local ObjectLevelField = ____object_2Dfield.ObjectLevelField
 local ____ability_2Dtype = require("engine.object-data.entry.ability-type")
 local AbilityType = ____ability_2Dtype.AbilityType
+local ____linked_2Dset = require("utility.linked-set")
+local nonEmptyLinkedSetOf = ____linked_2Dset.nonEmptyLinkedSetOf
 local convertAbilityBooleanField = _G.ConvertAbilityBooleanField
 local convertAbilityIntegerField = _G.ConvertAbilityIntegerField
 local convertAbilityRealField = _G.ConvertAbilityRealField
@@ -431,6 +433,54 @@ ____exports.AbilityUnitTypeIdLevelField = __TS__Class()
 local AbilityUnitTypeIdLevelField = ____exports.AbilityUnitTypeIdLevelField
 AbilityUnitTypeIdLevelField.name = "AbilityUnitTypeIdLevelField"
 __TS__ClassExtends(AbilityUnitTypeIdLevelField, ____exports.AbilityObjectDataEntryIdLevelField)
+____exports.AbilityEnumLevelField = __TS__Class()
+local AbilityEnumLevelField = ____exports.AbilityEnumLevelField
+AbilityEnumLevelField.name = "AbilityEnumLevelField"
+__TS__ClassExtends(AbilityEnumLevelField, ____exports.AbilityLevelField)
+function AbilityEnumLevelField.prototype.getNativeFieldById(self, id)
+    return convertAbilityIntegerLevelField(id)
+end
+function AbilityEnumLevelField.prototype.getNativeFieldValue(self, instance, level)
+    local value = instance:getField(self.nativeField, level)
+    if self.values:contains(value) then
+        return value
+    end
+    return self.values:first()
+end
+function AbilityEnumLevelField.prototype.setNativeFieldValue(self, instance, level, value)
+    return instance:setField(self.nativeField, level, value)
+end
+__TS__SetDescriptor(
+    AbilityEnumLevelField.prototype,
+    "defaultValue",
+    {get = function(self)
+        return self.values:first()
+    end},
+    true
+)
+__TS__ObjectDefineProperty(
+    AbilityEnumLevelField,
+    "valueChangeEvent",
+    {get = function(self)
+        return self:getOrCreateValueChangeEvent()
+    end}
+)
+____exports.AbilityBuffPolarityLevelField = __TS__Class()
+local AbilityBuffPolarityLevelField = ____exports.AbilityBuffPolarityLevelField
+AbilityBuffPolarityLevelField.name = "AbilityBuffPolarityLevelField"
+__TS__ClassExtends(AbilityBuffPolarityLevelField, ____exports.AbilityEnumLevelField)
+function AbilityBuffPolarityLevelField.prototype.____constructor(self, ...)
+    AbilityBuffPolarityLevelField.____super.prototype.____constructor(self, ...)
+    self.values = nonEmptyLinkedSetOf(0, 1, 2)
+end
+____exports.AbilityBuffResistanceTypeLevelField = __TS__Class()
+local AbilityBuffResistanceTypeLevelField = ____exports.AbilityBuffResistanceTypeLevelField
+AbilityBuffResistanceTypeLevelField.name = "AbilityBuffResistanceTypeLevelField"
+__TS__ClassExtends(AbilityBuffResistanceTypeLevelField, ____exports.AbilityEnumLevelField)
+function AbilityBuffResistanceTypeLevelField.prototype.____constructor(self, ...)
+    AbilityBuffResistanceTypeLevelField.____super.prototype.____constructor(self, ...)
+    self.values = nonEmptyLinkedSetOf(1, 2, 3)
+end
 local allowedTargetCombatClassificationsByLevelByAbilityTypeId = postcompile(function()
     local allowedTargetCombatClassificationsByLevelByAbilityTypeId = {}
     for ____, abilityType in ipairs(AbilityType:getAll()) do

package/engine/unit.d.ts

@@ -4,6 +4,7 @@ import "./internal/unit/ability";
 import "./internal/unit/allowed-targets";
 import "./internal/unit/buff";
 import "./internal/unit/expiration-timer";
+import "./internal/unit/item";
 import "./internal/unit+ability";
 import "./internal/unit+damage";
 import "./internal/unit+rally";

package/engine/unit.lua

@@ -4,6 +4,7 @@ require("engine.internal.unit.ability")
 require("engine.internal.unit.allowed-targets")
 require("engine.internal.unit.buff")
 require("engine.internal.unit.expiration-timer")
+require("engine.internal.unit.item")
 require("engine.internal.unit+ability")
 require("engine.internal.unit+damage")
 require("engine.internal.unit+rally")

package/net/socket.d.ts

@@ -1,9 +1,15 @@
 /** @noSelfInFile */
 import { Event } from "../event";
 import { Player } from "../core/types/player";
+declare const enum SocketPropertyKey {
+    ID = 0,
+    CHUNK_ID = 1
+}
 export declare class Socket {
-    private readonly id;
+    private readonly [SocketPropertyKey.ID];
+    private readonly [SocketPropertyKey.CHUNK_ID];
     readonly onMessage: Event<[Player, string]>;
     constructor();
     send(data: string): void;
 }
+export {};

package/net/socket.lua

@@ -7,6 +7,11 @@ local Event = ____event.Event
 local ____network = require("network")
 local send = ____network.send
 local onReceive = ____network.onReceive
+local MAX_PAYLOAD_LENGTH = ____network.MAX_PAYLOAD_LENGTH
+local ____math = require("math")
+local ceil = ____math.ceil
+local stringSub = string.sub
+local tableConcat = table.concat
 local nextId = 0
 ____exports.Socket = __TS__Class()
 local Socket = ____exports.Socket
@@ -14,13 +19,49 @@ Socket.name = "Socket"
 function Socket.prototype.____constructor(self)
     local ____tostring_0 = tostring
     nextId = nextId + 1
-    self.id = ____tostring_0(nextId)
+    self[0] = ____tostring_0(nextId)
+    local ____tostring_1 = tostring
+    nextId = nextId + 1
+    self[1] = ____tostring_1(nextId)
     self.onMessage = __TS__New(Event)
-    onReceive[self.id]:addListener(function(sender, data)
-        Event.invoke(self.onMessage, sender, data)
+    local chunksByPlayer = {}
+    onReceive[self[0]]:addListener(function(sender, data)
+        local chunks = chunksByPlayer[sender]
+        if chunks ~= nil then
+            chunks[#chunks + 1] = data
+            Event.invoke(
+                self.onMessage,
+                sender,
+                tableConcat(chunks)
+            )
+            chunksByPlayer[sender] = nil
+        else
+            Event.invoke(self.onMessage, sender, data)
+        end
+    end)
+    onReceive[self[1]]:addListener(function(sender, data)
+        local chunks = chunksByPlayer[sender]
+        if chunks == nil then
+            chunks = {}
+            chunksByPlayer[sender] = chunks
+        end
+        chunks[#chunks + 1] = data
     end)
 end
 function Socket.prototype.send(self, data)
-    send(self.id, data)
+    local chunks = ceil(#data / MAX_PAYLOAD_LENGTH) - 1
+    local offset = 1
+    for _ = 0, chunks - 1 do
+        local nextOffset = offset + MAX_PAYLOAD_LENGTH
+        send(
+            self[1],
+            stringSub(data, offset, nextOffset - 1)
+        )
+        offset = nextOffset
+    end
+    send(
+        self[0],
+        stringSub(data, offset)
+    )
 end
 return ____exports

package/network.d.ts

@@ -2,6 +2,7 @@
 import { Event } from "./event";
 import { Player } from "./core/types/player";
 import { Operation, OperationContinue, OperationMonitor } from "./operation";
+export declare const MAX_PAYLOAD_LENGTH = 255;
 export declare const onReceive: {
     [prefix: string]: Event<[Player, string]>;
 } & {

package/network.lua

@@ -25,6 +25,7 @@ local concat = table.concat
 local pack = string.pack
 local sub = string.sub
 local ____unpack = string.unpack
+____exports.MAX_PAYLOAD_LENGTH = 255
 ____exports.onReceive = setmetatable(
     {},
     {__index = function(self, prefix)
@@ -42,11 +43,11 @@ ____exports.onReceive = setmetatable(
     end}
 )
 function ____exports.send(id, payload)
-    if #payload > 255 then
+    if #payload > ____exports.MAX_PAYLOAD_LENGTH then
         error(
             __TS__New(
                 IllegalArgumentException,
-                "payload length must be <= 256, but was " .. tostring(#payload)
+                (("payload length must be <= " .. tostring(____exports.MAX_PAYLOAD_LENGTH)) .. ", but was ") .. tostring(#payload)
             ),
             0
         )

package/objutil/buff.lua

@@ -762,7 +762,7 @@ Unit.onDamaging:addListener(function(source, target, event)
         end)
     end
 end)
-Unit.onItemPickup:addListener(function(unit, item)
+Unit.itemPickedUpEvent:addListener(function(unit, item)
     if item.powerup and item:hasAbility(fourCC("APdi")) then
     end
 end)

package/package.json

@@ -1,7 +1,7 @@
 {
     "$schema": "https://json.schemastore.org/package",
     "name": "warscript",
-    "version": "0.0.1-dev.07e3832",
+    "version": "0.0.1-dev.099f0af",
     "description": "A typescript library for Warcraft III using Warpack.",
     "keywords": [
         "warcraft",
@@ -24,7 +24,7 @@
         "@warscript/language-extensions": "^0.0.1",
         "@warscript/tstl-plugin": "^0.0.4",
         "lua-types": "^2.13.1",
-        "warpack": "0.0.1-dev.2c4e71e"
+        "warpack": "0.0.1-dev.880fc91"
     },
     "devDependencies": {
         "@typescript-eslint/eslint-plugin": "^8.13.0",

package/property.d.ts

@@ -0,0 +1,55 @@
+/** @noSelfInFile */
+import { Player } from "./core/types/player";
+import { Event } from "./event";
+export declare class PersistentPropertiesConfig {
+    static defaultFileName: string;
+}
+declare const enum PropertyPropertyKey {
+    DEFAULT_VALUE = 0,
+    VALUE = 1,
+    IS_CHANGED = 2
+}
+export declare class Property<T> {
+    readonly valueChangeEvent: Event<[newValue: T, oldValue: T]>;
+    private [PropertyPropertyKey.DEFAULT_VALUE];
+    private [PropertyPropertyKey.VALUE];
+    private [PropertyPropertyKey.IS_CHANGED]?;
+    constructor(defaultValue: T);
+    get defaultValue(): T;
+    set defaultValue(defaultValue: T);
+    get value(): T;
+    set value(value: T);
+    get isChanged(): boolean;
+    reset(): boolean;
+    set(value: T): boolean;
+    get(): T;
+}
+declare const enum PlayerPropertyPropertyKey {
+    DEFAULT_VALUE = 0,
+    VALUE_BY_PLAYER = 1,
+    IS_CHANGED_BY_PLAYER = 2
+}
+export declare class PlayerProperty<T> {
+    readonly valueChangeEvent: Event<[player: Player, newValue: T, oldValue: T]>;
+    private readonly [PlayerPropertyPropertyKey.DEFAULT_VALUE];
+    private readonly [PlayerPropertyPropertyKey.VALUE_BY_PLAYER];
+    private readonly [PlayerPropertyPropertyKey.IS_CHANGED_BY_PLAYER];
+    constructor(defaultValue: T);
+    isChanged(player: Player): boolean;
+    reset(player: Player): boolean;
+    set(player: Player, value: T): boolean;
+    get(player: Player): T;
+}
+export declare class PersistentProperty<T extends undefined | boolean | number | string> extends Property<T> {
+    readonly id: number;
+    constructor(id: number, defaultValue: T, valueChangeEventListener?: (newValue: T, oldValue: T) => void);
+    reset(): boolean;
+    set(value: T): boolean;
+}
+export declare class PersistentPlayerProperty<T extends string | number | boolean> extends PlayerProperty<T> {
+    readonly id: number;
+    constructor(id: number, initialValue: T, valueChangeEventListener?: (player: Player, newValue: T, oldValue: T) => void);
+    reset(player: Player): boolean;
+    set(player: Player, value: T): boolean;
+}
+export {};