particles wrapper update plus tween and hue support.

Author: jjppof

assets/plugins/particle-storm.js

@@ -1065,6 +1065,7 @@ export class Map {
                 property_info.message,
                 property_info.thought_message,
                 property_info.back_interaction_message,
+                property_info.allow_only_front_interaction,
                 avatar,
                 property_info.shop_key,
                 property_info.inn_key,
@@ -1475,6 +1476,9 @@ export class Map {
                 if (layer_obj.properties.reveal_layer || hidden) {
                     layer_sprite.visible = false;
                 }
+                if (layer_obj.properties.opacity !== undefined) {
+                    layer_sprite.alpha = layer_obj.properties.opacity;
+                }
             } else {
                 layer_sprite = layer_obj.sprite;
             }

base/Map.ts

@@ -38,6 +38,7 @@ export class NPC extends ControllableChar {
     private _message: string;
     private _thought_message: string;
     private _back_interaction_message: string;
+    private _allow_only_front_interaction: boolean;
     private _avatar: string;
     private _voice_key: string;
     private _base_collision_layer: number;
@@ -114,6 +115,7 @@ export class NPC extends ControllableChar {
         message,
         thought_message,
         back_interaction_message,
+        allow_only_front_interaction,
         avatar,
         shop_key,
         inn_key,
@@ -174,6 +176,7 @@ export class NPC extends ControllableChar {
         this._message = message ?? "";
         this._thought_message = thought_message ?? "";
         this._back_interaction_message = back_interaction_message ?? "";
+        this._allow_only_front_interaction = allow_only_front_interaction ?? false;
         this._avatar = avatar ?? null;
         this._voice_key = voice_key ?? "";
         this._shop_key = shop_key;
@@ -235,6 +238,10 @@ export class NPC extends ControllableChar {
     get back_interaction_message() {
         return this._back_interaction_message;
     }
+    /** If true, the hero will only be able to interact with this NPC when he's on the front of it. */
+    get allow_only_front_interaction() {
+        return this._allow_only_front_interaction;
+    }
     /** The avatar key of this NPC. */
     get avatar() {
         return this._avatar;

base/NPC.ts

@@ -3,6 +3,7 @@ import {GoldenSun} from "GoldenSun";
 import {GAME_HEIGHT, GAME_WIDTH} from "./magic_numbers";
 import {elements, element_colors_in_battle, hex2rgb} from "./utils";
 import * as _ from "lodash";
+import {EventValue} from "game_events/GameEvent";
 
 export type AdvParticleValue =
     | number
@@ -87,6 +88,8 @@ export type Emitter = {
         step: number;
         visible: boolean;
     };
+    hue_angle?: number;
+    random_animation_start?: boolean;
     particles_display_blend_mode?: string;
     render_white_core?: boolean;
     core_custom_color?: string;
@@ -123,6 +126,13 @@ export type Emitter = {
         frame_rate: number;
         loop: boolean;
     };
+    tween_emitter?: {
+        duration: number;
+        x?: number | EventValue;
+        y?: number | EventValue;
+        easing?: string;
+        incremental?: boolean;
+    };
 };
 
 export type ParticlesInfo = {
@@ -154,10 +164,10 @@ export class ParticlesWrapper {
         },
         element?: elements,
         xy_pos_getter?: (
-            x: number | string,
-            y: number | string,
-            shift_x: number,
-            shift_y: number
+            x: number | string | EventValue,
+            y: number | string | EventValue,
+            shift_x: number | EventValue,
+            shift_y: number | EventValue
         ) => {x: number; y: number}
     ) {
         const promises: Promise<void>[] = [];
@@ -317,7 +327,59 @@ export class ParticlesWrapper {
                     emitter_info.shift_x,
                     emitter_info.shift_y
                 );
-                emitter.emit(emitter_info.emitter_data_key, x, y, {
+                if (
+                    emitter_info.hue_angle !== undefined ||
+                    emitter_info.random_animation_start ||
+                    adv_particles_seq.particles_callback ||
+                    emitter_info.animation !== undefined
+                ) {
+                    emitter.onEmit = new Phaser.Signal();
+                    emitter.onEmit.add(
+                        (emitter: Phaser.ParticleStorm.Emitter, particle: Phaser.ParticleStorm.Particle) => {
+                            if (emitter_info.hue_angle !== undefined) {
+                                if (!particle.sprite.filters) {
+                                    const hue_filter = this.game.add.filter("Hue") as Phaser.Filter.Hue;
+                                    particle.sprite.filters = [hue_filter];
+                                    hue_filter.angle = emitter_info.hue_angle;
+                                }
+                            }
+                            if (emitter_info.random_animation_start) {
+                                if (particle.sprite.animations.currentAnim) {
+                                    particle.sprite.frameName = _.sample(
+                                        Object.keys(particle.sprite.animations.currentAnim._frameData._frameNames)
+                                    );
+                                }
+                            }
+                            if (adv_particles_seq.particles_callback) {
+                                adv_particles_seq.particles_callback(particle);
+                            }
+                            if (emitter_info.animation !== undefined) {
+                                if (
+                                    !particle.sprite.animations.currentAnim ||
+                                    !particle.sprite.animations.currentAnim.isPlaying
+                                ) {
+                                    const particle_key = adv_particles_seq.data[emitter_info.emitter_data_key]
+                                        .image as string;
+                                    const particle_sprite_base = this.data.info.misc_sprite_base_list[particle_key];
+                                    const anim_key = particle_sprite_base.getAnimationKey(
+                                        particle_key,
+                                        emitter_info.animation.animation_key
+                                    );
+                                    particle_sprite_base.setAnimation(particle.sprite, particle_key);
+                                    particle.sprite.animations.play(
+                                        anim_key,
+                                        emitter_info.animation.frame_rate,
+                                        emitter_info.animation.loop
+                                    );
+                                }
+                            }
+                        }
+                    );
+                }
+                const pos = {x: x, y: y};
+                const get_x = () => pos.x;
+                const get_y = () => pos.y;
+                emitter.emit(emitter_info.emitter_data_key, get_x, get_y, {
                     ...(emitter_info.total !== undefined && {total: emitter_info.total}),
                     ...(emitter_info.repeat !== undefined && {repeat: emitter_info.repeat}),
                     ...(emitter_info.frequency !== undefined && {frequency: emitter_info.frequency}),
@@ -330,31 +392,32 @@ export class ParticlesWrapper {
                     ...(emitter_info.radiate !== undefined && {radiate: emitter_info.radiate}),
                     ...(emitter_info.radiateFrom !== undefined && {radiateFrom: emitter_info.radiateFrom}),
                 });
-                if (adv_particles_seq.particles_callback) {
-                    emitter.forEach((particle: Phaser.ParticleStorm.Particle) => {
-                        adv_particles_seq.particles_callback(particle);
-                    }, this);
-                }
-                if (emitter_info.animation !== undefined) {
-                    const particle_key = adv_particles_seq.data[emitter_info.emitter_data_key].image as string;
-                    const particle_sprite_base = this.data.info.misc_sprite_base_list[particle_key];
-                    const anim_key = particle_sprite_base.getAnimationKey(
-                        particle_key,
-                        emitter_info.animation.animation_key
-                    );
-                    emitter.forEach((particle: Phaser.ParticleStorm.Particle) => {
-                        particle_sprite_base.setAnimation(particle.sprite, particle_key);
-                    }, this);
-                    emitter.onEmit = new Phaser.Signal();
-                    emitter.onEmit.add(
-                        (emitter: Phaser.ParticleStorm.Emitter, particle: Phaser.ParticleStorm.Particle) => {
-                            particle.sprite.animations.play(
-                                anim_key,
-                                emitter_info.animation.frame_rate,
-                                emitter_info.animation.loop
-                            );
+                if (emitter_info.tween_emitter) {
+                    const dest: {x?: number; y?: number} = {};
+                    if (emitter_info.tween_emitter.x) {
+                        if (typeof emitter_info.tween_emitter.x !== "number") {
+                            dest.x = this.data.game_event_manager.get_value(emitter_info.tween_emitter.x);
+                        } else {
+                            dest.x = emitter_info.tween_emitter.x;
                         }
-                    );
+                        dest.x = (emitter_info.tween_emitter.incremental ? pos.x : 0) + dest.x;
+                    }
+                    if (emitter_info.tween_emitter.y) {
+                        if (typeof emitter_info.tween_emitter.y !== "number") {
+                            dest.y = this.data.game_event_manager.get_value(emitter_info.tween_emitter.y);
+                        } else {
+                            dest.y = emitter_info.tween_emitter.y;
+                        }
+                        dest.y = (emitter_info.tween_emitter.incremental ? pos.y : 0) + dest.y;
+                    }
+                    this.game.add
+                        .tween(pos)
+                        .to(
+                            dest,
+                            emitter_info.tween_emitter.duration,
+                            _.get(Phaser.Easing, emitter_info.tween_emitter.easing ?? "Linear.None"),
+                            true
+                        );
                 }
                 emitters.push(emitter);
             });

base/ParticlesWrapper.ts

@@ -169,6 +169,12 @@ export class GameEventManager {
             }
             const is_close_check = this.data.hero.is_close(npc);
             if (is_close_check) {
+                if (
+                    npc.allow_only_front_interaction &&
+                    (npc.tile_pos.y + 1 !== this.data.hero.tile_pos.y || npc.tile_pos.x !== this.data.hero.tile_pos.x)
+                ) {
+                    continue;
+                }
                 this.data.hero.stop_char();
                 npc.stop_char();
                 this.control_enable = false;

base/game_events/GameEventManager.ts

@@ -1,5 +1,5 @@
 import {ParticlesInfo} from "ParticlesWrapper";
-import {GameEvent, event_types} from "./GameEvent";
+import {EventValue, GameEvent, event_types} from "./GameEvent";
 
 enum game_groups {
     LOWER = "lower",
@@ -29,7 +29,39 @@ export class ParticlesEvent extends GameEvent {
 
     async _fire() {
         ++this.data.game_event_manager.events_running_count;
-        const promises = this.data.particle_wrapper.start_particles(this.particles_info, this.group);
+        const xy_pos_getter = (
+            x: number | EventValue,
+            y: number | EventValue,
+            shift_x: number | EventValue,
+            shift_y: number | EventValue
+        ) => {
+            let this_x = x as number;
+            let this_y = y as number;
+            let this_shift_x = shift_x as number;
+            let this_shift_y = shift_y as number;
+            if (x !== undefined && typeof x !== "number") {
+                this_x = this.data.game_event_manager.get_value(x);
+            }
+            if (y !== undefined && typeof y !== "number") {
+                this_y = this.data.game_event_manager.get_value(y);
+            }
+            if (shift_x !== undefined && typeof shift_x !== "number") {
+                this_shift_x = this.data.game_event_manager.get_value(shift_x);
+            }
+            if (shift_y !== undefined && typeof shift_y !== "number") {
+                this_shift_y = this.data.game_event_manager.get_value(shift_y);
+            }
+            this_x += this_shift_x ?? 0;
+            this_y += this_shift_y ?? 0;
+            return {x: this_x, y: this_y};
+        };
+        const promises = this.data.particle_wrapper.start_particles(
+            this.particles_info,
+            this.group,
+            undefined,
+            undefined,
+            xy_pos_getter
+        );
         const udpate_callback = () => this.data.particle_wrapper.render();
         this.data.game_event_manager.add_callback(udpate_callback);
         await Promise.all(promises);

base/game_events/ParticlesEvent.ts

@@ -191,6 +191,7 @@ declare module Phaser {
             scrollSpeed: Phaser.Point;
             force: Phaser.Point;
             onEmit: Phaser.Signal;
+            newParticleCallbacks?: ((sprite: Phaser.Sprite) => void)[]
             onComplete: Phaser.Signal;
             onKill: Phaser.Signal;
             particleClass: Phaser.ParticleStorm.Particle;

types/particlestorm.d.ts

@@ -135,6 +135,7 @@ declare module Phaser {
         enableUpdate: boolean;
         frame: number;
         frameTotal: number;
+        _frameData: any;
         game: Phaser.Game;
         isFinished: boolean;
         isPaused: boolean;