@rpgjs/server 5.0.0-alpha.23 → 5.0.0-alpha.25

package/tests/item.spec.ts

@@ -0,0 +1,577 @@
+import { beforeEach, test, expect, afterEach, describe, vi } from 'vitest'
+import { testing, waitForSyncComplete } from '@rpgjs/testing'
+import { defineModule, createModule } from '@rpgjs/common'
+import { RpgPlayer, RpgServer } from '../src'
+import { RpgClient } from '../../client/src'
+import { ItemLog } from '../src/logs'
+import type { ItemObject } from '../src/Player/ItemManager'
+
+// Define test items as objects for database
+const TestPotion = {
+    id: 'TestPotion',
+  name: 'Test Potion',
+  description: 'Restores 100 HP',
+  price: 200,
+  hpValue: 100,
+  consumable: true,
+  _type: 'item' as const,
+}
+
+const TestSword = {
+  name: 'Test Sword',
+  description: 'A basic sword',
+  price: 500,
+  atk: 50,
+  _type: 'weapon' as const,
+}
+
+const TestArmor = {
+  name: 'Test Armor',
+  description: 'Basic armor',
+  price: 300,
+  pdef: 30,
+  sdef: 20,
+  _type: 'armor' as const,
+}
+
+const TestNonConsumable = {
+  name: 'Test Non-Consumable',
+  description: 'Cannot be used',
+  price: 100,
+  consumable: false,
+  _type: 'item' as const,
+}
+
+const TestExpensiveItem = {
+  name: 'Expensive Item',
+  description: 'Very expensive',
+  price: 10000,
+  _type: 'item' as const,
+}
+
+const TestNoPriceItem = {
+  name: 'No Price Item',
+  description: 'Item without price',
+  _type: 'item' as const,
+}
+
+// Define server module with items in database
+const serverModule = defineModule<RpgServer>({
+  maps: [
+    {
+      id: 'test-map',
+      file: '',
+    },
+  ],
+  database: {
+    'TestPotion': TestPotion,
+    'TestSword': TestSword,
+    'TestArmor': TestArmor,
+    'TestNonConsumable': TestNonConsumable,
+    'TestExpensiveItem': TestExpensiveItem,
+    'TestNoPriceItem': TestNoPriceItem,
+  },
+  player: {
+    async onConnected(player) {
+      await player.changeMap('test-map', { x: 100, y: 100 })
+    },
+  },
+})
+
+// Define client module
+const clientModule = defineModule<RpgClient>({
+  // Client-side logic
+})
+
+let player: RpgPlayer
+let client: any
+let fixture: any
+
+beforeEach(async () => {
+  const myModule = createModule('TestModule', [
+    {
+      server: serverModule,
+      client: clientModule,
+    },
+  ])
+
+  fixture = await testing(myModule)
+  client = await fixture.createClient()
+  player = await client.waitForMapChange('test-map')
+ 
+})
+
+afterEach(async () => {
+  fixture.clear()
+})
+
+test('should add item ', async () => {
+    const item = player.addItem(TestPotion, 5)
+    expect(item).toBeDefined()
+    expect(item.id()).toBe('TestPotion')
+    expect(item.quantity()).toBe(5)
+    expect(item.name()).toBe('Test Potion')
+    await waitForSyncComplete(player as any, client.client)
+    console.log((client.client.sceneMap.currentPlayer() as any).items())
+  })
+
+/*
+describe('Item Management - Basic Operations', () => {
+  test('should add item using string ID', () => {
+    const item = player.addItem('TestPotion', 5)
+    expect(item).toBeDefined()
+    expect(item.id()).toBe('TestPotion')
+    expect(item.quantity()).toBe(5)
+    expect(item.name()).toBe('Test Potion')
+  })
+
+  test('should add item using object', () => {
+    const customItem: ItemObject = {
+      id: 'custom-item',
+      name: 'Custom Item',
+      description: 'A custom item',
+      price: 150,
+      onAdd(player) {
+        // Hook test
+      },
+    }
+    const item = player.addItem(customItem, 3)
+    expect(item).toBeDefined()
+    expect(item.id()).toBe('custom-item')
+    expect(item.quantity()).toBe(3)
+    expect(item.name()).toBe('Custom Item')
+  })
+
+  test('should add item without ID (auto-generated)', () => {
+    const customItem: ItemObject = {
+      name: 'Auto ID Item',
+      price: 100,
+    }
+    const item = player.addItem(customItem, 1)
+    expect(item).toBeDefined()
+    expect(item.id()).toMatch(/^item-\d+$/)
+    expect(item.name()).toBe('Auto ID Item')
+  })
+
+  test('should increment quantity when adding existing item', () => {
+    player.addItem('TestPotion', 3)
+    const item = player.addItem('TestPotion', 2)
+    expect(item.quantity()).toBe(5)
+  })
+
+  test('should throw error when adding item without map', async () => {
+    const newFixture = await testing()
+    const newClient = await newFixture.createClient()
+    const newPlayer = newClient.player
+
+    expect(() => {
+      newPlayer.addItem('TestPotion', 1)
+    }).toThrow('Player must be on a map to add items')
+
+    newFixture.clear()
+  })
+
+  test('should throw error when adding item with invalid string ID', () => {
+    expect(() => {
+      player.addItem('NonExistentItem', 1)
+    }).toThrow('The ID=NonExistentItem data is not found in the database')
+  })
+
+  test('should get item from inventory', () => {
+    player.addItem('TestPotion', 5)
+    const item = player.getItem('TestPotion')
+    expect(item).toBeDefined()
+    expect(item.id()).toBe('TestPotion')
+    expect(item.quantity()).toBe(5)
+  })
+
+  test('should return undefined when getting non-existent item', () => {
+    const item = player.getItem('TestPotion')
+    expect(item).toBeUndefined()
+  })
+
+  test('should check if player has item', () => {
+    expect(player.hasItem('TestPotion')).toBe(false)
+    player.addItem('TestPotion', 1)
+    expect(player.hasItem('TestPotion')).toBe(true)
+  })
+
+  test('should remove item from inventory', () => {
+    player.addItem('TestPotion', 5)
+    const item = player.removeItem('TestPotion', 2)
+    expect(item).toBeDefined()
+    expect(item?.quantity()).toBe(3)
+  })
+
+  test('should remove item completely when quantity reaches zero', () => {
+    player.addItem('TestPotion', 2)
+    player.removeItem('TestPotion', 2)
+    expect(player.hasItem('TestPotion')).toBe(false)
+    const item = player.getItem('TestPotion')
+    expect(item).toBeUndefined()
+  })
+
+  test('should throw error when removing non-existent item', () => {
+    expect(() => {
+      player.removeItem('TestPotion', 1)
+    }).toThrow()
+  })
+})
+
+describe('Item Management - Buy and Sell', () => {
+  test('should buy item and reduce gold', () => {
+    player.gold = 1000
+    const item = player.buyItem('TestPotion', 2)
+    expect(item).toBeDefined()
+    expect(item.quantity()).toBe(2)
+    expect(player.gold).toBe(600) // 1000 - (200 * 2)
+  })
+
+  test('should throw error when buying item without price', () => {
+    player.gold = 1000
+    expect(() => {
+      player.buyItem('TestNoPriceItem', 1)
+    }).toThrow()
+  })
+
+  test('should throw error when not enough gold', () => {
+    player.gold = 100
+    expect(() => {
+      player.buyItem('TestExpensiveItem', 1)
+    }).toThrow()
+  })
+
+  test('should sell item and increase gold', () => {
+    player.gold = 1000
+    player.addItem('TestPotion', 3)
+    const item = player.sellItem('TestPotion', 2)
+    expect(item).toBeDefined()
+    expect(player.gold).toBe(1200) // 1000 + (200 / 2 * 2)
+    expect(player.getItem('TestPotion')?.quantity()).toBe(1)
+  })
+
+  test('should throw error when selling non-existent item', () => {
+    expect(() => {
+      player.sellItem('TestPotion', 1)
+    }).toThrow()
+  })
+
+  test('should throw error when selling more items than available', () => {
+    player.addItem('TestPotion', 2)
+    expect(() => {
+      player.sellItem('TestPotion', 5)
+    }).toThrow()
+  })
+
+  test('should throw error when selling item without price', () => {
+    player.addItem('TestNoPriceItem', 1)
+    expect(() => {
+      player.sellItem('TestNoPriceItem', 1)
+    }).toThrow()
+  })
+})
+
+describe('Item Management - Use Item', () => {
+  test('should use consumable item', () => {
+    const initialHp = player.hp
+    player.addItem('TestPotion', 1)
+    const item = player.useItem('TestPotion')
+    expect(item).toBeDefined()
+    expect(player.hasItem('TestPotion')).toBe(false)
+    // Note: applyEffect might not be implemented in test environment
+  })
+
+  test('should throw error when using non-existent item', () => {
+    expect(() => {
+      player.useItem('TestPotion')
+    }).toThrow()
+  })
+
+  test('should throw error when using non-consumable item', () => {
+    player.addItem('TestNonConsumable', 1)
+    expect(() => {
+      player.useItem('TestNonConsumable')
+    }).toThrow()
+  })
+
+  test('should handle hitRate chance (success)', () => {
+    // Mock Math.random to return a value that passes hitRate
+    const originalRandom = Math.random
+    Math.random = vi.fn(() => 0.5) // 0.5 < 1.0 (default hitRate)
+
+    player.addItem('TestPotion', 1)
+    const item = player.useItem('TestPotion')
+    expect(item).toBeDefined()
+    expect(player.hasItem('TestPotion')).toBe(false)
+
+    Math.random = originalRandom
+  })
+
+  test('should handle hitRate chance (failure)', () => {
+    // Mock Math.random to return a value that fails hitRate
+    const originalRandom = Math.random
+    Math.random = vi.fn(() => 0.99) // 0.99 > 1.0 (default hitRate)
+
+    player.addItem('TestPotion', 1)
+    expect(() => {
+      player.useItem('TestPotion')
+    }).toThrow()
+
+    // Item should still be removed even on failure
+    expect(player.hasItem('TestPotion')).toBe(false)
+
+    Math.random = originalRandom
+  })
+
+  test('should use item with custom hitRate', () => {
+    const customItem: ItemObject = {
+      id: 'chance-item',
+      name: 'Chance Item',
+      price: 100,
+      consumable: true,
+      hitRate: 0.5, // 50% chance
+    }
+    player.addItem(customItem, 1)
+
+    // Mock Math.random to pass
+    const originalRandom = Math.random
+    Math.random = vi.fn(() => 0.3) // 0.3 < 0.5
+
+    const item = player.useItem('chance-item')
+    expect(item).toBeDefined()
+
+    Math.random = originalRandom
+  })
+})
+
+describe('Item Management - Equipment', () => {
+  test('should equip weapon', () => {
+    player.addItem('TestSword', 1)
+    player.equip('TestSword', true)
+    const item = player.getItem('TestSword')
+    expect((item as any).equipped).toBe(true)
+    expect(player.equipments().some((eq) => eq.id() === 'TestSword')).toBe(true)
+  })
+
+  test('should unequip weapon', () => {
+    player.addItem('TestSword', 1)
+    player.equip('TestSword', true)
+    player.equip('TestSword', false)
+    const item = player.getItem('TestSword')
+    expect((item as any).equipped).toBe(false)
+    expect(player.equipments().some((eq) => eq.id() === 'TestSword')).toBe(false)
+  })
+
+  test('should equip armor', () => {
+    player.addItem('TestArmor', 1)
+    player.equip('TestArmor', true)
+    const item = player.getItem('TestArmor')
+    expect((item as any).equipped).toBe(true)
+  })
+
+  test('should throw error when equipping non-existent item', () => {
+    expect(() => {
+      player.equip('TestSword', true)
+    }).toThrow()
+  })
+
+  test('should throw error when equipping regular item (not weapon/armor)', () => {
+    player.addItem('TestPotion', 1)
+    expect(() => {
+      player.equip('TestPotion', true)
+    }).toThrow()
+  })
+
+  test('should throw error when equipping already equipped item', () => {
+    player.addItem('TestSword', 1)
+    player.equip('TestSword', true)
+    expect(() => {
+      player.equip('TestSword', true)
+    }).toThrow()
+  })
+})
+
+describe('Item Management - Parameters (ATK, PDEF, SDEF)', () => {
+  test('should calculate attack from equipped weapon', () => {
+    player.addItem('TestSword', 1)
+    player.equip('TestSword', true)
+    expect(player.atk).toBe(50)
+  })
+
+  test('should calculate physical defense from equipped armor', () => {
+    player.addItem('TestArmor', 1)
+    player.equip('TestArmor', true)
+    expect(player.pdef).toBe(30)
+  })
+
+  test('should calculate skill defense from equipped armor', () => {
+    player.addItem('TestArmor', 1)
+    player.equip('TestArmor', true)
+    expect(player.sdef).toBe(20)
+  })
+
+  test('should return 0 for parameters when no equipment', () => {
+    expect(player.atk).toBe(0)
+    expect(player.pdef).toBe(0)
+    expect(player.sdef).toBe(0)
+  })
+
+  test('should sum parameters from multiple equipped items', () => {
+    const sword2: ItemObject & { atk: number } = {
+      id: 'sword2',
+      name: 'Sword 2',
+      price: 600,
+      atk: 75,
+      _type: 'weapon' as const,
+    }
+    player.getCurrentMap()?.addInDatabase('sword2', sword2)
+
+    player.addItem('TestSword', 1)
+    player.addItem('sword2', 1)
+    player.equip('TestSword', true)
+    player.equip('sword2', true)
+
+    // Only one weapon should be equipped at a time typically, but test the sum
+    expect(player.atk).toBeGreaterThanOrEqual(50)
+  })
+})
+
+describe('Item Management - Hooks', () => {
+  test('should call onAdd hook when adding item', () => {
+    const onAddSpy = vi.fn()
+    const customItem: ItemObject = {
+      id: 'hook-item',
+      name: 'Hook Item',
+      price: 100,
+      onAdd: onAddSpy,
+    }
+
+    player.addItem(customItem, 1)
+    expect(onAddSpy).toHaveBeenCalledWith(player)
+  })
+
+  test('should call onRemove hook when removing item', () => {
+    const onRemoveSpy = vi.fn()
+    const customItem: ItemObject = {
+      id: 'remove-hook-item',
+      name: 'Remove Hook Item',
+      price: 100,
+      onRemove: onRemoveSpy,
+    }
+
+    player.addItem(customItem, 1)
+    player.removeItem('remove-hook-item', 1)
+    expect(onRemoveSpy).toHaveBeenCalledWith(player)
+  })
+
+  test('should call onUse hook when using item', () => {
+    const onUseSpy = vi.fn()
+    const customItem: ItemObject = {
+      id: 'use-hook-item',
+      name: 'Use Hook Item',
+      price: 100,
+      consumable: true,
+      onUse: onUseSpy,
+    }
+
+    // Mock Math.random to ensure success
+    const originalRandom = Math.random
+    Math.random = vi.fn(() => 0.5)
+
+    player.addItem(customItem, 1)
+    player.useItem('use-hook-item')
+    expect(onUseSpy).toHaveBeenCalledWith(player)
+
+    Math.random = originalRandom
+  })
+
+  test('should call onUseFailed hook when item usage fails', () => {
+    const onUseFailedSpy = vi.fn()
+    const customItem: ItemObject = {
+      id: 'fail-hook-item',
+      name: 'Fail Hook Item',
+      price: 100,
+      consumable: true,
+      hitRate: 0.1, // 10% chance
+      onUseFailed: onUseFailedSpy,
+    }
+
+    // Mock Math.random to fail
+    const originalRandom = Math.random
+    Math.random = vi.fn(() => 0.9) // 0.9 > 0.1
+
+    player.addItem(customItem, 1)
+    try {
+      player.useItem('fail-hook-item')
+    } catch (e) {
+      // Expected to throw
+    }
+    expect(onUseFailedSpy).toHaveBeenCalledWith(player)
+
+    Math.random = originalRandom
+  })
+
+  test('should call onEquip hook when equipping item', () => {
+    const onEquipSpy = vi.fn()
+    const customWeapon: ItemObject & { atk: number } = {
+      id: 'equip-hook-weapon',
+      name: 'Equip Hook Weapon',
+      price: 500,
+      atk: 40,
+      _type: 'weapon' as const,
+      onEquip: onEquipSpy,
+    }
+
+    player.addItem(customWeapon, 1)
+    player.equip('equip-hook-weapon', true)
+    expect(onEquipSpy).toHaveBeenCalledWith(player, true)
+
+    player.equip('equip-hook-weapon', false)
+    expect(onEquipSpy).toHaveBeenCalledWith(player, false)
+  })
+})
+
+describe('Item Management - Edge Cases', () => {
+  test('should handle adding item with class (if supported)', () => {
+    // This test would require an actual Item class
+    // For now, we test that object items work
+    const itemObj: ItemObject = {
+      id: 'class-like-item',
+      name: 'Class Like Item',
+      price: 100,
+    }
+    const item = player.addItem(itemObj, 1)
+    expect(item).toBeDefined()
+  })
+
+  test('should handle merging existing item data with new object', () => {
+    // Add item first
+    player.addItem('TestPotion', 1)
+
+    // Add same item with different properties
+    const updatedItem: ItemObject = {
+      id: 'TestPotion',
+      name: 'Updated Potion',
+      price: 250,
+    }
+    const item = player.addItem(updatedItem, 1)
+    expect(item.name()).toBe('Updated Potion')
+    expect(item.quantity()).toBe(2)
+  })
+
+  test('should handle multiple items in inventory', () => {
+    player.addItem('TestPotion', 3)
+    player.addItem('TestSword', 1)
+    player.addItem('TestArmor', 2)
+
+    expect(player.hasItem('TestPotion')).toBe(true)
+    expect(player.hasItem('TestSword')).toBe(true)
+    expect(player.hasItem('TestArmor')).toBe(true)
+
+    expect(player.getItem('TestPotion')?.quantity()).toBe(3)
+    expect(player.getItem('TestSword')?.quantity()).toBe(1)
+    expect(player.getItem('TestArmor')?.quantity()).toBe(2)
+  })
+})
+
+*/

package/tests/module.spec.ts

@@ -0,0 +1,38 @@
+import { beforeEach, test, expect } from 'vitest'
+import { testing } from '@rpgjs/testing'
+import { defineModule, createModule } from '@rpgjs/common'
+import { RpgPlayer, RpgServer } from '../src'
+import { RpgClient } from '../../client/src'
+
+// Define your server module
+const serverModule = defineModule<RpgServer>({
+  player: {
+    onConnected(player) {
+      player.setVariable('test', 'value')
+    }
+  }
+})
+
+// Define your client module
+const clientModule = defineModule<RpgClient>({
+  // Client-side logic
+})
+
+let player: RpgPlayer
+
+beforeEach(async () => {
+    // Create module using createModule
+    const myModule = createModule('MyModule', [{
+        server: serverModule,
+        client: clientModule
+    }])
+    
+    // Pass the module created with createModule to testing
+    const fixture = await testing(myModule)
+    const client = await fixture.createClient()
+    player = client.player
+})
+
+test('Module hook was called', () => {
+  expect(player.getVariable('test')).toBe('value')
+})

package/tests/player-param.spec.ts

@@ -0,0 +1,28 @@
+
+import { testing } from '@rpgjs/testing'
+import { beforeEach, describe, expect, test, vi } from 'vitest'
+import { ATK, MAXHP, MAXHP_CURVE, MAXSP, MAXSP_CURVE, RpgPlayer } from '../src'
+
+let player: RpgPlayer
+
+beforeEach(async () => {
+   const fixture = await testing();  
+   const client = await fixture.createClient()
+   player = client.player
+})
+
+test('Test HP', () => {
+   expect(player.hp).toBe(MAXHP_CURVE.start)
+})
+
+test('Test SP', () => {
+   expect(player.sp).toBe(MAXSP_CURVE.start)
+})
+
+test('Test MaxHP', () => {
+   expect(player.param[MAXHP]).toBe(MAXHP_CURVE.start)
+})
+
+test('Test MaxSP', () => {
+   expect(player.param[MAXSP]).toBe(MAXSP_CURVE.start)
+})