@rpgjs/server 3.3.2 → 4.0.0-beta.3

package/src/Player/SkillManager.ts

@@ -0,0 +1,229 @@
+import { Utils }  from '@rpgjs/common'
+import { Effect } from '@rpgjs/database'
+import { SkillLog } from '../logs'
+import { StateManager } from './StateManager'
+import { EffectManager } from './EffectManager'
+import { ParameterManager } from './ParameterManager';
+import { RpgPlayer } from './Player';
+
+import { 
+    INT
+} from '../presets'
+
+const { 
+    isArray, 
+    isString, 
+    isInstanceOf,
+    applyMixins
+} = Utils
+
+export class SkillManager {
+
+    skills: any[]
+
+    private _getSkillIndex(skillClass) {
+        return this.skills.findIndex(skill => {
+            if (isString(skill)) {
+                return skill.id == skillClass
+            }
+            return isInstanceOf(skill, skillClass)
+        })
+    }
+
+    /**
+     * Retrieves a skill. Returns null, if not found
+     * ```ts
+     * import Fire from 'your-database/skills/fire'
+     * 
+     * player.getSkill(Fire)
+     *  ```
+     * 
+     * @title Get Skill
+     * @method player.getSkill(skillClass)
+     * @param {SkillClass} skillClass 
+     * @returns {instance of SkillClass | null}
+     * @memberof SkillManager
+     */
+    getSkill(skillClass) {
+        const index = this._getSkillIndex(skillClass)
+        return this.skills[index]
+    }
+
+    /**
+     * Learn a skill. Attributes the coefficient 1 to the parameter INT (intelligence) if cd is not present on the class.
+     * 
+     * `onLearn()` method is called on the SkillClass
+     * 
+     * ```ts
+     * import Fire from 'your-database/skills/fire'
+     * 
+     * player.learnSkill(Fire)
+     *  ```
+     * 
+     * @title Learn Skill
+     * @method player.learnSkill(skillClass)
+     * @param {SkillClass} skillClass 
+     * @returns {instance of SkillClass}
+     * @memberof SkillManager
+     */
+    learnSkill(skillClass) {
+        const instance = new skillClass()
+        if (!instance.coefficient) instance.coefficient = {
+            [INT]: 1
+        }
+        this.skills.push(instance)
+        this['execMethod']('onLearn', [this], instance)
+        return instance
+    }
+
+    /**
+     * Forget a skill
+     * 
+     * `onForget()` method is called on the SkillClass
+     * 
+     * ```ts
+     * import Fire from 'your-database/skills/fire'
+     * 
+     * try {
+     *      player.forgetSkill(Fire) 
+     * }
+     * catch (err) {
+     *      console.log(err)
+     * }
+     *  ```
+     * 
+     * @title Forget Skill
+     * @method player.learnSkill(skillClass)
+     * @param {SkillClass} skillClass 
+     * @throws {SkillLog} notLearned 
+     * If trying to forget a skill not learned
+     *  ```
+     * {
+     *      id: SKILL_NOT_LEARNED,
+     *      msg: '...'
+     * }
+     * ```
+     * @returns {instance of SkillClass}
+     * @memberof SkillManager
+     */
+    forgetSkill(skillClass) {
+        const index = this._getSkillIndex(skillClass)
+        if (index == -1) {
+            throw SkillLog.notLearned(skillClass)
+        }
+        this.skills.splice(index, 1)
+        const instance = this.skills[index]
+        this['execMethod']('onForget', [this], instance)
+        return instance
+    }
+
+    /**
+     * Using a skill
+     * 
+     * `onUse()` method is called on the SkillClass
+     * 
+     * If other players are indicated then damage will be done to these other players. The method `applyDamage()` will be executed
+     * 
+     * ```ts
+     * import Fire from 'your-database/skills/fire'
+     * 
+     * try {
+     *      player.useSkill(Fire) 
+     * }
+     * catch (err) {
+     *      console.log(err)
+     * }
+     *  ```
+     * 
+     * or 
+     * 
+     * 
+     * * ```ts
+     * import Fire from 'your-database/skills/fire'
+     * 
+     * try {
+     *      player.useSkill(Fire, otherPlayer) 
+     * }
+     * catch (err) {
+     *      console.log(err)
+     * }
+     *  ```
+     * 
+     * @title Use Skill
+     * @method player.useSkill(skillClass,otherPlayer)
+     * @param {SkillClass} skillClass
+     * @param {Array<RpgPlayer> | RpgPlayer} [otherPlayer] 
+     * @throws {SkillLog} restriction 
+     * If the player has the `Effect.CAN_NOT_SKILL` effect 
+     *  ```
+     * {
+     *      id: RESTRICTION_SKILL,
+     *      msg: '...'
+     * }
+     * ```
+     * @throws {SkillLog} notLearned 
+     * If the player tries to use an unlearned skill
+     *  ```
+     * {
+     *      id: SKILL_NOT_LEARNED,
+     *      msg: '...'
+     * }
+     * ```
+     * @throws {SkillLog} notEnoughSp 
+     * If the player does not have enough SP to use the skill
+     *  ```
+     * {
+     *      id: NOT_ENOUGH_SP,
+     *      msg: '...'
+     * }
+     * ```
+     * @throws {SkillLog} chanceToUseFailed 
+     * If the chance to use the skill has failed (defined with the `hitRate` property)
+     *  ```
+     * {
+     *      id: USE_CHANCE_SKILL_FAILED,
+     *      msg: '...'
+     * }
+     * ```
+     * 
+     * `onUseFailed()` method is called on the SkillClass
+     * 
+     * @returns {instance of SkillClass}
+     * @memberof SkillManager
+     * @todo
+     */
+    useSkill(skillClass, otherPlayer?: RpgPlayer | RpgPlayer[]) {
+        const skill = this.getSkill(skillClass)
+        if (this.hasEffect(Effect.CAN_NOT_SKILL)) {
+            throw SkillLog.restriction(skillClass)
+        }
+        if (!skill) {
+            throw SkillLog.notLearned(skillClass)
+        }
+        if (skill.spCost > this.sp) {
+            throw SkillLog.notEnoughSp(skillClass, skill.spCost, this.sp)
+        }
+        this.sp -= (skill.spCost / (this.hasEffect(Effect.HALF_SP_COST) ? 2 : 1))
+        const hitRate = skill.hitRate || 1
+        if (Math.random() > hitRate) {
+            this['execMethod']('onUseFailed', [this, otherPlayer], skill)
+            throw SkillLog.chanceToUseFailed(skillClass)
+        }
+        if (otherPlayer) {
+            let players: any = otherPlayer
+            if (!isArray(players)) {
+                players = [otherPlayer]
+            }
+            for (let player of players) {
+                this.applyStates(player, skill)
+                player.applyDamage(this, skill)
+            } 
+        }
+        this['execMethod']('onUse', [this, otherPlayer], skill)
+        return skill
+    }
+}
+
+applyMixins(SkillManager, [ParameterManager, StateManager, EffectManager])
+
+export interface SkillManager extends ParameterManager, StateManager, EffectManager { }

package/src/Player/StateManager.ts

@@ -0,0 +1,230 @@
+import { Utils }  from '@rpgjs/common'
+import { ItemFixture } from './ItemFixture'
+import { RpgPlayer } from './Player'
+import { StateLog } from '../logs/state'
+
+const { 
+    isInstanceOf,
+    applyMixins
+} = Utils
+
+export class StateManager {
+
+    states: any[] = []
+
+    _statesEfficiency: { rate: number, state: any }[]
+
+    /** 
+     * Recovers the player's states defense on inventory.  This list is generated from the `statesDefense` property defined on the weapons or armors equipped.
+     * If several items have the same element, only the highest rate will be taken into account.
+     * 
+     * ```ts
+     * import { Armor, State } from '@rpgjs/server'
+     * 
+     * @State({
+     *      name: 'Paralyze'
+     * })
+     * class Paralyze {}
+     * 
+     * @Armor({
+     *      name: 'Shield',
+     *      statesDefense: [{ rate: 1, state: Paralyze }]
+     * })
+     * class Shield {}
+     * 
+     * @Armor({
+     *      name: 'FireShield',
+     *      statesDefense: [{ rate: 0.5, state: Paralyze }]
+     * })
+     * class FireShield {}
+     *
+     * player.addItem(Shield)
+     * player.addItem(FireShield)
+     * player.equip(Shield)
+     * player.equip(FireShield)
+     * 
+     * console.log(player.statesDefense) // [{ rate: 1, state: instance of Paralyze }]
+     * ``` 
+     * @title Get States Defense
+     * @prop {Array<{ rate: number, state: StateClass}>} player.statesDefense
+     * @readonly
+     * @memberof StateManager
+     * */
+    get statesDefense(): { rate: number, state: any }[] {
+        return this.getFeature('statesDefense', 'state')
+    }
+
+    /** 
+     * Set or retrieves all the states where the player is vulnerable or not. 
+     * 
+     * ```ts
+     * import { Class, State } from '@rpgjs/server'
+     * 
+     * @State({
+     *      name: 'Paralyze'
+     * })
+     * class Paralyze {}
+     * 
+     * @State({
+     *      name: 'Sleep'
+     * })
+     * class Sleep {}
+     * 
+     * @Class({
+     *      name: 'Fighter',
+     *      statesEfficiency: [{ rate: 1, state: Paralyze }]
+     * })
+     * class Hero {}
+     * 
+     * player.setClass(Hero)
+     * 
+     * console.log(player.statesEfficiency) // [{ rate: 1, instance of Paralyze }]
+     * 
+     * player.statesEfficiency = [{ rate: 2, state: Sleep }]
+     * 
+     * console.log(player.statesEfficiency) // [{ rate: 1, state: instance of Paralyze }, { rate: 2, state: instance of Sleep }]
+     * ``` 
+     * @title Set/Get States Efficiency
+     * @prop {Array<{ rate: number, state: StateClass}>} player.statesEfficiency
+     * @memberof StateManager
+     * */
+    get statesEfficiency() {
+        return this._statesEfficiency
+    }
+
+    set statesEfficiency(val) {
+        this._statesEfficiency = val
+    }
+
+    applyStates(player: RpgPlayer, { addStates, removeStates }) {
+        if (addStates) {
+            for (let { state, rate } of addStates) {
+                player.addState(state, rate)
+            }
+        }
+        if (removeStates) {
+            for (let { state, rate } of removeStates) {
+                player.removeState(state, rate)
+            }
+        } 
+    }
+
+    /**
+     * Get a state to the player. Returns `null` if the state is not present on the player
+     * ```ts
+     * import Paralyze from 'your-database/states/paralyze'
+     * 
+     * player.getState(Paralyze)
+     *  ```
+     * 
+     * @title Get State
+     * @method player.getState(stateClass)
+     * @param {StateClass} stateClass
+     * @returns {instance of StateClass | null}
+     * @memberof StateManager
+     */
+    getState(stateClass) {
+        return this.states.find(({ state }) => state instanceof stateClass)
+    }
+
+    /**
+     * Adds a state to the player. Set the chance between 0 and 1 that the state can apply
+     * ```ts
+     * import Paralyze from 'your-database/states/paralyze'
+     * 
+     * try { 
+     *      player.addState(Paralyze)
+     * }
+     * catch (err) {
+     *      console.log(err)
+     * }
+     *  ```
+     * 
+     * @title Add State
+     * @method player.addState(stateClass,chance=1)
+     * @param {StateClass} stateClass
+     * @param {number} [chance] 1 by default
+     * @throws {StateLog} addFailed 
+     * If the chance to add the state has failed (defined with the `chance` param)
+     *  ```
+     * {
+     *      id: ADD_STATE_FAILED,
+     *      msg: '...'
+     * }
+     * ```
+     * @returns {instance of StateClass}
+     * @memberof StateManager
+     * @todo
+     */
+    addState(stateClass, chance = 1): object | null {
+        const state = this.getState(stateClass)
+        if (!state) {
+            if (Math.random() > chance) {
+                throw StateLog.addFailed(stateClass)
+            }
+            //const efficiency = this.findStateEfficiency(stateClass)
+            const instance = new stateClass()
+            this.states.push(instance)
+            this.applyStates(<any>this, instance)
+            return instance
+        }
+        return null
+    }
+
+    /**
+     * Remove a state to the player. Set the chance between 0 and 1 that the state can be removed
+     * ```ts
+     * import Paralyze from 'your-database/states/paralyze'
+     * 
+     * try { 
+     *      player.removeState(Paralyze)
+     * }
+     * catch (err) {
+     *      console.log(err)
+     * }
+     *  ```
+     * 
+     * @title Remove State
+     * @method player.removeState(stateClass,chance=1)
+     * @param {StateClass} stateClass
+     * @param {number} [chance] 1 by default
+     * @throws {StateLog} removeFailed 
+     * If the chance to remove the state has failed (defined with the `chance` param)
+     *  ```
+     * {
+     *      id: REMOVE_STATE_FAILED,
+     *      msg: '...'
+     * }
+     * ```
+     * @throws {StateLog} notApplied 
+     * If the status does not exist
+     *  ```
+     * {
+     *      id: STATE_NOT_APPLIED,
+     *      msg: '...'
+     * }
+     * ```
+     * @returns {instance of StateClass}
+     * @memberof StateManager
+     */
+    removeState(stateClass, chance = 1) {
+        const index = this.states.findIndex(state => state instanceof stateClass)
+        if (index != -1) {
+            if (Math.random() > chance) {
+                throw StateLog.removeFailed(stateClass)
+            }
+            this.states.splice(index, 1)
+        }
+        else {
+            throw StateLog.notApplied(stateClass)
+        }
+    }
+
+    private findStateEfficiency(stateClass) {
+        return this.statesEfficiency.find(state => isInstanceOf(state.state, stateClass))
+    }
+}
+
+applyMixins(StateManager, [ItemFixture])
+
+export interface StateManager extends ItemFixture { }

package/src/Player/VariableManager.ts

@@ -0,0 +1,55 @@
+export class VariableManager {
+    variables: Map<string, any>
+
+    /** 
+     * Assign a variable to the player
+     * 
+     * ```ts
+     * player.setVariable('OPEN_CHEST', true)
+     * ```
+     * 
+     * @title Set variable
+     * @method player.setVariable(key,val)
+     * @param {string} key
+     * @param {any} val
+     * @returns {void}
+     * @memberof VariableManager
+     * */
+    setVariable(key: string, val) {
+        this.variables.set(key, val)
+    }
+
+    /** 
+     * Get a variable
+     * 
+     * ```ts
+     * const val = player.getVariable('OPEN_CHEST')
+     * ```
+     * 
+     * @title Get variable
+     * @method player.setVariable(key,val)
+     * @param {string} key
+     * @returns {any} 
+     * @memberof VariableManager
+     * */
+    getVariable(key: string) {
+        return this.variables.get(key)
+    }
+
+    /** 
+     * Remove a variable
+     * 
+     * ```ts
+     * player.removeVariable('OPEN_CHEST')
+     * ```
+     * 
+     * @title Remove variable
+     * @method player.removeVariable(key)
+     * @param {string} key
+     * @returns {boolean} true if a variable existed and has been removed, or false if the variable does not exist.
+     * @memberof VariableManager
+     * */
+    removeVariable(key: string) {
+        return this.variables.delete(key)
+    }
+}

package/src/Query.ts

@@ -0,0 +1,172 @@
+import { World } from 'simple-room'
+import { RpgShape, Utils } from '@rpgjs/common'
+import { RpgPlayer } from './Player/Player'
+import { Observable } from 'rxjs'
+
+const { isString } = Utils
+
+class QueryClass {
+    /** 
+     * Listen to the changes on all the rooms
+     * 
+     * ```ts
+     * import { RpgWorld } from '@rpgjs/server'
+     * import { map } from 'rxjs/operators' // install rxjs
+     * 
+     * RpgWorld.changes
+     *  .pipe(
+     *      map(rooms => rooms['mymap'])
+     *  )
+     *  .subscribe((room) => {
+     *      const users: any = Object.values(room.users)
+     *      console.log(users)
+     *  })
+     * ``` 
+     * 
+     * @title Subscribe to the world
+     * @prop {Observable} RpgWorld.changes
+     * @memberof RpgWorld
+     * */
+    get changes(): Observable<any> {
+        return World.changes.asObservable() as any
+    }
+
+    /**
+     * Retrieve a player according to his ID
+     * 
+     * ```ts
+     * import { RpgWorld } from '@rpgjs/server'
+     * 
+     * const player = RpgWorld.getPlayer(player) // player is RpgPlayer (player.id) or string (id)
+     * ```
+     * 
+     * @title Get Player
+     * @method RpgWorld.getPlayer(player)
+     * @param {RpgPlayer | string} player identifier
+     * @returns {RpgPlayer}
+     * @memberof RpgWorld
+     */
+    getPlayer(player: RpgPlayer | string): RpgPlayer {
+        const id: any = isString(player) ? player : '' + (player as RpgPlayer).id
+        const _player: any = World.getUser(id)
+        return _player as RpgPlayer
+    }
+
+    /**
+     * Recover all the players of the game
+     * 
+     * ```ts
+     * import { RpgWorld } from '@rpgjs/server'
+     * 
+     * const players = RpgWorld.getPlayers()
+     * ```
+     * 
+     * @title Get all Players
+     * @method RpgWorld.getPlayers()
+     * @returns {Array<RpgPlayer>}
+     * @memberof RpgWorld
+     */
+    getPlayers(): RpgPlayer[] {
+        const users: any = World.getUsers()
+        const array = Object.values(users) as RpgPlayer[]
+        return array.map((user: RpgPlayer) => this.getPlayer(user))
+    }
+
+    /**
+     * Recover all map objects: players and events. If you specify the `player` parameter, it also retrieves the events in scenario mode of the player in question
+     * 
+     * ```ts
+     * import { RpgWorld } from '@rpgjs/server'
+     * 
+     * const objects = RpgWorld.getObjectsOfMap('mapname')
+     * console.log(objects)
+     * ```
+     * 
+     * Also retrieve events in Scenario mode:
+     * 
+     * ```ts
+     * import { RpgWorld } from '@rpgjs/server'
+     * 
+     * const objects = RpgWorld.getObjectsOfMap('mapname', 'playerid')
+     * ```
+     * 
+     * @title Get all objects of map
+     * @method RpgWorld.getObjectsOfMap(map,playerId?)
+     * @param {string} map Map Name
+     * @param {RpgPlayer | string} playerId player identifier
+     * @returns {Array<RpgPlayer>}
+     * @memberof RpgWorld
+     */
+    getObjectsOfMap(map: string, playerId?: RpgPlayer | string): RpgPlayer[] {
+        return Object.values(this._getObjectsOfMap(map, playerId)) as RpgPlayer[]
+    }
+
+    _getObjectsOfMap(map: string, playerId?: RpgPlayer | string): { [id: string]: RpgPlayer } {
+        const room: any = World.getRoom(map)
+        let player: any = null
+        if (playerId) {
+            player = this.getPlayer(playerId)
+        }
+        return {
+            ...room.users,
+            ...room.events,
+            ...(player ? player.events : {})
+        }
+    }
+
+    /**
+     * Find all the shapes of the map
+     * 
+     * ```ts
+     * import { RpgWorld } from '@rpgjs/server'
+     * 
+     * const shapes = RpgWorld.getShapesOfMap('mapname')
+     * console.log(shapes)
+     * ```
+     * 
+     * @title Get all shapes of map
+     * @method RpgWorld.getShapesOfMap(map)
+     * @param {string} map Map Name
+     * @returns {Array<RpgShape>}
+     * @memberof RpgWorld
+     */
+    getShapesOfMap(map: string): RpgShape[] {
+        return Object.values(this._getShapesOfMap(map))
+    }
+
+    _getShapesOfMap(map: string): { [id: string]: RpgShape } {
+        const room: any = World.getRoom(map)
+        return room.shapes
+    }
+
+    // TODO
+    getRooms<T>(): Map<string, T> {
+        return World.getRooms() as Map<string, T>
+    }
+
+    getRoom<T>(name: string): T {
+        return World.getRoom(name) as T
+    }
+
+    /**
+     * Recover all the players of a map
+     * 
+     * ```ts
+     * import { RpgWorld } from '@rpgjs/server'
+     * 
+     * const players = RpgWorld.getPlayersOfMap('mapname')
+     * ```
+     * 
+     * @title Get all Players a map
+     * @method RpgWorld.getPlayersOfMap(map)
+     * @param {string} map Map Name
+     * @returns {Array<RpgPlayer>}
+     * @memberof RpgWorld
+     */
+    getPlayersOfMap(map: string): RpgPlayer[] {
+        const room: any = World.getRoom(map)
+        return Object.values(room.users) as RpgPlayer[]
+    }
+}
+
+export const Query = new QueryClass()