@takaro/modules 0.0.0-next.0da151e

package/src/modules/lottery/commands/viewTickets.js

@@ -0,0 +1,28 @@
+import { takaro, data } from '@takaro/helpers';
+
+async function main() {
+  const { pog, gameServerId, module: mod } = data;
+
+  const varKey = 'lottery_tickets_bought';
+
+  const tickets = (
+    await takaro.variable.variableControllerSearch({
+      filters: {
+        gameServerId: [gameServerId],
+        key: [varKey],
+        moduleId: [mod.moduleId],
+        playerId: [pog.playerId],
+      },
+    })
+  ).data.data;
+
+  let ticketsBought = 0;
+
+  if (tickets.length === 1) {
+    ticketsBought = parseInt(JSON.parse(tickets[0].value).amount, 10);
+  }
+
+  await pog.pm(`You have bought ${ticketsBought} tickets.`);
+}
+
+await main();

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,86 @@
+import { ModuleTransferDTO, ICommand, ICronJob, IPermission, ModuleTransferVersionDTO } from '../../BuiltinModule.js';
+
+export class Lottery extends ModuleTransferDTO<Lottery> {
+  constructor() {
+    super();
+
+    this.name = 'lottery';
+    this.author = 'Takaro';
+    this.supportedGames = ['all'];
+    this.versions = [
+      new ModuleTransferVersionDTO({
+        tag: '0.0.2',
+        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.',
+            requiredPermissions: ['LOTTERY_BUY'],
+            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.',
+            requiredPermissions: ['LOTTERY_VIEW_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,61 @@
+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...');
+
+  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 {
+      id: itemRecord.id,
+      quality: item.quality,
+      amount: item.amount,
+    };
+  });
+
+  await Promise.all(
+    fullItems.map(async (item) => {
+      return takaro.gameserver.gameServerControllerGiveItem(data.gameServerId, data.player.id, {
+        name: item.id,
+        quality: item.quality ?? '',
+        amount: item.amount,
+      });
+    }),
+  );
+
+  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,86 @@
+import { ModuleTransferDTO, ICommand, IHook, ModuleTransferVersionDTO } from '../../BuiltinModule.js';
+import { HookEvents } from '../../dto/index.js';
+
+export class PlayerOnboarding extends ModuleTransferDTO<PlayerOnboarding> {
+  constructor() {
+    super();
+
+    this.name = 'playerOnboarding';
+    this.author = 'Takaro';
+    this.supportedGames = ['all'];
+    this.versions = [
+      new ModuleTransferVersionDTO({
+        tag: '0.0.3',
+        description:
+          'Collection of functions that are executed when a player joins the server. Helps with onboarding new players, like sending a welcome message. Fixed issue with starterkit item identifiers.',
+        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: {
+            items: {
+              item: {
+                'ui:widget': 'item',
+              },
+            },
+          },
+        }),
+        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/cronJobs/Automated message.js

@@ -0,0 +1,47 @@
+import { data, takaro } from '@takaro/helpers';
+
+async function main() {
+  const { module: mod, gameServerId } = data;
+
+  // Check what the last message we sent was
+  const lastMessageVar = (
+    await takaro.variable.variableControllerSearch({
+      filters: {
+        key: ['lastMessage'],
+        moduleId: [mod.moduleId],
+        gameServerId: [gameServerId],
+      },
+    })
+  ).data.data[0];
+
+  // If we haven't sent any messages yet, start with the first one
+  const lastMessage = lastMessageVar ? parseInt(lastMessageVar.value, 10) : -1;
+  // The next message we should send is the next in the array
+  // However, if we're at the end of the array, we should start over
+  const nextMessage = data.module.userConfig.messages[lastMessage + 1] ? lastMessage + 1 : 0;
+  // The actual text of the message we're going to send
+  const messageToSend = data.module.userConfig.messages[nextMessage];
+
+  // Send the message to the game server
+  await takaro.gameserver.gameServerControllerSendMessage(data.gameServerId, {
+    message: messageToSend,
+  });
+
+  // Update the last message variable so the next time this cron job runs, we know what to send
+  if (lastMessageVar) {
+    // The variable already exists, update it
+    await takaro.variable.variableControllerUpdate(lastMessageVar.id, {
+      value: nextMessage.toString(),
+    });
+  } else {
+    // The variable doesn't exist, create it
+    await takaro.variable.variableControllerCreate({
+      key: 'lastMessage',
+      value: nextMessage.toString(),
+      moduleId: mod.moduleId,
+      gameServerId: gameServerId,
+    });
+  }
+}
+
+await main();

package/src/modules/serverMessages/index.ts

@@ -0,0 +1,46 @@
+import { ModuleTransferDTO, ICronJob, ModuleTransferVersionDTO } from '../../BuiltinModule.js';
+
+export class ServerMessages extends ModuleTransferDTO<ServerMessages> {
+  constructor() {
+    super();
+
+    this.name = 'serverMessages';
+    this.author = 'Takaro';
+    this.supportedGames = ['all'];
+    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,
+            },
+          },
+          required: ['messages'],
+        }),
+        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), getVariableKey(args.tp, true)],
+      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,24 @@
+import { takaro, data, TakaroUserError } from '@takaro/helpers';
+import { getWaypointName, waypointReconciler } from './utils.js';
+
+async function main() {
+  const { pog, gameServerId, arguments: args, module: mod } = data;
+
+  const variable = await takaro.variable.variableControllerSearch({
+    filters: {
+      key: [getWaypointName(args.waypoint)],
+      gameServerId: [gameServerId],
+      moduleId: [mod.moduleId],
+    },
+  });
+
+  if (!variable.data.data.length) {
+    throw new TakaroUserError(`Waypoint ${args.waypoint} doesn't exist.`);
+  }
+
+  await takaro.variable.variableControllerDelete(variable.data.data[0].id);
+  await waypointReconciler();
+  await pog.pm(`Waypoint ${args.waypoint} deleted.`);
+}
+
+await main();

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

@@ -0,0 +1,23 @@
+import { data, checkPermission } from '@takaro/helpers';
+import { ensureWaypointsModule } from './utils.js';
+
+async function main() {
+  const { pog, gameServerId } = data;
+
+  const { waypointsDefinition } = await ensureWaypointsModule();
+
+  const allWaypoints = waypointsDefinition.latestVersion.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, true)],
+      moduleId: [mod.moduleId],
+    },
+    sortBy: 'key',
+    sortDirection: 'asc',
+  });
+
+  const teleports = teleportRes.data.data;
+
+  if (teleports.length === 0) {
+    throw new TakaroUserError(
+      `No public 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, {
+    key: getVariableKey(args.tp),
+    value: JSON.stringify(teleport),
+  });
+
+  await data.player.pm(`Teleport ${args.tp} is now private.`);
+}
+
+await main();

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

@@ -0,0 +1,60 @@
+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.value;
+
+  if (!mod.userConfig.allowPublicTeleports) {
+    throw new TakaroUserError('Public teleports are disabled.');
+  }
+
+  const hasPermission = checkPermission(pog, 'TELEPORTS_CREATE_PUBLIC');
+
+  const existingPublicTeleportsForPlayerRes = await takaro.variable.variableControllerSearch({
+    search: {
+      key: ['pubtp_'],
+    },
+    filters: {
+      gameServerId: [gameServerId],
+      playerId: [pog.playerId],
+      moduleId: [mod.moduleId],
+    },
+  });
+
+  if (existingPublicTeleportsForPlayerRes.data.data.length >= hasPermission.count) {
+    throw new TakaroUserError(
+      `You have reached the maximum number of public teleports for your role, maximum allowed is ${hasPermission.count}`,
+    );
+  }
+
+  const teleports = (
+    await takaro.variable.variableControllerSearch({
+      filters: {
+        gameServerId: [gameServerId],
+        playerId: [pog.playerId],
+        moduleId: [mod.moduleId],
+        key: [getVariableKey(args.tp)],
+      },
+      sortBy: 'key',
+      sortDirection: 'asc',
+    })
+  ).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, {
+    key: getVariableKey(args.tp, true),
+    value: JSON.stringify(teleport),
+  });
+
+  await data.player.pm(`Teleport ${args.tp} is now public.`);
+}
+
+await main();