@takaro/modules 0.0.13 → 0.0.15

package/src/__tests__/economy/zombieKillReward.integration.test.ts

@@ -0,0 +1,296 @@
+import { EventsAwaiter, expect, IntegrationTest, IShopSetup, shopSetup } from '@takaro/test';
+import { HookEvents } from '../../dto/index.js';
+import { Client, PlayerOutputDTO } from '@takaro/apiclient';
+
+const group = 'EconomyUtils:ZombieKillReward';
+
+async function triggerKills(client: Client, player: PlayerOutputDTO, gameServerId: string, count: number) {
+  const events = (await new EventsAwaiter().connect(client)).waitForEvents(HookEvents.ENTITY_KILLED, count);
+
+  if (!player.playerOnGameServers) throw new Error('Player has no pogs');
+  const pog = player.playerOnGameServers.find((pog) => pog.gameServerId === gameServerId);
+  if (!pog) throw new Error('Player not found on game server');
+
+  await Promise.all(
+    Array.from({ length: count }, () => {
+      return client.gameserver.gameServerControllerExecuteCommand(gameServerId, {
+        command: `triggerKill ${pog.gameId}`,
+      });
+    }),
+  );
+
+  await events;
+  return events;
+}
+
+const tests = [
+  new IntegrationTest<IShopSetup>({
+    group,
+    snapshot: false,
+    setup: shopSetup,
+    name: 'Simple happy path, killing one zombie gives one currency',
+    test: async function () {
+      const pogBefore = (
+        await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(
+          this.setupData.gameserver.id,
+          this.setupData.players[0].id,
+        )
+      ).data.data;
+
+      (
+        await this.client.gameserver.gameServerControllerInstallModule(
+          this.setupData.gameserver.id,
+          this.setupData.economyUtilsModule.id,
+        )
+      ).data.data;
+      const zombieKillCronjob = this.setupData.economyUtilsModule.cronJobs.find(
+        (cronjob) => cronjob.name === 'zombieKillReward',
+      );
+      if (!zombieKillCronjob) throw new Error('Cronjob not found');
+      await triggerKills(this.client, this.setupData.players[0], this.setupData.gameserver.id, 1);
+      await this.client.cronjob.cronJobControllerTrigger({
+        gameServerId: this.setupData.gameserver.id,
+        moduleId: this.setupData.economyUtilsModule.id,
+        cronjobId: zombieKillCronjob.id,
+      });
+
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.CRONJOB_EXECUTED, 1);
+      await events;
+
+      const pogAfter = (
+        await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(
+          this.setupData.gameserver.id,
+          this.setupData.players[0].id,
+        )
+      ).data.data;
+      expect(pogAfter.currency).to.equal(pogBefore.currency + 1);
+    },
+  }),
+  /**
+   * First kill 3 zombies, then trigger the cronjob
+   * Check if the player has 3 currency
+   * Then kill 4 zombies
+   * Check if the player has 7 currency
+   */
+  new IntegrationTest<IShopSetup>({
+    group,
+    snapshot: false,
+    setup: shopSetup,
+    name: 'Killing multiple zombies',
+    test: async function () {
+      const pogBefore = (
+        await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(
+          this.setupData.gameserver.id,
+          this.setupData.players[0].id,
+        )
+      ).data.data;
+
+      (
+        await this.client.gameserver.gameServerControllerInstallModule(
+          this.setupData.gameserver.id,
+          this.setupData.economyUtilsModule.id,
+        )
+      ).data.data;
+      const zombieKillCronjob = this.setupData.economyUtilsModule.cronJobs.find(
+        (cronjob) => cronjob.name === 'zombieKillReward',
+      );
+      if (!zombieKillCronjob) throw new Error('Cronjob not found');
+      await triggerKills(this.client, this.setupData.players[0], this.setupData.gameserver.id, 3);
+      await this.client.cronjob.cronJobControllerTrigger({
+        gameServerId: this.setupData.gameserver.id,
+        moduleId: this.setupData.economyUtilsModule.id,
+        cronjobId: zombieKillCronjob.id,
+      });
+
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.CRONJOB_EXECUTED, 1);
+      await events;
+
+      let pogAfter = (
+        await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(
+          this.setupData.gameserver.id,
+          this.setupData.players[0].id,
+        )
+      ).data.data;
+      expect(pogAfter.currency).to.equal(pogBefore.currency + 3);
+
+      await triggerKills(this.client, this.setupData.players[0], this.setupData.gameserver.id, 4);
+      await this.client.cronjob.cronJobControllerTrigger({
+        gameServerId: this.setupData.gameserver.id,
+        moduleId: this.setupData.economyUtilsModule.id,
+        cronjobId: zombieKillCronjob.id,
+      });
+
+      const events2 = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.CRONJOB_EXECUTED, 1);
+      await events2;
+
+      pogAfter = (
+        await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(
+          this.setupData.gameserver.id,
+          this.setupData.players[0].id,
+        )
+      ).data.data;
+      expect(pogAfter.currency).to.equal(pogBefore.currency + 7);
+    },
+  }),
+  new IntegrationTest<IShopSetup>({
+    group,
+    snapshot: false,
+    setup: shopSetup,
+    name: 'Different players killing zombies assigns the right amount to the right players',
+    test: async function () {
+      const pogBefore1 = (
+        await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(
+          this.setupData.gameserver.id,
+          this.setupData.players[0].id,
+        )
+      ).data.data;
+      const pogBefore2 = (
+        await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(
+          this.setupData.gameserver.id,
+          this.setupData.players[1].id,
+        )
+      ).data.data;
+
+      (
+        await this.client.gameserver.gameServerControllerInstallModule(
+          this.setupData.gameserver.id,
+          this.setupData.economyUtilsModule.id,
+        )
+      ).data.data;
+      const zombieKillCronjob = this.setupData.economyUtilsModule.cronJobs.find(
+        (cronjob) => cronjob.name === 'zombieKillReward',
+      );
+      if (!zombieKillCronjob) throw new Error('Cronjob not found');
+      await triggerKills(this.client, this.setupData.players[0], this.setupData.gameserver.id, 3);
+      await triggerKills(this.client, this.setupData.players[1], this.setupData.gameserver.id, 4);
+      await this.client.cronjob.cronJobControllerTrigger({
+        gameServerId: this.setupData.gameserver.id,
+        moduleId: this.setupData.economyUtilsModule.id,
+        cronjobId: zombieKillCronjob.id,
+      });
+
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.CRONJOB_EXECUTED, 1);
+      await events;
+
+      const pogAfter1 = (
+        await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(
+          this.setupData.gameserver.id,
+          this.setupData.players[0].id,
+        )
+      ).data.data;
+      const pogAfter2 = (
+        await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(
+          this.setupData.gameserver.id,
+          this.setupData.players[1].id,
+        )
+      ).data.data;
+      expect(pogAfter1.currency).to.equal(pogBefore1.currency + 3);
+      expect(pogAfter2.currency).to.equal(pogBefore2.currency + 4);
+    },
+  }),
+  new IntegrationTest<IShopSetup>({
+    group,
+    snapshot: false,
+    setup: shopSetup,
+    name: 'Can configure a custom amount of currency per kill',
+    test: async function () {
+      const pogBefore = (
+        await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(
+          this.setupData.gameserver.id,
+          this.setupData.players[0].id,
+        )
+      ).data.data;
+      (
+        await this.client.gameserver.gameServerControllerInstallModule(
+          this.setupData.gameserver.id,
+          this.setupData.economyUtilsModule.id,
+          {
+            userConfig: JSON.stringify({ zombieKillReward: 5 }),
+          },
+        )
+      ).data.data;
+      const zombieKillCronjob = this.setupData.economyUtilsModule.cronJobs.find(
+        (cronjob) => cronjob.name === 'zombieKillReward',
+      );
+      if (!zombieKillCronjob) throw new Error('Cronjob not found');
+      await triggerKills(this.client, this.setupData.players[0], this.setupData.gameserver.id, 1);
+      await this.client.cronjob.cronJobControllerTrigger({
+        gameServerId: this.setupData.gameserver.id,
+        moduleId: this.setupData.economyUtilsModule.id,
+        cronjobId: zombieKillCronjob.id,
+      });
+
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.CRONJOB_EXECUTED, 1);
+      await events;
+
+      const pogAfter = (
+        await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(
+          this.setupData.gameserver.id,
+          this.setupData.players[0].id,
+        )
+      ).data.data;
+      expect(pogAfter.currency).to.equal(pogBefore.currency + 5);
+    },
+  }),
+  new IntegrationTest<IShopSetup>({
+    group,
+    snapshot: false,
+    setup: shopSetup,
+    name: 'Can override amount earned per role',
+    test: async function () {
+      const zombieKillEarnerPermission = await this.client.permissionCodesToInputs(['ZOMBIE_KILL_REWARD_OVERRIDE']);
+      await this.client.role.roleControllerUpdate(this.setupData.role.id, {
+        permissions: [
+          {
+            permissionId: zombieKillEarnerPermission[0].permissionId,
+            count: 3,
+          },
+        ],
+      });
+
+      const pogBefore = (
+        await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(
+          this.setupData.gameserver.id,
+          this.setupData.players[0].id,
+        )
+      ).data.data;
+      (
+        await this.client.gameserver.gameServerControllerInstallModule(
+          this.setupData.gameserver.id,
+          this.setupData.economyUtilsModule.id,
+          {
+            userConfig: JSON.stringify({ zombieKillReward: 5 }),
+          },
+        )
+      ).data.data;
+
+      const zombieKillCronjob = this.setupData.economyUtilsModule.cronJobs.find(
+        (cronjob) => cronjob.name === 'zombieKillReward',
+      );
+      if (!zombieKillCronjob) throw new Error('Cronjob not found');
+      await triggerKills(this.client, this.setupData.players[0], this.setupData.gameserver.id, 1);
+      await this.client.cronjob.cronJobControllerTrigger({
+        gameServerId: this.setupData.gameserver.id,
+        moduleId: this.setupData.economyUtilsModule.id,
+        cronjobId: zombieKillCronjob.id,
+      });
+
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(HookEvents.CRONJOB_EXECUTED, 1);
+      await events;
+
+      const pogAfter = (
+        await this.client.playerOnGameserver.playerOnGameServerControllerGetOne(
+          this.setupData.gameserver.id,
+          this.setupData.players[0].id,
+        )
+      ).data.data;
+      expect(pogAfter.currency).to.equal(pogBefore.currency + 3);
+    },
+  }),
+];
+
+describe(group, function () {
+  tests.forEach((test) => {
+    test.run();
+  });
+});

package/src/__tests__/gimme.integration.test.ts

@@ -1,5 +1,6 @@
 import { IntegrationTest, expect, IModuleTestsSetupData, modulesTestSetup, EventsAwaiter } from '@takaro/test';
 import { GameEvents } from '../dto/index.js';
+import { faker } from '@faker-js/faker';
 
 const group = 'gimme suite';
 
@@ -10,12 +11,17 @@ const tests = [
     setup: modulesTestSetup,
     name: 'Can give an item to a player',
     test: async function () {
+      const items = (await this.client.item.itemControllerSearch()).data.data;
       await this.client.gameserver.gameServerControllerInstallModule(
         this.setupData.gameserver.id,
         this.setupData.gimmeModule.id,
         {
           userConfig: JSON.stringify({
-            items: ['apple', 'banana', 'orange'],
+            items: items.map((item) => ({
+              item: item.id,
+              amount: faker.number.int({ min: 1, max: 10 }),
+              quality: faker.number.int({ min: 1, max: 6 }).toString(),
+            })),
             commands: [],
           }),
         },
@@ -28,7 +34,7 @@ const tests = [
       });
 
       expect((await events).length).to.be.eq(1);
-      expect((await events)[0].data.meta.msg).to.match(/You received (apple|banana|orange)/);
+      expect((await events)[0].data.meta.msg).to.match(/You received \dx \w/);
     },
   }),
   /*   new IntegrationTest<IModuleTestsSetupData>({

package/src/__tests__/onboarding.integration.test.ts

@@ -1,11 +1,12 @@
 import { IntegrationTest, expect, IModuleTestsSetupData, modulesTestSetup, EventsAwaiter } from '@takaro/test';
-import { EventPlayerConnected, GameEvents } from '../dto/gameEvents.js';
+import { GameEvents } from '../dto/gameEvents.js';
 import { HookEvents } from '../main.js';
+import { faker } from '@faker-js/faker';
 
 const group = 'Onboarding';
 const groupStarterkit = 'Onboarding - Starterkit';
 
-const _tests = [
+const tests = [
   new IntegrationTest<IModuleTestsSetupData>({
     group,
     snapshot: false,
@@ -16,21 +17,14 @@ const _tests = [
         this.setupData.gameserver.id,
         this.setupData.onboardingModule.id,
       );
-      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE);
-      await this.client.hook.hookControllerTrigger({
-        gameServerId: this.setupData.gameserver.id,
-        playerId: this.setupData.players[0].id,
-        eventType: GameEvents.PLAYER_CONNECTED,
-        eventMeta: new EventPlayerConnected({
-          player: {
-            gameId: '1',
-          },
-          msg: 'Player connected',
-        }),
+      const events = (await new EventsAwaiter().connect(this.client)).waitForEvents(GameEvents.CHAT_MESSAGE, 5);
+      await this.client.gameserver.gameServerControllerExecuteCommand(this.setupData.gameserver.id, {
+        command: 'connectAll',
       });
 
-      expect((await events).length).to.be.eq(1);
-      expect((await events)[0].data.meta.msg).to.match(/Welcome .+ to the server!/);
+      expect((await events).length).to.be.eq(5);
+      // Expect all messages to match
+      expect((await events).every((event) => event.data.meta.msg.match(/Welcome .+ to the server!/))).to.be.true;
     },
   }),
   new IntegrationTest<IModuleTestsSetupData>({
@@ -39,12 +33,17 @@ const _tests = [
     setup: modulesTestSetup,
     name: 'Starterkit command gives the player items',
     test: async function () {
+      const items = (await this.client.item.itemControllerSearch()).data.data;
       await this.client.gameserver.gameServerControllerInstallModule(
         this.setupData.gameserver.id,
         this.setupData.onboardingModule.id,
         {
           userConfig: JSON.stringify({
-            starterKitItems: ['cigar'],
+            starterKitItems: items.map((item) => ({
+              item: item.id,
+              amount: faker.number.int({ min: 1, max: 6 }),
+              quality: faker.number.int({ min: 1, max: 6 }).toString(),
+            })),
           }),
         },
       );
@@ -64,12 +63,17 @@ const _tests = [
     setup: modulesTestSetup,
     name: 'Starterkit command can only be used once',
     test: async function () {
+      const items = (await this.client.item.itemControllerSearch()).data.data;
       await this.client.gameserver.gameServerControllerInstallModule(
         this.setupData.gameserver.id,
         this.setupData.onboardingModule.id,
         {
           userConfig: JSON.stringify({
-            starterKitItems: ['cigar'],
+            starterKitItems: items.map((item) => ({
+              item: item.id,
+              amount: faker.number.int({ min: 1, max: 6 }),
+              quality: faker.number.int({ min: 1, max: 6 }).toString(),
+            })),
           }),
         },
       );
@@ -114,9 +118,8 @@ const _tests = [
   }),
 ];
 
-// Temp disabled...
-/* describe(group, function () {
+describe(group, function () {
   tests.forEach((test) => {
     test.run();
   });
-}); */
+});

package/src/main.ts

@@ -1,5 +1,6 @@
 import { BuiltinModule } from './BuiltinModule.js';
 import { ChatBridge } from './modules/chatBridge/index.js';
+import { DailyRewards } from './modules/dailyRewards/index.js';
 import { EconomyUtils } from './modules/economyUtils/index.js';
 import { GeoBlock } from './modules/geoBlock/index.js';
 import { Gimme } from './modules/gimme/index.js';
@@ -30,6 +31,7 @@ export function getModules(): Array<BuiltinModule<unknown>> {
       new Lottery(),
       new GeoBlock(),
       new TimedShutdown(),
+      new DailyRewards(),
     ];
   }
 

package/src/modules/dailyRewards/commands/daily.js

@@ -0,0 +1,118 @@
+import { takaro, data, TakaroUserError, checkPermission } from '@takaro/helpers';
+import { DAILY_KEY, STREAK_KEY, getMultiplier } from './utils.js';
+
+async function main() {
+  const { pog, gameServerId, module: mod } = data;
+
+  if (!checkPermission(pog, 'DAILY_CLAIM')) {
+    throw new TakaroUserError('You do not have permission to claim daily rewards.');
+  }
+
+  // Get last claim time
+  const lastClaimRes = await takaro.variable.variableControllerSearch({
+    filters: {
+      key: [DAILY_KEY],
+      gameServerId: [gameServerId],
+      playerId: [pog.playerId],
+      moduleId: [mod.moduleId],
+    },
+  });
+
+  const now = new Date();
+  let streak = 1;
+
+  if (lastClaimRes.data.data.length > 0) {
+    const lastClaim = new Date(JSON.parse(lastClaimRes.data.data[0].value));
+    const hoursSinceLastClaim = (now - lastClaim) / (1000 * 60 * 60);
+
+    // Check if 24 hours have passed
+    if (hoursSinceLastClaim < 24) {
+      const nextClaimTime = new Date(lastClaim.getTime() + 24 * 60 * 60 * 1000);
+      throw new TakaroUserError(`You can claim your next reward at ${nextClaimTime.toLocaleString()}`);
+    }
+
+    // Get current streak
+    const streakRes = await takaro.variable.variableControllerSearch({
+      filters: {
+        key: [STREAK_KEY],
+        gameServerId: [gameServerId],
+        playerId: [pog.playerId],
+        moduleId: [mod.moduleId],
+      },
+    });
+
+    if (streakRes.data.data.length > 0) {
+      // If claimed within 48 hours, increment streak
+      if (hoursSinceLastClaim < 48) {
+        streak = Math.min(JSON.parse(streakRes.data.data[0].value) + 1, mod.userConfig.maxStreak);
+        await takaro.variable.variableControllerUpdate(streakRes.data.data[0].id, {
+          value: JSON.stringify(streak),
+        });
+      } else {
+        // Reset streak if more than 48 hours
+        await takaro.variable.variableControllerUpdate(streakRes.data.data[0].id, {
+          value: JSON.stringify(1),
+        });
+      }
+    } else {
+      // Create new streak record
+      await takaro.variable.variableControllerCreate({
+        key: STREAK_KEY,
+        value: JSON.stringify(1),
+        gameServerId,
+        playerId: pog.playerId,
+        moduleId: mod.moduleId,
+      });
+    }
+
+    // Update last claim time
+    await takaro.variable.variableControllerUpdate(lastClaimRes.data.data[0].id, {
+      value: JSON.stringify(now),
+    });
+  } else {
+    // First time claim
+    await takaro.variable.variableControllerCreate({
+      key: DAILY_KEY,
+      value: JSON.stringify(now),
+      gameServerId,
+      playerId: pog.playerId,
+      moduleId: mod.moduleId,
+    });
+    await takaro.variable.variableControllerCreate({
+      key: STREAK_KEY,
+      value: JSON.stringify(1),
+      gameServerId,
+      playerId: pog.playerId,
+      moduleId: mod.moduleId,
+    });
+  }
+
+  const multiplier = await getMultiplier(pog);
+  const baseReward = mod.userConfig.baseReward * streak * multiplier;
+  let bonusReward = 0;
+  let milestoneMessage = '';
+
+  // Check for milestones
+  for (const milestone of mod.userConfig.milestoneRewards) {
+    if (streak === milestone.days) {
+      bonusReward = milestone.reward;
+      milestoneMessage = `\n${milestone.message}`;
+      break;
+    }
+  }
+
+  // Award total rewards
+  const totalReward = baseReward + bonusReward;
+  await takaro.playerOnGameserver.playerOnGameServerControllerAddCurrency(gameServerId, pog.playerId, {
+    currency: totalReward,
+  });
+
+  const currencyName = (await takaro.settings.settingsControllerGetOne('currencyName', gameServerId)).data.data.value;
+  await pog.pm(
+    `Daily reward claimed! You received ${totalReward} ${currencyName}\n` +
+      `Current streak: ${streak} days${multiplier > 1 ? ` (${multiplier}x bonus!)` : ''}` +
+      milestoneMessage,
+  );
+}
+
+await main();

package/src/modules/dailyRewards/commands/streak.js

@@ -0,0 +1,42 @@
+import { data, takaro } from '@takaro/helpers';
+import { getPlayerStreak, getLastClaim, getMultiplier } from './utils.js';
+
+async function main() {
+  const { pog, gameServerId, module: mod } = data;
+
+  const streak = await getPlayerStreak(gameServerId, pog.playerId, mod.moduleId);
+  const lastClaim = await getLastClaim(gameServerId, pog.playerId, mod.moduleId);
+  const multiplier = await getMultiplier(pog);
+  const prefix = (await takaro.settings.settingsControllerGetOne('commandPrefix', gameServerId)).data.data.value;
+
+  if (!streak || !lastClaim) {
+    await pog.pm(`You haven't claimed any daily rewards yet! Use ${prefix}daily to get started.`);
+    return;
+  }
+
+  const nextClaimTime = new Date(lastClaim.getTime() + 24 * 60 * 60 * 1000);
+  const now = new Date();
+  const canClaim = now >= nextClaimTime;
+
+  // Find next milestone
+  let nextMilestone = null;
+  for (const milestone of mod.userConfig.milestoneRewards) {
+    if (milestone.days > streak) {
+      nextMilestone = milestone;
+      break;
+    }
+  }
+
+  let message = `Current streak: ${streak} days${multiplier > 1 ? ` (${multiplier}x donor bonus!)` : ''}\n`;
+  message += canClaim
+    ? `Your daily reward is available! Use ${prefix}daily to claim it!\n`
+    : `Next reward available at: ${nextClaimTime.toLocaleString()}\n`;
+
+  if (nextMilestone) {
+    message += `\n🎯 Next milestone: ${nextMilestone.days} days (${nextMilestone.days - streak} days to go!)`;
+  }
+
+  await pog.pm(message);
+}
+
+await main();

package/src/modules/dailyRewards/commands/topstreak.js

@@ -0,0 +1,54 @@
+import { takaro, data } from '@takaro/helpers';
+import { STREAK_KEY } from './utils.js';
+
+async function main() {
+  const { pog, gameServerId, module: mod, arguments: args } = data;
+
+  // Limit count to reasonable number
+  const count = Math.min(Math.max(1, args.count), 50);
+
+  // Get all streaks
+  const streaksRes = await takaro.variable.variableControllerSearch({
+    filters: {
+      key: [STREAK_KEY],
+      gameServerId: [gameServerId],
+      moduleId: [mod.moduleId],
+    },
+    limit: 1000, // Get all possible streaks
+  });
+
+  if (streaksRes.data.data.length === 0) {
+    await pog.pm('No players have started their daily streak yet!');
+    return;
+  }
+
+  // Sort by streak value
+  const sortedStreaks = streaksRes.data.data
+    .map((record) => ({
+      playerId: record.playerId,
+      streak: JSON.parse(record.value),
+    }))
+    .sort((a, b) => b.streak - a.streak)
+    .slice(0, count);
+
+  // Get player names
+  const playerDetails = await Promise.all(
+    sortedStreaks.map(async (record) => {
+      const player = (await takaro.player.playerControllerGetOne(record.playerId)).data.data;
+      return {
+        name: player.name,
+        streak: record.streak,
+      };
+    }),
+  );
+
+  // Build message
+  let message = `Top ${count} Daily Streaks:\n\n`;
+  playerDetails.forEach((player, index) => {
+    message += `${index + 1}. ${player.name}: ${player.streak} days\n`;
+  });
+
+  await pog.pm(message);
+}
+
+await main();

package/src/modules/dailyRewards/functions/utils.js

@@ -0,0 +1,36 @@
+import { takaro, checkPermission } from '@takaro/helpers';
+
+export const DAILY_KEY = 'daily_timestamp';
+export const STREAK_KEY = 'daily_streak';
+
+export async function getMultiplier(pog) {
+  const perm = checkPermission(pog, 'DAILY_REWARD_MULTIPLIER');
+  if (perm) return perm.count;
+  return 1;
+}
+
+export async function getPlayerStreak(gameServerId, playerId, moduleId) {
+  const streakRes = await takaro.variable.variableControllerSearch({
+    filters: {
+      key: [STREAK_KEY],
+      gameServerId: [gameServerId],
+      playerId: [playerId],
+      moduleId: [moduleId],
+    },
+  });
+
+  return streakRes.data.data.length ? parseInt(JSON.parse(streakRes.data.data[0].value)) : 0;
+}
+
+export async function getLastClaim(gameServerId, playerId, moduleId) {
+  const lastClaimRes = await takaro.variable.variableControllerSearch({
+    filters: {
+      key: [DAILY_KEY],
+      gameServerId: [gameServerId],
+      playerId: [playerId],
+      moduleId: [moduleId],
+    },
+  });
+
+  return lastClaimRes.data.data.length ? new Date(JSON.parse(lastClaimRes.data.data[0].value)) : null;
+}