@rpgjs/client 4.2.2 → 5.0.0-alpha.0

package/src/Scene/SceneData.ts

@@ -1,13 +0,0 @@
-export interface SceneDataOptions {
-    inputs?: {
-
-    }
-}
-
-export function SceneData(options) {
-    return (target) => {
-        for (let key in options) {
-            target.prototype[key] = options[key]
-        }
-    }
-}

package/src/Sound/RpgSound.ts

@@ -1,50 +0,0 @@
-import { Howl, Howler } from 'howler'
-import { log } from '../Logger'
-import { sounds } from './Sounds'
-
-class RpgSoundClass {
-    private sounds: Map<string, Howl> = new Map()
-
-    get(id: string): Howl {
-        if (this.sounds.has(id)) {
-            return this.sounds.get(id) as Howl
-        }
-        const resource = sounds.get(id)
-        if (!resource) {
-            throw log(`Impossible to find the ${id} sound. Did you put the right name or create the sound?`)
-        }
-        const howl = new Howl({
-            src: [resource.sound],
-            loop: resource.loop,
-            autoplay: resource.autoplay,
-            volume: resource.volume,
-            sprite: resource.sprite
-        })
-        this.sounds.set(id, howl)
-        return howl
-    }
-
-    stop(id: string) {
-        this.get(id).stop()
-    }
-
-    play(id: string): boolean {
-        const sound = this.get(id)
-        if (!sound.playing()) {
-            sound.play()
-            return true
-        }
-        return false
-    }
-
-    clear() {
-        this.sounds.clear()
-        this.global.stop()
-    }
-
-    get global(): typeof Howler {
-        return Howler
-    }
-}
-
-export const RpgSound = new RpgSoundClass()

package/src/Sound/Sound.ts

@@ -1,91 +0,0 @@
-interface SoundOptions {
-    /** 
-     * The link to the sound
-     * 
-     * > Do not use the `images` property
-     * > Remember to wrap the link to the image with the `require` function.
-     * 
-     * ```ts
-     * sound: require('./assets/sound.ogg')
-     * ```
-     * 
-     * @prop {string} [sound]
-     * @memberof Sound
-     * */
-    sound?: string
-
-    /** 
-     * The sound will restart at the beginning when it is finished.
-     * 
-     * @prop {boolean} [loop]
-     * @memberof Sound
-     * */
-    loop?: boolean,
-
-    /** 
-     * Volume
-     * 
-     * @prop {number} [volume]
-     * @memberof Sound
-     * */
-    volume?: number
-}
-
-type SoundIdOptions = SoundOptions & {
-    /** 
-     * Sound identifier.
-     * 
-     * > Do not use the `sounds` property
-     * 
-     * @prop {string} [id]
-     * @memberof Sound
-     * */
-    id: string
-
-    /** 
-     * The link to the sound
-     * 
-     * > Do not use the `images` property
-     * > Remember to wrap the link to the image with the `require` function.
-     * 
-     * ```ts
-     * sound: require('./assets/sound.ogg')
-     * ```
-     * 
-     * @prop {string} [sound]
-     * @memberof Sound
-     * */
-    sound: string
-}
-type SoundIdsOptions = SoundOptions & {
-    /** 
-    * Put the different sounds that are concerned by the properties below.
-    * The key of the object is the identifier of the sound and the value and the link to the sound.
-    * 
-    * > Remember to wrap the link to the sound with the `require` function.
-    * 
-    * ```ts
-    * sounds: {
-    *    hero: require('./assets/sound.ogg')
-    * }
-    * ```
-    * 
-    * @prop { { [id: string]: string } } [sounds]
-    * @memberof Sound
-    * */
-    sounds?: {
-        [id: string]: string
-    }
-}
-
-export function Sound(options: SoundIdOptions)
-export function Sound(options: SoundIdsOptions)
-export function Sound(options: SoundIdOptions | SoundIdsOptions) {
-    return (target: Function) => {
-        if ('sounds' in options)  target['sounds'] = options.sounds
-        if ('id' in options) target['id'] = options.id
-        for (let key in options) {
-            target.prototype[key] = options[key]
-        }
-    }
-}

package/src/Sound/Sounds.ts

@@ -1,7 +0,0 @@
-import { _initResource } from '../Resources'
-
-export const sounds = new Map()
-
-export function _initSound(_sounds, engine) {
-    return _initResource(sounds, _sounds, 'sound', engine)
-}

package/src/Sprite/Character.ts

@@ -1,157 +0,0 @@
-import { Utils, RpgPlugin, HookClient } from '@rpgjs/common'
-import { spritesheets } from './Spritesheets'
-import { Animation } from '../Effects/Animation'
-import { Animation as AnimationEnum } from '../Effects/AnimationCharacter'
-import { RpgComponent } from '../Components/Component'
-import { TransformOptions } from './Spritesheet'
-import { Sprite } from 'pixi.js'
-
-const { capitalize } = Utils
-
-export default class Character extends Sprite {
-    static readonly id: string = 'graphic'
-
-    private spritesheet: any
-    private playStandardAnimation: boolean = true
-    public animation: Animation
-    private objSaved: object = {}
-    private data: any = {}
-    
-     /** @internal */
-     h: number = 1
-     /** @internal */
-     w: number = 1
-    
-    /** @internal */
-    anim: Animation
-
-    constructor(private component: RpgComponent, private graphic: string) {
-        super()
-        this.data = component.logic
-        this.setGraphic(graphic)
-    }
-
-    /** @internal */
-    showAnimation(graphic: string | string[], animationName: string): Animation | null {
-        const refreshAnimation = (graphic: string) => {
-            this.removeChild(this.animation)
-            this.animation = new Animation(graphic)
-            this.addChild(this.animation)
-            this.setAnimationAnchor()
-        }
-        const memoryGraphic = this.graphic
-        let graphicId: string | undefined = ''
-
-         // Changes only graphics already defined on the character
-        if (Utils.isArray(graphic)) {
-            graphicId = (graphic as string[]).find(id => id == this.graphic)
-        }
-        else {
-            graphicId = graphic as string
-        }
-
-        if (!graphicId) {
-            return null
-        }
-
-        refreshAnimation(graphicId)
-
-        this.component.animationIsPlaying = true
-        
-        this.animation.onFinish = () => {
-            this.playStandardAnimation = true
-            this.component.animationIsPlaying = false
-            refreshAnimation(memoryGraphic)
-            this.update(this.objSaved)
-        }
-
-        this.playStandardAnimation = false
-        this.playAnimation(animationName)
-        return this.animation
-    }
-
-    /** @internal */
-    setGraphic(graphic: string) {
-        (this.children as Animation[]).forEach((graphic: Animation, index: number) => {
-            if (graphic.id == this.graphic) {
-                this.removeChildAt(index)
-            }
-        })
-        this.graphic = graphic
-        this.spritesheet = spritesheets.get(this.graphic)
-        this.animation = new Animation(this.graphic)
-        this.addChild(this.animation)
-        this.setAnimationAnchor()
-    }
-
-    getGraphicHeight(): number {
-        return this.animation.getSpriteHeight()
-    }
-
-    getGraphicWidth(): number {
-        return this.animation.getSpriteWidth()
-    }
-
-    animationSprite() {
-        return this.animation.animation$
-    }
-
-    private setAnimationAnchor(): void {
-        this.animation.hitbox = { h: this.data.hHitbox, w: this.data.wHitbox }
-        this.animation.applyTransform = (frame, animation, spritesheet) => {
-            const { spriteWidth, spriteHeight } = animation
-            const prop: keyof TransformOptions = 'spriteRealSize'
-            const currentAnchor = frame[prop] || animation[prop] || spritesheet[prop]
-            if (currentAnchor) {
-                return {}
-            }
-            return {
-                spriteRealSize: {
-                    width: spriteWidth,
-                    height: spriteHeight
-                }
-            }
-        }
-    }
-
-    /** @internal */
-    update(obj, options: any = {}, deltaRatio: number = 1): {
-        moving: boolean
-        instance: Character
-    } {
-        const { moving } = options
-        this.data = obj
-        if (this.anim) this.anim.update(deltaRatio)
-        if (this.animation) this.animation.update(deltaRatio)
-
-        if (this.playStandardAnimation) {
-            if (moving) {
-               RpgPlugin.emit(HookClient.SpriteMove, this)
-               this.playAnimation(AnimationEnum.Walk)
-            }
-            else {
-               this.playAnimation(AnimationEnum.Stand)
-            }
-        }
-
-        this.objSaved = obj
-
-        return {
-            moving,
-            instance: this
-        }
-    }
-
-    /** @internal */
-    playAnimation(name: string) {
-        const hook = `onCharacter${capitalize(name)}`
-        if (!this.spritesheet) return
-        if (this.spritesheet[hook]) {
-            this.spritesheet[hook](this)
-        }
-        else if (this.animation.has(name)) {
-            this.animation.play(name, [this.data.direction])
-        }
-    }
-
-}

package/src/Sprite/Player.ts

@@ -1,3 +0,0 @@
-import Character from './Character'
-
-export class RpgSprite extends Character {}