fack.hpp

Go to the documentation of this file.

// Copyright 2004, 2005 Maurizio Colucci.  
//
// This file is part of FACK.  
//
// FACK 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 2 of the License, or
// (at your option) any later version.
//
// FACK 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 Foobar; if not, write to the Free Software Foundation,
// Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

#ifndef fack_hpp_already_included
#define fack_hpp_already_included
 
#include <SDL.h>  
#include <SDL_image.h>
#include <boost/shared_ptr.hpp>
#include <list>
#include <vector>
#include <string>
#include <map>
#include <math.h>
#include <set>
#include <boost/variant.hpp>
#include <iostream> 
#include <sstream>
#include <fstream>

#include <guichan.hpp>
#include <guichan/sdl.hpp>

using boost::shared_ptr;
using std::list;
using std::vector;
using std::string;
using std::ofstream;
using std::ostream;
using std::istream;
using std::ifstream;

using std::pair;
using std::make_pair;
using std::set;
using std::map;
using std::cout;
using std::cerr;
using std::endl;
using boost::variant;

using boost::get;
using boost::dynamic_pointer_cast;

#define pt shared_ptr
#define NEW(x) pt_of(new x)

#define MATCH_IN_ANY_ORDER(i1, v1, i2, v2) ((i1==v1 && i2 == v2) || (i1==v2 && i2 ==v1))



template <class T>
pt<T>
pt_of(T* t){
    return pt<T>(t);
}



#define foreach(i, l)  for((i) = (l).begin(); (i) != (l).end(); (i)++)




#define setof(X, L, P, OUT)  OUT.clear(); for(X = L.begin(); X != L.end(); X++) { if(P){ OUT.push_back(*X);}}



#define setof_(M, X, L, P, OUT)  OUT.clear(); for(X = L.begin(); X != L.end(); X++) { if(P){ OUT.push_back(M);}}



SDL_Rect
create_rect(
    int x1, int y2, int x2, int y2);

template<class T, class I>
bool 
pt_cast(pt<I> i, pt<T> & i2){
    i2 = dynamic_pointer_cast<T>(i);
    return i2 != 0;
}



template<class T, class V>
bool 
var_cast(V i, T & i2){
    if (typeid(T) == i.type()){
        i2 = get<T>(i);
        return true;
    }
    else{
        return false;
    }
}





template<class T>
typename T::value_type 
min(const T & l){
    // BEGIN decl.
    typename T::const_iterator i;
    typename T::value_type smallest;
    // END
    smallest = *l.begin();
    foreach(i, l){
        if ( *i  <  smallest){
            smallest = *i;}}
    return smallest;
}
            
template<class T>
typename T::value_type 
max(const T & l){
    // BEGIN decl.
    typename T::const_iterator i;
    typename T::value_type biggest;
    // END
    biggest = l.front();
    foreach(i, l){
        if ( *i  >  biggest){
            biggest = *i;}}
    return biggest;
}

template<class Map>
typename Map::mapped_type
map_get(const Map & m, typename Map::key_type i)
{
    // BEGIN decl
    typename Map::const_iterator x;
    // END

    x = m.find(i);
    assert(x != m.end());
    return x->second;
}




template<class T>
class seq_list : public list<T>{
    public:
        seq_list<T>& 
        operator <<(T item)
        {
            push_back(item);
            return *this;
        }

};


template<class T>
seq_list<T>
ulist(T first_el)
{
    seq_list<T> ret;
    ret << first_el;
    return ret;
}


template<class T>
pt<vector<typename T::value_type> >
vector_of(const T & l)
{
    // BEGIN decl
    pt<vector<typename T::value_type> > ret;
    typename T::const_iterator i;
    int x;
    // END
  
    ret = pt_of(new vector<typename T::value_type>());
    ret->resize(l.size());
    for(x = 0, i = l.begin(); i != l.end(); x++, i++){
        (*ret)[x] = *i;}
    return ret;
}

    
template<class T>
pt<set<typename T::value_type> >
set_of(const T & l)
{
    // BEGIN decl
    pt<set<typename T::value_type> > ret;
    typename T::const_iterator i;
    int x;
    // END

    ret = pt_of(new set<typename T::value_type>());
    for( i = l.begin(); i != l.end(); x++, i++)
    {
        ret->insert(*i);
    }
    return ret;
}

    

template<class Set> 
bool 
in( typename Set::key_type i, 
    const Set & s)
{
    // BEGIN decl
    typename Set::const_iterator x;
    // END

    x = s.find(i);
    return x != s.end();
}

template<class L> 
bool 
in_list( typename L::value_type el, 
    const L & l)
{
    // BEGIN decl
    typename L::const_iterator it;
    // END
    for(it = l.begin() ; it != l.end(); it++){
        if (*it == el){
            return true;}}
    return false;
}




template<class T>
struct vector2{

        vector<T> v;

        int w, h;

        vector2(int w, int h)
        {
            this->v.resize(w * h);
            this->w = w;
            this->h = h;
        }

        vector2(){}

        T
        get(int x, int y) const
        {
            return v[x + y * w];  
        }

        void
        set(int x, int y, const T& val)
        {
            v[x + y * w] = val;  
        }


        void
        fill_with(const T & val);
};


struct rgb
{
        Uint8 r, g, b;

        rgb(
            Uint8 r,
            Uint8 g, 
            Uint8 b)
        {
            this->r = r;
            this->g = g;
            this->b = b;
        }
        rgb(){}
};


struct rgbaf{ 
        float r; 
        float g;
        float b; 
        float a;
        rgbaf(float r_, float g_, float b_, float a_): r(r_), g(g_), b(b_), a(a_) {}
        rgbaf(){}
};

struct int_pair{
        int x, y;
        int_pair(int x, int y){
            this->x = x;
            this->y = y;}
        int_pair(){}

        bool
        operator<(
            const int_pair& p) const;

        bool
        operator==(
            const int_pair& p) const;
        
        int_pair
        operator-(
            const int_pair& p) const;

        int_pair
        operator+(
            const int_pair& p) const;
};

struct cfsurf{
        int offs_x, offs_y;
        int apparent_wt, apparent_ht;
        int real_wt, real_ht;
        vector<rgbaf> pixels;


        cfsurf(int apparent_wt_, int apparent_ht_, 
            int real_wt_, int real_ht_, int offset_x_, int offset_y_);
        cfsurf(){}

        cfsurf(const cfsurf& l)
        {
            apparent_wt = l.apparent_wt;
            apparent_ht = l.apparent_ht;
            real_wt = l.real_wt;
            real_ht = l.real_ht;
            offs_y = l.offs_y;
            offs_x = l.offs_x;
            pixels = l.pixels; 
        }

        static
        pt<cfsurf> 
        from_sdl_surface(SDL_Surface * s);


        void 
        set_pixel(
            int x, 
            int y, 
            rgbaf pix);

        rgbaf
        get_pixel(
            int x, 
            int y)const;

        void
        opaque_blit_to_sdl_surface(
            SDL_Surface * screen,
            SDL_Rect src_rect_to_blit /* this rect will be blitted at 0,0 on the screen */ )const;



        void
        blit_with_src_alpha(
            cfsurf & dest)const;


};


struct quick_message
{
        string text;
        float timer;

        quick_message(string text)
        {
            this->text = text;
            this->timer =  text.size() * 0.04f + 1.0f; // @@
        }
};

// struct persistent
// {
//      virtual
//      string
//      get_persistent_id()const = 0;
// };

enum walk_there_or_not {walk_there_to_look_at, do_not_walk_there_to_look_at};

struct can_appear_closed_in_inv{
        virtual 
        SDL_Surface * get_inv_surf() =0;

        virtual
        bool can_be_moved_across_containers()const = 0;

};

struct obj_or_concept
{
        string readable_name;

        virtual
        SDL_Surface *
        get_inv_surf() const = 0;

        obj_or_concept(
            string readable_name)
        {
            this->readable_name = readable_name;
        }

        virtual
        bool
        can_be_moved_across_containers()const=0;
};

struct token_of_verb_text
{

        virtual
        string
        to_string(
            const pt<obj_or_concept> o1,
            const pt<obj_or_concept> o2)const = 0;
};

struct TOVT_string : public token_of_verb_text
{
        string str;

        TOVT_string(
            string str)
        {
            this->str = str;
        }

        string
        to_string(
            const pt<obj_or_concept> o1,
            const pt<obj_or_concept> o2)const
        {
            return str;
        }

};

struct TOVT_name_of_first_obj : public token_of_verb_text 
{
        string
        to_string(
            const pt<obj_or_concept> o1,
            const pt<obj_or_concept> o2)const
        {
            return o1->readable_name;
        }
};

struct TOVT_name_of_second_obj : public token_of_verb_text 
{
        string
        to_string(
            const pt<obj_or_concept> o1,
            const pt<obj_or_concept> o2)const
        {
            return o2->readable_name;
        }

};

struct verb
{
        list<pt<token_of_verb_text> > tokens;
        rgb color;

        verb(
            const list<pt<token_of_verb_text> > & tokens,
            rgb color)
        {
            this->tokens = tokens;
            this->color = color;
        }

        verb(){}
};



struct concept : public obj_or_concept
{
        SDL_Surface* inv_surf;

        concept(
            string readable_name,
            SDL_Surface * inv_surf)
            : obj_or_concept(readable_name)
        {
            this->inv_surf = inv_surf;
        }


        SDL_Surface *
        get_inv_surf() const 
        {
            return inv_surf;
        }

        bool can_be_moved_across_containers() const
        {
            return true;
        }

};

struct phys_obj : public obj_or_concept
{
        pt<can_appear_closed_in_inv>  pick_up_info;

        phys_obj(
            string readable_name,
            pt<can_appear_closed_in_inv>  pick_up_info)
            : obj_or_concept(readable_name)
        {
            this->pick_up_info = pick_up_info;
            assert(pick_up_info);
        }

        SDL_Surface *
        get_inv_surf() const 
        {
            return pick_up_info->get_inv_surf();
        }

        bool can_be_moved_across_containers() const;

};

struct phys_obj_with_verbs : public phys_obj
{
        vector<pt<verb> > verbs;
        bool none_of_the_above;

        phys_obj_with_verbs(
            const vector<pt<verb> >& verbs,
            bool none_of_the_above,
            string readable_name,
            pt<can_appear_closed_in_inv>  pick_up_info)

            : phys_obj(readable_name, pick_up_info)
        {
            this->verbs = verbs;
            this->none_of_the_above = none_of_the_above;
        }
};


struct dialog_choice
{
        virtual ~dialog_choice(){}

        SDL_Rect rect;

        dialog_choice(
            SDL_Rect rect)
        {
            this->rect = rect;
        }

};

struct dialog_choice_verb_object : public dialog_choice
{
        pt<verb> v; 
        pt<phys_obj> obj_for_which_the_verb_was_chosen; 
        pt<phys_obj> passive_obj; 
        
        dialog_choice_verb_object(
            pt<verb> v,
            pt<phys_obj> obj_for_which_the_verb_was_chosen,
            pt<phys_obj> passive_obj,
            SDL_Rect rect)

            : dialog_choice(rect)
        {
            this->v = v;
            this->obj_for_which_the_verb_was_chosen = obj_for_which_the_verb_was_chosen;
            this->passive_obj = passive_obj;
        }
};

struct dialog_choice_double_other : public dialog_choice
{
        dialog_choice_double_other(
            SDL_Rect rect)
            : dialog_choice(rect)
        {}
};

struct hot_zone
{
        virtual bool point_in_zone(int_pair point) const=0;

        pt<obj_or_concept> obj;

        hot_zone(
            pt<obj_or_concept> obj)
        {
            this->obj = obj;
        }
};

struct bg_hot_zone : public hot_zone
{
        int y_walkbehind;
        bool visible;

        bg_hot_zone(
            int y_walkbehind,
            bool visible,
            pt<obj_or_concept> obj)

            : hot_zone(obj)
        {
            this->y_walkbehind = y_walkbehind;
            this->visible = visible;
        }
            
};

struct hot_zone_square : public bg_hot_zone
{
        int x1, x2, y1, y2;

        bool point_in_zone(int_pair point) const;

        hot_zone_square(int x1, int y1, int x2, int y2, 
                        pt<obj_or_concept> i,
                        bool visible, int y_walkbehind)
            : bg_hot_zone(y_walkbehind,
                          visible,
                          i)
        {
            assert(x1 < x2);
            assert(y1 < y2);
            this->x1 = x1;
            this->y2 = y2;
            this->x2 = x2;
            this->y1 = y1;
        }


};

struct hot_zone_pixel_perfect: public bg_hot_zone
{
        pt<cfsurf> surf;

        bool point_in_zone(int_pair point) const;

        hot_zone_pixel_perfect(
            pt<cfsurf> surf,
            pt<obj_or_concept> i,
            bool visible, 
            int y_walkbehind)

            : bg_hot_zone( y_walkbehind,
                           visible,
                           i)
        {
            this->surf = surf;
        }

};

struct player_state{
        virtual ~player_state(){}
};




struct anim_frame{
        int w, h;
        vector<rgbaf> pixels;
        int_pair hot_spot;
        float duration;

        anim_frame(int w, int h, int_pair hot_spot, float duration)
        {
            this->w  = w;
            this->h = h;
            this->hot_spot = hot_spot;
            this->duration = duration;
            this->pixels.resize(w * h);
        }
        anim_frame(int w, int h, int_pair hot_spot, float duration, 
                   const vector<rgbaf> & pixels)
        {
            this->w  = w;
            this->h = h;
            assert(pixels.size() == w * h);
            this->duration = duration;
            this->hot_spot = hot_spot;
            this->pixels = pixels;
        }
        anim_frame(){}
 

        bool 
        point_in_surf(
            int_pair p,
            int_pair pl,
            float scaling) const;


        static
        pt<anim_frame> 
        from_sdl_surface(
            SDL_Surface * s, 
            int_pair hot_spot,
            float duration);

        void 
        set_pixel(
            int x, 
            int y, 
            rgbaf pix);


        rgbaf
        get_pixel(
            int x, 
            int y) const;


        rgbaf 
        get_pixel_with_interpolation(
            float px,
            float py) const;

};

struct animation
{
        vector<pt<anim_frame> > frames;

        animation(
            const vector<pt<anim_frame> >& frames)
        {

            this->frames = frames;
        }
        animation(
            const list<pt<anim_frame> >& frames)
        {

            this->frames = *vector_of(frames);
        }
};



struct PS_still_and_parsing : public player_state
{

        pt<animation> anim;
        int cur_frame;
        float timer;


        PS_still_and_parsing(
            pt<animation> anim,
            float timer,
            int cur_frame)
        {
            this->anim = anim;
            this->timer = timer;
            this->cur_frame = cur_frame; 
        }
};




template<class T>
struct pos_and
{
        typedef T value_type;

        int_pair pos;
        T o;

        pos_and(const T& o, int_pair pos)
        {
            this->pos = pos;
            this->o = o;
        }

        pos_and(){}

        bool
        operator==(const pos_and<T>& ob)
        {
            return o == ob.o /* @@ equality of pointers*/ && pos == ob.pos;
        }


};


struct game_state_t 
{
        virtual ~game_state_t(){}

        bool paused;

        game_state_t()
        {
            paused = false;
        }

};

struct container_pick_result
{
        virtual ~container_pick_result(){}
};

struct cannot_be_closed{};

struct popup : public obj_or_concept
{
        variant<SDL_Rect, cannot_be_closed> closing_area;
        SDL_Surface* picture;
        int_pair position_in_screen;
        pt<can_appear_closed_in_inv> pick_up_info;

        virtual 
        void
        render(
            SDL_Surface * screen,
            const pt<game_state_t> game_state) const = 0;


        virtual
        pt<container_pick_result>
        item_at_screen_pos(
            int_pair pos,
            pt<popup> me_as_a_smart_ptr) const = 0;

        popup(
            string readable_name,
            variant<SDL_Rect, cannot_be_closed> closing_area,
            SDL_Surface* picture,
            int_pair position_in_screen,
            pt<can_appear_closed_in_inv> pick_up_info)

            : obj_or_concept( readable_name)
        {
            assert(pick_up_info);
            this->closing_area = closing_area;
            this->picture = picture;
            this->position_in_screen = position_in_screen;
            this->pick_up_info = pick_up_info;
        }


};



struct zoomable_zone : public hot_zone
{
        SDL_Rect rect;
        bool intersect_rect_and_picture;

        bool
        point_in_zone(int_pair point) const;


        zoomable_zone(
            SDL_Rect rect,
            bool intersect_rect_and_picture,
            pt<obj_or_concept> obj)
            : hot_zone(obj)
        {
            this->rect = rect;
            this->intersect_rect_and_picture = intersect_rect_and_picture;
        }

};




struct zoomable : public popup
{
        list<pt<zoomable_zone> > sorted_zones;


        pt<container_pick_result>
        item_at_screen_pos(
            int_pair pos,
            pt<popup> me_as_a_smart_ptr) const ;

        zoomable(
            list<pt<zoomable_zone> > sorted_zones,
            string readable_name,
            variant<SDL_Rect, cannot_be_closed> closing_area,
            SDL_Surface* picture,
            int_pair position_in_screen,
            pt<can_appear_closed_in_inv> pick_up_info)

            : popup( readable_name,
                     closing_area,
                     picture,
                     position_in_screen,
                     pick_up_info)
        {
            this->sorted_zones = sorted_zones;
        }

        SDL_Surface*
        get_inv_surf()const
        {
            return pick_up_info->get_inv_surf();
        }


        void
        render(
            SDL_Surface * screen,
            const pt<game_state_t> game_state) const;

        bool
        can_be_moved_across_containers()const
        {
            return true;
        }

};


enum container_type{ CONCEPTS, PHYS_OBJECTS, CAN_CONTAIN_ANYTHING};


struct container : public popup
{
        container_type type;
        SDL_Rect drop_in_area;
        bool can_be_dragged;
        list<pos_and<pt<obj_or_concept> > > sorted_items;

        pt<container_pick_result>
        item_at_screen_pos(
            int_pair pos,
            pt<popup> me_as_a_smart_ptr) const ;


        container(
            string readable_name,
            pt<can_appear_closed_in_inv> pick_up_info,
            SDL_Rect drop_in_area,
            SDL_Surface* picture,
            const list<pos_and<pt<obj_or_concept> > >& sorted_items,
            int_pair position_in_screen,
            variant<SDL_Rect, cannot_be_closed> closing_area,
            container_type type,
            bool can_be_dragged)
            : popup( readable_name,
                        closing_area,
                        picture,
                        position_in_screen,
                        pick_up_info)
        {
            this->type = type;
            this->drop_in_area = drop_in_area;
            this->sorted_items = sorted_items;
            this->can_be_dragged = can_be_dragged;
        }

        SDL_Surface*
        get_inv_surf()const
        {
            return pick_up_info->get_inv_surf();
        }

        void
        add_item( 
            const pt<obj_or_concept> i);

        void
        remove_item_not_recursively( 
            const pt<obj_or_concept> i);

        void
        remove_item_recursively( 
            const pt<obj_or_concept> i);


        void
        add_item_in_pos(
            pos_and<pt<obj_or_concept> > obj_and_pos);



        bool
        can_contain_this_obj(pt<obj_or_concept> o)const;

        bool
        can_be_moved_across_containers()const;


        void
        render(
            SDL_Surface * screen,
            const pt<game_state_t> game_state) const;

    private:

        bool
        container::remove_item_aux(
            const pt<obj_or_concept> item);


        bool
        container::remove_item_rec_aux(
            const pt<obj_or_concept> item);

};


struct PS_missing_one_item : public PS_still_and_parsing{
        pt<obj_or_concept> obj_already_chosen;
        
        PS_missing_one_item(
            pt<obj_or_concept> obj_already_chosen,
            pt<animation> anim,
            float timer,
            int cur_frame)
            : PS_still_and_parsing(anim, timer, cur_frame)
        {
            this->obj_already_chosen = obj_already_chosen;
        }
};


struct PS_choosing_verb : public PS_still_and_parsing{
        pt<phys_obj> obj_one;
        pt<phys_obj> obj_two;
        list<pt<dialog_choice> > choices;
        SDL_Rect cancel_rect;
        
        
        PS_choosing_verb( 
            pt<phys_obj> obj_one,
            pt<phys_obj> obj_two,
            list<pt<dialog_choice> > choices,
            SDL_Rect cancel_rect,
            pt<animation> anim,
            float timer,
            int cur_frame)

            : PS_still_and_parsing( anim, timer, cur_frame)
        {
            this->obj_one = obj_one;
            this->obj_two = obj_two;
            this->choices = choices;
            this->cancel_rect = cancel_rect;
        }
};


struct PS_missing_two_items : public PS_still_and_parsing 
{
        PS_missing_two_items(
            pt<animation> anim,
            float timer,
            int cur_frame)

            : PS_still_and_parsing(anim, timer, cur_frame)
        {}

};



// struct serializable
// {
//      virtual
//      void 
//      serialize(
//          ostream& o)const = 0;

//      virtual
//      void 
//      deserialize_once_subtype_known(
//          istream& o,
//          const list<pt<obj> > & objects) = 0;

        
// };


struct game_state_normal_t : public game_state_t 
{
};

struct game_state_flashing_inv_t : public game_state_t
{
        pt<obj_or_concept> item_that_is_flashing;
        float timer;

        game_state_flashing_inv_t(
            pt<obj_or_concept> item_that_is_flashing)
        {
            this->item_that_is_flashing = item_that_is_flashing;
            this->timer = 3; // seconds @@
        }

        game_state_flashing_inv_t(){}

};

struct player_illumination
{
        virtual
        float
        get_illum_factor_at(
            int x, int y) const = 0;

};


struct player_illumination_constant : public player_illumination
{
        float multiplier;

        player_illumination_constant(
            float multiplier)
        {
            this->multiplier = multiplier;
        }

        float
        get_illum_factor_at(
            int x, int y) const 
        {
            return this->multiplier;
        }

};


struct player_illumination_pixel_level : public player_illumination
{
        vector2<float> multipliers;

        player_illumination_pixel_level(
            vector2<float> multipliers)
        {
            this->multipliers = multipliers;
        }
};

struct circle_t
{
        float radius;
        int_pair center;

        circle_t(
            float radius,
            int_pair center)
        {
            this->radius = radius;
            this->center = center;
        }
};


struct light
{
        float weight;
        float oscillation_speed;
        float oscillation_amplitude;
        pt<player_illumination> pl_illum;

        virtual 
        ~light(){}

    protected:
        light( float weight, float oscillation_speed, 
               float oscillation_amplitude,
               pt<player_illumination> pl_illum)
        {
            this->weight = weight;
            this->oscillation_amplitude = oscillation_amplitude;
            this->oscillation_speed = oscillation_speed;
            this->pl_illum = pl_illum;
        }

};

struct light_fixed_in_loc : public light
{
        light_fixed_in_loc( float weight, float oscillation_speed, 
               float oscillation_amplitude,
               pt<player_illumination> pl_illum)
            : light(weight, oscillation_speed, oscillation_amplitude, pl_illum)
        {}

};

struct light_across_loc : public light
{
        pt<phys_obj> obj_which_emits_the_light;
        float light_radius;

        light_across_loc( float weight, float oscillation_speed, 
                          float oscillation_amplitude,
                          pt<player_illumination> pl_illum,
                          pt<phys_obj> obj_which_emits_the_light,
                          float light_radius)
            : light( weight, oscillation_speed, oscillation_amplitude,
                     pl_illum)
        {
            this->obj_which_emits_the_light = obj_which_emits_the_light;
            this->light_radius = light_radius;
        }

};

struct surf_with_name{
        pt<light> ligh;
        pt<cfsurf> surf;

        surf_with_name(pt<light> ligh, pt<cfsurf> surf)
        {
            this->surf = surf;
            this->ligh = ligh;
        }
};

struct no_item{};

struct room_scaling_data{
        float y1, scaling_at_y1, y2, scaling_at_y2;
};

struct printable
{
        virtual
        void
        print_with_transparency(
            cfsurf & background,
            const room_scaling_data& d,
            const set<pt<light> > active_lights) = 0;

        virtual 
        int 
        y()= 0;
};


struct layer_unlit_after_anim
{
        list<surf_with_name> lit_versions;
        int y_walkbehind;

        layer_unlit_after_anim(
            list<surf_with_name> lit_versions,
            int y_walkbehind)
        {
            this->lit_versions  = lit_versions;
            this->y_walkbehind = y_walkbehind;
        }
};


struct layer_unlit_before_anim
{
        int y_walkbehind;
        bool visible;

        layer_unlit_before_anim(
            int y_walkbehind,
            bool visible)
        {
            this->y_walkbehind = y_walkbehind;
            this->visible = visible;
        }

        virtual
        pt<layer_unlit_after_anim>
        get_cur_frame(float dt) = 0;

};

struct layer_unlit_not_anim : public layer_unlit_before_anim
{
        list<surf_with_name> lit_versions;

        layer_unlit_not_anim(
            const list<surf_with_name>& lit_versions,
            int y_walkbehind,
            bool visible)
            : layer_unlit_before_anim(y_walkbehind, visible)
        {
            this->lit_versions = lit_versions;
        }

        pt<layer_unlit_after_anim>
        get_cur_frame(float dt)
        {
            return NEW(layer_unlit_after_anim(lit_versions, y_walkbehind));
        }


};

struct layer_unlit_anim : public layer_unlit_before_anim
{
        list<list<surf_with_name> > anim;
        float timer, frame_change_interval;
        list<list<surf_with_name> >::const_iterator cur_frame;

        layer_unlit_anim(
            const list<list<surf_with_name> >& anim,
            int y_walkbehind,
            bool visible,
            float frame_change_interval)
            : layer_unlit_before_anim(y_walkbehind, visible)
        {
            this->anim = anim;
            this->timer = 0;
            this->cur_frame = this->anim.begin();
            this->frame_change_interval = frame_change_interval;
        }

        pt<layer_unlit_after_anim>
        get_cur_frame(float dt);


};

struct layer_lit : public printable{
        pt<cfsurf> surf;
        int y_walkbehind;

        layer_lit(const pt<cfsurf> surf_, int y_walkbehind_){
            y_walkbehind = y_walkbehind_;
            surf = surf_;}
        layer_lit(){}

        void
        print_with_transparency(
            cfsurf & background,
            const room_scaling_data& d,
            const set<pt<light> > active_lights);



        int 
        y()
        {return y_walkbehind;}
};





   



struct mood_t{
        virtual 
        ~mood_t(){}
};

struct mood_and_string
{
        pt<mood_t> mood;
        string str;

        mood_and_string(
            pt<mood_t> mood,
            string str)
        {
            this->mood = mood;
            this->str = str;
        }
};

struct anim_and_string
{
        pt<animation> anim;
        string str;

        anim_and_string(
            pt<animation> anim,
            string str)
        {
            this->anim = anim;
            this->str = str;
        }
};

typedef  seq_list<mood_and_string> speech_t;

typedef  seq_list<anim_and_string> speech2_t;



struct script_cmd
{
        virtual ~script_cmd(){}
};

typedef seq_list<pt<script_cmd> > script_cmds_t;


struct transition_of_fixed_light
{
        pt<light_fixed_in_loc> ligh;
        float cur_timer;
        float end_timer;
        float start_intensity;
        float end_intensity;
        bool switch_off_light_at_the_end;

        transition_of_fixed_light(
            pt<light_fixed_in_loc> ligh,
            float end_timer,
            float start_intensity,
            float end_intensity,
            bool switch_off_light_at_the_end)
        {
            this->switch_off_light_at_the_end = switch_off_light_at_the_end;
            this->ligh = ligh;
            this->start_intensity = start_intensity;
            this->end_timer = end_timer;
            this->end_intensity = end_intensity;
            this->cur_timer = 0.0f;
        }

};

struct scr_cmd_light_transition : public script_cmd
{
        float time_delta;
        pt<light_fixed_in_loc> ligh;
        float start_intensity;
        float dest_intensity;
        bool switch_off_light_at_the_end;

        scr_cmd_light_transition(
            float time_delta,
            pt<light_fixed_in_loc> ligh,
            float start_intensity,
            float dest_intensity,
            bool switch_off_light_at_the_end)
        {
            this->time_delta = time_delta;
            this->switch_off_light_at_the_end = switch_off_light_at_the_end;
            this->ligh = ligh;
            this->dest_intensity = dest_intensity;
            this->start_intensity = start_intensity;
        }

};


struct scr_cmd_passive_anim : public script_cmd
{
        pt<animation> anim;

        scr_cmd_passive_anim(
            pt<animation> anim)
        {
            this->anim = anim;
        }
};
struct scr_cmd_quick_message : public script_cmd
{
        string text;

        scr_cmd_quick_message(
            string text)
        {
            this->text = text;
        }
};

struct scr_cmd_open_popup : public script_cmd
{

        pt<popup > dr;

        scr_cmd_open_popup(
            pt<popup> dr)
        {
            this->dr = dr;
        }
};


struct scr_cmd_set_sitting_state : public script_cmd
{
        string situation_name;
        string occupied_place;

        scr_cmd_set_sitting_state(
            string situation_name,
            string occupied_place)
        {
            this->situation_name = situation_name;
            this->occupied_place = occupied_place;
        }
};



enum direction{
    d_up, d_down, d_left, d_right};

enum horizontal_dir{
    hd_right, hd_left};

enum walking_phase{
    CONTACT, RECOIL, PASSING, HIGH_POINT};





struct can_appear_closed_in_inv_no: public can_appear_closed_in_inv
{
        SDL_Surface * get_inv_surf();

        bool
        can_be_moved_across_containers()const
        {
            return false;
        }

};

struct can_appear_closed_in_inv_yes: public can_appear_closed_in_inv
{
        SDL_Surface* inv_surf;
        bool can_be_moved_to_another_container;

        can_appear_closed_in_inv_yes(
            SDL_Surface *inv_surf,
            bool can_be_moved_to_another_container = true)
        {
            this->inv_surf = inv_surf;
            this->can_be_moved_to_another_container = can_be_moved_to_another_container;
        }

        SDL_Surface * get_inv_surf();

        bool
        can_be_moved_across_containers()const
        {
            return can_be_moved_to_another_container;
        }

        
};






struct scr_cmd_walk : public script_cmd
{
        int_pair dest;

        scr_cmd_walk(   
            int_pair dest)
        {
            this->dest = dest;
        }
};




struct AI_substate
{
        virtual ~AI_substate(){}
};

struct PS_governed_by_AI : public player_state
{
        vector<pt<script_cmd> > commands;
        int cur_cmd_it;
        pt<AI_substate> substate;

        PS_governed_by_AI(
            const vector<pt<script_cmd> > & commands,
            int cur_cmd_it,
            pt<AI_substate> substate)
        {
            this->commands= commands;
            this->cur_cmd_it = cur_cmd_it;
            this->substate = substate;

        }

};

struct AI_substate_passive_anim: public AI_substate
{
        pt<animation> anim;
        int cur_frame;
        float timer;

        AI_substate_passive_anim(pt<animation> anim)
        {
            this->anim = anim;
            this->timer = 0;
            this->cur_frame = 0;
        }
};

struct AI_substate_walk : public AI_substate
{
        vector<int_pair> route; // @@ transform to list
        int cur_pos; // transform to iterator @@
        horizontal_dir cur_foot;
        walking_phase cur_phase;
        float timer;

        AI_substate_walk(
            const vector<int_pair> & route)
        {
            this->route = route;
            this->cur_pos = 0;
            this->timer = 0;
            this->cur_foot = hd_left;
            this->cur_phase = CONTACT;
        }


};



struct walk_frame_id{
        horizontal_dir foot;
        walking_phase phase;
        direction dir;

        walk_frame_id(
            horizontal_dir foot,
            walking_phase phase, 
            direction dir)
        {
            this->phase = phase;
            this->foot = foot;
            this->dir = dir;
        }

        bool operator<(const walk_frame_id& w)const;
};






pt<vector2<bool> > 
walking_map_from_sdl_surface(SDL_Surface * s);


string string_of_int(int i);



struct anim_frame_and_pos : public printable 
{

        pt<anim_frame> surf;

        int position_x, position_y;
        bool must_be_scaled;
    
        anim_frame_and_pos( const pt<anim_frame> surf,
                            int position_x, int position_y,
                            bool must_be_scaled)
        {
            this->surf = surf;
            this->position_x = position_x;
            this->position_y = position_y;
            this->must_be_scaled = must_be_scaled;
        }

        anim_frame_and_pos() {}

        void
        print_with_transparency(
            cfsurf & background,
            const room_scaling_data& d,
            const set<pt<light> > active_lights);

        int 
        y()
        {return position_y;}

};

struct no_sentence{};

struct sentence_with_location
{
        string text;
        int x_left, y_top, x_right;
        rgb color;

        sentence_with_location(string text, int x_left, int y_top, int x_right, rgb color)
        {
            this->text = text;
            this->x_left = x_left;
            this->x_right = x_right;
            this->y_top = y_top;
            this->color = color;
        }
        sentence_with_location(){}
};

struct result_exec_next_scr_cmd
{
        pt<player_state> new_pl_state;
        int new_cmd_it;
        int_pair new_pl_pos;
        direction new_pl_dir;

        result_exec_next_scr_cmd(
            pt<player_state> new_pl_state,
            int new_cmd_it,
            int_pair new_pl_pos,
            direction new_pl_dir)
        {
            this->new_pl_dir = new_pl_dir;
            this->new_pl_pos = new_pl_pos;
            this->new_cmd_it = new_cmd_it;
            this->new_pl_state = new_pl_state;
        }
            
        result_exec_next_scr_cmd(){}
        
};

struct update_AI_result
{
        pt<anim_frame> frame;
        int_pair pos;
        direction dir;
        variant<no_sentence, sentence_with_location> maybe_sentence;
        pt<player_state> new_player_state;
            
        update_AI_result(
            pt<anim_frame> frame,
            int_pair pos,
            direction dir,
            variant<no_sentence, sentence_with_location> maybe_sentence,
            pt<player_state> new_player_state)
        {
            this->frame = frame;
            this->pos = pos;
            this->dir = dir;
            this->maybe_sentence = maybe_sentence;
            this->new_player_state = new_player_state;
        }
        update_AI_result(){}
};


struct location 
{
        seq_list<pt<bg_hot_zone> > sorted_hot_zones;
        seq_list<pt<layer_unlit_before_anim> >  sorted_unlit_layers_before_anim;
        pt<vector2<bool> > walking_map;
        room_scaling_data scaling_data; 
        set<pt<light_fixed_in_loc> > active_lights;
        set<string> occupied_sitting_places;
        

        location(
            seq_list<pt<bg_hot_zone> > sorted_hot_zones,
            seq_list<pt<layer_unlit_before_anim> >  unlit_layers,
            pt<vector2<bool> > walking_map,
            room_scaling_data scaling_data,
            set<pt<light_fixed_in_loc> > active_lights)
        {
            this->sorted_hot_zones = sorted_hot_zones;
            this->sorted_unlit_layers_before_anim = unlit_layers;
            this->walking_map = walking_map;
            this->scaling_data = scaling_data;
            this->active_lights = active_lights;
            // occupied_sitting_places empty
        }

};

struct scr_cmd_change_light : public script_cmd
{
        bool turn_on;
        pt<light_fixed_in_loc> ligh;
        pt<location> loc;
            
        scr_cmd_change_light(
            bool turn_on, 
            pt<light_fixed_in_loc> ligh,
            pt<location> loc)
        {
            this->turn_on = turn_on;
            this->ligh = ligh;
            this->loc = loc;
        }
};

struct scr_cmd_change_loc: public script_cmd
{
        pt<location> new_loc;
        int_pair position;

        scr_cmd_change_loc(
            pt<location> new_loc,
            int_pair position)
        {
            this->new_loc = new_loc;
            this->position = position;
        }
};

typedef seq_list<seq_list<mood_and_string> > dialog_t;

struct anim_right_left
{
        pt<animation> right, left;

        anim_right_left(
            pt<animation> right, 
            pt<animation> left)
        {
            this->right = right;
            this->left = left;
        }

        pt<animation>
        get_anim(horizontal_dir dir) const;

        anim_right_left(){} // needed for putting anim_right_left in a std::map
};

typedef map< pt<mood_t>, anim_right_left > anim_of_mood_t;


struct still_situation
{
        virtual ~still_situation(){}
};

struct still_situation_normal : public still_situation {};

struct still_situation_sitting : public still_situation 
{
        string situation_name;
        string occupied_place;

        still_situation_sitting(
            string situation_name,
            string occupied_place)
        {
            this->situation_name = situation_name;
            this->occupied_place = occupied_place;
        }
};


struct dragging_state{
        virtual ~dragging_state(){}
};

struct dragging_state_not_dragging : public dragging_state{};

struct dragging_state_maybe_dragging_obj : public dragging_state
{
        pos_and<pt<obj_or_concept> > obj_and_pos;
        int_pair offset_of_mouse_in_obj;
        int_pair orig_mouse_pos;
        pt<container> orig_container;

        dragging_state_maybe_dragging_obj(
            pos_and<pt<obj_or_concept> > obj_and_pos,
            int_pair offset_of_mouse_in_obj,
            pt<container> orig_container,
            int_pair orig_mouse_pos)
        {
            this->obj_and_pos = obj_and_pos;
            this->offset_of_mouse_in_obj = offset_of_mouse_in_obj;
            this->orig_mouse_pos = orig_mouse_pos;
            this->orig_container = orig_container;
        }
};
struct dragging_state_dragging_open_popup : public dragging_state
{
        pt<popup> pop;
        int_pair offset_of_mouse_in_obj;

        dragging_state_dragging_open_popup(
            int_pair offset_of_mouse_in_obj,
            pt<popup> pop)
        {
            this->offset_of_mouse_in_obj = offset_of_mouse_in_obj;
            this->pop = pop;
        }
};

struct PC
{
        map<walk_frame_id, pt<anim_frame> >  walk_frame_when;
        pt<player_state> state; 
        map<direction, pt<animation> > anim_of_norm_still_sit;
        map<string, pt<animation> > anim_of_sitting_still_sit;
        int_pair  pos;
        float walk_step_horiz;
        float walk_step_vert;
        pt<container> cache;
        pt<location> loc;
        pt<phys_obj> obj;
        direction cur_dir;
        rgb text_color;
        anim_of_mood_t anim_of_mood; 
        pt<still_situation> still_situat;
        pt<dragging_state> drag_st;
        list<pt<popup> > open_popups;

        PC(
            const map<walk_frame_id, pt<anim_frame> >&  walk_frame_when,
            pt<player_state> state,
            const map<direction, pt<animation> > & anim_of_norm_still_sit,
            const map<string, pt<animation> > & anim_of_sitting_still_sit,
            int_pair  pos,
            float walk_step_horiz,
            float walk_step_vert,
            const pt<container> cache,
            pt<location> loc,
            pt<phys_obj> obj,
            direction cur_dir,
            rgb text_color,
            anim_of_mood_t anim_of_mood,
            pt<still_situation> still_situat)
        {
            this->drag_st = NEW(dragging_state_not_dragging());
            this->still_situat = still_situat;
            this->anim_of_mood = anim_of_mood;
            this->text_color = text_color;
            this->obj = obj;
            this->loc = loc;
            this->walk_frame_when = walk_frame_when;
            this->state = state;
            this->anim_of_sitting_still_sit = anim_of_sitting_still_sit;
            this->anim_of_norm_still_sit = anim_of_norm_still_sit;
            this->pos = pos;
            this->walk_step_horiz = walk_step_horiz;
            this->walk_step_vert = walk_step_vert;

            this->cache = cache;

            this->cur_dir = cur_dir;
        }



};

enum add_or_remove {ADD, REMOVE};
enum show_or_hide {SHOW, HIDE};


struct AI_substate_waiting_for_person_to_stop_talking : public AI_substate
{
        pt<PC> person;
        pt<anim_frame> frame;

        AI_substate_waiting_for_person_to_stop_talking(
            pt<PC> person,
            pt<anim_frame> frame)
        {
            this->person = person;
            this->frame = frame;
        }
};
struct scr_cmd_wait_for_person_to_stop_talking : public script_cmd
{
        pt<PC> person;

        scr_cmd_wait_for_person_to_stop_talking(
            pt<PC> person)
        {
            this->person = person;
        }
};

struct scr_cmd_remove_from_container : public script_cmd
{
 
        pt<container> cont;
        pt<obj_or_concept> object;

        scr_cmd_remove_from_container(
            pt<container> cont,
            pt<obj_or_concept> object)
        {
            this->object = object;
            this->cont = cont;
        }
};
struct scr_cmd_add_to_container : public script_cmd
{
 
        pt<container> cont;
        pt<obj_or_concept> object;

        scr_cmd_add_to_container(
            pt<container> cont,
            pt<obj_or_concept> object)
        {
            this->object = object;
            this->cont = cont;
        }
};
struct scr_cmd_add_to_container_in_pos : public script_cmd
{
 
        pt<container> cont;
        int_pair pos;
        pt<obj_or_concept> object;

        scr_cmd_add_to_container_in_pos(
            pt<container> cont,
            pt<obj_or_concept> object,
            int_pair pos)
        {
            this->cont = cont;
            this->object = object;
            this->pos = pos;
        }
};


struct scr_cmd_modify_zone : public script_cmd
{
 
        pt<bg_hot_zone> zone;
        show_or_hide show;

        scr_cmd_modify_zone(
            show_or_hide show,
            pt<bg_hot_zone> zone)
        {
            this->show = show;
            this->zone = zone;
        }
};

struct scr_cmd_modify_layer : public script_cmd
{
 
        pt<layer_unlit_before_anim> layer;
        show_or_hide show;

        scr_cmd_modify_layer(
            show_or_hide show,
            pt<layer_unlit_before_anim> layer)
        {
            this->show = show;
            this->layer = layer;
        }
};






enum option_close_containers{ close_any_open_container, do_not_close_containers};

struct scr_cmd_speak : public script_cmd
{
        speech_t speech;
        option_close_containers close_containers;

        scr_cmd_speak(
            const speech_t & speech,
            option_close_containers close_containers) 
        {
            this->speech = speech;
            this->close_containers = close_containers;
        }

};


struct AI_substate_speaking_while_sitting : public AI_substate
{
        list<string> speech;
        list<string>::const_iterator current_phrase;
        float speech_timer;
        pt<anim_frame> frame;

        AI_substate_speaking_while_sitting (
            const list<string> & speech,
            pt<anim_frame> frame)
        {
            this->speech = speech;
            this->current_phrase = this->speech.begin();
            this->speech_timer = 0;
            this->frame = frame;
        }

};

struct AI_substate_speaking_while_standing : public AI_substate
{
        int cur_frame_it;
        float anim_timer;
        speech2_t speech;
        speech2_t::const_iterator current_phrase;
        float speech_timer;

        AI_substate_speaking_while_standing(
            const speech2_t& speech)
        {
            this->anim_timer = 0;
            this->cur_frame_it = 0;
            this->speech = speech;
            this->current_phrase = this->speech.begin();
            this->speech_timer = 0;
        }
};

struct scr_cmd_look_at_fixed_direction : public script_cmd
{
        direction dir;

        scr_cmd_look_at_fixed_direction(
            direction dir)
        {
            this->dir = dir;
        }
};

typedef map<int, SDL_Surface*> surf_of_letter_t;



struct container_pick_result_void : public container_pick_result{};

struct container_pick_result_closing_area : public container_pick_result
{
        pt<popup> pop;

        container_pick_result_closing_area(
            pt<popup> pop)
        {
            this->pop = pop;
        }
};

struct container_pick_result_container_drag_area : public container_pick_result
{
        pt<popup> pop;

        container_pick_result_container_drag_area(
            pt<popup> pop)
        {
            this->pop = pop;
        }
};

struct container_pick_result_obj_and_pos : public container_pick_result
{
        pos_and<pt<obj_or_concept> > obj_and_pos;
        pt<popup> pop;
        
        container_pick_result_obj_and_pos(
            const pos_and<pt<obj_or_concept> > & obj_and_pos,
            pt<popup> pop)
        {
            this->obj_and_pos = obj_and_pos;
            this->pop = pop;
        }
};

struct container_pick_result_obj : public container_pick_result
{
      pt<obj_or_concept>  obj;
      pt<popup> pop;
        
      container_pick_result_obj(
         const pt<obj_or_concept>  obj,
         pt<popup> pop)
      {
         this->obj = obj;
         this->pop = pop;
      }
};



enum special_button_pick_result
{
    SBPR_SAVE_LOAD, SBPR_CYCLE_PLAYER, SBPR_NOTHING, SBPR_STAY_FOLLOW
};


struct dir_watcher_list_model : public gcn::ListModel
{
      dir_watcher_list_model();

      int
      getNumberOfElements();

      string
      getElementAt(int i);


      void
      rescan_dir();

      vector<string> strings;
};


class FACK : public gcn::ActionListener
{
    public:
    
        void
        start();


    protected:
    
        FACK(int argc, char ** argv);

        // BEGIN pure virtual functions that must be implemented in
        // the derived class
        virtual void
        execute_action_verb_object(
            const pt<verb> v, 
            const pt<obj_or_concept> obj_for_which_no_verb_was_chosen,
            const pt<obj_or_concept> obj_for_which_the_verb_was_chosen) = 0;

        virtual void
        execute_action_object_object(
            const pt<obj_or_concept> o1, 
            const pt<obj_or_concept> o2) = 0;
    
        virtual void
        execute_action_double_none_of_the_above(
            const pt<phys_obj> o1, 
            const pt<phys_obj> o2) = 0;
        
 
        // END
        

        // BEGIN utility fuctions that the derived class can use
        void
        execute_commands(
            pt<PC> player,
            const list<pt<script_cmd> > & commands);



        void
        define_dialog_aux(
            const dialog_t & dialog,
            pt<PC> first_player, 
            pt<PC> second_player, 
            script_cmds_t & commands_first,
            script_cmds_t & commands_second) const;
    

        static bool
        contains_recursively(
            pt<container> cont,
            pt<obj_or_concept> o,
            pt<container> & real_cont,
            int_pair & pos );


        static bool
        contains_not_recursively(
            pt<container> cont,
            pt<obj_or_concept> o,
            int_pair & pos );
    
        virtual void
        active_player_changed(pt<PC> new_act_pl){}
        
        // END


        // BEGIN protected member variables that must be initialized
        // by the derived class
        SDL_Surface* special_buttons_icon;
        int_pair special_buttons_icon_pos;
        SDL_Rect zone_save_load_game, zone_cycle_active_player, zone_toggle_stay_follow;

        surf_of_letter_t surf_of_letter;

        pt<PC> act_pl;

        seq_list<pt<PC> > players; // for switching

        set<pt<location> > locations;

        pt<phys_obj> hand,  eye, mouth,  foot, ear, body; 

        pt<concept> topic_hello, topic_yes, topic_no, topic_bye; // @@ why here?

        set<pt<light_across_loc> > lights_across_loc;
        // END


        // BEGIN members that must not be written but can be read or
        // written by the derived class
        SDL_Surface* screen;

        pt<quick_message> quick_msg;

        list<pt<transition_of_fixed_light> > transitions_of_fixed_light;
        // END

    private:

        bool must_exit; 

        pt<gcn::SDLGraphics> gcn_graphics;
        pt<gcn::Gui> gcn_gui;
        pt<gcn::Container> gcn_top_container;

        pt<gcn::Window> gcn_save_window;
        pt<gcn::Container> gcn_save_cont;
        pt<gcn::Button> gcn_cancel_save_button;
        pt<gcn::Button> gcn_save_button;
        pt<gcn::TextField> gcn_save_text_field;

        pt<gcn::Window> gcn_options_window;
        pt<gcn::Container> gcn_options_cont;

        pt<dir_watcher_list_model> list_model;



        pt<gcn::Window> gcn_load_window;
        pt<gcn::Container> gcn_load_cont;
        pt<gcn::Button> gcn_cancel_load_button;
        pt<gcn::ListBox> gcn_load_listbox;
        pt<gcn::ScrollArea> gcn_load_scroll_area;
        
        pt<gcn::SDLInput> gcn_input;
        pt<gcn::SDLImageLoader> gcn_image_loader;
        pt<gcn::ImageFont> gcn_font;

        pt<gcn::Button> gcn_options_save_button;
        pt<gcn::Button> gcn_options_cancel_button;
        pt<gcn::Button> gcn_options_fullscreen_button;
        pt<gcn::Button> gcn_options_load_button;
        pt<gcn::Button> gcn_options_quit_button;

        

        void action(const string& eventId);


        void
        recompute_on_lights(
            set<pt<light> > & on_lights ) const;

        special_button_pick_result
        special_button_at_pos(
            int_pair pos) const;


        pt<layer_lit> 
        lit_layer_of_unlit_layer ( 
            const layer_unlit_after_anim & unlit,
            const set<pt<light> > & on_lights,
            float time,
            SDL_Rect visible_rect)const;

        pt<circle_t>
        circle_of_light(pt<light> l) const;

        update_AI_result
        update_AI_state(pt<PC> player, float dt,
                        int_pair top_left_of_obj_in_cont_coords);

        void
        update_light_transitions(float dt);

        SDL_Rect
        find_scrolling_rect(
            int_pair size_of_bg_surf);
        
        result_exec_next_scr_cmd
        exec_next_scr_cmd(
            const vector<pt<script_cmd> > commands,
            int cur_cmd_it,
            const pt<PC> pl,
            pt<anim_frame> last_frame,
            bool increm_cmd_at_start,
            bool must_set_player_left_or_right);

        pt<game_state_t> game_state;

        void
        close_all_open_popups(
            const pt<PC> pl);

        void
        render_command_bar( 
            int_pair mouse_screen,
            int_pair mouse_bg,
            const map<pt<PC>, pt<anim_frame> > & cur_frame_of_player) const;

        void
        manage_button_up(
            list<SDL_Event>::const_iterator ev);

        int
        calc_command_bar_ht() const
        {
            return 2 + map_get(surf_of_letter, 'a')->h;
        }

        
        pt<container_pick_result>
        item_in_popup_at_screen_pos(
            int_pair screen_pos) const;


        void
        the_obj_was_clicked(
            pt<obj_or_concept> o,
            int_pair mouse);

        void 
        drop_item(
            pt<dragging_state_maybe_dragging_obj> st,
            int_pair mouse);


        void
        cycle_active_player();


        void
        stand_up_if_sitting(
            pt<PC> pl);

};

void 
blit_char( 
    const anim_frame_and_pos & src,
    float scaling ,
    float lighting,
    cfsurf & screen );


struct surf_and_weight{
        pt<cfsurf> surf;
        float oscillation_amplitude;
        float oscillation_speed;

        pt<circle_t> circle;

        float calc_weight(int_pair pos) const;

        surf_and_weight(
            pt<cfsurf> surf, 
            float weight,
            float oscillation_amplitude, 
            float oscillation_speed,
            pt<circle_t> circle);

        surf_and_weight(){}
    
        bool operator< (const surf_and_weight& s) const;

    private:
        float weight;
};

inline
float
surf_and_weight::calc_weight(int_pair pos) const
{
    
    if(circle)
    {
        // BEGIN decl
        float dx, dy;
        float distance_squared, circle_rad_squared, ratio;
        // END

        dx = float(abs(pos.x - circle->center.x));
        dy = float(abs(pos.y - circle->center.y));
        distance_squared =  dx * dx + dy * dy;
        circle_rad_squared = circle->radius * circle->radius;

        if (distance_squared >= circle_rad_squared)
        {
            return 0;
        }
        else
        {
            ratio = distance_squared / circle_rad_squared;
            return weight * ( 1.0f - ratio  );
        }
    }
    else
    {
        return weight;
    }
}

inline
surf_and_weight::surf_and_weight(
    pt<cfsurf> surf, float weight,
    float oscillation_amplitude, float oscillation_speed,
    pt<circle_t> circle)
{
    assert(0 <= oscillation_amplitude  && oscillation_amplitude < 0.5f);
    this->weight = weight;
    this->surf = surf;
    this->circle = circle;
    this->oscillation_speed = oscillation_speed;
    this->oscillation_amplitude = oscillation_amplitude;
}

pt<cfsurf> 
sum_each_pixel( const list<surf_and_weight > & surfs, float time,
                SDL_Rect visible_rect);


pt<layer_lit> 
lit_layer_of_unlit_layer ( 
    const layer_unlit_after_anim & unlit,
    const set<pt<light> > & on_lights,
    float time ,
    SDL_Rect visible_rect);

inline
rgbaf 
sum_rgbaf(rgbaf r1, rgbaf r2){
    return rgbaf(r1.r + r2.r
                 , r1.g + r2.g
                 , r1.b + r2.b
                 , r1.a + r2.a);
}

inline
rgbaf
rgbaf_of_rgbai(Uint8 r, Uint8 g, Uint8 b, Uint8 a){
    return rgbaf( float(r)
                  , float(g)
                  , float(b)
                  , float(a) / 255.0f);
}

inline
rgbaf
mul_scalar_rgbaf(float scal, rgbaf rg){
    return rgbaf( scal * rg.r
                  , scal * rg.g
                  , scal * rg.b
                  , scal * rg.a );
}

inline
rgbaf 
mul_scalar_rgbaf_noalpha(float scal, rgbaf rg){
    return rgbaf( scal * rg.r
                  , scal * rg.g
                  , scal * rg.b
                  , rg.a );
}



inline
void 
cfsurf::set_pixel(
    int x, 
    int y, 
    rgbaf pix)
{
    // BEGIN decl
    int x2, y2;
    // END

    // BEGIN precond
    x2 = x - offs_x;
    y2 = y - offs_y;
    assert(0<= x2 && x2 < real_wt);
    assert(0<= y2 && y2 < real_ht);
    // END

    pixels[ y2 * real_wt + x2] = pix;
}


inline
rgbaf
cfsurf::get_pixel(
    int x, 
    int y)const
{
    // BEGIN decl
    int x2, y2;
    // END

    // BEGIN precond
    assert (0 <= x && x < apparent_wt);
    assert (0 <= y && y < apparent_ht);
    // END

    x2 = x - offs_x;
    y2 = y - offs_y;
    if (   0<= x2 && x2 < real_wt
        &&  0<= y2 && y2 < real_ht){
        return pixels[ y2 * real_wt + x2];}
    else{
        return rgbaf(0.f ,0.f ,0.f ,0.f );} // useful to merge
    // surfaces with different
    // real widths.
}

inline
rgbaf 
anim_frame::get_pixel_with_interpolation(
    float px,
    float py) const
{
    // BEGIN decl
    float x_low, x_high, y_low, y_high;
    int x_low_i, x_high_i, y_low_i, y_high_i;
    float delta_x, delta_y;
    float weight_x1, weight_x2, weight_y1, weight_y2;
    rgbaf p1, p2, p3, p4, p12, p34, p;
    // END

    // BEGIN precond
    assert(w > 0);
    assert(h > 0);
    assert(px >= 0.0f);
    assert(py >= 0.0f);
    // due to approximation errors, I don't know how to check for this:
    //     assert(int(px) < w);
    //     assert(int(py) < h);
    // END


    x_low = std::max(0.0f, px - 0.5f);
    x_high = std::min (float(w) -0.1f, px + 0.5f);
    y_low = std::max(0.0f, py - 0.5f);
    y_high = std::min ( float(h) - 0.1f, py + 0.5f ) ;

    assert(x_low < x_high);
    assert(y_low < y_high);

    x_low_i = int( floor(x_low)); // floor() is important because, if
    // x_low==0.5f, x_low_i could be set
    // to 1, which is wrong.
    x_high_i = int(floor(x_high)); // floor() is important because, if
    // x_high == 1.5, x_high_i could be
    // set to 2, which is wrong.
    y_low_i = int( floor(y_low));
    y_high_i = int(floor(y_high));

    assert(x_low_i < w);
    assert(y_low_i < h);
    assert(x_high_i < w);

    if (y_high_i >= h){
        cout << "w = " << w << ", h = " << h << ", y_high_i = " << y_high_i <<endl;}
    assert(y_high_i < h);


    p1 = get_pixel(  x_low_i, y_low_i);
    p2 = get_pixel(  x_high_i, y_low_i);
    p3 = get_pixel(  x_low_i, y_high_i);
    p4 = get_pixel(  x_high_i, y_high_i);

    delta_x = nearbyint(px) - px; 
    delta_y = nearbyint(py) - py;

    weight_x1 = 0.5f  + delta_x;
    weight_x2 = 0.5f  - delta_x;

    weight_y1 = 0.5f  + delta_y;
    weight_y2 = 0.5f  - delta_y;

    assert(weight_x1 >= 0.0f);
    assert(weight_x2 >= 0.0f);
    assert(weight_y1 >= 0.0f);
    assert(weight_y2 >= 0.0f);

    // in order to compute p from p1, p2, p3, p4, first we blend
    // p1 and p2 to obtain p12, then p3 and p4 to obtain p34, and
    // finally p34 and p12 to obtain p.
    p12 = sum_rgbaf( mul_scalar_rgbaf(weight_x1, p1)
        , mul_scalar_rgbaf(weight_x2, p2));
    p34 = sum_rgbaf( mul_scalar_rgbaf(weight_x1, p3)
        ,  mul_scalar_rgbaf(weight_x2, p4));
    p = sum_rgbaf( mul_scalar_rgbaf(weight_y1, p12)
        , mul_scalar_rgbaf(weight_y2, p34));

        
    return p;
}

inline
rgbaf
anim_frame::get_pixel(
    int x, 
    int y) const
{
    // BEGIN precond
    assert (0 <= x && x < w);
    assert (0 <= y && y < h);
    // END
    return pixels[ y * w + x];
}





#endif

---