@takaro/modules 0.0.1

package/src/dto/gameEvents.ts

@@ -0,0 +1,154 @@
+import { IsEnum, IsString, ValidateNested, IsOptional, IsNumber } from 'class-validator';
+import { TakaroDTO } from '@takaro/util';
+import { Type } from 'class-transformer';
+import { BaseEvent } from './base.js';
+import { ValueOf } from 'type-fest';
+
+export const GameEvents = {
+  LOG_LINE: 'log',
+  PLAYER_CONNECTED: 'player-connected',
+  PLAYER_DISCONNECTED: 'player-disconnected',
+  CHAT_MESSAGE: 'chat-message',
+  PLAYER_DEATH: 'player-death',
+  ENTITY_KILLED: 'entity-killed',
+} as const;
+
+export type GameEventTypes = ValueOf<typeof GameEvents>;
+
+export class IGamePlayer extends TakaroDTO<IGamePlayer> {
+  /**
+   * Unique identifier for this player, as used by the game
+   */
+  @IsString()
+  gameId!: string;
+  /**
+   * The players username
+   */
+  @IsString()
+  name!: string;
+
+  @IsString()
+  @IsOptional()
+  steamId?: string;
+
+  @IsString()
+  @IsOptional()
+  epicOnlineServicesId?: string;
+
+  @IsString()
+  @IsOptional()
+  xboxLiveId?: string;
+
+  @IsString()
+  @IsOptional()
+  platformId?: string;
+
+  @IsString()
+  @IsOptional()
+  ip?: string;
+
+  @IsNumber()
+  @IsOptional()
+  ping?: number;
+}
+
+export class BaseGameEvent<T> extends BaseEvent<T> {
+  @IsEnum(GameEvents)
+  declare type: ValueOf<typeof GameEvents>;
+
+  @IsString()
+  @IsOptional()
+  msg: string;
+}
+
+export interface IPosition {
+  x: number;
+  y: number;
+  z: number;
+}
+
+export class EventLogLine extends BaseGameEvent<EventLogLine> {
+  @IsString()
+  type = GameEvents.LOG_LINE;
+}
+
+export class EventPlayerConnected extends BaseGameEvent<EventPlayerConnected> {
+  type = GameEvents.PLAYER_CONNECTED;
+  @ValidateNested()
+  @Type(() => IGamePlayer)
+  player: IGamePlayer;
+}
+
+export class EventPlayerDisconnected extends BaseGameEvent<EventPlayerDisconnected> {
+  type = GameEvents.PLAYER_DISCONNECTED;
+  @ValidateNested()
+  @Type(() => IGamePlayer)
+  player: IGamePlayer;
+}
+
+export enum ChatChannel {
+  GLOBAL = 'global',
+  TEAM = 'team',
+  FRIENDS = 'friends',
+  WHISPER = 'whisper',
+}
+
+export class EventChatMessage extends BaseGameEvent<EventChatMessage> {
+  type = GameEvents.CHAT_MESSAGE;
+  @ValidateNested()
+  @Type(() => IGamePlayer)
+  player?: IGamePlayer;
+
+  @IsEnum(Object.values(ChatChannel))
+  channel: ChatChannel;
+
+  declare msg: string;
+}
+
+export class IPosition {
+  @IsNumber()
+  x: number;
+  @IsNumber()
+  y: number;
+  @IsNumber()
+  z: number;
+}
+
+export class EventPlayerDeath extends BaseGameEvent<EventPlayerDeath> {
+  type = GameEvents.PLAYER_DEATH;
+  @ValidateNested()
+  @Type(() => IGamePlayer)
+  player: IGamePlayer;
+
+  @IsOptional()
+  @ValidateNested()
+  @Type(() => IGamePlayer)
+  attacker?: IGamePlayer;
+
+  @IsOptional()
+  @ValidateNested()
+  @Type(() => IPosition)
+  position: IPosition;
+}
+
+export class EventEntityKilled extends BaseGameEvent<EventEntityKilled> {
+  type = GameEvents.ENTITY_KILLED;
+  @ValidateNested()
+  @Type(() => IGamePlayer)
+  player: IGamePlayer;
+
+  @IsString()
+  entity: string;
+
+  @IsString()
+  weapon: string;
+}
+
+export const GameEventsMapping = {
+  [GameEvents.PLAYER_CONNECTED]: EventPlayerConnected,
+  [GameEvents.PLAYER_DISCONNECTED]: EventPlayerDisconnected,
+  [GameEvents.CHAT_MESSAGE]: EventChatMessage,
+  [GameEvents.PLAYER_DEATH]: EventPlayerDeath,
+  [GameEvents.ENTITY_KILLED]: EventEntityKilled,
+  [GameEvents.LOG_LINE]: EventLogLine,
+} as const;

package/src/dto/index.ts

@@ -0,0 +1,25 @@
+import { DiscordEvents, DiscordEventsMapping } from './discordEvents.js';
+import { GameEvents, GameEventsMapping } from './gameEvents.js';
+import { TakaroEvents, TakaroEventsMapping } from './takaroEvents.js';
+import { ValueOf } from 'type-fest';
+import { BaseEvent } from './base.js';
+
+export * from './discordEvents.js';
+export * from './gameEvents.js';
+export * from './takaroEvents.js';
+export * from './base.js';
+
+export const HookEvents = {
+  ...GameEvents,
+  ...DiscordEvents,
+  ...TakaroEvents,
+} as const;
+
+export const EventMapping: Record<EventTypes, typeof BaseEvent<any>> = {
+  ...GameEventsMapping,
+  ...DiscordEventsMapping,
+  ...TakaroEventsMapping,
+} as const;
+
+export type EventPayload = ValueOf<(typeof EventMapping)[ValueOf<typeof HookEvents>]>;
+export type EventTypes = ValueOf<typeof HookEvents>;

package/src/dto/takaroEvents.ts

@@ -0,0 +1,290 @@
+import {
+  IsBoolean,
+  IsDefined,
+  IsEnum,
+  IsIP,
+  IsISO31661Alpha2,
+  IsJSON,
+  IsNumber,
+  IsObject,
+  IsOptional,
+  IsString,
+  ValidateNested,
+} from 'class-validator';
+import { BaseEvent } from './base.js';
+import { ValueOf } from 'type-fest';
+import { Type } from 'class-transformer';
+import { TakaroDTO } from '@takaro/util';
+
+export const TakaroEvents = {
+  ROLE_ASSIGNED: 'role-assigned',
+  ROLE_REMOVED: 'role-removed',
+  ROLE_CREATED: 'role-created',
+  ROLE_UPDATED: 'role-updated',
+  ROLE_DELETED: 'role-deleted',
+  COMMAND_EXECUTED: 'command-executed',
+  HOOK_EXECUTED: 'hook-executed',
+  CRONJOB_EXECUTED: 'cronjob-executed',
+  CURRENCY_ADDED: 'currency-added',
+  CURRENCY_DEDUCTED: 'currency-deducted',
+  SETTINGS_SET: 'settings-set',
+  PLAYER_NEW_IP_DETECTED: 'player-new-ip-detected',
+  SERVER_STATUS_CHANGED: 'server-status-changed',
+  MODULE_CREATED: 'module-created',
+  MODULE_UPDATED: 'module-updated',
+  MODULE_DELETED: 'module-deleted',
+  MODULE_INSTALLED: 'module-installed',
+  MODULE_UNINSTALLED: 'module-uninstalled',
+  PLAYER_CREATED: 'player-created',
+} as const;
+
+export class BaseTakaroEvent<T> extends BaseEvent<T> {
+  @IsEnum(TakaroEvents)
+  declare type: ValueOf<typeof TakaroEvents>;
+
+  @IsString()
+  msg: string;
+}
+
+export class TakaroEventPlayerNewIpDetected extends BaseEvent<TakaroEventPlayerNewIpDetected> {
+  @IsString()
+  type = TakaroEvents.PLAYER_NEW_IP_DETECTED;
+
+  @IsISO31661Alpha2()
+  country: string;
+
+  @IsString()
+  city: string;
+
+  @IsString()
+  longitude: string;
+
+  @IsString()
+  latitude: string;
+
+  @IsIP()
+  ip: string;
+}
+
+export class TakaroEventCurrencyDeducted extends BaseEvent<TakaroEventCurrencyDeducted> {
+  @IsString()
+  type = TakaroEvents.CURRENCY_DEDUCTED;
+
+  @IsNumber()
+  amount: number;
+}
+
+export class TakaroEventCurrencyAdded extends BaseEvent<TakaroEventCurrencyAdded> {
+  @IsString()
+  type = TakaroEvents.CURRENCY_ADDED;
+
+  @IsNumber()
+  amount: number;
+}
+
+export class TakaroEventFunctionResult extends TakaroDTO<TakaroEventFunctionResult> {
+  @ValidateNested({ each: true })
+  @Type(() => TakaroEventFunctionLog)
+  logs: TakaroEventFunctionLog[];
+
+  @IsBoolean()
+  success: boolean;
+
+  @IsString()
+  @IsOptional()
+  reason: string;
+
+  @IsNumber()
+  @IsOptional()
+  tryAgainIn: number;
+}
+
+export class TakaroEventFunctionLog extends TakaroDTO<TakaroEventFunctionLog> {
+  @IsString()
+  msg: string;
+
+  @IsOptional()
+  details: Record<string, unknown> | string | undefined;
+}
+
+export class TakaroEventCommandDetails extends TakaroDTO<TakaroEventCommandDetails> {
+  @IsString()
+  id: string;
+  @IsString()
+  name: string;
+  @IsObject()
+  arguments: Record<string, unknown>;
+}
+
+export class TakaroEventCommandExecuted extends BaseEvent<TakaroEventCommandExecuted> {
+  @IsString()
+  type = TakaroEvents.COMMAND_EXECUTED;
+
+  @IsDefined()
+  data: Record<string, unknown>;
+
+  @ValidateNested({ each: true })
+  @Type(() => TakaroEventFunctionResult)
+  result: TakaroEventFunctionResult;
+
+  @IsOptional()
+  @ValidateNested()
+  @Type(() => TakaroEventCommandDetails)
+  command: TakaroEventCommandDetails;
+}
+
+export class TakaroEventHookExecuted extends BaseEvent<TakaroEventHookExecuted> {
+  @IsString()
+  type = TakaroEvents.HOOK_EXECUTED;
+
+  @IsDefined()
+  data: Record<string, unknown>;
+
+  @ValidateNested({ each: true })
+  @Type(() => TakaroEventFunctionResult)
+  result: TakaroEventFunctionResult;
+}
+
+export class TakaroEventCronjobExecuted extends BaseEvent<TakaroEventCronjobExecuted> {
+  @IsString()
+  type = TakaroEvents.CRONJOB_EXECUTED;
+
+  @IsDefined()
+  data: Record<string, unknown>;
+
+  @ValidateNested({ each: true })
+  @Type(() => TakaroEventFunctionResult)
+  result: TakaroEventFunctionResult;
+}
+
+export class TakaroEventRoleMeta extends TakaroDTO<TakaroEventRoleMeta> {
+  @IsString()
+  id: string;
+  @IsString()
+  name: string;
+}
+
+export class TakaroEventRoleAssigned extends BaseEvent<TakaroEventRoleAssigned> {
+  @IsString()
+  type = TakaroEvents.ROLE_ASSIGNED;
+
+  @ValidateNested()
+  @Type(() => TakaroEventRoleMeta)
+  role: TakaroEventRoleMeta;
+}
+
+export class TakaroEventRoleRemoved extends BaseEvent<TakaroEventRoleRemoved> {
+  @IsString()
+  type = TakaroEvents.ROLE_REMOVED;
+
+  @ValidateNested()
+  @Type(() => TakaroEventRoleMeta)
+  role: TakaroEventRoleMeta;
+}
+
+export class TakaroEventRoleCreated extends BaseEvent<TakaroEventRoleCreated> {
+  @IsString()
+  type = TakaroEvents.ROLE_CREATED;
+
+  @ValidateNested()
+  @Type(() => TakaroEventRoleMeta)
+  role: TakaroEventRoleMeta;
+}
+
+export class TakaroEventRoleUpdated extends BaseEvent<TakaroEventRoleUpdated> {
+  @IsString()
+  type = TakaroEvents.ROLE_UPDATED;
+
+  @ValidateNested()
+  @Type(() => TakaroEventRoleMeta)
+  role: TakaroEventRoleMeta;
+}
+
+export class TakaroEventRoleDeleted extends BaseEvent<TakaroEventRoleDeleted> {
+  @IsString()
+  type = TakaroEvents.ROLE_DELETED;
+
+  @ValidateNested()
+  @Type(() => TakaroEventRoleMeta)
+  role: TakaroEventRoleMeta;
+}
+
+export class TakaroEventSettingsSet extends BaseEvent<TakaroEventSettingsSet> {
+  @IsString()
+  type = TakaroEvents.SETTINGS_SET;
+
+  @IsString()
+  key: string;
+
+  @IsString()
+  @IsOptional()
+  value: string | null;
+}
+
+export class TakaroEventServerStatusChanged extends BaseEvent<TakaroEventServerStatusChanged> {
+  @IsString()
+  type = TakaroEvents.SERVER_STATUS_CHANGED;
+
+  @IsString()
+  status: string;
+
+  @IsOptional()
+  details?: Record<string, unknown> | string | null;
+}
+
+export class TakaroEventModuleCreated extends BaseEvent<TakaroEventModuleCreated> {
+  @IsString()
+  type = TakaroEvents.MODULE_CREATED;
+}
+
+export class TakaroEventModuleUpdated extends BaseEvent<TakaroEventModuleUpdated> {
+  @IsString()
+  type = TakaroEvents.MODULE_UPDATED;
+}
+
+export class TakaroEventModuleDeleted extends BaseEvent<TakaroEventModuleDeleted> {
+  @IsString()
+  type = TakaroEvents.MODULE_DELETED;
+}
+
+export class TakaroEventModuleInstalled extends BaseEvent<TakaroEventModuleInstalled> {
+  @IsString()
+  type = TakaroEvents.MODULE_INSTALLED;
+
+  @IsJSON()
+  userConfig: string;
+
+  @IsJSON()
+  systemConfig: string;
+}
+
+export class TakaroEventModuleUninstalled extends BaseEvent<TakaroEventModuleUninstalled> {
+  @IsString()
+  type = TakaroEvents.MODULE_UNINSTALLED;
+}
+export class TakaroEventPlayerCreated extends BaseEvent<TakaroEventPlayerCreated> {
+  @IsString()
+  type = TakaroEvents.PLAYER_CREATED;
+}
+
+export const TakaroEventsMapping = {
+  [TakaroEvents.ROLE_ASSIGNED]: TakaroEventRoleAssigned,
+  [TakaroEvents.PLAYER_NEW_IP_DETECTED]: TakaroEventPlayerNewIpDetected,
+  [TakaroEvents.CURRENCY_DEDUCTED]: TakaroEventCurrencyDeducted,
+  [TakaroEvents.CURRENCY_ADDED]: TakaroEventCurrencyAdded,
+  [TakaroEvents.COMMAND_EXECUTED]: TakaroEventCommandExecuted,
+  [TakaroEvents.ROLE_REMOVED]: TakaroEventRoleRemoved,
+  [TakaroEvents.ROLE_CREATED]: TakaroEventRoleCreated,
+  [TakaroEvents.ROLE_UPDATED]: TakaroEventRoleUpdated,
+  [TakaroEvents.ROLE_DELETED]: TakaroEventRoleDeleted,
+  [TakaroEvents.SETTINGS_SET]: TakaroEventSettingsSet,
+  [TakaroEvents.HOOK_EXECUTED]: TakaroEventHookExecuted,
+  [TakaroEvents.CRONJOB_EXECUTED]: TakaroEventCronjobExecuted,
+  [TakaroEvents.SERVER_STATUS_CHANGED]: TakaroEventServerStatusChanged,
+  [TakaroEvents.MODULE_CREATED]: TakaroEventModuleCreated,
+  [TakaroEvents.MODULE_UPDATED]: TakaroEventModuleUpdated,
+  [TakaroEvents.MODULE_DELETED]: TakaroEventModuleDeleted,
+  [TakaroEvents.MODULE_INSTALLED]: TakaroEventModuleInstalled,
+  [TakaroEvents.MODULE_UNINSTALLED]: TakaroEventModuleUninstalled,
+  [TakaroEvents.PLAYER_CREATED]: TakaroEventPlayerCreated,
+} as const;

package/src/main.ts

@@ -0,0 +1,36 @@
+import { BuiltinModule } from './BuiltinModule.js';
+import { ChatBridge } from './modules/chatBridge/index.js';
+import { EconomyUtils } from './modules/economyUtils/index.js';
+import { GeoBlock } from './modules/geoBlock/index.js';
+import { Gimme } from './modules/gimme/index.js';
+import { HighPingKicker } from './modules/highPingKicker/index.js';
+import { Lottery } from './modules/lottery/index.js';
+import { PlayerOnboarding } from './modules/playerOnboarding/index.js';
+import { ServerMessages } from './modules/serverMessages/index.js';
+import { Teleports } from './modules/teleports/index.js';
+export { BuiltinModule, ICommand, ICommandArgument, ICronJob, IHook, IFunction } from './BuiltinModule.js';
+
+export * from './dto/index.js';
+
+import { Utils } from './modules/utils/index.js';
+
+let cached: Array<BuiltinModule<unknown>> | null = null;
+
+export function getModules(): Array<BuiltinModule<unknown>> {
+  if (!cached) {
+    cached = [
+      new Utils(),
+      new Teleports(),
+      new PlayerOnboarding(),
+      new ServerMessages(),
+      new ChatBridge(),
+      new Gimme(),
+      new HighPingKicker(),
+      new EconomyUtils(),
+      new Lottery(),
+      new GeoBlock(),
+    ];
+  }
+
+  return cached;
+}

package/src/modules/.eslintrc

@@ -0,0 +1,5 @@
+{
+  "rules": {
+    "no-console": ["off"]
+  }
+}

package/src/modules/chatBridge/hooks/DiscordToGame.js

@@ -0,0 +1,18 @@
+import { takaro, data } from '@takaro/helpers';
+
+async function main() {
+  try {
+    if (data.eventData.author.isBot) return;
+
+    await takaro.gameserver.gameServerControllerSendMessage(data.gameServerId, {
+      message: `[D] ${data.eventData.author.displayName}:  ${data.eventData.msg}`,
+    });
+  } catch (error) {
+    console.error(error);
+    await takaro.discordControllerSendMessage(data.discordChannelId, {
+      message: 'Failed to forward your message to the game. Please try again later.',
+    });
+  }
+}
+
+await main();

package/src/modules/chatBridge/hooks/GameToDiscord.js

@@ -0,0 +1,18 @@
+import { takaro, data } from '@takaro/helpers';
+
+async function main() {
+  const onlyGlobal = data.module.userConfig.onlyGlobalChat;
+
+  if (onlyGlobal && data.eventData.channel !== 'global') return;
+
+  const discordChannel = data.module.systemConfig.hooks['DiscordToGame Discord channel ID'];
+
+  const sender = data.player ? data.player.name : 'Non-player';
+  const message = `**${sender}**: ${data.eventData.msg}`;
+
+  await takaro.discord.discordControllerSendMessage(discordChannel, {
+    message: message,
+  });
+}
+
+await main();

package/src/modules/chatBridge/hooks/PlayerConnected.js

@@ -0,0 +1,11 @@
+import { takaro, data } from '@takaro/helpers';
+
+async function main() {
+  const discordChannel = data.module.systemConfig.hooks['DiscordToGame Discord channel ID'];
+
+  await takaro.discord.discordControllerSendMessage(discordChannel, {
+    message: `[🔌 Connected]: ${data.player.name}`,
+  });
+}
+
+await main();

package/src/modules/chatBridge/hooks/PlayerDisconnected.js

@@ -0,0 +1,11 @@
+import { takaro, data } from '@takaro/helpers';
+
+async function main() {
+  const discordChannel = data.module.systemConfig.hooks['DiscordToGame Discord channel ID'];
+
+  await takaro.discord.discordControllerSendMessage(discordChannel, {
+    message: `[👋 Disconnected]: ${data.player.name}`,
+  });
+}
+
+await main();

package/src/modules/chatBridge/index.ts

@@ -0,0 +1,59 @@
+import { BuiltinModule, IHook } from '../../BuiltinModule.js';
+import { HookEvents } from '../../dto/index.js';
+
+export class ChatBridge extends BuiltinModule<ChatBridge> {
+  constructor() {
+    super(
+      'chatBridge',
+      'Connect chat to other services like Discord.',
+      JSON.stringify({
+        $schema: 'http://json-schema.org/draft-07/schema#',
+        type: 'object',
+        properties: {
+          sendPlayerConnected: {
+            title: 'Send player connected',
+            type: 'boolean',
+            description: 'Send a message when a player connects.',
+            default: true,
+          },
+          sendPlayerDisconnected: {
+            title: 'Send player disconnected',
+            type: 'boolean',
+            description: 'Send a message when a player disconnects.',
+            default: true,
+          },
+          onlyGlobalChat: {
+            title: 'Only global chat',
+            type: 'boolean',
+            default: true,
+            description: 'Only relay messages from global chat. (no team chat or private messages)',
+          },
+        },
+        additionalProperties: false,
+      })
+    );
+
+    this.hooks = [
+      new IHook({
+        eventType: HookEvents.DISCORD_MESSAGE,
+        name: 'DiscordToGame',
+        function: this.loadFn('hooks', 'DiscordToGame'),
+      }),
+      new IHook({
+        eventType: HookEvents.CHAT_MESSAGE,
+        name: 'GameToDiscord',
+        function: this.loadFn('hooks', 'GameToDiscord'),
+      }),
+      new IHook({
+        eventType: HookEvents.PLAYER_CONNECTED,
+        name: 'PlayerConnected',
+        function: this.loadFn('hooks', 'PlayerConnected'),
+      }),
+      new IHook({
+        eventType: HookEvents.PLAYER_DISCONNECTED,
+        name: 'PlayerDisconnected',
+        function: this.loadFn('hooks', 'PlayerDisconnected'),
+      }),
+    ];
+  }
+}

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

@@ -0,0 +1,8 @@
+import { takaro, data } from '@takaro/helpers';
+
+async function main() {
+  const currencyName = (await takaro.settings.settingsControllerGetOne('currencyName', data.gameServerId)).data.data;
+  await data.player.pm(`balance: ${data.pog.currency} ${currencyName.value}`);
+}
+
+await main();

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

@@ -0,0 +1,55 @@
+import { takaro, data, TakaroUserError } from '@takaro/helpers';
+
+async function main() {
+  const { gameServerId, pog: sender, module: mod } = data;
+
+  // try to find a variable with key "confirmTransfer"
+  const variables = (
+    await takaro.variable.variableControllerSearch({
+      filters: {
+        key: 'confirmTransfer',
+        gameServerId,
+        moduleId: mod.moduleId,
+        playerId: sender.playerId,
+      },
+    })
+  ).data.data;
+
+  if (variables.length === 0) {
+    throw new TakaroUserError('You have no pending transfer.');
+  }
+
+  // Remove the variable before potentially executing the transaction.
+  await takaro.variable.variableControllerDelete(variables[0].id);
+  const pendingTransfer = JSON.parse(variables[0].value);
+
+  await takaro.playerOnGameserver.playerOnGameServerControllerTransactBetweenPlayers(
+    sender.gameServerId,
+    sender.id,
+    pendingTransfer.receiver.id,
+    {
+      currency: pendingTransfer.amount,
+    }
+  );
+
+  const receiverName = (await takaro.player.playerControllerGetOne(pendingTransfer.receiver.playerId)).data.data.name;
+  const senderName = (await takaro.player.playerControllerGetOne(sender.playerId)).data.data.name;
+  const currencyName = (await takaro.settings.settingsControllerGetOne('currencyName', gameServerId)).data.data.value;
+
+  const messageToSender = sender.pm(
+    `You successfully transferred ${pendingTransfer.amount} ${currencyName} to ${receiverName}`
+  );
+
+  const messageToReceiver = takaro.gameserver.gameServerControllerSendMessage(gameServerId, {
+    message: `You received ${pendingTransfer.amount} ${currencyName} from ${senderName}`,
+    opts: {
+      recipient: {
+        gameId: pendingTransfer.receiver.gameId,
+      },
+    },
+  });
+  await Promise.all([messageToSender, messageToReceiver]);
+  return;
+}
+
+await main();