@takaro/modules 0.0.1

package/src/modules/lottery/cronJobs/drawLottery.js

@@ -0,0 +1,124 @@
+import { takaro, data } from '@takaro/helpers';
+
+function getTotalPrize(tickets, ticketPrice, profitMargin) {
+  const amount = tickets.reduce((acc, ticket) => {
+    const ticketAmount = parseInt(JSON.parse(ticket.value).amount, 10);
+
+    return acc + ticketAmount;
+  }, 0);
+
+  const rawTotal = amount * ticketPrice;
+  const profit = rawTotal * profitMargin;
+  const totalPrize = rawTotal - profit;
+
+  return totalPrize;
+}
+
+async function drawWinner(takaro, gameServerId, tickets) {
+  const randomIndex = Math.floor(Math.random() * tickets.length);
+  const winnerTicket = tickets[randomIndex];
+
+  const winner = (await takaro.player.playerControllerGetOne(winnerTicket.playerId)).data.data;
+  const pog = await takaro.playerOnGameserver.playerOnGameServerControllerSearch({
+    filters: {
+      gameServerId: [gameServerId],
+      playerId: [winner.id],
+    },
+  });
+
+  return {
+    name: winner.name,
+    playerId: pog.data.data[0].playerId,
+  };
+}
+
+async function refundPlayer(takaro, gameServerId, playerId, amount, currencyName) {
+  const pog = (
+    await takaro.playerOnGameserver.playerOnGameServerControllerSearch({
+      filters: {
+        gameServerId: [gameServerId],
+        playerId: [playerId],
+      },
+    })
+  ).data.data[0];
+
+  await takaro.playerOnGameserver.playerOnGameServerControllerAddCurrency(gameServerId, pog.playerId, {
+    currency: amount,
+  });
+
+  await takaro.gameserver.gameServerControllerSendMessage(gameServerId, {
+    message: `You have been refunded ${amount} ${currencyName} because the lottery has been cancelled.`,
+    opts: {
+      recipient: {
+        gameId: pog.gameId,
+      },
+    },
+  });
+}
+
+async function cleanUp(takaro, tickets) {
+  const deleteTasks = tickets.map((ticket) => takaro.variable.variableControllerDelete(ticket.id));
+  await Promise.allSettled(deleteTasks);
+}
+
+async function main() {
+  const { gameServerId, module: mod } = data;
+
+  let tickets = [];
+
+  try {
+    const currencyName = (await takaro.settings.settingsControllerGetOne('currencyName', gameServerId)).data.data.value;
+    const ticketCost = mod.systemConfig.commands.buyTicket.cost;
+
+    tickets = (
+      await takaro.variable.variableControllerSearch({
+        filters: {
+          gameServerId: [gameServerId],
+          moduleId: [mod.moduleId],
+          key: ['lottery_tickets_bought'],
+        },
+      })
+    ).data.data;
+
+    if (tickets.length === 0) {
+      await takaro.gameserver.gameServerControllerSendMessage(gameServerId, {
+        message: 'No one has bought any tickets. The lottery has been cancelled.',
+      });
+
+      return;
+    }
+
+    if (tickets.length === 1) {
+      await takaro.gameserver.gameServerControllerSendMessage(gameServerId, {
+        message: 'Only one person has bought a ticket. The lottery has been cancelled.',
+      });
+
+      const amount = parseInt(JSON.parse(tickets[0].value).amount, 10) * ticketCost;
+
+      await refundPlayer(takaro, gameServerId, tickets[0].playerId, amount, currencyName);
+
+      return;
+    }
+
+    const totalPrize = getTotalPrize(tickets, ticketCost, mod.userConfig.profitMargin);
+    const { name: winnerName, playerId } = await drawWinner(takaro, gameServerId, tickets);
+
+    await takaro.gameserver.gameServerControllerSendMessage(gameServerId, {
+      message: 'The lottery raffle is about to start!',
+    });
+    await takaro.gameserver.gameServerControllerSendMessage(gameServerId, { message: 'drumrolls please...' });
+    await takaro.gameserver.gameServerControllerSendMessage(gameServerId, { message: 'The winner is...' });
+
+    await takaro.playerOnGameserver.playerOnGameServerControllerAddCurrency(gameServerId, playerId, {
+      currency: totalPrize,
+    });
+
+    await takaro.gameserver.gameServerControllerSendMessage(gameServerId, {
+      message: `${winnerName}! Congratulations! You have won ${totalPrize} ${currencyName}!`,
+    });
+  } finally {
+    await cleanUp(takaro, tickets);
+  }
+}
+
+await main();

package/src/modules/lottery/index.ts

@@ -0,0 +1,80 @@
+import { BuiltinModule, ICommand, ICronJob, IPermission } from '../../BuiltinModule.js';
+
+export class Lottery extends BuiltinModule<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,
+      })
+    );
+
+    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,
+          },
+        ],
+      }),
+      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

@@ -0,0 +1,47 @@
+import { takaro, data, TakaroUserError } from '@takaro/helpers';
+
+const VARIABLE_KEY = 't_starterkit_lock';
+
+async function main() {
+  const items = data.module.userConfig.starterKitItems;
+
+  if (!items || items.length === 0) {
+    throw new TakaroUserError(
+      'No starter kit items configured. Please ask your server administrator to configure this.'
+    );
+  }
+
+  const starterKitLockRes = await takaro.variable.variableControllerSearch({
+    filters: {
+      key: [VARIABLE_KEY],
+      gameServerId: [data.gameServerId],
+      playerId: [data.player.id],
+    },
+  });
+
+  if (starterKitLockRes.data.data.length > 0) {
+    throw new TakaroUserError('You already used starterkit on this server');
+  }
+
+  await data.player.pm('You are about to receive your starter kit...');
+
+  await Promise.all(
+    items.map(async (item) => {
+      return takaro.gameserver.gameServerControllerGiveItem(data.gameServerId, data.player.id, {
+        name: item,
+        amount: 1,
+      });
+    })
+  );
+
+  await takaro.variable.variableControllerCreate({
+    key: VARIABLE_KEY,
+    value: '1',
+    gameServerId: data.gameServerId,
+    playerId: data.player.id,
+  });
+
+  await data.player.pm(`Gave ${items.length} items, enjoy!`);
+}
+
+await main();

package/src/modules/playerOnboarding/hooks/playerConnected.js

@@ -0,0 +1,14 @@
+import { takaro, data } from '@takaro/helpers';
+
+async function main() {
+  const { player } = data;
+
+  const rawMessage = data.module.userConfig.message;
+  const message = rawMessage.replace('{player}', player.name);
+
+  await takaro.gameserver.gameServerControllerSendMessage(data.gameServerId, {
+    message,
+  });
+}
+
+await main();

package/src/modules/playerOnboarding/index.ts

@@ -0,0 +1,58 @@
+import { BuiltinModule, ICommand, IHook } from '../../BuiltinModule.js';
+import { HookEvents } from '../../dto/index.js';
+export class PlayerOnboarding extends BuiltinModule<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!',
+          },
+          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',
+            },
+          },
+        },
+        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: [],
+      }),
+    ];
+  }
+}

package/src/modules/serverMessages/cronJobs/Automated message.js

@@ -0,0 +1,12 @@
+import { takaro, data } from '@takaro/helpers';
+
+async function main() {
+  const randomMessage =
+    data.module.userConfig.messages[Math.floor(Math.random() * data.module.userConfig.messages.length)];
+
+  await takaro.gameserver.gameServerControllerSendMessage(data.gameServerId, {
+    message: randomMessage,
+  });
+}
+
+await main();

package/src/modules/serverMessages/index.ts

@@ -0,0 +1,40 @@
+import { BuiltinModule, ICronJob } from '../../BuiltinModule.js';
+
+export class ServerMessages extends BuiltinModule<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,
+            },
+            minItems: 1,
+          },
+        },
+        required: ['messages'],
+      })
+    );
+
+    this.cronJobs = [
+      new ICronJob({
+        name: 'Automated message',
+        temporalValue: '*/30 * * * *',
+        function: this.loadFn('cronJobs', 'Automated message'),
+      }),
+    ];
+  }
+}

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

@@ -0,0 +1,25 @@
+import { takaro, data, TakaroUserError } from '@takaro/helpers';
+import { getVariableKey } from './utils.js';
+
+async function main() {
+  const { pog, gameServerId, arguments: args, module: mod } = data;
+
+  const existingVariable = await takaro.variable.variableControllerSearch({
+    filters: {
+      key: [getVariableKey(args.tp)],
+      gameServerId: [gameServerId],
+      playerId: [pog.playerId],
+      moduleId: [mod.moduleId],
+    },
+  });
+
+  if (existingVariable.data.data.length === 0) {
+    throw new TakaroUserError(`Teleport ${args.tp} does not exist.`);
+  }
+
+  await takaro.variable.variableControllerDelete(existingVariable.data.data[0].id);
+
+  await data.player.pm(`Teleport ${args.tp} deleted.`);
+}
+
+await main();

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

@@ -0,0 +1,77 @@
+import { takaro, data, checkPermission, TakaroUserError } from '@takaro/helpers';
+
+function getWaypointName(name) {
+  return `waypoint ${name}`;
+}
+
+async function main() {
+  const { pog, gameServerId, 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 } = await ensureWaypointsModule();
+
+  const variable = await takaro.variable.variableControllerSearch({
+    filters: {
+      key: [getWaypointName(args.waypoint)],
+      gameServerId: [gameServerId],
+      moduleId: [waypointsInstallation.moduleId],
+    },
+  });
+
+  if (!variable.data.data.length) {
+    throw new TakaroUserError(`Waypoint ${args.waypoint} doesn't exist.`);
+  }
+
+  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 pog.pm(`Waypoint ${args.waypoint} deleted.`);
+}
+
+await main();

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

@@ -0,0 +1,55 @@
+import { takaro, data, checkPermission } from '@takaro/helpers';
+
+async function main() {
+  const { pog, gameServerId } = data;
+
+  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 { waypointsDefinition } = await ensureWaypointsModule();
+
+  const allWaypoints = waypointsDefinition.commands;
+
+  const waypointsWithPermission = allWaypoints
+    .filter((waypoint) => checkPermission(pog, `WAYPOINTS_USE_${waypoint.trigger.toUpperCase()}_${gameServerId}`))
+    .sort((a, b) => a.trigger.localeCompare(b.trigger));
+
+  if (!waypointsWithPermission.length) {
+    await pog.pm('There are no waypoints available.');
+    return;
+  }
+
+  await pog.pm(`Available waypoints: ${waypointsWithPermission.map((waypoint) => waypoint.trigger).join(', ')}`);
+}
+
+await main();

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

@@ -0,0 +1,39 @@
+import { takaro, data, TakaroUserError } from '@takaro/helpers';
+import { getVariableKey } from './utils.js';
+
+async function main() {
+  const { pog, gameServerId, arguments: args, module: mod } = data;
+
+  const prefix = (await takaro.settings.settingsControllerGetOne('commandPrefix', gameServerId)).data.data;
+
+  const teleportRes = await takaro.variable.variableControllerSearch({
+    filters: {
+      gameServerId: [gameServerId],
+      playerId: [pog.playerId],
+      key: [getVariableKey(args.tp)],
+      moduleId: [mod.moduleId],
+    },
+    sortBy: 'key',
+    sortDirection: 'asc',
+  });
+
+  const teleports = teleportRes.data.data;
+
+  if (teleports.length === 0) {
+    throw new TakaroUserError(`No teleport with name ${args.tp} found, use ${prefix}settp <name> to set one first.`);
+  }
+
+  const teleportRecord = teleports[0];
+  const teleport = JSON.parse(teleportRecord.value);
+
+  await takaro.variable.variableControllerUpdate(teleportRecord.id, {
+    value: JSON.stringify({
+      ...teleport,
+      public: false,
+    }),
+  });
+
+  await data.player.pm(`Teleport ${args.tp} is now private.`);
+}
+
+await main();

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

@@ -0,0 +1,71 @@
+import { takaro, data, checkPermission, TakaroUserError } from '@takaro/helpers';
+import { getVariableKey } from './utils.js';
+
+async function main() {
+  const { pog, gameServerId, module: mod, arguments: args } = data;
+
+  const prefix = (await takaro.settings.settingsControllerGetOne('commandPrefix', gameServerId)).data.data;
+
+  if (!mod.userConfig.allowPublicTeleports) {
+    throw new TakaroUserError('Public teleports are disabled.');
+  }
+
+  const hasPermission = checkPermission(pog, 'TELEPORTS_CREATE_PUBLIC');
+
+  if (!hasPermission) {
+    throw new TakaroUserError('You do not have permission to create public teleports.');
+  }
+
+  const existingTeleportsForPlayerRes = await takaro.variable.variableControllerSearch({
+    search: {
+      key: 'tp_',
+    },
+    filters: {
+      gameServerId: [gameServerId],
+      playerId: [pog.playerId],
+      moduleId: [mod.moduleId],
+    },
+  });
+
+  const existingPublicTeleportsForPlayer = existingTeleportsForPlayerRes.data.data.filter((tp) => {
+    const teleport = JSON.parse(tp.value);
+    return teleport.public;
+  });
+
+  if (existingPublicTeleportsForPlayer.length >= hasPermission.count) {
+    throw new TakaroUserError(
+      `You have reached the maximum number of public teleports for your role, maximum allowed is ${hasPermission.count}`
+    );
+  }
+
+  const teleportRes = await takaro.variable.variableControllerSearch({
+    filters: {
+      gameServerId: [gameServerId],
+      playerId: [pog.playerId],
+      moduleId: [mod.moduleId],
+      key: [getVariableKey(args.tp)],
+    },
+    sortBy: 'key',
+    sortDirection: 'asc',
+  });
+
+  const teleports = teleportRes.data.data;
+
+  if (teleports.length === 0) {
+    throw new TakaroUserError(`No teleport with name ${args.tp} found, use ${prefix}settp <name> to set one first.`);
+  }
+
+  const teleportRecord = teleports[0];
+  const teleport = JSON.parse(teleportRecord.value);
+
+  await takaro.variable.variableControllerUpdate(teleportRecord.id, {
+    value: JSON.stringify({
+      ...teleport,
+      public: true,
+    }),
+  });
+
+  await data.player.pm(`Teleport ${args.tp} is now public.`);
+}
+
+await main();