warscript 0.0.1-dev.404878c

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

@@ -0,0 +1,8 @@
+/// <reference types="warpack-types/warpack" />
+/** @noSelfInFile */
+import { Upgrade, UpgradeId } from "../upgrade";
+export declare class BlankUpgrade extends Upgrade {
+    static readonly BASE_ID: UpgradeId;
+    protected static readonly IS_SYNTHETIC = true;
+    constructor(object: WarObject);
+}

package/engine/object-data/entry/upgrade/blank.lua

@@ -0,0 +1,22 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local ____exports = {}
+local ____upgrade = require("engine.object-data.entry.upgrade")
+local Upgrade = ____upgrade.Upgrade
+____exports.BlankUpgrade = __TS__Class()
+local BlankUpgrade = ____exports.BlankUpgrade
+BlankUpgrade.name = "BlankUpgrade"
+__TS__ClassExtends(BlankUpgrade, Upgrade)
+function BlankUpgrade.prototype.____constructor(self, object)
+    Upgrade.prototype.____constructor(self, object)
+    self.iconPath = ""
+    self.hotkey = ""
+    self.name = ""
+    self.tooltipText = ""
+    self.tooltipExtendedText = ""
+    self.techTreeDependencies = {}
+end
+BlankUpgrade.BASE_ID = fourCC("Rhsb")
+BlankUpgrade.IS_SYNTHETIC = true
+return ____exports

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

@@ -0,0 +1,59 @@
+/// <reference types="warpack-types/warpack" />
+/** @noSelfInFile */
+import { TupleOf } from "../../../utility/types";
+import { TechTreeDependency, TechTreeDependencyInput } from "../auxiliary/tech-tree-dependency";
+import { ObjectDataEntry, ObjectDataEntryId, ObjectDataEntryLevelFieldValueSupplier } from "../entry";
+import { AbilityTypeId } from "./ability-type";
+export type UpgradeId = ObjectDataEntryId & {
+    readonly __upgradeId: unique symbol;
+};
+export declare const enum UpgradeEffectType {
+    ABILITY_LEVEL_BONUS = "rlev",
+    ADD_ULTRAVISION = "rauv",
+    APPLY_AUTO_ATTACK_UPGRADE_BONUS = "ratt",
+    APPLY_ARMOR_UPGRADE_BONUS = "rarm",
+    AUTO_ATTACK_TARGET_COUNT_BONUS = "ratc"
+}
+export type UpgradeEffect = {
+    type: UpgradeEffectType.ADD_ULTRAVISION | UpgradeEffectType.APPLY_AUTO_ATTACK_UPGRADE_BONUS | UpgradeEffectType.APPLY_ARMOR_UPGRADE_BONUS;
+    bonusBase: undefined;
+    bonusIncrement: undefined;
+    abilityTypeId: undefined;
+} | {
+    type: UpgradeEffectType.ABILITY_LEVEL_BONUS;
+    bonusBase: number;
+    bonusIncrement: number;
+    abilityTypeId: AbilityTypeId;
+} | {
+    type: UpgradeEffectType.AUTO_ATTACK_TARGET_COUNT_BONUS;
+    bonusBase: number;
+    bonusIncrement: number;
+    abilityTypeId: undefined;
+};
+export declare abstract class Upgrade extends ObjectDataEntry<UpgradeId> {
+    private static readonly idGenerator;
+    protected static generateId(): number;
+    protected static getObjectData(map: WarMap): WarObjects;
+    get buttonPositionX(): number;
+    set buttonPositionX(buttonPositionX: number);
+    get buttonPositionY(): number;
+    set buttonPositionY(buttonPositionY: number);
+    get iconPath(): string[];
+    set iconPath(iconPath: ObjectDataEntryLevelFieldValueSupplier<string>);
+    get effects(): TupleOf<UpgradeEffect, 0 | 1 | 2 | 3 | 4>;
+    set effects(effects: TupleOf<UpgradeEffect, 0 | 1 | 2 | 3 | 4>);
+    get levelCount(): number;
+    set levelCount(levelCount: number);
+    get techTreeDependencies(): TechTreeDependency[][];
+    set techTreeDependencies(techTreeDependencies: ObjectDataEntryLevelFieldValueSupplier<TechTreeDependencyInput[]>);
+    get hotkey(): string[];
+    set hotkey(hotkey: ObjectDataEntryLevelFieldValueSupplier<string>);
+    get name(): string[];
+    set name(name: ObjectDataEntryLevelFieldValueSupplier<string>);
+    get tooltipText(): string[];
+    set tooltipText(tooltipText: ObjectDataEntryLevelFieldValueSupplier<string>);
+    get tooltipExtendedText(): string[];
+    set tooltipExtendedText(tooltipExtendedText: ObjectDataEntryLevelFieldValueSupplier<string>);
+    private getEffect;
+    private setEffect;
+}

package/engine/object-data/entry/upgrade.lua

@@ -0,0 +1,238 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local __TS__New = ____lualib.__TS__New
+local __TS__SetDescriptor = ____lualib.__TS__SetDescriptor
+local ____exports = {}
+local ____arrays = require("utility.arrays")
+local map = ____arrays.map
+local mapIndexed = ____arrays.mapIndexed
+local ____tech_2Dtree_2Ddependency = require("engine.object-data.auxiliary.tech-tree-dependency")
+local extractTechTreeDependencyInputLevel = ____tech_2Dtree_2Ddependency.extractTechTreeDependencyInputLevel
+local extractTechTreeDependencyInputObjectDataEntryId = ____tech_2Dtree_2Ddependency.extractTechTreeDependencyInputObjectDataEntryId
+local ____entry = require("engine.object-data.entry")
+local extractObjectDataEntryLevelArrayFieldValue = ____entry.extractObjectDataEntryLevelArrayFieldValue
+local ObjectDataEntry = ____entry.ObjectDataEntry
+local ____object_2Ddata_2Dentry_2Did_2Dgenerator = require("engine.object-data.utility.object-data-entry-id-generator")
+local ObjectDataEntryIdGenerator = ____object_2Ddata_2Dentry_2Did_2Dgenerator.ObjectDataEntryIdGenerator
+____exports.Upgrade = __TS__Class()
+local Upgrade = ____exports.Upgrade
+Upgrade.name = "Upgrade"
+__TS__ClassExtends(Upgrade, ObjectDataEntry)
+function Upgrade.generateId(self)
+    return self.idGenerator:next()
+end
+function Upgrade.getObjectData(self, map)
+    return map.objects.upgrade
+end
+function Upgrade.prototype.getEffect(self, i)
+    local effectType = self:getStringField("gef" .. tostring(i))
+    if effectType == "rlev" then
+        return {
+            type = effectType,
+            bonusBase = self:getNumberField("gba" .. tostring(i)),
+            bonusIncrement = self:getNumberField("gmo" .. tostring(i)),
+            abilityTypeId = self:getObjectDataEntryIdField("gco" .. tostring(i))
+        }
+    end
+    return nil
+end
+function Upgrade.prototype.setEffect(self, i, effect)
+    self:setStringField(
+        "gef" .. tostring(i),
+        effect and effect.type or "_"
+    )
+    self:setNumberField(
+        "gba" .. tostring(i),
+        effect and effect.bonusBase or 0
+    )
+    self:setNumberField(
+        "gmo" .. tostring(i),
+        effect and effect.bonusIncrement or 0
+    )
+    if (effect and effect.abilityTypeId) ~= nil then
+        self:setObjectDataEntryIdField(
+            "gco" .. tostring(i),
+            effect and effect.abilityTypeId
+        )
+    else
+        self:setStringField(
+            "gco" .. tostring(i),
+            ""
+        )
+    end
+end
+Upgrade.idGenerator = __TS__New(
+    ObjectDataEntryIdGenerator,
+    fourCC("R000")
+)
+__TS__SetDescriptor(
+    Upgrade.prototype,
+    "buttonPositionX",
+    {
+        get = function(self)
+            return self:getNumberField("gbpx")
+        end,
+        set = function(self, buttonPositionX)
+            self:setNumberField("gbpx", buttonPositionX)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Upgrade.prototype,
+    "buttonPositionY",
+    {
+        get = function(self)
+            return self:getNumberField("gbpy")
+        end,
+        set = function(self, buttonPositionY)
+            self:setNumberField("gbpy", buttonPositionY)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Upgrade.prototype,
+    "iconPath",
+    {
+        get = function(self)
+            return self:getStringLevelField("gar1")
+        end,
+        set = function(self, iconPath)
+            self:setStringLevelField("gar1", iconPath)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Upgrade.prototype,
+    "effects",
+    {
+        get = function(self)
+            local effects = {}
+            for i = 1, 4 do
+                local effect = self:getEffect(i)
+                if effect ~= nil then
+                    effects[#effects + 1] = effect
+                end
+            end
+            return effects
+        end,
+        set = function(self, effects)
+            for i = 1, 4 do
+                self:setEffect(i, effects[i])
+            end
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Upgrade.prototype,
+    "levelCount",
+    {
+        get = function(self)
+            return self:getNumberField("glvl")
+        end,
+        set = function(self, levelCount)
+            self:setNumberField("glvl", levelCount)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Upgrade.prototype,
+    "techTreeDependencies",
+    {
+        get = function(self)
+            local techTreeDependencyIds = self:getObjectDataEntryIdsLevelField("greq")
+            local techTreeDependencyInternalLevels = self:getNumbersLevelField("grqc")
+            return mapIndexed(
+                techTreeDependencyIds,
+                function(level, levelTechTreeDependencyIds)
+                    local levelTechTreeDependencyInternalLevels = techTreeDependencyInternalLevels[level + 1] or ({})
+                    return mapIndexed(
+                        levelTechTreeDependencyIds,
+                        function(index, levelTechTreeDependencyId)
+                            local levelTechTreeDependencyInternalLevel = levelTechTreeDependencyInternalLevels[index + 1] or 1
+                            if #____exports.Upgrade:getAllIdsByBaseIds(levelTechTreeDependencyId) ~= 0 then
+                                return {upgradeId = levelTechTreeDependencyId, level = levelTechTreeDependencyInternalLevel - 1}
+                            else
+                                return {unitTypeId = levelTechTreeDependencyId}
+                            end
+                        end
+                    )
+                end
+            )
+        end,
+        set = function(self, techTreeDependencies)
+            local currentTechTreeDependencies = self.techTreeDependencies
+            local techTreeDependencyIds = {}
+            local techTreeDependencyInternalLevels = {}
+            for level = 0, self.levelCount - 1 do
+                local levelTechTreeDependencies = extractObjectDataEntryLevelArrayFieldValue(techTreeDependencies, level, currentTechTreeDependencies[level + 1])
+                techTreeDependencyIds[level + 1] = map(levelTechTreeDependencies, extractTechTreeDependencyInputObjectDataEntryId)
+                techTreeDependencyInternalLevels[level + 1] = map(
+                    map(levelTechTreeDependencies, extractTechTreeDependencyInputLevel),
+                    function(level) return level + 1 end
+                )
+            end
+            self:setObjectDataEntryIdsLevelField("greq", techTreeDependencyIds)
+            self:setNumbersLevelField("grqc", techTreeDependencyInternalLevels)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Upgrade.prototype,
+    "hotkey",
+    {
+        get = function(self)
+            return self:getStringLevelField("ghk1")
+        end,
+        set = function(self, hotkey)
+            self:setStringLevelField("ghk1", hotkey)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Upgrade.prototype,
+    "name",
+    {
+        get = function(self)
+            return self:getStringLevelField("gnam")
+        end,
+        set = function(self, name)
+            self:setStringLevelField("gnam", name)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Upgrade.prototype,
+    "tooltipText",
+    {
+        get = function(self)
+            return self:getStringLevelField("gtp1")
+        end,
+        set = function(self, tooltipText)
+            self:setStringLevelField("gtp1", tooltipText)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Upgrade.prototype,
+    "tooltipExtendedText",
+    {
+        get = function(self)
+            return self:getStringLevelField("gub1")
+        end,
+        set = function(self, tooltipExtendedText)
+            self:setStringLevelField("gub1", tooltipExtendedText)
+        end
+    },
+    true
+)
+return ____exports

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

@@ -0,0 +1,80 @@
+/// <reference types="warpack-types/warpack" />
+/** @noSelfInFile */
+import { AttachmentPreset, AttachmentPresetInput } from "./auxiliary/attachment-preset";
+import { MutableKeys } from "../../utility/types";
+export type ObjectDataEntryId = number & {
+    readonly __objectDataEntryId: unique symbol;
+};
+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);
+export type ObjectDataEntryProperties<T extends ObjectDataEntry> = Partial<T[MutableKeys<T>]>;
+export type ObjectDataEntryLevelFieldValueSupplier<ValueType extends string | number | boolean | undefined | Record<string, any>, InputValueType = ValueType> = ValueType | readonly ValueType[] | ((level: number, currentValue: InputValueType) => ValueType);
+export declare const extractObjectDataEntryLevelFieldValue: <ValueType extends string | number | boolean | Record<string, any> | undefined, InputValueType = ValueType>(supplier: ObjectDataEntryLevelFieldValueSupplier<ValueType, InputValueType>, level: number, currentValue: InputValueType) => ValueType;
+export declare const extractObjectDataEntryLevelArrayFieldValue: <T extends string | number | boolean | Record<string, any> | undefined, S extends T[]>(supplier: ObjectDataEntryLevelFieldValueSupplier<S, S>, level: number, currentValue: S) => S;
+export declare abstract class ObjectDataEntry<Id extends ObjectDataEntryId = ObjectDataEntryId> {
+    protected readonly object: WarObject;
+    static readonly BASE_ID: ObjectDataEntryId;
+    protected static readonly IS_SYNTHETIC: boolean;
+    private readonly levelFieldParametersByField;
+    private readonly maxAffectedLevelByField;
+    private _isInternal;
+    get isInternal(): boolean;
+    protected static generateId(): number;
+    protected static getObjectData(map: WarMap): WarObjects;
+    static getAllIdsByBaseIds<T extends ObjectDataEntry>(this: ObjectDataEntryAbstractConstructor<T>, baseIds: number | number[]): ObjectDataEntryIdType<T>[];
+    static create<T extends ObjectDataEntry>(this: ObjectDataEntryConstructor<T>, ...args: [id?: number, properties?: ObjectDataEntryProperties<T>] | [properties: ObjectDataEntryProperties<T>]): T;
+    static getAllByBaseIds<T extends ObjectDataEntry>(this: ObjectDataEntryAbstractConstructor<T>, baseIds: number | number[]): T[];
+    static getAll<T extends ObjectDataEntry>(this: ObjectDataEntryAbstractConstructor<T>): T[];
+    static of<T extends ObjectDataEntry>(this: ObjectDataEntryAbstractConstructor<T>, id: number): T | undefined;
+    constructor(object: WarObject);
+    get id(): Id;
+    get baseId(): Id;
+    get isCustom(): boolean;
+    getFieldValue<This extends this, Args extends any[], T>(this: This, field: {
+        getValue(entry: This, ...args: Args): T;
+    }, ...args: Args): T;
+    setFieldValue<This extends this, Args extends any[]>(this: This, field: {
+        setValue(entry: This, ...args: Args): boolean;
+    }, ...args: Args): void;
+    protected getBooleanField(field: string): boolean;
+    protected setBooleanField(field: string, value: boolean): void;
+    protected getNumberField(field: string): number;
+    protected setNumberField(field: string, value: number): void;
+    protected getStringField(field: string): string;
+    protected setStringField(field: string, value: string): void;
+    protected getObjectDataEntryIdField<Id extends ObjectDataEntryId>(field: string): Id;
+    protected setObjectDataEntryIdField<Id extends ObjectDataEntryId>(field: string, value: Id): void;
+    protected getAttachmentPresetField(modelPathField: string, nodeFQNField: string): AttachmentPreset | undefined;
+    protected setAttachmentPresetField(modelPathField: string, nodeFQNField: string, attachmentPreset: AttachmentPresetInput | undefined): void;
+    protected getBooleansField(field: string): boolean[];
+    protected setBooleansField(field: string, values: boolean[]): void;
+    protected getNumbersField(field: string): number[];
+    protected setNumbersField(field: string, values: number[]): void;
+    protected getStringsField(field: string): string[];
+    protected setStringsField(field: string, values: string[]): void;
+    protected getObjectDataEntryIdsField<Id extends ObjectDataEntryId>(field: string): Id[];
+    protected setObjectDataEntryIdsField<Id extends ObjectDataEntryId>(field: string, values: Id[]): void;
+    protected getAttachmentPresetListField(modelPathListField: string, nodeFQNFields: string[]): AttachmentPreset[];
+    protected setAttachmentPresetListField(modelPathListField: string, nodeFQNFields: string[], lengthField: string, attachmentPresets: AttachmentPresetInput[]): void;
+    protected setFlagLevelFieldValue(fieldId: string, flag: 1 | 2 | 4 | 8 | 16, supplier: ObjectDataEntryLevelFieldValueSupplier<boolean>): void;
+    protected getFlagLevelFieldValue(fieldId: string, flag: 1 | 2 | 4 | 8 | 16): boolean[];
+    protected getBooleanLevelField(field: string): boolean[];
+    protected setBooleanLevelField(field: string, values: ObjectDataEntryLevelFieldValueSupplier<boolean>): void;
+    protected getNumberLevelField(field: string): number[];
+    protected setNumberLevelField(field: string, values: ObjectDataEntryLevelFieldValueSupplier<number>): void;
+    protected getStringLevelField(field: string): string[];
+    protected setStringLevelField(field: string, values: ObjectDataEntryLevelFieldValueSupplier<string>): void;
+    protected getObjectDataEntryIdLevelField<Id extends ObjectDataEntryId>(field: string): Id[];
+    protected setObjectDataEntryIdLevelField<Id extends ObjectDataEntryId>(field: string, values: ObjectDataEntryLevelFieldValueSupplier<Id>): void;
+    protected getBooleansLevelField(field: string): boolean[][];
+    protected setBooleansLevelField(field: string, values: ObjectDataEntryLevelFieldValueSupplier<boolean[]>): void;
+    protected getNumbersLevelField(field: string): number[][];
+    protected setNumbersLevelField(field: string, values: ObjectDataEntryLevelFieldValueSupplier<number[]>): void;
+    protected getStringsLevelField(field: string): string[][];
+    protected setStringsLevelField(field: string, values: ObjectDataEntryLevelFieldValueSupplier<string[]>): void;
+    protected getObjectDataEntryIdsLevelField<T extends ObjectDataEntryId>(field: string): T[][];
+    protected setObjectDataEntryIdsLevelField<T extends ObjectDataEntryId>(field: string, values: ObjectDataEntryLevelFieldValueSupplier<T[]>): void;
+    private getLevelField;
+    private setLevelField;
+}