@takaro/modules 0.0.0-next.0da151e

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

@@ -0,0 +1,50 @@
+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 prefix = (await takaro.settings.settingsControllerGetOne('commandPrefix', gameServerId)).data.data.value;
+
+  const existingVariable = await findTp(args.tp, pog.playerId);
+
+  if (existingVariable.data.data.length > 0) {
+    throw new TakaroUserError(`Teleport ${args.tp} already exists, use ${prefix}deletetp ${args.tp} to delete it.`);
+  }
+
+  const hasPermission = checkPermission(pog, 'TELEPORTS_USE');
+  const allPlayerTeleports = await takaro.variable.variableControllerSearch({
+    search: {
+      key: [getVariableKey(undefined), getVariableKey(undefined, true)],
+    },
+    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,
+      dimension: data.pog.dimension,
+    }),
+    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,31 @@
+import { takaro, data, TakaroUserError } from '@takaro/helpers';
+import { getWaypointName, waypointReconciler } from './utils.js';
+
+async function main() {
+  const { pog, gameServerId, arguments: args, module: mod } = data;
+
+  try {
+    await takaro.variable.variableControllerCreate({
+      moduleId: mod.moduleId,
+      gameServerId,
+      key: getWaypointName(args.waypoint),
+      value: JSON.stringify({
+        x: pog.positionX,
+        y: pog.positionY,
+        z: pog.positionZ,
+        dimension: pog.dimension,
+      }),
+    });
+  } catch (error) {
+    if (error.message === 'Request failed with status code 409') {
+      throw new TakaroUserError(`Waypoint ${args.waypoint} already exists.`);
+    }
+    throw error;
+  }
+
+  await waypointReconciler();
+
+  await pog.pm(`Waypoint ${args.waypoint} set.`);
+}
+
+await main();

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

@@ -0,0 +1,84 @@
+import { takaro, data, TakaroUserError } from '@takaro/helpers';
+import { findTp } from './utils.js';
+
+async function main() {
+  const { pog, gameServerId, arguments: args, module: mod } = data;
+
+  const ownedTeleportRes = await findTp(args.tp, pog.playerId);
+
+  let teleports = ownedTeleportRes.data.data;
+
+  if (mod.userConfig.allowPublicTeleports) {
+    const publicTeleportRes = await findTp(args.tp, null, true);
+    teleports = teleports.concat(publicTeleportRes.data.data);
+  }
+
+  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(),
+      });
+      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,
+      dimension: teleport.dimension,
+    });
+
+    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,
+    dimension: teleport.dimension,
+  });
+
+  await data.player.pm(`Teleported to ${teleport.name}.`);
+}
+
+await main();

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

@@ -0,0 +1,57 @@
+import { takaro, data, TakaroUserError, checkPermission } from '@takaro/helpers';
+
+function getWaypointName(name) {
+  return `waypoint ${name}`;
+}
+
+async function main() {
+  const { pog, gameServerId, trigger, module, itemId } = data;
+
+  const triggeredCommand = module.version.commands.find((command) => command.id === itemId);
+
+  if (!triggeredCommand) {
+    throw new Error('Waypoint not found.');
+  }
+
+  if (!triggeredCommand.name.includes(`server ${gameServerId}`)) {
+    console.log(`Waypoint ${trigger} is not for this server.`);
+    return;
+  }
+
+  if (!checkPermission(pog, `WAYPOINTS_USE_${trigger.toUpperCase()}_${gameServerId}`)) {
+    throw new TakaroUserError(`You are not allowed to use the waypoint ${trigger}.`);
+  }
+
+  const teleportsModule = (
+    await takaro.module.moduleControllerSearch({
+      filters: {
+        builtin: ['teleports'],
+      },
+    })
+  ).data.data[0];
+
+  const variable = await takaro.variable.variableControllerSearch({
+    filters: {
+      key: [getWaypointName(trigger)],
+      gameServerId: [gameServerId],
+      moduleId: [teleportsModule.id],
+    },
+  });
+
+  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,
+    dimension: waypoint.dimension,
+  });
+
+  await pog.pm(`Teleported to waypoint ${trigger}.`);
+}
+
+await main();

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

@@ -0,0 +1,62 @@
+import { takaro, data } from '@takaro/helpers';
+import { getVariableKey } from './utils.js';
+
+async function main() {
+  const { pog, gameServerId, module: mod } = data;
+
+  const prefix = (await takaro.settings.settingsControllerGetOne('commandPrefix', gameServerId)).data.data.value;
+
+  const ownedTeleports = (
+    await takaro.variable.variableControllerSearch({
+      filters: {
+        gameServerId: [gameServerId],
+        playerId: [pog.playerId],
+        moduleId: [mod.moduleId],
+      },
+      search: {
+        key: [getVariableKey(undefined, false)],
+      },
+      sortBy: 'key',
+      sortDirection: 'asc',
+    })
+  ).data.data;
+
+  const publicTeleports = (
+    await takaro.variable.variableControllerSearch({
+      filters: {
+        gameServerId: [gameServerId],
+        moduleId: [mod.moduleId],
+      },
+      search: {
+        key: [getVariableKey(undefined, true)],
+      },
+      sortBy: 'key',
+      sortDirection: 'asc',
+    })
+  ).data.data
+    // Filter out public teleports that are owned by the player
+    // Since we'll be showing them in the owned teleports list
+    .filter((teleport) => {
+      return teleport.playerId !== pog.playerId;
+    });
+
+  const teleports = [...ownedTeleports, ...publicTeleports];
+
+  if (teleports.length === 0) {
+    await data.player.pm(`You have no teleports available, 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}) ${
+        rawTeleport.key.startsWith('pub') ? '(public)' : ''
+      }`
+    );
+  }
+}
+
+await main();

package/src/modules/teleports/cronJobs/Waypoint reconciler.js

@@ -0,0 +1,7 @@
+import { waypointReconciler } from './utils.js';
+
+async function main() {
+  await waypointReconciler();
+}
+
+await main();

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

@@ -0,0 +1,189 @@
+import { takaro, data } from '@takaro/helpers';
+
+export function getVariableKey(tpName, pub = false) {
+  if (pub && tpName) return `pubtp_${tpName}`;
+  if (pub && !tpName) return 'pubtp_';
+  if (tpName) return `tp_${tpName}`;
+  return 'tp_';
+}
+
+export async function findTp(tpName, playerId, pub = false) {
+  const { gameServerId, module: mod } = data;
+
+  if (pub) {
+    return takaro.variable.variableControllerSearch({
+      filters: {
+        key: [getVariableKey(tpName, true)],
+        gameServerId: [gameServerId],
+        playerId: [playerId].filter(Boolean),
+        moduleId: [mod.moduleId],
+      },
+      sortBy: 'key',
+      sortDirection: 'asc',
+    });
+  }
+
+  return takaro.variable.variableControllerSearch({
+    filters: {
+      key: [getVariableKey(tpName)],
+      gameServerId: [gameServerId],
+      playerId: [playerId].filter(Boolean),
+      moduleId: [mod.moduleId],
+    },
+    sortBy: 'key',
+    sortDirection: 'asc',
+  });
+}
+
+export async function ensureWaypointsModule() {
+  const { gameServerId } = data;
+  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',
+      })
+    ).data.data;
+  }
+
+  let waypointsInstallation = (
+    await takaro.module.moduleInstallationsControllerGetInstalledModules({
+      filters: { gameserverId: [gameServerId] },
+    })
+  ).data.data.find((module) => module.module.name === 'Waypoints');
+
+  if (!waypointsInstallation) {
+    console.log('Waypoints installation not found, installing it.');
+    waypointsInstallation = (
+      await takaro.module.moduleInstallationsControllerInstallModule({
+        gameServerId,
+        versionId: waypointsDefinition.latestVersion.id,
+      })
+    ).data.data;
+  }
+
+  return { waypointsInstallation, waypointsDefinition };
+}
+
+export function getWaypointName(name) {
+  return `waypoint ${name}`;
+}
+
+export function getWaypointId(varName) {
+  const split = varName.split(' ')[1];
+  if (split) return split;
+  return varName;
+}
+
+/**
+ * This function is responsible to read all the configured waypoints (vars)
+ * and then ensuring that the waypoints module has the correct config
+ */
+export async function waypointReconciler() {
+  console.log('Reconciling waypoints');
+  const { waypointsInstallation, waypointsDefinition } = await ensureWaypointsModule();
+  const { gameServerId, module: mod } = data;
+
+  // Get all the installed waypoints
+  const waypointVars = (
+    await takaro.variable.variableControllerSearch({
+      filters: {
+        moduleId: [mod.moduleId],
+        gameServerId: [gameServerId],
+      },
+      search: {
+        key: [getWaypointName('')],
+      },
+    })
+  ).data.data;
+
+  const waypointsInModule = waypointsDefinition.latestVersion.commands;
+
+  // Check if any waypoints are missing in module
+  const missingWaypoints = waypointVars.filter((waypointVar) => {
+    const existingWaypointsForServer = waypointsInModule.filter((waypoint) => waypoint.name.includes(gameServerId));
+    return !existingWaypointsForServer.some((waypoint) => waypoint.trigger === getWaypointId(waypointVar.key));
+  });
+
+  // Check if there are waypoints too many in module compared to our vars
+  const toDeleteWaypoints = waypointsInModule.filter((waypoint) => {
+    // We ignore any commands that are not for this game server
+    if (!waypoint.name.includes(gameServerId)) return false;
+    return !waypointVars.some((waypointVar) => getWaypointId(waypointVar.key) === waypoint.trigger);
+  });
+
+  if (!missingWaypoints.length && !toDeleteWaypoints.length) {
+    // No changes in waypoints, exit
+    return;
+  }
+
+  console.log(
+    'Missing waypoints:',
+    missingWaypoints.map((waypoint) => waypoint.key),
+  );
+  console.log(
+    'To delete waypoints:',
+    toDeleteWaypoints.map((waypoint) => waypoint.trigger),
+  );
+
+  // Fetch the teleporting code template
+  const teleportCommand = await takaro.command.commandControllerSearch({
+    filters: {
+      moduleId: [mod.moduleId],
+      name: ['teleportwaypoint'],
+    },
+  });
+
+  // Edit the module accordingly
+  await Promise.all([
+    ...missingWaypoints.map((waypoint) => {
+      return takaro.command.commandControllerCreate({
+        name: `waypoint ${getWaypointId(waypoint.key)} server ${gameServerId}`,
+        trigger: getWaypointId(waypoint.key),
+        helpText: `Teleport to waypoint ${getWaypointId(waypoint.key)}.`,
+        function: teleportCommand.data.data[0].function.code,
+        versionId: waypointsInstallation.versionId,
+      });
+    }),
+    ...toDeleteWaypoints.map((waypointVar) => {
+      return takaro.command.commandControllerRemove(waypointVar.id);
+    }),
+  ]);
+
+  // Update permissions
+  const existingPermissions = waypointsDefinition.latestVersion.permissions || [];
+  const permissionInputDTOs = existingPermissions.map((permission) => ({
+    permission: permission.permission,
+    description: permission.description,
+    friendlyName: permission.friendlyName,
+    canHaveCount: permission.canHaveCount,
+  }));
+  // We need to filter out the permissions we deleted in the above lines
+  const filteredPermissionsInputs = permissionInputDTOs.filter((permission) => {
+    return !toDeleteWaypoints.some(
+      (waypoint) => permission.permission === `WAYPOINTS_USE_${waypoint.trigger.toUpperCase()}_${gameServerId}`,
+    );
+  });
+  const gameServer = (await takaro.gameserver.gameServerControllerGetOne(gameServerId)).data.data;
+  await takaro.module.moduleControllerUpdate(waypointsInstallation.moduleId, {
+    latestVersion: {
+      permissions: [
+        ...filteredPermissionsInputs,
+        ...missingWaypoints.map((waypoint) => ({
+          permission: `WAYPOINTS_USE_${getWaypointId(waypoint.key).toUpperCase()}_${gameServerId}`,
+          description: `Use the waypoint ${getWaypointId(waypoint.key)} on ${gameServer.name}.`,
+          friendlyName: `Use waypoint ${getWaypointId(waypoint.key)} on ${gameServer.name}`,
+          canHaveCount: false,
+        })),
+      ],
+    },
+  });
+}

package/src/modules/teleports/index.ts

@@ -0,0 +1,217 @@
+import {
+  ModuleTransferDTO,
+  ICommand,
+  IFunction,
+  IPermission,
+  ModuleTransferVersionDTO,
+  ICronJob,
+} from '../../BuiltinModule.js';
+import { Duration } from 'luxon';
+
+export class Teleports extends ModuleTransferDTO<Teleports> {
+  constructor() {
+    super();
+
+    this.name = 'teleports';
+    this.author = 'Takaro';
+    this.supportedGames = ['7 days to die', 'rust', 'minecraft'];
+    this.versions = [
+      new ModuleTransferVersionDTO({
+        tag: '0.0.4',
+        description: 'A set of commands to allow players to set their own teleport points and teleport to them.',
+        configSchema: 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,
+        }),
+        uiSchema: JSON.stringify({
+          timeout: { 'ui:widget': 'duration' },
+        }),
+        functions: [
+          new IFunction({
+            name: 'utils',
+            function: this.loadFn('functions', 'utils'),
+          }),
+        ],
+        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,
+          }),
+        ],
+        commands: [
+          new ICommand({
+            function: this.loadFn('commands', 'teleport'),
+            name: 'teleport',
+            trigger: 'tp',
+            helpText: 'Teleports to one of your set locations.',
+            requiredPermissions: ['TELEPORTS_USE'],
+            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.',
+            requiredPermissions: ['TELEPORTS_USE'],
+            arguments: [],
+          }),
+          new ICommand({
+            function: this.loadFn('commands', 'settp'),
+            name: 'settp',
+            trigger: 'settp',
+            helpText: 'Sets a location to teleport to.',
+            requiredPermissions: ['TELEPORTS_USE'],
+            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.',
+            requiredPermissions: ['TELEPORTS_CREATE_PUBLIC'],
+            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.',
+            requiredPermissions: ['TELEPORTS_MANAGE_WAYPOINTS'],
+            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.',
+            requiredPermissions: ['TELEPORTS_MANAGE_WAYPOINTS'],
+            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.',
+          }),
+        ],
+        cronJobs: [
+          new ICronJob({
+            name: 'Waypoint reconciler',
+            temporalValue: '*/30 * * * *',
+            function: this.loadFn('cronJobs', 'Waypoint reconciler'),
+          }),
+        ],
+      }),
+    ];
+  }
+}