effect.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef NUVIE_CORE_EFFECT_H
#define NUVIE_CORE_EFFECT_H


#include "ultima/nuvie/misc/call_back.h"
#include "ultima/nuvie/core/map.h"
#include "ultima/nuvie/core/obj_manager.h"
#include "ultima/nuvie/core/anim_manager.h"

namespace Ultima {
namespace Nuvie {

//class Actor;
class EffectManager;
class Game;
class MapWindow;
class NuvieAnim;
class Screen;
class TimedAdvance;
class TimedCallback;
class ObjManager;

// Effects add themselves to EffectManager and most start immediately.

/* Effects: * = unwritten or untested
 * Quake - earthquake from cyclops or volcanos
 * Hit - hit actor anim + sfx
 * Explosive - explosion caused by powder keg, volcanos, or cannonball hit
 * ThrowObject - any thrown object or tile
 * Cannonball (FIX: change to UseCodeThrow)
 * Missile - throw object to ground or actor; optionally cause damage
 * *Boomerang - spin Missile and return to sender
 * Drop - throw obj from inventory to ground
 * Sleep - pause game & advance time quickly
 * Fade - fade the mapwindow in or out
 * GameFadeIn - blocks user-input until Fade is complete
 * *Palette - do something with the color palette
 * Vanish - fade from an image of the mapwindow to the real mapwindow
 * *FadeObject - might not need this since Vanish can be used
 * U6WhitePotion - will probably make PaletteEffect to do this
 */


/* Control animation and sounds in the game world.
 */
class Effect : public CallBack {
protected:
    Game *game;
    EffectManager *effect_manager;
    bool defunct;

    uint32 retain_count;

public:
    Effect();
    ~Effect() override;

    void retain() {
        retain_count++;
    }
    void release() {
        if (retain_count > 0) retain_count--;
    }
    bool is_retained() const {
        return retain_count == 0 ? false : true;
    }

    void delete_self() {
        defunct = true;
    }
    void add_anim(NuvieAnim *anim);

    bool is_defunct() const {
        return defunct;
    }
    uint16 callback(uint16, CallBack *, void *) override {
        return 0;
    }
};

/* Toss a cannon ball from one actor to another, or from an object towards
 * a numbered direction.
 */
class CannonballEffect : public Effect {
    UseCode *usecode;
    NuvieAnim *anim;
//  *sfx;
    Obj *obj;
    MapCoord target_loc; // where cannonball will hit

    void start_anim();

public:
    CannonballEffect(Obj *src_obj, sint8 direction = -1);
//    CannonballEffect(Actor *src_actor, Actor *target_actor); from a ship

    uint16 callback(uint16 msg, CallBack *caller, void *data) override;
};

class ProjectileEffect : public Effect {
protected:
    uint16 tile_num;

    MapCoord start_loc; // where explosion will start
    vector<MapCoord> targets;
    uint8 anim_speed;
    bool trail;
    uint16 initial_tile_rotation;
    uint16 rotation_amount;
    uint8 src_tile_y_offset;
    uint16 finished_tiles;

    vector<MapEntity> hit_entities;

    virtual void start_anim();

public:
    ProjectileEffect() : tile_num(0), anim_speed(0), trail(false),
            initial_tile_rotation(0), rotation_amount(0), src_tile_y_offset(0),
            finished_tiles(0) {
    }
    ProjectileEffect(uint16 tileNum, MapCoord start, MapCoord target, uint8 speed, bool trailFlag, uint16 initialTileRotation, uint16 rotationAmount, uint8 src_y_offset);
    ProjectileEffect(uint16 tileNum, MapCoord start, const vector<MapCoord> &t, uint8 speed, bool trailFlag, uint16 initialTileRotation);

    void init(uint16 tileNum, MapCoord start, const vector<MapCoord> &t, uint8 speed, bool trailFlag, uint16 initialTileRotation, uint16 rotationAmount, uint8 src_y_offset);

    uint16 callback(uint16 msg, CallBack *caller, void *data) override;

    vector<MapEntity> *get_hit_entities() {
        return &hit_entities;
    }
};

class ExpEffect : public ProjectileEffect {
    //UseCode *usecode;
    NuvieAnim *anim;

    //Obj *obj;
    uint16 exp_tile_num;

protected:
    void start_anim() override;
public:
    ExpEffect(uint16 tileNum, const MapCoord &location);

};

/* Use to add an effect with timed activity. Self-contained timer must be
 * stopped/started with the included methods.
 */
class TimedEffect : public Effect {
protected:
    TimedCallback *timer;
public:
    TimedEffect()                  {
        timer = nullptr;
    }
    TimedEffect(uint32 delay)      {
        timer = nullptr;
        start_timer(delay);
    }
    ~TimedEffect() override                 {
        stop_timer();
    }

    void start_timer(uint32 delay);
    void stop_timer();

    void delete_self() {
        stop_timer();
        Effect::delete_self();
    }

    uint16 callback(uint16 msg, CallBack *caller, void *data) override {
        if (msg == MESG_TIMED) delete_self();    //= 0;
        return 0;
    }
};


/* Shake the visible play area around.
 */
class QuakeEffect : public TimedEffect {
    MapWindow *map_window;
    static QuakeEffect *current_quake; // do nothing if already active
    sint32 sx, sy; // last map_window movement amount
    MapCoord orig; // map_window location at start
    Actor *orig_actor; // center map_window on actor
    uint32 stop_time;
    uint8 strength; // magnitude

public:
    QuakeEffect(uint8 magnitude, uint32 duration, Actor *keep_on = nullptr);
    ~QuakeEffect() override;
    uint16 callback(uint16 msg, CallBack *caller, void *data) override;

    void init_directions();
    void recenter_map();
    void stop_quake();
};


/* Hit target actor.
 */
class HitEffect : public Effect {
public:
    HitEffect(Actor *target, uint32 duration = 300);
    HitEffect(const MapCoord &location);
    uint16 callback(uint16 msg, CallBack *caller, void *data) override;
};

/* Print text to MapWindow for a given duration
 */
class TextEffect : public Effect {

public:
    TextEffect(Std::string text);
    TextEffect(Std::string text, const MapCoord &location);
    uint16 callback(uint16 msg, CallBack *caller, void *data) override;
};


/* Create explosion animation and sounds from the source location out to
 * specified radius. Hit actors and objects for `dmg'.
 */
class ExplosiveEffect : public Effect {
protected:
    NuvieAnim *anim;
//  *sfx;
    MapCoord start_at;
    uint32 radius;
    uint16 hit_damage; // hp taken off actors hit by explosion

    void start_anim();

public:
    ExplosiveEffect(uint16 x, uint16 y, uint32 size, uint16 dmg = 0);
    uint16 callback(uint16 msg, CallBack *caller, void *data) override;

    // children can override
    virtual void delete_self() {
        Effect::delete_self();
    }
    virtual bool hit_object(Obj *obj) {
        return false;    // explosion hit something
    }
    // true return=end effect
};


/* Explosion that sends usecode event to an object on completion.
 */
class UseCodeExplosiveEffect : public ExplosiveEffect {
    Obj *obj; // explosion came from this object (can be nullptr)
    Obj *original_obj; // don't hit this object (chain-reaction avoidance hack)

public:
    UseCodeExplosiveEffect(Obj *src_obj, uint16 x, uint16 y, uint32 size, uint16 dmg = 0, Obj *dont_hit_me = nullptr)
        : ExplosiveEffect(x, y, size, dmg), obj(src_obj), original_obj(dont_hit_me) {
    }
    void delete_self() override;
    bool hit_object(Obj *hit_obj) override; // explosion hit something



};


/* Toss object tile from one location to another with a TossAnim, and play a
 * sound effect. The ThrowObjectEffect is constructed with uninitialized
 * parameters and isn't started until start_anim() is called.
 */
class ThrowObjectEffect : public Effect {
protected:
    ObjManager *obj_manager;
    NuvieAnim *anim; // TossAnim
//  *sfx;
    MapCoord start_at, stop_at; // start_at -> stop_at
    Obj *throw_obj; // object being thrown
    const Tile *throw_tile; // graphic to use (default is object's tile)
    uint16 throw_speed; // used in animation
    uint16 degrees; // rotation of tile
    uint8 stop_flags; // TossAnim blocking flags

public:
    ThrowObjectEffect();
    ~ThrowObjectEffect() override { }

    void hit_target(); // stops effect
    void start_anim();

    uint16 callback(uint16 msg, CallBack *caller, void *data) override = 0;
};


/* Drop an object from an actor's inventory. Object is removed from the actor
 * after starting the effect, and added to the map when the effect is complete.
 * Effect speed is gametype-defined.
 */
class DropEffect : public ThrowObjectEffect {
    Actor *drop_from_actor;
public:
    DropEffect(Obj *obj, uint16 qty, Actor *actor, MapCoord *drop_loc);

    void hit_target();

    void get_obj(Obj *obj, uint16 qty);
    uint16 callback(uint16 msg, CallBack *caller, void *data) override;
};

#define MISSILE_DEFAULT_SPEED 200
#define MISSILE_HIT_TARGET  TOSS_TO_BLOCKING
#define MISSILE_HIT_OBJECTS (TOSS_TO_BLOCKING|TOSS_TO_OBJECT)
#define MISSILE_HIT_ACTORS  (TOSS_TO_BLOCKING|TOSS_TO_ACTOR)
#define MISSILE_HIT_ALL     (TOSS_TO_BLOCKING|TOSS_TO_OBJECT|TOSS_TO_ACTOR)

/* Throw a missile towards a target location. If the target is an actor or
 * object, it will be hit for the requested damage. If the target is an empty
 * map location, the object will be added to the map. The missile always stops
 * if hitting a blocking tile.
 *
 * Decide in the attack logic, before constructing this, whether or not it was
 * successful, and use the appropriate constructor. You can set the effect to
 * hit any actors or objects in the way if the attack missed.
 */
class MissileEffect : public ThrowObjectEffect {
    ActorManager *actor_manager;

    uint16 hit_damage; // hp taken off actor/object hit by missile
    Actor *hit_actor;
    Obj *hit_obj;

public:
    MissileEffect(uint16 tile_num, uint16 obj_n, const MapCoord &source,
                  const MapCoord &target, uint8 dmg, uint8 intercept = MISSILE_HIT_TARGET, uint16 speed = MISSILE_DEFAULT_SPEED);

    void init(uint16 tile_num, uint16 obj_n, const MapCoord &source,
              const MapCoord &target, uint32 dmg, uint8 intercept, uint32 speed);
    void hit_target();
    void hit_blocking();
    uint16 callback(uint16 msg, CallBack *caller, void *data) override;
};

#if 0
/* Throw an object and bring it back.
 */
class BoomerangEffect : public ThrowObjectEffect {
// I might even add an arc from the center line for a cool effect.
};


/* Cycle or modify the game palette in some way.
 */
class PaletteEffect : public TimedEffect {
// palette effects are created from child classes (new BlackPotionEffect();)
// ...and these can include SFX like any other effect
// but PaletteEffect is not abstract (new PaletteEffect(timing & color params...);)
};


#endif


/* For sleeping at inns. Fade-out, advance time, and fade-in.
 */
class SleepEffect : public Effect {
    TimedAdvance *timer; // timed event
    uint8 stop_hour, stop_minute; // sleep until this time
    Std::string stop_time;
public:
    SleepEffect(Std::string until);
    SleepEffect(uint8 to_hour);
    ~SleepEffect() override;

    uint16 callback(uint16 msg, CallBack *caller, void *data) override;
    void delete_self();
};


typedef enum { FADE_PIXELATED, FADE_CIRCLE, FADE_PIXELATED_ONTOP } FadeType;
typedef enum { FADE_IN, FADE_OUT } FadeDirection;

/* Manipulate the MapWindow for two types of fades. One is a stippled-like fade
 * that draws pixels to random locations on the screen until completely flooded
 * with a set color. The other changes the ambient light until fully black.
 */
class FadeEffect : public TimedEffect {
protected:
    static FadeEffect *current_fade; // do nothing if already active

    MapWindow *map_window;
    Screen *screen; // for PIXELATED, the overlay is blitted to the screen...
    Common::Rect *viewport; // ...at the MapWindow coordinates set here
    Graphics::ManagedSurface *overlay; // this is what gets blitted

    FadeType fade_type; // PIXELATED[_ONTOP] or CIRCLE
    FadeDirection fade_dir; // IN (removing color) or OUT (adding color)
    uint32 fade_speed; // meaning of this depends on fade_type
    uint8 pixelated_color; // color from palette that is being faded to/from
    Graphics::ManagedSurface *fade_from; // image being faded from or to (or nullptr if coloring)
    uint16 fade_x, fade_y; // start fade from this point (to fade_from size)

    uint32 evtime, prev_evtime; // time of last message to callback()
    uint32 pixel_count, colored_total; // number of pixels total/colored
    uint16 fade_iterations; // number of times we've updated the fade effect

public:
    FadeEffect(FadeType fade, FadeDirection dir, uint32 color = 0, uint32 speed = 0);
    FadeEffect(FadeType fade, FadeDirection dir, Graphics::ManagedSurface *capture, uint32 speed = 0);
    FadeEffect(FadeType fade, FadeDirection dir, Graphics::ManagedSurface *capture, uint16 x, uint16 y, uint32 speed = 0);
    ~FadeEffect() override;
    uint16 callback(uint16 msg, CallBack *caller, void *data) override;

    bool pixelated_fade_out();
    bool pixelated_fade_in();
    bool circle_fade_out();
    bool circle_fade_in();

    void delete_self();

protected:
    void init(FadeType fade, FadeDirection dir, uint32 color, Graphics::ManagedSurface *capture, uint16 x, uint16 y, uint32 speed);
    void init_pixelated_fade();
    void init_circle_fade();

    inline bool find_free_pixel(uint32 &rnum, uint32 pixel_count);
    uint32 pixels_to_check();
    bool pixelated_fade_core(uint32 pixels_to_check, sint16 fade_to);
//    inline uint32 get_random_pixel(uint16 center_thresh = 0);
};


/* Front-end to FadeEffect that fades in, and resumes game.
 */
class GameFadeInEffect : public FadeEffect {
public:
    GameFadeInEffect(uint32 color);
    ~GameFadeInEffect() override;
    uint16 callback(uint16 msg, CallBack *caller, void *data) override;
};


/* Captures an image of the MapWindow without an object, then places the object
 * on the map and fades to the new image. (or the opposite if FADE_OUT is used)
 */
class FadeObjectEffect : public Effect {
    ObjManager *obj_manager;
    Obj *fade_obj;
    FadeDirection fade_dir;
public:
    FadeObjectEffect(Obj *obj, FadeDirection dir);
    ~FadeObjectEffect() override;
    uint16 callback(uint16 msg, CallBack *caller, void *data) override;
};


/* Do a blocking fade-to (FADE_OUT) from a captured image of the game area, to
 * the active game area. (transparent) This is used for vanish or morph effects.
 */
#define VANISH_WAIT true
#define VANISH_NOWAIT false
class VanishEffect : public Effect {
    bool input_blocked;
public:
    VanishEffect(bool pause_user = VANISH_NOWAIT);
    ~VanishEffect() override;
    uint16 callback(uint16 msg, CallBack *caller, void *data) override;
};

class TileFadeEffect : public TimedEffect {
    //TileAnim *anim;
    //Tile *to_tile;
    //Tile *anim_tile;
    Actor *actor;
    //uint8 color_from, color_to;
    bool inc_reverse;
    uint16 spd;

    uint16 num_anim_running;
public:
    TileFadeEffect(const MapCoord &loc, Tile *from, Tile *to, FadeType type, uint16 speed);
    //TileFadeEffect(MapCoord loc, Tile *from, uint8 color_from, uint8 color_to, bool reverse, uint16 speed);
    TileFadeEffect(Actor *a, uint16 speed);
    ~TileFadeEffect() override;
    uint16 callback(uint16 msg, CallBack *caller, void *data) override;

protected:
    void add_actor_anim();
    void add_fade_anim(const MapCoord &loc, Tile *tile);
    void add_tile_anim(const MapCoord &loc, Tile *tile);
    void add_obj_anim(Obj *obj);
};

class TileBlackFadeEffect : public TimedEffect {
    Actor *actor;
    Obj *obj;
    uint8 color;
    bool reverse;
    uint16 fade_speed;

    uint16 num_anim_running;
public:
    TileBlackFadeEffect(Actor *a, uint8 fade_color, uint16 speed);
    TileBlackFadeEffect(Obj *o, uint8 fade_color, uint16 speed);
    ~TileBlackFadeEffect() override;
    uint16 callback(uint16 msg, CallBack *caller, void *data) override;
protected:
    void init(uint8 fade_color, uint16 speed);
    void add_actor_anim();
    void add_obj_anim(Obj *o);
    void add_tile_anim(const MapCoord &loc, Tile *tile);
};

/* Briefly modify the mapwindow colors, disable map-blacking and player
 * movement for a few seconds, then enable both.
 */
class XorEffect : public TimedEffect {
    MapWindow *map_window;
    uint32 length;
    Graphics::ManagedSurface *capture; // this is what gets blitted

    void xor_capture(uint8 mod);
    void init_effect();

public:
    /* eff_ms=length of visual effect */
    XorEffect(uint32 eff_ms);
    ~XorEffect() override { }

    /* Called by the timer between each effect stage. */
    uint16 callback(uint16 msg, CallBack *caller, void *data) override;
};

/* Briefly modify the mapwindow colors, disable map-blacking and player
 * movement for a few seconds, then enable both.
 */
class U6WhitePotionEffect : public TimedEffect {
    MapWindow *map_window;
    uint8 state; // 0=start, 1=eff1, 2=eff2, 3=x-ray, 4=complete
    uint32 start_length, eff1_length, eff2_length, xray_length;
    Graphics::ManagedSurface *capture; // this is what gets blitted
    Obj *potion; // allows effect to call usecode and delete object

    void xor_capture(uint8 mod);
    void init_effect();

public:
    /* eff_ms=length of visual effect; delay_ms=length of x-ray effect */
    U6WhitePotionEffect(uint32 eff_ms, uint32 delay_ms, Obj *callback_obj = nullptr);
    ~U6WhitePotionEffect() override { }

    /* Called by the timer between each effect stage. */
    uint16 callback(uint16 msg, CallBack *caller, void *data) override;
};


class XRayEffect : public TimedEffect {
    uint32 xray_length;
    void init_effect();

public:
    /* eff_ms=length of x-ray effect */
    XRayEffect(uint32 eff_ms);
    ~XRayEffect() override { }

    uint16 callback(uint16 msg, CallBack *caller, void *data) override;
};

/* Pause the game, create an effect, and wait for user input to continue. */
class PauseEffect: public Effect {
public:
    /* Called by the Effect handler when input is available. */
    uint16 callback(uint16 msg, CallBack *caller, void *data) override;
    virtual void delete_self() {
        Effect::delete_self();
    }
    PauseEffect();
    ~PauseEffect() override { }
};

/* Gather text from scroll input then continue. */
class TextInputEffect: public Effect {
    Std::string input;
public:
    /* Called by the Effect handler when input is available. */
    uint16 callback(uint16 msg, CallBack *caller, void *data) override;
    TextInputEffect(const char *allowed_chars, bool can_escape);
    ~TextInputEffect() override { }
    Std::string get_input() {
        return input;
    }
};

class WizardEyeEffect: public Effect {
public:
    /* Called by the Effect handler when input is available. */
    uint16 callback(uint16 msg, CallBack *caller, void *data) override;
    virtual void delete_self() {
        Effect::delete_self();
    }
    WizardEyeEffect(const MapCoord &location, uint16 duration);
    ~WizardEyeEffect() override { }
};

/* colors for PeerEffect */
const uint8 peer_tilemap[4] = {
    0x0A, // GROUND/PASSABLE
    0x09, // WATER
    0x07, // WALLS/BLOCKED
    0x0C  // DANGER/DAMAGING
};

#define PEER_TILEW 4
const uint8 peer_tile[PEER_TILEW * PEER_TILEW] = {
    0, 1, 0, 1,
    1, 0, 1, 0,
    0, 1, 0, 1,
    1, 0, 1, 0
};

/* Display an overview of the current area in the MapWindow. Any new actions
 * cancel the effect and return to the prompt.
 * (area is 48x48 tiles around the player, regardless of MapWindow size)
 */
class PeerEffect : public PauseEffect {
    MapWindow *map_window;
    Graphics::ManagedSurface *overlay; // this is what gets blitted
    Obj *gem; // allows effect to call usecode and delete object
    MapCoord area; // area to display (top-left corner)
    uint8 tile_trans; // peer_tile transparency mask (0 or 1)
    uint16 map_pitch;

    inline void blit_tile(uint16 x, uint16 y, uint8 c);
    inline void blit_actor(Actor *actor);
    inline uint8 get_tilemap_type(uint16 wx, uint16 wy, uint8 wz);
    void fill_buffer(uint8 *mapbuffer, uint16 x, uint16 y);
    void peer();

public:
    PeerEffect(uint16 x, uint16 y, uint8 z, Obj *callback_obj = 0);
    ~PeerEffect() override { }
    void init_effect();
    void delete_self() override;
};

class WingStrikeEffect : public Effect {
protected:

    Actor *actor;

public:
    WingStrikeEffect(Actor *target_actor);

    uint16 callback(uint16 msg, CallBack *caller, void *data) override;
};

class HailStormEffect : public Effect {
public:
    HailStormEffect(const MapCoord &target);

    uint16 callback(uint16 msg, CallBack *caller, void *data) override;
};

#define EFFECT_PROCESS_GUI_INPUT true

/* Run an effect asynchronously and keep updating the world until the effect completes. */
class AsyncEffect : public Effect {
protected:
    Effect *effect;
    bool effect_complete;

public:
    AsyncEffect(Effect *e);
    ~AsyncEffect() override;
    void run(bool process_gui_input = false);
    uint16 callback(uint16 msg, CallBack *caller, void *data) override;
};

} // End of namespace Nuvie
} // End of namespace Ultima

#endif