@takaro/modules 0.0.0-next.0da151e

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

@@ -0,0 +1,29 @@
+import { takaro, data } from '@takaro/helpers';
+
+async function main() {
+  const richest = (
+    await takaro.playerOnGameserver.playerOnGameServerControllerSearch({
+      limit: 10,
+      sortBy: 'currency',
+      sortDirection: 'desc',
+      extend: ['player'],
+    })
+  ).data.data;
+
+  const currencyName = (await takaro.settings.settingsControllerGetOne('currencyName', data.gameServerId)).data.data
+    .value;
+
+  // TODO: change this to name when it become available in playerOnGameServer
+  const richestStrings = richest.map(async (pog, index) => {
+    const playerName = (await takaro.player.playerControllerGetOne(pog.playerId)).data.data.name;
+    return `${index + 1}. ${playerName} - ${pog.currency} ${currencyName}`;
+  });
+
+  await data.player.pm('Richest players:');
+
+  for (const string of richestStrings) {
+    await data.player.pm(await string);
+  }
+}
+
+await main();

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

@@ -0,0 +1,73 @@
+import { takaro, data, TakaroUserError } from '@takaro/helpers';
+
+async function main() {
+  const { pog: sender, arguments: args, gameServerId, module: mod } = data;
+
+  const currencyName = (await takaro.settings.settingsControllerGetOne('currencyName', gameServerId)).data.data.value;
+
+  const prefix = (await takaro.settings.settingsControllerGetOne('commandPrefix', gameServerId)).data.data.value;
+
+  // args.receiver has an argument type of "player". Arguments of this type are automatically resolved to the player's id.
+  // If the player doesn't exist or multiple players with the same name where found, it will have thrown an error before this command is executed.
+  const receiver = args.receiver;
+  const senderName = (await takaro.player.playerControllerGetOne(sender.playerId)).data.data.name;
+  const receiverName = (await takaro.player.playerControllerGetOne(receiver.playerId)).data.data.name;
+
+  if (mod.userConfig.pendingAmount !== 0 && args.amount >= mod.userConfig.pendingAmount) {
+    // create a variable to store confirmation requirement
+    // TODO: in the future, we should probably add an expiration date to this variable.
+    await takaro.variable.variableControllerCreate({
+      key: 'confirmTransfer',
+      value: JSON.stringify({
+        amount: args.amount,
+        receiver: {
+          id: receiver.id,
+          gameId: receiver.gameId,
+          playerId: receiver.playerId,
+        },
+      }),
+      moduleId: mod.moduleId,
+      playerId: sender.playerId,
+      gameServerId,
+    });
+
+    // NOTE: we should maybe check if the player has enough balance to send the amount since this is only checked when the transaction is executed.
+    await sender.pm(
+      `You are about to send ${args.amount} ${currencyName} to ${receiverName}. (Please confirm by typing ${prefix}confirmtransfer)`,
+    );
+    return;
+  }
+
+  try {
+    await takaro.playerOnGameserver.playerOnGameServerControllerTransactBetweenPlayers(
+      sender.gameServerId,
+      sender.id,
+      receiver.id,
+      {
+        currency: args.amount,
+      },
+    );
+  } catch {
+    throw new TakaroUserError(
+      `Failed to transfer ${args.amount} ${currencyName} to ${receiverName}. Are you sure you have enough balance?`,
+    );
+  }
+
+  const messageToReceiver = takaro.gameserver.gameServerControllerSendMessage(gameServerId, {
+    message: `You received ${args.amount} ${currencyName} from ${senderName}`,
+    opts: {
+      recipient: {
+        gameId: receiver.gameId,
+      },
+    },
+  });
+
+  await Promise.all([
+    sender.pm(`You successfully transferred ${args.amount} ${currencyName} to ${receiverName}`),
+    messageToReceiver,
+  ]);
+
+  return;
+}
+
+await main();

package/src/modules/economyUtils/cronJobs/zombieKillReward.js

@@ -0,0 +1,82 @@
+import { data, takaro, checkPermission } from '@takaro/helpers';
+
+const VARIABLE_KEY = 'lastZombieKillReward';
+
+async function main() {
+  const { gameServerId, module: mod } = data;
+
+  const lastRunRes = (
+    await takaro.variable.variableControllerSearch({
+      filters: {
+        key: [VARIABLE_KEY],
+        gameServerId: [gameServerId],
+        moduleId: [mod.moduleId],
+      },
+    })
+  ).data.data;
+
+  // We last ran the rewards script at this time
+  // If this is the first time we run it, just get the last 5 minutes
+  const lastRun = lastRunRes.length ? new Date(JSON.parse(lastRunRes[0].value)) : new Date(Date.now() - 5 * 60 * 1000);
+
+  // Fetch all the kill events since the last time we gave out rewards
+  const killEvents = (
+    await takaro.event.eventControllerSearch({
+      filters: { eventName: ['entity-killed'], gameserverId: [gameServerId] },
+      greaterThan: { createdAt: lastRun.toISOString() },
+      limit: 1000,
+    })
+  ).data.data;
+
+  console.log(`Found ${killEvents.length} kill events since ${lastRun.toISOString()}`);
+
+  // Group the events by player
+  const playerKills = {};
+  for (const killEvent of killEvents) {
+    if (!playerKills[killEvent.playerId]) {
+      playerKills[killEvent.playerId] = [];
+    }
+
+    playerKills[killEvent.playerId].push(killEvent);
+  }
+
+  // Give each player their reward
+  // We use Promise.allSettled to run this concurrently
+  const results = await Promise.allSettled(
+    Object.entries(playerKills).map(async ([playerId, kills]) => {
+      const pog = (await takaro.playerOnGameserver.playerOnGameServerControllerGetOne(gameServerId, playerId)).data
+        .data;
+      const hasPermission = checkPermission(pog, 'ZOMBIE_KILL_REWARD_OVERRIDE');
+      const defaultReward = mod.userConfig.zombieKillReward;
+      const reward = hasPermission && hasPermission.count != null ? hasPermission.count : defaultReward;
+      const totalReward = reward * kills.length;
+      return takaro.playerOnGameserver.playerOnGameServerControllerAddCurrency(gameServerId, playerId, {
+        currency: totalReward,
+      });
+    }),
+  );
+
+  // Log any errors
+  for (const result of results) {
+    if (result.status === 'rejected') {
+      console.error(result.reason);
+      throw new Error(`Failed to give rewards: ${result.reason}`);
+    }
+  }
+
+  // Update the last run time
+  if (lastRunRes.length) {
+    await takaro.variable.variableControllerUpdate(lastRunRes[0].id, {
+      value: JSON.stringify(new Date()),
+    });
+  } else {
+    await takaro.variable.variableControllerCreate({
+      key: VARIABLE_KEY,
+      value: JSON.stringify(new Date()),
+      moduleId: mod.moduleId,
+      gameServerId,
+    });
+  }
+}
+
+await main();

package/src/modules/economyUtils/index.ts

@@ -0,0 +1,197 @@
+import { ModuleTransferDTO, ICommand, ICronJob, IPermission, ModuleTransferVersionDTO } from '../../BuiltinModule.js';
+
+export class EconomyUtils extends ModuleTransferDTO<EconomyUtils> {
+  constructor() {
+    super();
+
+    this.name = 'economyUtils';
+    this.author = 'Takaro';
+    this.supportedGames = ['all'];
+    this.versions = [
+      new ModuleTransferVersionDTO({
+        tag: '0.0.3',
+        description: 'A set of commands to allow players to manage their currency.',
+        configSchema: JSON.stringify({
+          $schema: 'http://json-schema.org/draft-07/schema#',
+          type: 'object',
+          properties: {
+            pendingAmount: {
+              title: 'Pending amount',
+              type: 'number',
+              description:
+                'When a player transfers money, they must confirm the transfer when the amount is equal or above this value. Set to 0 to disable.',
+              default: 0,
+            },
+            zombieKillReward: {
+              title: 'Zombie kill reward',
+              type: 'number',
+              description:
+                'The default amount of currency a player receives for killing a zombie. This can be overridden by roles.',
+              default: 1,
+            },
+          },
+          required: [],
+          additionalProperties: false,
+        }),
+        permissions: [
+          new IPermission({
+            permission: 'ECONOMY_UTILS_MANAGE_CURRENCY',
+            friendlyName: 'Manage currency',
+            description:
+              'Allows players to manage currency of other players. This includes granting and revoking currency.',
+            canHaveCount: false,
+          }),
+          new IPermission({
+            permission: 'ZOMBIE_KILL_REWARD_OVERRIDE',
+            friendlyName: 'Zombie kill reward override',
+            description: 'Allows a role to override the amount of currency a player receives for killing a entity.',
+            canHaveCount: true,
+          }),
+        ],
+        cronJobs: [
+          new ICronJob({
+            function: this.loadFn('cronJobs', 'zombieKillReward'),
+            name: 'zombieKillReward',
+            temporalValue: '*/5 * * * *',
+          }),
+        ],
+
+        commands: [
+          new ICommand({
+            function: this.loadFn('commands', 'balance'),
+            name: 'balance',
+            trigger: 'balance',
+            helpText: 'Check your balance.',
+            arguments: [],
+          }),
+          new ICommand({
+            function: this.loadFn('commands', 'topCurrency'),
+            name: 'topCurrency',
+            trigger: 'topcurrency',
+            helpText: 'List of the 10 players with the highest balance.',
+            arguments: [],
+          }),
+          new ICommand({
+            function: this.loadFn('commands', 'grantCurrency'),
+            name: 'grantCurrency',
+            trigger: 'grantcurrency',
+            helpText: 'Grant money to a player. The money is not taken from your own balance but is new currency.',
+            requiredPermissions: ['ECONOMY_UTILS_MANAGE_CURRENCY'],
+            arguments: [
+              {
+                name: 'receiver',
+                type: 'player',
+                helpText: 'The player to grant currency to.',
+                position: 0,
+                defaultValue: null,
+              },
+              {
+                name: 'amount',
+                type: 'number',
+                helpText: 'The amount of money.',
+                position: 1,
+                defaultValue: null,
+              },
+            ],
+          }),
+          new ICommand({
+            function: this.loadFn('commands', 'revokeCurrency'),
+            name: 'revokeCurrency',
+            trigger: 'revokecurrency',
+            helpText: 'Revokes money from a player. The money disappears.',
+            requiredPermissions: ['ECONOMY_UTILS_MANAGE_CURRENCY'],
+            arguments: [
+              {
+                name: 'receiver',
+                type: 'player',
+                helpText: 'The player to revoke currency from.',
+                position: 0,
+                defaultValue: null,
+              },
+              {
+                name: 'amount',
+                type: 'number',
+                helpText: 'The amount of money.',
+                position: 1,
+                defaultValue: null,
+              },
+            ],
+          }),
+          new ICommand({
+            function: this.loadFn('commands', 'confirmTransfer'),
+            name: 'confirmTransfer',
+            trigger: 'confirmtransfer',
+            helpText: 'Confirms a pending transfer.',
+            arguments: [],
+          }),
+          new ICommand({
+            function: this.loadFn('commands', 'transfer'),
+            name: 'transfer',
+            trigger: 'transfer',
+            helpText: 'Transfer money to another player.',
+            arguments: [
+              {
+                name: 'receiver',
+                type: 'player',
+                helpText: 'The player to transfer money to.',
+                position: 0,
+                defaultValue: null,
+              },
+              {
+                name: 'amount',
+                type: 'number',
+                helpText: 'The amount of money to transfer.',
+                position: 1,
+                defaultValue: null,
+              },
+            ],
+          }),
+          new ICommand({
+            function: this.loadFn('commands', 'claim'),
+            name: 'claim',
+            trigger: 'claim',
+            helpText: 'Claim your pending shop orders.',
+            arguments: [
+              {
+                name: 'all',
+                type: 'boolean',
+                helpText: 'If true, claim ALL pending orders. If false, claim only the first one.',
+                position: 0,
+                defaultValue: 'false',
+              },
+            ],
+          }),
+          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/geoBlock/hooks/IPDetected.js

@@ -0,0 +1,53 @@
+import { takaro, data, checkPermission } from '@takaro/helpers';
+
+async function main() {
+  const { gameServerId, player, pog } = data;
+  const { country } = data.eventData;
+  const { ban, banDuration, countries, message, mode } = data.module.userConfig;
+
+  async function handleAction() {
+    if (ban) {
+      const now = new Date();
+      const expiresAt = new Date(now.getTime() + banDuration * 1000);
+      await takaro.player.banControllerCreate({
+        gameServerId,
+        playerId: player.id,
+        until: expiresAt,
+        reason: message,
+      });
+    } else {
+      await takaro.gameserver.gameServerControllerKickPlayer(gameServerId, player.id, {
+        reason: message,
+      });
+    }
+  }
+
+  const isImmune = checkPermission(pog, 'GEOBLOCK_IMMUNITY');
+  if (isImmune) {
+    console.log('Player has immunity, no action');
+    return;
+  }
+
+  if (mode === 'allow') {
+    if (countries.includes(country)) {
+      console.log('Allowed country detected, no action');
+      return;
+    }
+    console.log('Blocked country detected, performing actions');
+    await handleAction();
+    return;
+  }
+
+  if (mode === 'deny') {
+    if (countries.includes(country)) {
+      console.log('Blocked country detected, performing actions');
+      await handleAction();
+      return;
+    } else {
+      console.log('Allowed country detected, no action');
+      return;
+    }
+  }
+}
+
+await main();