@takaro/modules 0.0.10 → 0.0.13

package/src/modules/economyUtils/commands/shop.js

@@ -0,0 +1,87 @@
+import { takaro, data, TakaroUserError } from '@takaro/helpers';
+
+async function main() {
+  const { arguments: args, player, gameServerId, user } = data;
+  const { page, item, action } = args;
+  const prefix = (await takaro.settings.settingsControllerGetOne('commandPrefix', gameServerId)).data.data.value;
+
+  // If command is called without any arguments
+  const messageWithoutPrefix = data.chatMessage.msg.slice(prefix.length).trim();
+  if (!messageWithoutPrefix.includes(' ')) {
+    await player.pm('This command allows you to browse the shop and view available items.');
+    await player.pm(`Usage: ${prefix}shop [page] [item] [action]`);
+    await player.pm(`${prefix}shop 2 - View the second page of shop items`);
+    await player.pm(`${prefix}shop 1 3 - View details about the third item on the first page`);
+    await player.pm(`${prefix}shop 1 3 buy - Purchase the third item on the first page`);
+    return;
+  }
+
+  const shopItems = await takaro.shopListing.shopListingControllerSearch({
+    limit: 5,
+    page: page - 1,
+    sortBy: 'name',
+    sortDirection: 'asc',
+    filters: {
+      gameServerId: [gameServerId],
+      draft: false,
+    },
+  });
+
+  if (shopItems.data.data.length === 0) {
+    await player.pm('No items found.');
+    return;
+  }
+
+  const currencyName = (await takaro.settings.settingsControllerGetOne('currencyName', data.gameServerId)).data.data;
+
+  if (!item) {
+    // List the shop items
+    for (const listing of shopItems.data.data) {
+      const items = listing.items.slice(0, 3).map((item) => {
+        return `${item.amount}x ${item.item.name}`;
+      });
+      await player.pm(`- ${listing.name} - ${listing.price} ${currencyName.value}. ${items.join(', ')}`);
+    }
+    return;
+  }
+
+  const selectedItem = shopItems.data.data[item - 1];
+  if (!selectedItem)
+    throw new TakaroUserError(
+      `Item not found. Please select an item from the list, valid options are 1-${shopItems.data.data.length}.`,
+    );
+
+  if (action === 'none') {
+    // Display more info about the item
+    await player.pm(`Listing ${selectedItem.name} - ${selectedItem.price} ${currencyName.value}`);
+    await Promise.all(
+      selectedItem.items.map((item) => {
+        const quality = item.quality ? `Quality: ${item.quality}` : '';
+        const description = (item.item.description ? `Description: ${item.item.description}` : '').replaceAll(
+          '\\n',
+          ' ',
+        );
+
+        return player.pm(`- ${item.amount}x ${item.item.name}. ${quality} ${description}`);
+      }),
+    );
+    return;
+  }
+
+  if (action === 'buy') {
+    if (!user) throw new TakaroUserError('You must link your account to Takaro to use this command.');
+
+    const orderRes = await takaro.shopOrder.shopOrderControllerCreate({
+      amount: 1,
+      listingId: selectedItem.id,
+      userId: user.id,
+    });
+    await player.pm(`You have purchased ${selectedItem.name} for ${selectedItem.price} ${currencyName.value}.`);
+    await takaro.shopOrder.shopOrderControllerClaim(orderRes.data.data.id);
+    return;
+  }
+
+  throw new TakaroUserError('Invalid action. Valid actions are "buy".');
+}
+
+await main();

package/src/modules/economyUtils/commands/transfer.js

@@ -47,7 +47,7 @@ async function main() {
         currency: args.amount,
       },
     );
-  } catch (_e) {
+  } catch {
     throw new TakaroUserError(
       `Failed to transfer ${args.amount} ${currencyName} to ${receiverName}. Are you sure you have enough balance?`,
     );

package/src/modules/economyUtils/index.ts

@@ -135,6 +135,35 @@ export class EconomyUtils extends BuiltinModule<EconomyUtils> {
           },
         ],
       }),
+      new ICommand({
+        function: this.loadFn('commands', 'shop'),
+        name: 'shop',
+        trigger: 'shop',
+        helpText: 'Browse the shop and view available items.',
+        arguments: [
+          {
+            name: 'page',
+            type: 'number',
+            helpText: 'Display more items from the shop by specifying a page number.',
+            position: 0,
+            defaultValue: '1',
+          },
+          {
+            name: 'item',
+            type: 'number',
+            helpText: 'Select a specific item to view more details.',
+            position: 1,
+            defaultValue: '0',
+          },
+          {
+            name: 'action',
+            type: 'string',
+            helpText: 'Perform an action on the selected item. Currently only "buy" is supported.',
+            position: 2,
+            defaultValue: 'none',
+          },
+        ],
+      }),
     ];
   }
 }

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

@@ -1,12 +1,47 @@
-import { takaro, data } from '@takaro/helpers';
+import { data, takaro } from '@takaro/helpers';
 
 async function main() {
-  const randomMessage =
-    data.module.userConfig.messages[Math.floor(Math.random() * data.module.userConfig.messages.length)];
+  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: randomMessage,
+    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/timedShutdown/cronJobs/Shutdown.js

@@ -0,0 +1,8 @@
+import { data, takaro } from '@takaro/helpers';
+
+async function main() {
+  const { gameServerId } = data;
+  await takaro.gameserver.gameServerControllerShutdown(gameServerId);
+}
+
+await main();

package/src/modules/timedShutdown/cronJobs/warning.js

@@ -0,0 +1,13 @@
+import { data, takaro } from '@takaro/helpers';
+
+async function main() {
+  const { gameServerId } = data;
+
+  const msg = data.module.userConfig.warningMessage;
+
+  await takaro.gameserver.gameServerControllerSendMessage(gameServerId, {
+    message: msg,
+  });
+}
+
+await main();

package/src/modules/timedShutdown/index.ts

@@ -0,0 +1,38 @@
+import { BuiltinModule, ICronJob } from '../../BuiltinModule.js';
+
+export class TimedShutdown extends BuiltinModule<TimedShutdown> {
+  constructor() {
+    super(
+      'timedShutdown',
+      'Automatically shut down the server at a specific time.',
+      JSON.stringify({
+        $schema: 'http://json-schema.org/draft-07/schema#',
+        type: 'object',
+        properties: {
+          warningMessage: {
+            type: 'string',
+            title: 'Warning message',
+            description: 'Message to send to players before the server shuts down.',
+            default: 'Server is shutting down in 5 minutes!',
+            minLength: 1,
+            maxLength: 1024,
+          },
+        },
+        required: ['warningMessage'],
+      }),
+    );
+
+    this.cronJobs = [
+      new ICronJob({
+        name: 'Shutdown',
+        temporalValue: '3 30 * * *',
+        function: this.loadFn('cronJobs', 'Shutdown'),
+      }),
+      new ICronJob({
+        name: 'warning',
+        temporalValue: '3 25 * * *',
+        function: this.loadFn('cronJobs', 'warning'),
+      }),
+    ];
+  }
+}