@takaro/modules 0.0.1

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

@@ -0,0 +1,54 @@
+import { takaro, data, checkPermission, TakaroUserError } from '@takaro/helpers';
+import { getVariableKey, findTp } from './utils.js';
+
+async function main() {
+  const { pog, gameServerId, module: mod, arguments: args } = data;
+
+  const hasPermission = checkPermission(pog, 'TELEPORTS_USE');
+
+  if (!hasPermission) {
+    throw new TakaroUserError('You do not have permission to use teleports.');
+  }
+
+  const prefix = (await takaro.settings.settingsControllerGetOne('commandPrefix', gameServerId)).data.data.value;
+
+  const existingVariable = await findTp(args.tp);
+
+  if (existingVariable.data.data.length > 0) {
+    throw new TakaroUserError(`Teleport ${args.tp} already exists, use ${prefix}deletetp ${args.tp} to delete it.`);
+  }
+
+  const allPlayerTeleports = await takaro.variable.variableControllerSearch({
+    search: {
+      key: getVariableKey(''),
+    },
+    filters: {
+      gameServerId: [gameServerId],
+      playerId: [pog.playerId],
+      moduleId: [mod.moduleId],
+    },
+  });
+
+  if (allPlayerTeleports.data.data.length >= hasPermission.count) {
+    throw new TakaroUserError(
+      `You have reached the maximum number of teleports for your role, maximum allowed is ${hasPermission.count}`
+    );
+  }
+
+  await takaro.variable.variableControllerCreate({
+    key: getVariableKey(args.tp),
+    value: JSON.stringify({
+      name: args.tp,
+      x: data.pog.positionX,
+      y: data.pog.positionY,
+      z: data.pog.positionZ,
+    }),
+    gameServerId,
+    moduleId: mod.moduleId,
+    playerId: pog.playerId,
+  });
+
+  await data.player.pm(`Teleport ${args.tp} set.`);
+}
+
+await main();

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

@@ -0,0 +1,112 @@
+import { takaro, data, checkPermission, TakaroUserError } from '@takaro/helpers';
+
+function getWaypointName(name) {
+  return `waypoint ${name}`;
+}
+
+async function main() {
+  const { pog, gameServerId, module: mod, arguments: args } = 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, waypointsDefinition } = await ensureWaypointsModule();
+
+  try {
+    await takaro.variable.variableControllerCreate({
+      moduleId: waypointsInstallation.moduleId,
+      gameServerId,
+      key: getWaypointName(args.waypoint),
+      value: JSON.stringify({
+        x: pog.positionX,
+        y: pog.positionY,
+        z: pog.positionZ,
+      }),
+    });
+  } catch (error) {
+    if (error.message === 'Request failed with status code 409') {
+      throw new TakaroUserError(`Waypoint ${args.waypoint} already exists.`);
+    }
+  }
+
+  const teleportCommand = await takaro.command.commandControllerSearch({
+    filters: {
+      moduleId: [mod.moduleId],
+      name: ['teleportwaypoint'],
+    },
+  });
+
+  await takaro.command.commandControllerCreate({
+    moduleId: waypointsInstallation.moduleId,
+    name: `waypoint ${args.waypoint} server ${gameServerId}`,
+    trigger: args.waypoint,
+    helpText: `Teleport to waypoint ${args.waypoint}.`,
+    function: teleportCommand.data.data[0].function.code,
+  });
+
+  const existingPermissions = waypointsDefinition.permissions || [];
+  const permissionInputDTOs = existingPermissions.map((permission) => ({
+    permission: permission.permission,
+    description: permission.description,
+    friendlyName: permission.friendlyName,
+    canHaveCount: permission.canHaveCount,
+  }));
+
+  const gameServer = (await takaro.gameserver.gameServerControllerGetOne(gameServerId)).data.data;
+
+  await takaro.module.moduleControllerUpdate(waypointsInstallation.moduleId, {
+    permissions: [
+      {
+        permission: `WAYPOINTS_USE_${args.waypoint.toUpperCase()}_${gameServerId}`,
+        description: `Use the waypoint ${args.waypoint} on ${gameServer.name}.`,
+        friendlyName: `Use waypoint ${args.waypoint} on ${gameServer.name}`,
+        canHaveCount: false,
+      },
+      ...permissionInputDTOs,
+    ],
+  });
+
+  // Need to reinstall the module to ensure the new commands systemconfig and permissions are properly in place
+  await takaro.gameserver.gameServerControllerInstallModule(gameServerId, waypointsInstallation.moduleId, {
+    systemConfig: JSON.stringify(waypointsInstallation.systemConfig),
+    userConfig: JSON.stringify(waypointsInstallation.userConfig),
+  });
+
+  await pog.pm(`Waypoint ${args.waypoint} set.`);
+}
+
+await main();

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

@@ -0,0 +1,93 @@
+import { takaro, data, checkPermission, TakaroUserError } from '@takaro/helpers';
+import { findTp } from './utils.js';
+
+async function main() {
+  const { pog, gameServerId, arguments: args, module: mod } = data;
+
+  if (!checkPermission(pog, 'TELEPORTS_USE')) {
+    throw new TakaroUserError('You do not have permission to use teleports.');
+  }
+
+  const ownedTeleportRes = await findTp(args.tp, pog.playerId);
+
+  let teleports = ownedTeleportRes.data.data;
+
+  if (mod.userConfig.allowPublicTeleports) {
+    const maybePublicTeleportRes = await findTp(args.tp);
+
+    const publicTeleports = maybePublicTeleportRes.data.data.filter((tele) => {
+      const teleport = JSON.parse(tele.value);
+      return teleport.public;
+    });
+
+    teleports = teleports.concat(publicTeleports);
+  }
+
+  if (teleports.length === 0) {
+    throw new TakaroUserError(`Teleport ${args.tp} does not exist.`);
+  }
+
+  const timeout = mod.userConfig.timeout;
+
+  if (timeout !== 0) {
+    const lastExecuted = await takaro.variable.variableControllerSearch({
+      filters: {
+        key: ['lastExecuted'],
+        gameServerId: [gameServerId],
+        playerId: [pog.playerId],
+        moduleId: [mod.moduleId],
+      },
+    });
+    let lastExecutedRecord = lastExecuted.data.data[0];
+
+    if (!lastExecutedRecord) {
+      const createRes = await takaro.variable.variableControllerCreate({
+        key: 'lastExecuted',
+        gameServerId,
+        playerId: pog.playerId,
+        moduleId: mod.moduleId,
+        value: new Date().toISOString(),
+      });
+      console.log(createRes);
+      lastExecutedRecord = createRes.data.data;
+    } else {
+      const lastExecutedTime = new Date(lastExecutedRecord.value);
+      const now = new Date();
+
+      const diff = now.getTime() - lastExecutedTime.getTime();
+
+      if (diff < timeout) {
+        throw new TakaroUserError('You cannot teleport yet. Please wait before trying again.');
+      }
+    }
+
+    const teleport = JSON.parse(teleports[0].value);
+
+    await takaro.gameserver.gameServerControllerTeleportPlayer(gameServerId, pog.playerId, {
+      x: teleport.x,
+      y: teleport.y,
+      z: teleport.z,
+    });
+
+    await data.player.pm(`Teleported to ${teleport.name}.`);
+
+    if (timeout !== 0 && lastExecutedRecord) {
+      await takaro.variable.variableControllerUpdate(lastExecutedRecord.id, {
+        value: new Date().toISOString(),
+      });
+    }
+    return;
+  }
+
+  const teleport = JSON.parse(teleports[0].value);
+
+  await takaro.gameserver.gameServerControllerTeleportPlayer(gameServerId, pog.playerId, {
+    x: teleport.x,
+    y: teleport.y,
+    z: teleport.z,
+  });
+
+  await data.player.pm(`Teleported to ${teleport.name}.`);
+}
+
+await main();

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

@@ -0,0 +1,72 @@
+import { takaro, data, TakaroUserError, checkPermission } from '@takaro/helpers';
+
+function getWaypointName(name) {
+  return `waypoint ${name}`;
+}
+
+async function main() {
+  const { pog, gameServerId, trigger } = data;
+
+  if (!checkPermission(pog, `WAYPOINTS_USE_${trigger.toUpperCase()}_${gameServerId}`)) {
+    throw new TakaroUserError(`You are not allowed to use the waypoint ${trigger}.`);
+  }
+
+  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(trigger)],
+      gameServerId: [gameServerId],
+      moduleId: [waypointsInstallation.moduleId],
+    },
+  });
+
+  if (variable.data.data.length === 0) {
+    throw new TakaroUserError(`Waypoint ${trigger} does not exist.`);
+  }
+
+  const waypoint = JSON.parse(variable.data.data[0].value);
+
+  await takaro.gameserver.gameServerControllerTeleportPlayer(gameServerId, pog.playerId, {
+    x: waypoint.x,
+    y: waypoint.y,
+    z: waypoint.z,
+  });
+
+  await pog.pm(`Teleported to waypoint ${trigger}.`);
+}
+
+await main();

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

@@ -0,0 +1,61 @@
+import { takaro, data } from '@takaro/helpers';
+
+async function main() {
+  const { pog, gameServerId, module: mod } = data;
+
+  const prefix = (await takaro.settings.settingsControllerGetOne('commandPrefix', gameServerId)).data.data;
+
+  const ownedTeleports = (
+    await takaro.variable.variableControllerSearch({
+      filters: {
+        gameServerId: [gameServerId],
+        playerId: [pog.playerId],
+        moduleId: [mod.moduleId],
+      },
+      search: {
+        key: 'tp',
+      },
+      sortBy: 'key',
+      sortDirection: 'asc',
+    })
+  ).data.data;
+
+  const maybePublicTeleports = (
+    await takaro.variable.variableControllerSearch({
+      filters: {
+        gameServerId: [gameServerId],
+        moduleId: [mod.moduleId],
+      },
+      search: {
+        key: ['tp'],
+      },
+      sortBy: 'key',
+      sortDirection: 'asc',
+    })
+  ).data.data;
+
+  const teleports = maybePublicTeleports.filter((tele) => {
+    const teleport = JSON.parse(tele.value);
+
+    const isPublic = teleport.public && teleport.playerId !== pog.playerId;
+    const isOwned = ownedTeleports.find((t) => t.playerId === pog.playerId);
+
+    return isPublic || isOwned;
+  });
+
+  if (teleports.length === 0) {
+    await data.player.pm(`You have no teleports set, use ${prefix}settp <name> to set one.`);
+    return;
+  }
+
+  await data.player.pm(`You have ${teleports.length} teleport${teleports.length === 1 ? '' : 's'} available`);
+
+  for (const rawTeleport of teleports) {
+    const teleport = JSON.parse(rawTeleport.value);
+    await data.player.pm(
+      ` - ${teleport.name}: ${teleport.x}, ${teleport.y}, ${teleport.z} ${teleport.public ? '(public)' : ''}`
+    );
+  }
+}
+
+await main();

package/src/modules/teleports/functions/utils.js

@@ -0,0 +1,20 @@
+import { takaro, data } from '@takaro/helpers';
+
+export function getVariableKey(tpName) {
+  return `tp_${tpName}`;
+}
+
+export async function findTp(tpName, playerId) {
+  const { gameServerId, module: mod } = data;
+
+  return takaro.variable.variableControllerSearch({
+    filters: {
+      key: [getVariableKey(tpName)],
+      gameServerId: [gameServerId],
+      playerId: [playerId].filter(Boolean),
+      moduleId: [mod.moduleId],
+    },
+    sortBy: 'key',
+    sortDirection: 'asc',
+  });
+}

package/src/modules/teleports/index.ts

@@ -0,0 +1,193 @@
+import { BuiltinModule, ICommand, IFunction, IPermission } from '../../BuiltinModule.js';
+import { Duration } from 'luxon';
+
+export class Teleports extends BuiltinModule<Teleports> {
+  constructor() {
+    super(
+      'teleports',
+      'A set of commands to allow players to set their own teleport points and teleport to them.',
+      JSON.stringify({
+        $schema: 'http://json-schema.org/draft-07/schema#',
+        type: 'object',
+        properties: {
+          timeout: {
+            title: 'Timeout',
+            description: 'The time one has to wait before teleporting again.',
+            'x-component': 'duration',
+            type: 'number',
+            minimum: 0,
+            default: Duration.fromObject({ second: 1 }).as('milliseconds'),
+          },
+          allowPublicTeleports: {
+            type: 'boolean',
+            description: 'Players can create public teleports.',
+            default: false,
+          },
+        },
+        required: [],
+        additionalProperties: false,
+      }),
+      JSON.stringify({
+        timeout: { 'ui:widget': 'duration' },
+      })
+    );
+
+    this.functions = [
+      new IFunction({
+        name: 'utils',
+        function: this.loadFn('functions', 'utils'),
+      }),
+    ];
+
+    this.permissions = [
+      new IPermission({
+        permission: 'TELEPORTS_CREATE_PUBLIC',
+        friendlyName: 'Create Public Teleports',
+        description: 'Allows the player to create public teleports.',
+        canHaveCount: true,
+      }),
+      new IPermission({
+        permission: 'TELEPORTS_USE',
+        friendlyName: 'Use Teleports',
+        description: 'Allows the player to use teleports modules.',
+        canHaveCount: true,
+      }),
+      new IPermission({
+        permission: 'TELEPORTS_MANAGE_WAYPOINTS',
+        friendlyName: 'Manage waypoints',
+        description: 'Allows creating, deleting, and managing waypoints.',
+        canHaveCount: false,
+      }),
+    ];
+
+    this.commands = [
+      new ICommand({
+        function: this.loadFn('commands', 'teleport'),
+        name: 'teleport',
+        trigger: 'tp',
+        helpText: 'Teleports to one of your set locations.',
+        arguments: [
+          {
+            name: 'tp',
+            type: 'string',
+            defaultValue: null,
+            helpText: 'The location to teleport to.',
+            position: 0,
+          },
+        ],
+      }),
+      new ICommand({
+        function: this.loadFn('commands', 'tplist'),
+        name: 'tplist',
+        trigger: 'tplist',
+        helpText: 'Lists all your set locations.',
+        arguments: [],
+      }),
+      new ICommand({
+        function: this.loadFn('commands', 'settp'),
+        name: 'settp',
+        trigger: 'settp',
+        helpText: 'Sets a location to teleport to.',
+        arguments: [
+          {
+            name: 'tp',
+            type: 'string',
+            defaultValue: null,
+            helpText: 'The location name.',
+            position: 0,
+          },
+        ],
+      }),
+      new ICommand({
+        function: this.loadFn('commands', 'deletetp'),
+        name: 'deletetp',
+        trigger: 'deletetp',
+        helpText: 'Deletes a location.',
+        arguments: [
+          {
+            name: 'tp',
+            type: 'string',
+            defaultValue: null,
+            helpText: 'The location name.',
+            position: 0,
+          },
+        ],
+      }),
+      new ICommand({
+        function: this.loadFn('commands', 'setpublic'),
+        name: 'setpublic',
+        trigger: 'setpublic',
+        helpText: 'Sets a teleport to be public, allowing other players to teleport to it.',
+        arguments: [
+          {
+            name: 'tp',
+            type: 'string',
+            defaultValue: null,
+            helpText: 'The location name.',
+            position: 0,
+          },
+        ],
+      }),
+      new ICommand({
+        function: this.loadFn('commands', 'setprivate'),
+        name: 'setprivate',
+        trigger: 'setprivate',
+        helpText: 'Sets a teleport to be private, only the teleport owner can teleport to it.',
+        arguments: [
+          {
+            name: 'tp',
+            type: 'string',
+            defaultValue: null,
+            helpText: 'The location name.',
+            position: 0,
+          },
+        ],
+      }),
+      new ICommand({
+        function: this.loadFn('commands', 'setwaypoint'),
+        name: 'setwaypoint',
+        trigger: 'setwaypoint',
+        helpText: 'Creates a new waypoint.',
+        arguments: [
+          {
+            name: 'waypoint',
+            type: 'string',
+            defaultValue: null,
+            helpText: 'The location name.',
+            position: 0,
+          },
+        ],
+      }),
+      new ICommand({
+        function: this.loadFn('commands', 'deletewaypoint'),
+        name: 'deletewaypoint',
+        trigger: 'deletewaypoint',
+        helpText: 'Deletes a waypoint.',
+        arguments: [
+          {
+            name: 'waypoint',
+            type: 'string',
+            defaultValue: null,
+            helpText: 'The location name.',
+            position: 0,
+          },
+        ],
+      }),
+      new ICommand({
+        function: this.loadFn('commands', 'listwaypoints'),
+        name: 'listwaypoints',
+        trigger: 'waypoints',
+        helpText: 'Lists all waypoints.',
+        arguments: [],
+      }),
+      new ICommand({
+        function: this.loadFn('commands', 'teleportwaypoint'),
+        name: 'teleportwaypoint',
+        trigger: 'teleportwaypoint',
+        arguments: [],
+        helpText:
+          'Placeholder command, this will not be used directly. The module will install aliases for this command corresponding to the waypoint names.',
+      }),
+    ];
+  }
+}

package/src/modules/utils/commands/help.js

@@ -0,0 +1,38 @@
+import { takaro, data, TakaroUserError } from '@takaro/helpers';
+
+async function main() {
+  const enabledModules = await takaro.gameserver.gameServerControllerGetInstalledModules(data.gameServerId);
+
+  const moduleCommands = await Promise.all(
+    enabledModules.data.data.map(async (mod) => {
+      return (await takaro.module.moduleControllerGetOne(mod.moduleId)).data.data.commands;
+    })
+  );
+
+  if (data.arguments.command === 'all') {
+    await data.player.pm('Available commands:');
+
+    for (const mod of moduleCommands) {
+      await Promise.all(
+        mod.map(async (command) => {
+          await data.player.pm(`${command.name}: ${command.helpText}`);
+        })
+      );
+    }
+  } else {
+    const allCommandsFlat = moduleCommands.flat();
+    const requestedCommand = allCommandsFlat.find((c) => {
+      return c.name === data.arguments.command;
+    });
+
+    if (!requestedCommand) {
+      throw new TakaroUserError(
+        `Unknown command "${data.arguments.command}", use this command without arguments to see all available commands.`
+      );
+    } else {
+      await data.player.pm(`${requestedCommand.name}: ${requestedCommand.helpText}`);
+    }
+  }
+}
+
+await main();

package/src/modules/utils/commands/ping.js

@@ -0,0 +1,7 @@
+import { data } from '@takaro/helpers';
+
+async function main() {
+  await data.player.pm('Pong!');
+}
+
+await main();

package/src/modules/utils/index.ts

@@ -0,0 +1,40 @@
+import { BuiltinModule, ICommand } from '../../BuiltinModule.js';
+
+export class Utils extends BuiltinModule<Utils> {
+  constructor() {
+    super(
+      'utils',
+      'A collection of useful commands',
+      JSON.stringify({
+        $schema: 'http://json-schema.org/draft-07/schema#',
+        type: 'object',
+        additionalProperties: false,
+      })
+    );
+
+    this.commands = [
+      new ICommand({
+        function: this.loadFn('commands', 'ping'),
+        name: 'ping',
+        trigger: 'ping',
+        helpText: 'Replies with pong, useful for testing if the connection works.',
+        arguments: [],
+      }),
+      new ICommand({
+        function: this.loadFn('commands', 'help'),
+        name: 'help',
+        trigger: 'help',
+        helpText: 'The text you are reading right now, displays information about commands.',
+        arguments: [
+          {
+            name: 'command',
+            type: 'string',
+            defaultValue: 'all',
+            helpText: 'The command to get help for',
+            position: 0,
+          },
+        ],
+      }),
+    ];
+  }
+}