@takaro/modules 0.0.14 → 0.0.18

package/src/modules/gimme/index.ts

@@ -1,48 +1,73 @@
-import { BuiltinModule, ICommand } from '../../BuiltinModule.js';
+import { ModuleTransferDTO, ICommand, ModuleTransferVersionDTO } from '../../BuiltinModule.js';
 
-export class Gimme extends BuiltinModule<Gimme> {
+export class Gimme extends ModuleTransferDTO<Gimme> {
   constructor() {
-    super(
-      'gimme',
-      'Randomly selects an item from a list of items.',
-      JSON.stringify({
-        $schema: 'http://json-schema.org/draft-07/schema#',
-        type: 'object',
-        properties: {
-          items: {
-            'x-component': 'item',
-            type: 'array',
-            title: 'Items',
-            description: 'List of items that a player can receive.',
-            uniqueItems: true,
+    super();
+
+    this.name = 'gimme';
+    this.versions = [
+      new ModuleTransferVersionDTO({
+        tag: '0.0.1',
+        description: 'Randomly selects item from a list of items and entities.',
+        configSchema: JSON.stringify({
+          $schema: 'http://json-schema.org/draft-07/schema#',
+          type: 'object',
+          properties: {
             items: {
-              type: 'string',
+              'x-component': 'item',
+              type: 'array',
+              title: 'Items',
+              description: 'List of items that a player can receive.',
+              uniqueItems: true,
+              items: {
+                type: 'object',
+                title: 'Item',
+                properties: {
+                  item: {
+                    type: 'string',
+                    title: 'Item',
+                  },
+                  amount: {
+                    type: 'number',
+                    title: 'Amount',
+                  },
+                  quality: {
+                    type: 'string',
+                    title: 'Quality',
+                  },
+                },
+              },
+            },
+            commands: {
+              title: 'Commands',
+              type: 'array',
+              default: ['say hello from gimme'],
+              items: {
+                type: 'string',
+              },
             },
           },
-          commands: {
-            title: 'Commands',
-            type: 'array',
-            default: ['say hello from gimme'],
+          required: ['items'],
+          additionalProperties: false,
+        }),
+        uiSchema: JSON.stringify({
+          items: {
             items: {
-              type: 'string',
+              item: {
+                'ui:widget': 'item',
+              },
             },
           },
-        },
-        required: ['items'],
-        additionalProperties: false,
-      }),
-      JSON.stringify({
-        items: { 'ui:widget': 'item' },
-      }),
-    );
-
-    this.commands = [
-      new ICommand({
-        function: this.loadFn('commands', 'gimme'),
-        name: 'gimme',
-        trigger: 'gimme',
-        helpText: 'Randomly selects item from a list of items and entities.',
-        arguments: [],
+        }),
+        commands: [
+          new ICommand({
+            function: this.loadFn('commands', 'gimme'),
+            name: 'gimme',
+            trigger: 'gimme',
+            helpText: 'Randomly selects item from a list of items and entities.',
+            arguments: [],
+          }),
+        ],
       }),
     ];
   }

package/src/modules/highPingKicker/index.ts

@@ -1,38 +1,41 @@
-import { BuiltinModule, ICronJob } from '../../BuiltinModule.js';
+import { ModuleTransferDTO, ICronJob, ModuleTransferVersionDTO } from '../../BuiltinModule.js';
 
-export class HighPingKicker extends BuiltinModule<HighPingKicker> {
+export class HighPingKicker extends ModuleTransferDTO<HighPingKicker> {
   constructor() {
-    super(
-      'highPingKicker',
-      'Automatically kick players with high ping, with warnings and configurable thresholds.',
-      JSON.stringify({
-        $schema: 'http://json-schema.org/draft-07/schema#',
-        type: 'object',
-        properties: {
-          pingThreshold: {
-            type: 'number',
-            title: 'Ping threshold',
-            description: 'A ping value that is deemed too high and prompts a warning.',
-            default: 200,
-            minimum: 0,
+    super();
+    this.name = 'highPingKicker';
+    this.versions = [
+      new ModuleTransferVersionDTO({
+        tag: '0.0.1',
+        description: 'Automatically kick players with high ping, with warnings and configurable thresholds.',
+        configSchema: JSON.stringify({
+          $schema: 'http://json-schema.org/draft-07/schema#',
+          type: 'object',
+          properties: {
+            pingThreshold: {
+              type: 'number',
+              title: 'Ping threshold',
+              description: 'A ping value that is deemed too high and prompts a warning.',
+              default: 200,
+              minimum: 0,
+            },
+            warningsBeforeKick: {
+              type: 'number',
+              title: 'Kick warnings',
+              description: 'Number of warnings before a player is kicked.',
+              default: 3,
+              minimum: 0,
+            },
           },
-          warningsBeforeKick: {
-            type: 'number',
-            title: 'Kick warnings',
-            description: 'Number of warnings before a player is kicked.',
-            default: 3,
-            minimum: 0,
-          },
-        },
-        required: [],
-      }),
-    );
-
-    this.cronJobs = [
-      new ICronJob({
-        name: 'Ping check',
-        temporalValue: '*/5 * * * *',
-        function: this.loadFn('cronJobs', 'Ping check'),
+          required: [],
+        }),
+        cronJobs: [
+          new ICronJob({
+            name: 'Ping check',
+            temporalValue: '*/5 * * * *',
+            function: this.loadFn('cronJobs', 'Ping check'),
+          }),
+        ],
       }),
     ];
   }

package/src/modules/lottery/index.ts

@@ -1,79 +1,81 @@
-import { BuiltinModule, ICommand, ICronJob, IPermission } from '../../BuiltinModule.js';
+import { ModuleTransferDTO, ICommand, ICronJob, IPermission, ModuleTransferVersionDTO } from '../../BuiltinModule.js';
 
-export class Lottery extends BuiltinModule<Lottery> {
+export class Lottery extends ModuleTransferDTO<Lottery> {
   constructor() {
-    super(
-      'lottery',
-      'Players can buy tickets for a lottery, and the winner is chosen at random.',
-      JSON.stringify({
-        $schema: 'http://json-schema.org/draft-07/schema#',
-        type: 'object',
-        properties: {
-          profitMargin: {
-            type: 'number',
-            maximum: 1,
-            minimum: 0,
-            description: 'The profit margin the server takes from the lottery.',
-            default: 0.1,
-          },
-        },
-        required: [],
-        additionalProperties: false,
-      }),
-    );
+    super();
 
-    this.permissions = [
-      new IPermission({
-        permission: 'LOTTERY_BUY',
-        friendlyName: 'Buy Lottery Tickets',
-        canHaveCount: false,
-        description: 'Allows the player to buy lottery tickets.',
-      }),
-      new IPermission({
-        permission: 'LOTTERY_VIEW_TICKETS',
-        friendlyName: 'View Lottery Tickets',
-        description: 'Allows the player to view his lottery tickets.',
-        canHaveCount: false,
-      }),
-    ];
-
-    this.cronJobs = [
-      new ICronJob({
-        name: 'drawLottery',
-        temporalValue: '0 0 * * *',
-        function: this.loadFn('cronJobs', 'drawLottery'),
-      }),
-    ];
-
-    this.commands = [
-      new ICommand({
-        function: this.loadFn('commands', 'buyTicket'),
-        name: 'buyTicket',
-        trigger: 'buyTicket',
-        helpText: 'Buy a lottery ticket.',
-        arguments: [
-          {
-            name: 'amount',
-            type: 'number',
-            helpText: 'The amount of tickets to buy.',
-            position: 0,
-            defaultValue: null,
+    this.name = 'lottery';
+    this.versions = [
+      new ModuleTransferVersionDTO({
+        tag: '0.0.1',
+        description: 'Players can buy tickets for a lottery, and the winner is chosen at random.',
+        configSchema: JSON.stringify({
+          $schema: 'http://json-schema.org/draft-07/schema#',
+          type: 'object',
+          properties: {
+            profitMargin: {
+              type: 'number',
+              maximum: 1,
+              minimum: 0,
+              description: 'The profit margin the server takes from the lottery.',
+              default: 0.1,
+            },
           },
+          required: [],
+          additionalProperties: false,
+        }),
+        permissions: [
+          new IPermission({
+            permission: 'LOTTERY_BUY',
+            friendlyName: 'Buy Lottery Tickets',
+            canHaveCount: false,
+            description: 'Allows the player to buy lottery tickets.',
+          }),
+          new IPermission({
+            permission: 'LOTTERY_VIEW_TICKETS',
+            friendlyName: 'View Lottery Tickets',
+            description: 'Allows the player to view his lottery tickets.',
+            canHaveCount: false,
+          }),
+        ],
+        cronJobs: [
+          new ICronJob({
+            name: 'drawLottery',
+            temporalValue: '0 0 * * *',
+            function: this.loadFn('cronJobs', 'drawLottery'),
+          }),
+        ],
+        commands: [
+          new ICommand({
+            function: this.loadFn('commands', 'buyTicket'),
+            name: 'buyTicket',
+            trigger: 'buyTicket',
+            helpText: 'Buy a lottery ticket.',
+            arguments: [
+              {
+                name: 'amount',
+                type: 'number',
+                helpText: 'The amount of tickets to buy.',
+                position: 0,
+                defaultValue: null,
+              },
+            ],
+          }),
+          new ICommand({
+            function: this.loadFn('commands', 'viewTickets'),
+            name: 'viewTickets',
+            trigger: 'viewTickets',
+            helpText: 'View your lottery tickets.',
+            arguments: [],
+          }),
+          new ICommand({
+            function: this.loadFn('commands', 'nextDraw'),
+            name: 'nextDraw',
+            trigger: 'nextDraw',
+            helpText: 'View when the next draw is.',
+            arguments: [],
+          }),
         ],
-      }),
-      new ICommand({
-        function: this.loadFn('commands', 'viewTickets'),
-        name: 'viewTickets',
-        trigger: 'viewTickets',
-        helpText: 'View your lottery tickets.',
-        arguments: [],
-      }),
-      new ICommand({
-        function: this.loadFn('commands', 'nextDraw'),
-        name: 'nextDraw',
-        trigger: 'nextDraw',
-        helpText: 'View when the next draw is.',
-        arguments: [],
       }),
     ];
   }

package/src/modules/playerOnboarding/commands/starterkit.js

@@ -7,7 +7,7 @@ async function main() {
 
   if (!items || items.length === 0) {
     throw new TakaroUserError(
-      'No starter kit items configured. Please ask your server administrator to configure this.'
+      'No starter kit items configured. Please ask your server administrator to configure this.',
     );
   }
 
@@ -25,13 +25,27 @@ async function main() {
 
   await data.player.pm('You are about to receive your starter kit...');
 
+  const itemRecords = (await takaro.item.itemControllerSearch({ filters: { id: items.map((_) => _.item) } })).data.data;
+  const fullItems = items.map((item) => {
+    const itemRecord = itemRecords.find((record) => record.id === item.item);
+    if (!itemRecord) {
+      throw new TakaroUserError(`Item with ID ${item.item} not found.`);
+    }
+    return {
+      code: itemRecord.code,
+      quality: item.quality,
+      amount: item.amount,
+    };
+  });
+
   await Promise.all(
-    items.map(async (item) => {
+    fullItems.map(async (item) => {
       return takaro.gameserver.gameServerControllerGiveItem(data.gameServerId, data.player.id, {
-        name: item,
-        amount: 1,
+        name: item.code,
+        quality: item.quality ?? '',
+        amount: item.amount,
       });
-    })
+    }),
   );
 
   await takaro.variable.variableControllerCreate({

package/src/modules/playerOnboarding/index.ts

@@ -1,58 +1,83 @@
-import { BuiltinModule, ICommand, IHook } from '../../BuiltinModule.js';
+import { ModuleTransferDTO, ICommand, IHook, ModuleTransferVersionDTO } from '../../BuiltinModule.js';
 import { HookEvents } from '../../dto/index.js';
 
-export class PlayerOnboarding extends BuiltinModule<PlayerOnboarding> {
+export class PlayerOnboarding extends ModuleTransferDTO<PlayerOnboarding> {
   constructor() {
-    super(
-      'playerOnboarding',
-      'Collection of functions that are executed when a player joins the server. Helps with onboarding new players, like sending a welcome message.',
-      JSON.stringify({
-        $schema: 'http://json-schema.org/draft-07/schema#',
-        type: 'object',
-        properties: {
-          message: {
-            title: 'Message',
-            description: 'The message to send to the player when they join the server.',
-            type: 'string',
-            minLength: 1,
-            maxLength: 256,
-            default: 'Welcome {player} to the server!',
+    super();
+
+    this.name = 'playerOnboarding';
+    this.versions = [
+      new ModuleTransferVersionDTO({
+        tag: '0.0.1',
+        description:
+          'Collection of functions that are executed when a player joins the server. Helps with onboarding new players, like sending a welcome message.',
+        configSchema: JSON.stringify({
+          $schema: 'http://json-schema.org/draft-07/schema#',
+          type: 'object',
+          properties: {
+            message: {
+              title: 'Message',
+              description: 'The message to send to the player when they join the server.',
+              type: 'string',
+              minLength: 1,
+              maxLength: 256,
+              default: 'Welcome {player} to the server!',
+            },
+            starterKitItems: {
+              type: 'array',
+              title: 'Starter kit items',
+              'x-component': 'item',
+              description:
+                'List of items a player will receive when they execute the starterkit command for the first time.',
+              uniqueItems: true,
+              items: {
+                type: 'object',
+                title: 'Item',
+                properties: {
+                  item: {
+                    type: 'string',
+                    title: 'Item',
+                  },
+                  amount: {
+                    type: 'number',
+                    title: 'Amount',
+                  },
+                  quality: {
+                    type: 'string',
+                    title: 'Quality',
+                  },
+                },
+              },
+            },
           },
+          required: [],
+          additionalProperties: false,
+        }),
+        uiSchema: JSON.stringify({
           starterKitItems: {
-            type: 'array',
-            'x-component': 'item',
-            title: 'Starter kit items',
-            description:
-              'List of items a player will receive when they execute the starterkit command for the first time.',
-            uniqueItems: true,
             items: {
-              type: 'string',
+              item: {
+                'ui:widget': 'item',
+              },
             },
           },
-        },
-        required: [],
-        additionalProperties: false,
-      }),
-      JSON.stringify({
-        starterKitItems: { 'ui:widget': 'item' },
-      }),
-    );
-
-    this.hooks = [
-      new IHook({
-        eventType: HookEvents.PLAYER_CONNECTED,
-        name: 'playerConnected',
-        function: this.loadFn('hooks', 'playerConnected'),
-      }),
-    ];
-
-    this.commands = [
-      new ICommand({
-        name: 'starterkit',
-        function: this.loadFn('commands', 'starterkit'),
-        trigger: 'starterkit',
-        helpText: 'Get a starter kit, you can only execute this once on a server!',
-        arguments: [],
+        }),
+        hooks: [
+          new IHook({
+            eventType: HookEvents.PLAYER_CONNECTED,
+            name: 'playerConnected',
+            function: this.loadFn('hooks', 'playerConnected'),
+          }),
+        ],
+        commands: [
+          new ICommand({
+            name: 'starterkit',
+            function: this.loadFn('commands', 'starterkit'),
+            trigger: 'starterkit',
+            helpText: 'Get a starter kit, you can only execute this once on a server!',
+            arguments: [],
+          }),
+        ],
       }),
     ];
   }

package/src/modules/serverMessages/index.ts

@@ -1,39 +1,43 @@
-import { BuiltinModule, ICronJob } from '../../BuiltinModule.js';
+import { ModuleTransferDTO, ICronJob, ModuleTransferVersionDTO } from '../../BuiltinModule.js';
 
-export class ServerMessages extends BuiltinModule<ServerMessages> {
+export class ServerMessages extends ModuleTransferDTO<ServerMessages> {
   constructor() {
-    super(
-      'serverMessages',
-      'Send automated, rotated, configurable messages to players on the server.',
-      JSON.stringify({
-        $schema: 'http://json-schema.org/draft-07/schema#',
-        type: 'object',
-        properties: {
-          messages: {
-            type: 'array',
-            title: 'Messages',
-            description: 'List of messages that will be sent to players on the server.',
-            default: [
-              // prettier-ignore
-              'This is an automated message, don\'t forget to read the server rules!',
-            ],
-            items: {
-              type: 'string',
-              minLength: 5,
-              maxLength: 1024,
+    super();
+
+    this.name = 'serverMessages';
+    this.versions = [
+      new ModuleTransferVersionDTO({
+        tag: '0.0.1',
+        description: 'Send automated, rotated, configurable messages to players on the server.',
+        configSchema: JSON.stringify({
+          $schema: 'http://json-schema.org/draft-07/schema#',
+          type: 'object',
+          properties: {
+            messages: {
+              type: 'array',
+              title: 'Messages',
+              description: 'List of messages that will be sent to players on the server.',
+              default: [
+                // prettier-ignore
+                'This is an automated message, don\'t forget to read the server rules!',
+              ],
+              items: {
+                type: 'string',
+                minLength: 5,
+                maxLength: 1024,
+              },
+              minItems: 1,
             },
-            minItems: 1,
           },
-        },
-        required: ['messages'],
-      }),
-    );
-
-    this.cronJobs = [
-      new ICronJob({
-        name: 'Automated message',
-        temporalValue: '*/30 * * * *',
-        function: this.loadFn('cronJobs', 'Automated message'),
+          required: ['messages'],
+        }),
+        cronJobs: [
+          new ICronJob({
+            name: 'Automated message',
+            temporalValue: '*/30 * * * *',
+            function: this.loadFn('cronJobs', 'Automated message'),
+          }),
+        ],
       }),
     ];
   }

package/src/modules/teleports/commands/deletewaypoint.js

@@ -1,56 +1,18 @@
 import { takaro, data, checkPermission, TakaroUserError } from '@takaro/helpers';
-
-function getWaypointName(name) {
-  return `waypoint ${name}`;
-}
+import { getWaypointName, waypointReconciler } from './utils.js';
 
 async function main() {
-  const { pog, gameServerId, arguments: args } = data;
+  const { pog, gameServerId, arguments: args, module: mod } = data;
 
   if (!checkPermission(pog, 'TELEPORTS_MANAGE_WAYPOINTS')) {
     throw new TakaroUserError('You do not have permission to manage waypoints.');
   }
 
-  async function ensureWaypointsModule() {
-    let waypointsDefinition = (
-      await takaro.module.moduleControllerSearch({
-        filters: {
-          name: ['Waypoints'],
-        },
-      })
-    ).data.data[0];
-
-    if (!waypointsDefinition) {
-      console.log('Waypoints module definition not found, creating it.');
-      waypointsDefinition = (
-        await takaro.module.moduleControllerCreate({
-          name: 'Waypoints',
-          description: 'Waypoints module for the teleport system.',
-        })
-      ).data.data;
-    }
-
-    let waypointsInstallation = (
-      await takaro.gameserver.gameServerControllerGetInstalledModules(gameServerId)
-    ).data.data.find((module) => module.name === 'Waypoints');
-
-    if (!waypointsInstallation) {
-      console.log('Waypoints module not found, installing it.');
-      waypointsInstallation = (
-        await takaro.gameserver.gameServerControllerInstallModule(gameServerId, waypointsDefinition.id)
-      ).data.data;
-    }
-
-    return { waypointsInstallation, waypointsDefinition };
-  }
-
-  const { waypointsInstallation } = await ensureWaypointsModule();
-
   const variable = await takaro.variable.variableControllerSearch({
     filters: {
       key: [getWaypointName(args.waypoint)],
       gameServerId: [gameServerId],
-      moduleId: [waypointsInstallation.moduleId],
+      moduleId: [mod.moduleId],
     },
   });
 
@@ -59,18 +21,7 @@ async function main() {
   }
 
   await takaro.variable.variableControllerDelete(variable.data.data[0].id);
-
-  const teleportCommand = await takaro.command.commandControllerSearch({
-    filters: {
-      moduleId: [waypointsInstallation.moduleId],
-      name: [`waypoint ${args.waypoint} server ${gameServerId}`],
-    },
-  });
-
-  if (teleportCommand.data.data.length) {
-    await takaro.command.commandControllerRemove(teleportCommand.data.data[0].id);
-  }
-
+  await waypointReconciler();
   await pog.pm(`Waypoint ${args.waypoint} deleted.`);
 }