@takaro/modules 0.0.13 → 0.0.15

package/src/modules/dailyRewards/hooks/dailyLoginCheck.js

@@ -0,0 +1,24 @@
+import { data, takaro } from '@takaro/helpers';
+import { getLastClaim } from './utils.js';
+
+async function main() {
+  const { pog, gameServerId, module: mod } = data;
+  const prefix = (await takaro.settings.settingsControllerGetOne('commandPrefix', gameServerId)).data.data.value;
+
+  const lastClaim = await getLastClaim(gameServerId, pog.playerId, mod.moduleId);
+
+  // First time player
+  if (!lastClaim) {
+    await pog.pm(`Welcome! Use ${prefix}daily to claim your first daily reward and start your streak!`);
+    return;
+  }
+
+  const now = new Date();
+  const nextClaimTime = new Date(lastClaim.getTime() + 24 * 60 * 60 * 1000);
+
+  if (now >= nextClaimTime) {
+    await pog.pm(`Your daily reward is ready! Use ${prefix}daily to claim it!`);
+  }
+}
+
+await main();

package/src/modules/dailyRewards/index.ts

@@ -0,0 +1,126 @@
+/* eslint-disable quotes */
+import { BuiltinModule, ICommand, IFunction, IHook, IPermission } from '../../BuiltinModule.js';
+
+export class DailyRewards extends BuiltinModule<DailyRewards> {
+  constructor() {
+    super(
+      'dailyRewards',
+      'Provides daily login rewards with streak tracking',
+      JSON.stringify({
+        $schema: 'http://json-schema.org/draft-07/schema#',
+        type: 'object',
+        properties: {
+          baseReward: {
+            type: 'number',
+            title: 'Base Reward',
+            description: 'Base amount of currency given for daily rewards. This is multiplied by streak level.',
+            default: 100,
+            minimum: 1,
+          },
+          maxStreak: {
+            type: 'number',
+            title: 'Maximum Streak',
+            description: 'Maximum streak level a player can reach',
+            default: 365,
+            minimum: 1,
+          },
+          milestoneRewards: {
+            type: 'array',
+            title: 'Milestone Rewards',
+            description: 'Additional rewards for reaching certain streak milestones',
+            items: {
+              type: 'object',
+              properties: {
+                days: {
+                  type: 'number',
+                  description: 'Days needed to reach milestone',
+                  minimum: 1,
+                },
+                reward: {
+                  type: 'number',
+                  description: 'Bonus reward amount',
+                },
+                message: {
+                  type: 'string',
+                  description: 'Message to show when milestone is reached',
+                },
+              },
+            },
+            default: [
+              { days: 7, reward: 1000, message: 'You did it! 7 days in a row!' },
+              { days: 30, reward: 5000, message: "A whole month! You're on fire!" },
+              { days: 90, reward: 20000, message: "90 days! You're unstoppable!" },
+              { days: 180, reward: 50000, message: "Half a year! You're a legend!" },
+              { days: 365, reward: 150000, message: "365 days! You're a true champion!" },
+            ],
+          },
+        },
+        required: ['baseReward', 'maxStreak', 'milestoneRewards'],
+        additionalProperties: false,
+      }),
+    );
+
+    this.functions = [
+      new IFunction({
+        name: 'utils',
+        function: this.loadFn('functions', 'utils'),
+      }),
+    ];
+
+    this.permissions = [
+      new IPermission({
+        permission: 'DAILY_CLAIM',
+        friendlyName: 'Claim Daily Rewards',
+        description: 'Allows the player to claim daily rewards',
+        canHaveCount: false,
+      }),
+      new IPermission({
+        permission: 'DAILY_REWARD_MULTIPLIER',
+        friendlyName: 'Multiplier',
+        description:
+          'Control the multiplier per role. This is useful to give your donors a little extra. Count is an integer multiplier.',
+        canHaveCount: true,
+      }),
+    ];
+
+    this.commands = [
+      new ICommand({
+        function: this.loadFn('commands', 'daily'),
+        name: 'daily',
+        trigger: 'daily',
+        helpText: 'Claim your daily reward',
+        arguments: [],
+      }),
+      new ICommand({
+        function: this.loadFn('commands', 'streak'),
+        name: 'streak',
+        trigger: 'streak',
+        helpText: 'Check your current daily reward streak and next claim time',
+        arguments: [],
+      }),
+      new ICommand({
+        function: this.loadFn('commands', 'topstreak'),
+        name: 'topstreak',
+        trigger: 'topstreak',
+        helpText: 'Shows the players with highest daily reward streaks',
+        arguments: [
+          {
+            name: 'count',
+            type: 'number',
+            defaultValue: '5',
+            helpText: 'Number of players to show (max 25)',
+            position: 0,
+          },
+        ],
+      }),
+    ];
+
+    this.hooks = [
+      new IHook({
+        eventType: 'player-connected',
+        name: 'dailyLoginCheck',
+        function: this.loadFn('hooks', 'dailyLoginCheck'),
+      }),
+    ];
+  }
+}

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

@@ -1,7 +1,7 @@
 import { takaro, data, TakaroUserError } from '@takaro/helpers';
 
 async function main() {
-  const { arguments: args, player, gameServerId, user } = data;
+  const { arguments: args, player, gameServerId } = data;
   const { page, item, action } = args;
   const prefix = (await takaro.settings.settingsControllerGetOne('commandPrefix', gameServerId)).data.data.value;
 
@@ -35,12 +35,14 @@ async function main() {
   const currencyName = (await takaro.settings.settingsControllerGetOne('currencyName', data.gameServerId)).data.data;
 
   if (!item) {
-    // List the shop items
+    // List the shop items with index
+    let index = 1;
     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(', ')}`);
+      await player.pm(`${index} - ${listing.name} - ${listing.price} ${currencyName.value}. ${items.join(', ')}`);
+      index++;
     }
     return;
   }
@@ -69,12 +71,10 @@ async function main() {
   }
 
   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,
+      playerId: player.id,
     });
     await player.pm(`You have purchased ${selectedItem.name} for ${selectedItem.price} ${currencyName.value}.`);
     await takaro.shopOrder.shopOrderControllerClaim(orderRes.data.data.id);

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

@@ -1,4 +1,4 @@
-import { BuiltinModule, ICommand, IPermission } from '../../BuiltinModule.js';
+import { BuiltinModule, ICommand, ICronJob, IPermission } from '../../BuiltinModule.js';
 
 export class EconomyUtils extends BuiltinModule<EconomyUtils> {
   constructor() {
@@ -16,6 +16,13 @@ export class EconomyUtils extends BuiltinModule<EconomyUtils> {
               '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,
@@ -30,6 +37,20 @@ export class EconomyUtils extends BuiltinModule<EconomyUtils> {
           '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,
+      }),
+    ];
+
+    this.cronJobs = [
+      new ICronJob({
+        function: this.loadFn('cronJobs', 'zombieKillReward'),
+        name: 'zombieKillReward',
+        temporalValue: '*/5 * * * *',
+      }),
     ];
 
     this.commands = [
@@ -73,7 +94,7 @@ export class EconomyUtils extends BuiltinModule<EconomyUtils> {
         function: this.loadFn('commands', 'revokeCurrency'),
         name: 'revokeCurrency',
         trigger: 'revokecurrency',
-        helpText: 'Grant money to a player. The money is not taken from your own balance but is new currency.',
+        helpText: 'Revokes money from a player. The money disappears.',
         arguments: [
           {
             name: 'receiver',

package/src/modules/geoBlock/hooks/IPDetected.js

@@ -9,9 +9,11 @@ async function main() {
     if (ban) {
       const now = new Date();
       const expiresAt = new Date(now.getTime() + banDuration * 1000);
-      await takaro.gameserver.gameServerControllerBanPlayer(gameServerId, player.id, {
+      await takaro.player.banControllerCreate({
+        gameServerId,
+        playerId: player.id,
+        until: expiresAt,
         reason: message,
-        expiresAt,
       });
     } else {
       await takaro.gameserver.gameServerControllerKickPlayer(gameServerId, player.id, {

package/src/modules/gimme/commands/gimme.js

@@ -15,12 +15,22 @@ async function main() {
   const randomOption = items.concat(commands)[randomIndex];
 
   if (randomIndex < items.length) {
-    await takaro.gameserver.gameServerControllerGiveItem(data.gameServerId, data.player.id, {
-      name: randomOption,
-      amount: 1,
-      quality: 0,
-    });
-    await data.player.pm(`You received ${randomOption}!`);
+    if (typeof randomOption === 'string') {
+      await takaro.gameserver.gameServerControllerGiveItem(data.gameServerId, data.player.id, {
+        name: randomOption,
+        amount: 1,
+        quality: '0',
+      });
+      await data.player.pm(`You received ${randomOption}!`);
+    } else {
+      const item = (await takaro.item.itemControllerFindOne(randomOption.item)).data.data;
+      await takaro.gameserver.gameServerControllerGiveItem(data.gameServerId, data.player.id, {
+        name: item.code,
+        amount: randomOption.amount,
+        quality: randomOption.quality ?? '',
+      });
+      await data.player.pm(`You received ${randomOption.amount}x ${item.name}!`);
+    }
   } else {
     await takaro.gameserver.gameServerControllerExecuteCommand(data.gameServerId, { command: randomOption });
   }

package/src/modules/gimme/index.ts

@@ -16,7 +16,22 @@ export class Gimme extends BuiltinModule<Gimme> {
             description: 'List of items that a player can receive.',
             uniqueItems: true,
             items: {
-              type: 'string',
+              type: 'object',
+              title: 'Item',
+              properties: {
+                item: {
+                  type: 'string',
+                  title: 'Item',
+                },
+                amount: {
+                  type: 'number',
+                  title: 'Amount',
+                },
+                quality: {
+                  type: 'string',
+                  title: 'Quality',
+                },
+              },
             },
           },
           commands: {
@@ -32,7 +47,13 @@ export class Gimme extends BuiltinModule<Gimme> {
         additionalProperties: false,
       }),
       JSON.stringify({
-        items: { 'ui:widget': 'item' },
+        items: {
+          items: {
+            item: {
+              'ui:widget': 'item',
+            },
+          },
+        },
       }),
     );
 

package/src/modules/playerOnboarding/commands/starterkit.js

@@ -7,7 +7,7 @@ async function main() {
 
   if (!items || items.length === 0) {
     throw new TakaroUserError(
-      'No starter kit items configured. Please ask your server administrator to configure this.'
+      'No starter kit items configured. Please ask your server administrator to configure this.',
     );
   }
 
@@ -25,13 +25,27 @@ async function main() {
 
   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 {
+      code: itemRecord.code,
+      quality: item.quality,
+      amount: item.amount,
+    };
+  });
+
   await Promise.all(
-    items.map(async (item) => {
+    fullItems.map(async (item) => {
       return takaro.gameserver.gameServerControllerGiveItem(data.gameServerId, data.player.id, {
-        name: item,
-        amount: 1,
+        name: item.code,
+        quality: item.quality ?? '',
+        amount: item.amount,
       });
-    })
+    }),
   );
 
   await takaro.variable.variableControllerCreate({

package/src/modules/playerOnboarding/index.ts

@@ -20,13 +20,28 @@ export class PlayerOnboarding extends BuiltinModule<PlayerOnboarding> {
           },
           starterKitItems: {
             type: 'array',
-            'x-component': 'item',
             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: 'string',
+              type: 'object',
+              title: 'Item',
+              properties: {
+                item: {
+                  type: 'string',
+                  title: 'Item',
+                },
+                amount: {
+                  type: 'number',
+                  title: 'Amount',
+                },
+                quality: {
+                  type: 'string',
+                  title: 'Quality',
+                },
+              },
             },
           },
         },
@@ -34,7 +49,13 @@ export class PlayerOnboarding extends BuiltinModule<PlayerOnboarding> {
         additionalProperties: false,
       }),
       JSON.stringify({
-        starterKitItems: { 'ui:widget': 'item' },
+        starterKitItems: {
+          items: {
+            item: {
+              'ui:widget': 'item',
+            },
+          },
+        },
       }),
     );