fack.cc

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

#include "fack.hpp"
#include <boost/filesystem/operations.hpp> // includes boost/filesystem/path.hpp
#include <boost/filesystem/fstream.hpp>    // ditto

#include <SDL/SDL_gfxPrimitives.h>   

#include <stdio.h>
#include <algorithm>
//#include <math.h> // floor, ceil

//#define NDEBUG // @@ uncomment this for speedup
#include <assert.h>


cfsurf::cfsurf(int apparent_wt_, int apparent_ht_, 
    int real_wt_, int real_ht_, int offset_x_, int offset_y_)
{
    apparent_wt = apparent_wt_;
    apparent_ht = apparent_ht_;
    real_wt = real_wt_;
    real_ht = real_ht_;
    offs_y = offset_y_;
    offs_x = offset_x_;
    pixels.resize(real_wt_ * real_ht_); 
}




string string_of_int(int i){
    std::ostringstream temp;
    temp << i;
    return temp.str();
}



void raise_exception(string s){
    cerr << s << endl;
    throw s;
}


bool
point_in_rect(int_pair p, SDL_Rect r)
{
    return (r.x <= p.x && p.x<r.x+r.w
        &&
        r.y <=p.y && p.y <r.y + r.h);
}

Uint32
get_raw_pixel_32bitpp(SDL_Surface * s, int x, int y)
{
    // BEGIN decl
    int bpp;
    Uint32 * ptr;
    SDL_PixelFormat * f;
    // END

    // BEGIN precond
    if(x >= s->w)
        raise_exception("x out of range");
    if(y >= s->h){
        cerr << " y = " << y << ", ht = " << s->h;
        raise_exception(string("get_raw_pixel_32bitpp: y out of range "));}
    f = s->format;
    bpp = f->BytesPerPixel;
    if (bpp != 4){
        raise_exception("Only 32 bitpp surfaces supported");}
    // END

    ptr = (Uint32 *) (s->pixels) + x + y * s->w;
    return * ptr;

}

void put_raw_pixel_32bitpp(SDL_Surface * s, int x, int y, Uint32 pixel)
{
    // BEGIN decl
    int bpp;
    Uint32 *p;
    // END

    
    if(x <= s->w && y <=s->h){//Put pixel only if it is in screen!    
        
        bpp = s->format->BytesPerPixel;
    
        if (bpp != 4){
            raise_exception("Only 32 bitpp surfaces supported");
        }
    
        p = (Uint32 *)(s->pixels) + x + y * s->w;
        *(Uint32 *)p = pixel;
    }
}
 



inline 
void 
anim_frame::set_pixel(
    int x, 
    int y, 
    rgbaf pix)
{


    // BEGIN precond
    assert(0<= x && x < w);
    assert(0<= y && y < h);
    // END
    pixels[ y * w + x] = pix;
}








pt<anim_frame> 
anim_frame::from_sdl_surface(
    SDL_Surface * s,
    int_pair hot_spot,
    float duration)
{
    // BEGIN decl
    pt<anim_frame> ret;
    int x, y;
    rgbaf pix;
    Uint32 raw_pixel;
    Uint32 * ptr;
    Uint8 r, g,b, a;
    // END

    // BEGIN precond
    assert(s != NULL);
    assert(s->format->BytesPerPixel == 4);
    // END


    ret = NEW( anim_frame(s->w, s->h, hot_spot, duration));
    SDL_LockSurface(s);
    for(x = 0; x< s->w ; x++){
        for ( y = 0 ; y< s->h ; y++){
            ptr = (Uint32 *) (s->pixels) + x + y * s->w;
            raw_pixel = * ptr;
            SDL_GetRGBA(raw_pixel, s->format, &r, &g, &b, &a);
            ret->set_pixel( x, y, rgbaf_of_rgbai(r, g,b, a));}}
    SDL_UnlockSurface(s);
    return ret;
}







bool surf_and_weight::operator< (const surf_and_weight& s) const{
    return this->surf < s.surf;
}




pt<cfsurf> 
cfsurf::from_sdl_surface(SDL_Surface * s)
{
    // BEGIN decl.
    pt<cfsurf> surf;
    int x, y;
    Uint32 raw_pixel;
    Uint32 * ptr;
    Uint8 r, g, b, a;
    rgbaf pix2;
    int real_wt, real_ht, offs_x, offs_y, apparent_wt, apparent_ht;
    int lowest_nontransparent_x_found_so_far;
    int lowest_nontransparent_y_found_so_far;
    int highest_nontransparent_x_found_so_far;
    int highest_nontransparent_y_found_so_far;
    // END

    // BEGIN precond
    assert(s != NULL);
    assert(s->format->BytesPerPixel == 4);
    // END

    lowest_nontransparent_y_found_so_far = INT_MAX;
    highest_nontransparent_y_found_so_far = INT_MIN;
    lowest_nontransparent_x_found_so_far = INT_MAX;
    highest_nontransparent_x_found_so_far = INT_MIN;

    SDL_LockSurface(s);
    for ( x = 0; x < s->w; x++)
    {
        for (y = 0; y < s->h; y++)
        {
            ptr = (Uint32 *) (s->pixels) + x + y * s->w;
            raw_pixel = * ptr;
            SDL_GetRGBA(raw_pixel, s->format, &r, &g, &b, &a);
            if (a != 0)
            { // not completely transparent
                if (x < lowest_nontransparent_x_found_so_far){
                    lowest_nontransparent_x_found_so_far = x;}
                if (x > highest_nontransparent_x_found_so_far){
                    highest_nontransparent_x_found_so_far = x;}
                if (y < lowest_nontransparent_y_found_so_far){
                    lowest_nontransparent_y_found_so_far = y;}
                if (y > highest_nontransparent_y_found_so_far){
                    highest_nontransparent_y_found_so_far = y;}
            }
        }
    }

    assert(lowest_nontransparent_y_found_so_far 
        < highest_nontransparent_y_found_so_far);
    assert(lowest_nontransparent_x_found_so_far 
        < highest_nontransparent_x_found_so_far);

    real_wt = highest_nontransparent_x_found_so_far
        - lowest_nontransparent_x_found_so_far;
    real_ht = highest_nontransparent_y_found_so_far
        - lowest_nontransparent_y_found_so_far;
    offs_x = lowest_nontransparent_x_found_so_far;
    offs_y = lowest_nontransparent_y_found_so_far;
    apparent_ht = s->h;
    apparent_wt = s->w;

    surf = NEW( cfsurf(apparent_wt, apparent_ht
                    , real_wt, real_ht
                    , offs_x, offs_y));
    for(x = offs_x; x< offs_x + real_wt; x++){
        for ( y = offs_y; y< offs_y + real_ht; y++){
            ptr = (Uint32 *) (s->pixels) + x + y * s->w;
            raw_pixel = * ptr;
            SDL_GetRGBA(raw_pixel, s->format, &r, &g, &b, &a);
            pix2 = rgbaf_of_rgbai(r, g, b, a);
            surf->set_pixel( x, y, pix2);}}
    SDL_UnlockSurface(s);
    return surf;
}





int
pow(int base, int exp){
    // BEGIN decl
    int p;
    int count;
    // END

    p = 1;
    for (count = 0; count< exp; count ++){
        p *= base;}
    return p;
}


template<class S> 
set<typename S::key_type>
subset(S s, vector<bool> must_be_included)
{
    // BEGIN decl.
    set<typename S::key_type> ret;
    typename S::key_type el;
    int i;
    typename S::const_iterator i2;
    // END

    // BEGIN precond
    assert(must_be_included.size() >= s.size());
    // END

    for ( i = 0 , i2 = s.begin()  ; i2 != s.end()  ; i++, i2++){
        if (must_be_included[i]){
            el = *i2;
            ret.insert(el);}}
    return ret;
}

vector<bool>
boolean_representation(int integer)
{
    // BEGIN decl.
    vector<bool> ret;
    int num_bits;
    int mask, i;
    // END

    num_bits = sizeof(integer) * 8;
    ret.resize(num_bits);
    for (i = 0; i < num_bits; i++){
        mask = 1 << i;
        ret[i] = ((integer & mask) != 0 ); }
    return ret;
}


string string_of_boolRepr(vector<bool> v){
    // BEGIN decl
    string ret;
    int i;
    // END

    ret = "";
    for (i = 0; i < v.size(); i++){
        if (v[i]){
            ret += "1";}
        else{
            ret += "0";}}
    return ret;}




float 
scaling_of_char(float char_y,
    const room_scaling_data & d)
{
    // BEGIN decl
    float a, b, tg_alpha;
    // END
    tg_alpha = (d.scaling_at_y2 - d.scaling_at_y1) / (d.y2 - d.y1);
    a = d.scaling_at_y1 - tg_alpha * d.y1;
    b = a / tg_alpha;
    return (b+ char_y ) * tg_alpha;
}



bool
surf_must_be_printed_before(
    const pt<anim_frame_and_pos> c1, 
    const pt<anim_frame_and_pos> c2)
{   


    return (c1->position_y < c2->position_y);

}

// pt<result_item_in_inv>
// FACK::item_in_inv_at_position( 
//     int_pair pos) const
// {
//     // BEGIN decl
//     variant<no_item, pt<phys_obj> > ret;
//     int i;
//     int item_rect_left, item_rect_right;
//     int item_rect_top, item_rect_bottom;
//     int item_wt, columns_count;
//     map<int, pt<obj_or_concept> > obj_of_index;
//     int remainder_wt;
//     // END


//     obj_of_index[0] = hand;
//     obj_of_index[1] = eye;
//     obj_of_index[2] = mouth;
//     obj_of_index[3] = foot;
//     obj_of_index[4] = body;
//     obj_of_index[5] = ear;
//     obj_of_index[9] = act_pl->;
//     obj_of_index[10] = act_pl->backpack;

//     item_wt = calc_size_of_inv_items();
//     columns_count = 11; 

//     item_rect_top = screen->h - item_wt;
//     item_rect_bottom = screen->h -1 ;

//     for ( i = 0; i< 11; i++)
//     {

//         item_rect_left =  i * item_wt;
//         item_rect_right = (i+1) * item_wt;

//         if ( item_rect_left <= pos.x && pos.x < item_rect_right
//             && 
//             item_rect_top <= pos.y && pos.y <= /*sic*/ item_rect_bottom)
//         {
//             if (in(i, obj_of_index))
//             {
//                 return NEW(result_item_in_inv_object_or_conc(map_get(obj_of_index, i)));
//             }
//          else if ( i == 7)
//          {
//              return NEW(result_item_in_inv_special_item_switch_player());
//          }
//          else if ( i == 6)
//          {
//              return NEW(result_item_in_inv_special_item_save_load());
//          }
//          else if ( i == 8)
//          {
//              return NEW(result_item_in_inv_special_item_stay_follow());
//          }
//         }
//     }

//     // BEGIN check whether the mouse is in the gap to the right of the
//     // screen. This area is associated to the last item.
//     remainder_wt = screen->w % calc_size_of_inv_items();
//     if (remainder_wt >0)
//     {
//         if ( screen->w -remainder_wt <= pos.x && pos.x < screen->w
//             && 
//             item_rect_top <= pos.y && pos.y <= /*sic*/ item_rect_bottom)
//         {
//          return NEW(result_item_in_inv_object_or_conc(map_get(obj_of_index, 10)));
//         }

//     }
//     // END

//     return NEW(result_item_in_inv_nothing());

// }

// void 
// FACK::render_inventory(
//     int_pair mouse) const
// {
//     // BEGIN decl
//     int columns_count; 
//     int c;
//     int item_wt;
//     SDL_Rect dest_rect;
//     int ret;
//     int remainder_wt;
//     int ht;
//     int item_rect_left, item_rect_right;
//     int item_rect_top, item_rect_bottom;
//     pt<game_state_flashing_inv_t> flashing;
//     pt<PS_governed_by_AI> governed_by_AI;
//     SDL_Surface* surf;
//     map<int, SDL_Surface*> icon_of_index;
//     // END

//     item_wt = ht = calc_size_of_inv_items();


        
//     if (!pt_cast(game_state, flashing) && pt_cast(act_pl->state, governed_by_AI))
//     {
//         SDL_Rect dest_rect;
//         dest_rect.x = 0;
//         dest_rect.y = screen->h - ht;
//         dest_rect.w = screen->w;
//         dest_rect.h = ht;

//         SDL_FillRect(screen, &dest_rect, SDL_MapRGB(screen->format, 10, 0, 0));

//     }
//     else
//     {
      
//         item_rect_top = screen->h - item_wt;
//         item_rect_bottom = screen->h -1 ;

//         columns_count = 11;

//         icon_of_index[0] = hand->pick_up_info->get_inv_surf();
//         icon_of_index[1] = eye->pick_up_info->get_inv_surf();
//         icon_of_index[2] = mouth->pick_up_info->get_inv_surf();
//         icon_of_index[3] = foot->pick_up_info->get_inv_surf();
//         icon_of_index[4] = body->pick_up_info->get_inv_surf();
//         icon_of_index[5] = ear->pick_up_info->get_inv_surf();
//         icon_of_index[6] = save_load_icon;
//         icon_of_index[7] = switch_player_icon;
//         icon_of_index[8] = stay_follow_icon;
//         icon_of_index[9] = bulb_icon;
//         icon_of_index[10] = inv_icon;



//         dest_rect.x = 0;
//         dest_rect.y = item_rect_top;
//         dest_rect.w = screen->w;
//         dest_rect.h = item_wt;
//         SDL_FillRect(screen, &dest_rect, SDL_MapRGB(screen->format, 10, 10, 10));

//         // BEGIN blit inv items
//         for ( c = 0; c< columns_count; c++)
//         {
//             surf = icon_of_index[c];

//             dest_rect.x = c * item_wt + (item_wt - surf->w)/2;
//             dest_rect.y = item_rect_top +  (item_wt - surf->h)/2;

//             ret = SDL_BlitSurface(map_get(icon_of_index, c),
//                                   NULL, screen, &dest_rect );
//             assert(ret == 0);

//             // BEGIN blit mouseover highlight
//             item_rect_left =  c * item_wt;
//             item_rect_right =  (c+1) * item_wt;

//             if (!pt_cast(game_state, flashing) )
//             {
//                 if ( item_rect_left <= mouse.x && mouse.x < item_rect_right
//                      && 
//                      item_rect_top <= mouse.y && mouse.y <= /*sic*/ item_rect_bottom)
//                 {
//                     rectangleRGBA(screen, 
//                                   item_rect_left, item_rect_top, item_rect_right, item_rect_bottom, 
//                                   200, 100, 100, 200);
//                 }
//             }
//             else
//             {
//                 if ( ( c == 10 && flashing->inv_is_flashing
//                        ||
//                        c == 9 && !flashing->inv_is_flashing)
//                      &&  
//                      int(floor(flashing->timer / 0.3f)) % 2 == 0)
//                 {
//                     rectangleRGBA(screen, 
//                                   item_rect_left, item_rect_top, item_rect_right, item_rect_bottom, 
//                                   200, 100, 100, 200);

//                 }
//             }
//             // END
//         }
//         // END

//      // BEGIN check whether the mouse is in the gap to the right of the
//      // screen. This area is associated to the last item.
//      remainder_wt = screen->w % calc_size_of_inv_items();

//      if ( screen->w -remainder_wt <= mouse.x && mouse.x < screen->w
//           && 
//           item_rect_top <= mouse.y && mouse.y <= /*sic*/ item_rect_bottom)
//      {
//          item_rect_left =  10* item_wt;
//             item_rect_right =  (10+1) * item_wt;

//          rectangleRGBA(screen, 
//                        item_rect_left, item_rect_top, item_rect_right, item_rect_bottom, 
//                        200, 100, 100, 200);

//      }
//      // END


      
//     }
// }


bool
hot_zone_square::point_in_zone(
    int_pair point) const
{
    return (this->x1 <= point.x && point.x <this->x2 && 
        this->y1 <= point.y && point.y < this->y2);
}

bool
hot_zone_pixel_perfect::point_in_zone(
    int_pair point) const
{
    // BEGIN decl
    rgbaf p;
    // END

    if ( 0<= point.x && point.x < surf->apparent_wt &&
        0<= point.y && point.y < surf->apparent_ht)
    {
        p = surf->get_pixel( point.x, point.y);
        return ( p.a != 0.0f );
    }
    else
    {
        return false;
    }
}

bool
player_is_closer_to_the_screen(
    const pt<PC> c1, 
    const pt<PC> c2)
{   
    return (c1->pos.y > c2->pos.y);
}


void 
FACK::drop_item(
    pt<dragging_state_maybe_dragging_obj> st,
    int_pair mouse)
{
    // BEGIN decl
    list<pt<popup> >::reverse_iterator zo;
    int_pair mouse_in_cont_coords, top_left_of_obj_in_cont_coords;
    pt<container> cont, co, real_co;
    int_pair top_left_of_obj, bottom_right_of_obj;
    list<pt<popup> > popups;
    int_pair pos;
    // END

    popups = act_pl->open_popups;
    popups.push_front(act_pl->cache);

    for(zo =  popups.rbegin();
        zo != popups.rend();
        zo ++)
    {
        if (pt_cast( *zo, co))
        {
            mouse_in_cont_coords = mouse - co->position_in_screen;

            top_left_of_obj =  mouse_in_cont_coords - st->offset_of_mouse_in_obj;
            bottom_right_of_obj = top_left_of_obj + int_pair(
                st->obj_and_pos.o->get_inv_surf()->w, 
                st->obj_and_pos.o->get_inv_surf()->h);

            if( point_in_rect(top_left_of_obj, co->drop_in_area) &&
                point_in_rect(bottom_right_of_obj, co->drop_in_area ))
            {
                if ( co->can_contain_this_obj(st->obj_and_pos.o)
                     && 
                     (   !pt_cast(st->obj_and_pos.o, cont) 
                         ||
                         ( cont != co 
                           &&
                           !contains_recursively(cont, co, real_co /* out*/, pos /* out*/) )))
                {
                    if ( st->orig_container == co 
                         ||
                         st->obj_and_pos.o->can_be_moved_across_containers())
                    {
                        co->add_item_in_pos(pos_and<pt<obj_or_concept> >(st->obj_and_pos.o, 
                                                                            top_left_of_obj));
                        return;
                    }
                    else
                    {
                        quick_msg = NEW(quick_message("This item cannot be moved across containers."));
                        break;
                    }
                }
                else
                {
                    quick_msg = NEW(quick_message("Item and container incompatible."));
                    break; // do not try with containers beneath this one.
                }
            }
        }
    }

    // BEGIN failed. put the item in its original container.
    st->orig_container->add_item_in_pos(st->obj_and_pos);
    // END
}



pt<container_pick_result>
container::item_at_screen_pos(
    int_pair screen_pos,
    pt<popup> myself_as_a_smart_ptr) const
{
    // BEGIN decl
    SDL_Rect rect;
    list<pos_and<pt<obj_or_concept> > >::const_reverse_iterator i;
    int_pair pos_in_item_coords, pos_in_container_coords;
    SDL_Surface* surf;
    SDL_Surface* surf2;
    Uint32 * addr;
    Uint32 raw_pix;
    Uint8 r, g, b, a;
    // END


    pos_in_container_coords = screen_pos - this->position_in_screen;

    for( i = this->sorted_items.rbegin(); 
         i != this->sorted_items.rend();
         i ++)
    {
        surf = i->o->get_inv_surf();

        pos_in_item_coords = pos_in_container_coords - i->pos;

        if (0 <= pos_in_item_coords.x && pos_in_item_coords.x < surf->w && 
            0 <= pos_in_item_coords.y && pos_in_item_coords.y < surf->h)
        {
            SDL_LockSurface(surf);
            addr = (Uint32 *)(surf->pixels) + pos_in_item_coords.y * surf->w + pos_in_item_coords.x;
            raw_pix = * addr;
            SDL_GetRGBA(raw_pix, surf->format, &r, &g, &b, &a);
            SDL_UnlockSurface(surf);
            if (a != 0)
            {
                return NEW(container_pick_result_obj_and_pos(pos_and<pt<obj_or_concept> >
                                                             (i->o, i->pos), 
                                                             myself_as_a_smart_ptr));
            }
        }

    }
    // BEGIN check if the container itself was clicked

    if(var_cast(this->closing_area, rect) && point_in_rect(pos_in_container_coords, rect))
    {
        return NEW(container_pick_result_closing_area(myself_as_a_smart_ptr));
    }
    else if(this->can_be_dragged)
    {
        if (point_in_rect(pos_in_container_coords, this->drop_in_area))
        {
            return NEW(container_pick_result_container_drag_area(myself_as_a_smart_ptr));
        }
        else
        {
            surf2 = this->picture;
                
            if (0 <= pos_in_container_coords.x && pos_in_container_coords.x < surf2->w && 
                0 <= pos_in_container_coords.y && pos_in_container_coords.y < surf2->h)
            {
                SDL_LockSurface(surf2);
                addr = (Uint32 *)(surf2->pixels) + pos_in_container_coords.y * surf2->w + 
                    pos_in_container_coords.x;
                raw_pix = * addr;
                SDL_GetRGBA(raw_pix, surf2->format, &r, &g, &b, &a);
                SDL_UnlockSurface(surf2);
                if (a != 0)
                {
                    return NEW(container_pick_result_container_drag_area(myself_as_a_smart_ptr));
                }
            }
        }
    }
    // END

    return NEW(container_pick_result_void());
}

pt<container_pick_result>
zoomable::item_at_screen_pos(
    int_pair screen_pos,
    pt<popup> myself_as_a_smart_ptr ) const
{
    // BEGIN decl
    SDL_Rect rect;
    list<pt<zoomable_zone> >::const_reverse_iterator z;
    int_pair  pos_in_container_coords;
    SDL_Surface* surf2;
    Uint32 * addr;
    Uint32 raw_pix;
    SDL_Rect surf_rect;
    Uint8 r, g, b, a;
    // END

    pos_in_container_coords = screen_pos - this->position_in_screen;

    // BEGIN find the alpha value of the pixel
    surf2 = this->picture;

    surf_rect = create_rect(0, 0, surf2->w, surf2->h);
                
    if (point_in_rect(pos_in_container_coords, surf_rect))
    {
        SDL_LockSurface(surf2);
        addr = (Uint32 *)(surf2->pixels) + pos_in_container_coords.y * surf2->w + 
            pos_in_container_coords.x;
        raw_pix = * addr;
        SDL_GetRGBA(raw_pix, surf2->format, &r, &g, &b, &a);
        SDL_UnlockSurface(surf2);
    }

    // END


    for( z = this->sorted_zones.rbegin(); 
         z != this->sorted_zones.rend();
         z ++)
    {

        if (   (*z)->point_in_zone(pos_in_container_coords) 
               &&
               (  a != 0
                  ||
                  !(*z)->intersect_rect_and_picture))
        {
            return NEW(container_pick_result_obj(
                           (*z)->obj, 
                           myself_as_a_smart_ptr));
        }

    }
    // BEGIN check if the container itself was clicked

    if(var_cast(this->closing_area, rect) && point_in_rect(pos_in_container_coords, rect))
    {
        return NEW(container_pick_result_closing_area(myself_as_a_smart_ptr));
    }
    else
    {
        if (point_in_rect(pos_in_container_coords, surf_rect) // then a was calculated earlier...
            &&
            a != 0)
        {
            return NEW(container_pick_result_container_drag_area(myself_as_a_smart_ptr));
        }

    }
    // END
    return NEW(container_pick_result_void());
}


pt<container_pick_result>
FACK::item_in_popup_at_screen_pos(
    int_pair screen_pos)  const
{
    // BEGIN decl
    list<pt<popup> >::reverse_iterator po;
    list<pt<popup> > popups;
    pt<container> co;
    pt<zoomable> zo;
    pt<container_pick_result> pick_res;
    pt<container_pick_result_void> void_res;
    // END

    popups = act_pl->open_popups;
    popups.push_front(act_pl->cache);

    for(po =  popups.rbegin();
        po != popups.rend();
        po++)
    {
        pick_res = (*po)->item_at_screen_pos(screen_pos, *po);
       
        if(!pt_cast(pick_res, void_res))
        {
            return pick_res;
        }
    }
    return NEW(container_pick_result_void());

}


variant<no_item, pt<obj_or_concept> >
item_in_room_at_position(
    int_pair pos,
    list<pt<PC> > players,
    const pt<PC> act_pl,
    const map<pt<PC>, pt<anim_frame> > & cur_frame_of_player)
{
    // BEGIN decl
    list<pt<bg_hot_zone> >::const_iterator z;
    list<pt<PC> >::const_iterator pl;
    pt<PC> item2;
    pt<bg_hot_zone> item1;
    pt<still_situation_sitting> sitting;
    bool must_be_scaled;
    float scal;
    // END

    foreach(z, act_pl->loc->sorted_hot_zones){
        if( (*z)->visible && (*z)->point_in_zone(pos))
        {
            item1 = *z;
            break;
        }
    }

    players.sort(player_is_closer_to_the_screen);

    foreach(pl, players){
        
        must_be_scaled = !pt_cast((*pl)->still_situat, sitting);

        scal = (must_be_scaled? 
                scaling_of_char( (*pl)->pos.y, act_pl->loc->scaling_data):
                1.0f);

        if( (*pl) != act_pl
            &&
            (*pl)->loc == act_pl->loc 
            && 
            map_get(
                cur_frame_of_player, 
                (*pl))  ->  point_in_surf( pos,
                                           (*pl)->pos,
                                           scal))
        {
            item2 = *pl;
            break;
        }
    }

    if (item1 && !item2)
    {
        return item1->obj;
    }
    else if (item2 && !item1)
    {
        return item2->obj;
    }
    else if (item1 && item2)
    {
        if (item1->y_walkbehind > item2->pos.y)
        {
            //cout << "choosing zone: zone y  = " << item1->y_walkbehind << ", PC y = " << item2->pos.y <<  endl;
            return item1->obj;
        }
        else
        {
            //cout << "choosing PC" << endl;
            return item2->obj;
        }
    }
    else
    {
        return no_item();
    }
}


bool
printable_must_be_printed_before(
    const pt<printable> p1, 
    const pt<printable> p2 )
{
    return p1->y() < p2->y();
}


void
render_layers_and_chars_in_correct_order(
    list< pt<printable> >& layers_and_chars_except_bg,
    cfsurf & bg_surf,
    SDL_Surface * screen,
    const room_scaling_data& d,
    SDL_Rect visible_rect_in_src_surf,
    set<pt<light> > active_lights)
{
    // BEGIN decl.
    list<pt<printable> >::const_iterator l;
    // END

    layers_and_chars_except_bg.sort(printable_must_be_printed_before);

    foreach(l, layers_and_chars_except_bg){
        (*l)->print_with_transparency(bg_surf, d, active_lights);
    }
    bg_surf.opaque_blit_to_sdl_surface( screen, visible_rect_in_src_surf);

}
        
        

Uint32 choose_some_video_flags(){
    // BEGIN decl
    const SDL_VideoInfo *videoInfo;
    Uint32 videoflags;
    // END

          
    videoflags = SDL_DOUBLEBUF;
    videoInfo = SDL_GetVideoInfo( );

    if ( !videoInfo ){
        raise_exception( "Video query failed: " + string(SDL_GetError()));
    }
    else{
        if ( videoInfo->hw_available ){
            videoflags |= SDL_HWSURFACE;
            cout << "HW Surface available" << endl;
        }
        else{
            videoflags |= SDL_SWSURFACE;
            cout << "SW Surface available" << endl;
        }
        if ( videoInfo->blit_hw ){
            videoflags |= SDL_HWACCEL;
            cout << "HW ACCEL available" << endl;
        }
                        
    }
        
    return videoflags;
}



pt<vector2<bool> > 
walking_map_from_sdl_surface(SDL_Surface * s)
{
    // BEGIN decl.
    pt<vector2<bool> > m;
    int x, y;
    rgbaf pix;
    Uint32 raw_pixel;
    Uint32 * ptr;
    Uint8 r, g,b, a;
    // END


    m = NEW( vector2<bool>(s->w, s->h));
    SDL_LockSurface(s);
    for (x = 0; x< s->w; x++){
        for (y = 0; y< s->h; y++){
            ptr = (Uint32 *) (s->pixels) + x + y * s->w;
            raw_pixel = * ptr;
            SDL_GetRGBA(raw_pixel, s->format, &r, &g, &b, &a);
            m->set( x , y, a != 0);
        }
    }
    SDL_UnlockSurface(s);
    return m;}


bool
is_walkable
( const vector2<bool>& walking_map, int x, int y)
{
    if ( 0 <= x && x < walking_map.w
        &&
        0 <= y && y < walking_map.h)
    {
        return walking_map.get( x , y);
    }
    else
    {
        return false;
    }

}

namespace path_finding{


    bool int_pair::operator==(const int_pair& p) const{
        return ( x == p.x && y == p.y);
    }
    bool int_pair::operator<(const int_pair& p) const{
        if(x < p.x)
            return true;
        else if (x > p.x){
            return false;}
        else{
            if ( y < p.y){
                return true;}
            else if (y > p.y){
                return false;}
            else{
                return false;}}}

    struct frontier_node{
            int_pair position;
            int cost_g;
            float cost_h;

            frontier_node(int_pair position, int cost_g, float cost_h){
                this->position = position;
                this->cost_h = cost_h;
                this->cost_g = cost_g;}
            frontier_node(){}
    };


    struct int_pair_and_cost{
            int_pair pair;
            int cost;
            int_pair_and_cost(int_pair pair, int cost){
                this->pair = pair;
                this->cost = cost;}
    };

    list<int_pair_and_cost>
    neighbours(  int_pair node)
    {
        // BEGIN decl
        list<int_pair_and_cost> ret;
        // END

        ret.push_back(int_pair_and_cost(int_pair(node.x-1, node.y), 10));
        ret.push_back(int_pair_and_cost(int_pair(node.x+1, node.y), 10));
        ret.push_back(int_pair_and_cost(int_pair(node.x, node.y-1), 10));
        ret.push_back(int_pair_and_cost(int_pair(node.x, node.y+1), 10));
        ret.push_back(int_pair_and_cost(int_pair(node.x-1, node.y-1), 11));
        ret.push_back(int_pair_and_cost(int_pair(node.x+1, node.y+1), 11));
        ret.push_back(int_pair_and_cost(int_pair(node.x+1, node.y-1), 11));
        ret.push_back(int_pair_and_cost(int_pair(node.x-1, node.y+1), 11));
        return ret;
    }

    float
    distance( int_pair p1, int_pair p2){
        // BEGIN decl
        float x, y;
        // END

        x = float(p1.x - p2.x);
        y = float(p1.y - p2.y);
        return sqrt( x * x + y * y);
    }


    bool
    compare_frontier_nodes(const frontier_node& f1,
        const frontier_node& f2){
        return f1.cost_g + f1.cost_h < f2.cost_g + f2.cost_h;     

    }

    bool 
    int_pair__equal(int_pair p1, int_pair p2){
        return p1.x == p2.x && p1.y == p2.y;}

    string
    string_of_int_pair(int_pair p){
        string ret;
        ret = string_of_int(p.x);
        ret += ", " + string_of_int(p.y);
        return ret;
    }

    struct no_route_found{};

    variant<no_route_found, pt<list<int_pair> > >
    best_route(
        int_pair from,
        int_pair to,
        const vector2<bool>& walkable)
    {
        // BEGIN decl.
        pt<list<int_pair> > route;
        list<int_pair>::const_iterator it;

        vector<int_pair> route2;
        list<frontier_node> frontier, nei3;
        frontier_node chosen_node;
        vector2<bool> visited;
        list<int_pair_and_cost> nei;
        list<int_pair_and_cost> nei2;
        list<int_pair_and_cost>::const_iterator n;
        int_pair nn;
        map<int_pair, int_pair> parent_of;
        map<int_pair, int_pair>::const_iterator parent_it;
        // END

        // BEGIN precond
        assert( walkable.get(from.x, from.y));
        assert( walkable.get(to.x, to.y));
        // END

        if (from == to)
        {
            return pt<list<int_pair> >();
        }
        else
        {

            visited = vector2<bool>(walkable.w, walkable.h);
            visited.fill_with(false);
            frontier.push_back(frontier_node(
                                   from, 0, 
                                   100 /* cost_h is irrelevant*/));
            visited.set(from.x, from.y, true);
            
            while(true)
            {
                if (frontier.empty())
                {
                    return no_route_found();
                }
                else
                {
                    chosen_node = frontier.front();  
                    frontier.pop_front();

                    if (int_pair__equal(chosen_node.position, to))
                    {
                        nn = to;
                        route = NEW( list<int_pair>());
                        route->push_front(nn);
                        while(! int_pair__equal( nn,from))
                        {
                            parent_it = parent_of.find(nn);
                            assert(parent_it  != parent_of.end());
                            nn = parent_it->second;
                            route->push_front(nn);
                        }
                        assert(route->front() == from);
                        route->pop_front();
                        return route;
                    }
                    else
                    {
                        nei = neighbours(chosen_node.position);
                        
                        setof( n,
                               nei,
                               ( n->pair.x >= 0 && n->pair.x <walkable.w
                                 &&
                                 n->pair.y >= 0 && n->pair.y <walkable.h
                                 &&
                                 ! visited.get( n->pair.x, n->pair.y) 
                                 &&
                                 walkable.get( n->pair.x, n->pair.y) ),
                               nei2);

                        foreach(n, nei2){
                            assert(!visited.get( n->pair.x, n->pair.y));
                            visited.set(n->pair.x, n->pair.y, true);       
                            parent_of[n->pair] = chosen_node.position;
                        }

                        setof_( frontier_node(n->pair /* pos */,
                                    chosen_node.cost_g + n->cost /* cost_g */,
                                    distance(n->pair, to) /* cost_h */),
                            n,
                            nei2,
                            true,
                            nei3);

                        nei3.sort(compare_frontier_nodes);
                        frontier.merge(nei3, compare_frontier_nodes);
                    }
                }
            }
            assert(false);
        }
    }
}; // namespace path_finding



using path_finding::best_route;
using path_finding::no_route_found;




bool
walk_frame_id::operator< (
    const walk_frame_id& w)const
{
    if (dir < w.dir)
    {
        return true;
    }
    else if (dir > w.dir)
    {
        return false;
    }
    else
    {
        if (foot < w.foot)
        {
            return true;
        }
        else if (foot > w.foot)
        {
            return false;
        }
        else
        {
            if (phase < w.phase)
            {
                return true;
            }
            else// if (phase > w.phase)
            {
                return false;
            }
        }
    }
}




pt<list<int_pair> >
compute_feet_positions(
    int_pair start_position,
    const list<int_pair>& route,
    const room_scaling_data& scaling_data,
    float walk_step_horiz,
    float walk_step_vert)
{
    // BEGIN decl.
    pt<list<int_pair> > route2;
    int_pair new_candidate, latest_certain_foot_pos;
    list<int_pair>::const_iterator route_it;
    float scal_of_cur_step, delta_x, delta_y;
    // END
    
    // BEGIN precond
    assert(route.size()>0);
    assert(! (route.front() == start_position));
    // END

    route2 = NEW( list<int_pair>());

    latest_certain_foot_pos = start_position;
    route_it = route.begin();

    scal_of_cur_step = scaling_of_char(float(latest_certain_foot_pos.y), scaling_data);

    do
    {
        new_candidate = *route_it;


        delta_x = float(std::abs(new_candidate.x - latest_certain_foot_pos.x));
        delta_y = float(std::abs(new_candidate.y - latest_certain_foot_pos.y));

        if(delta_x > scal_of_cur_step * walk_step_horiz || 
            delta_y > scal_of_cur_step * walk_step_vert)
        {
            latest_certain_foot_pos = new_candidate;
            route2->push_back(latest_certain_foot_pos);
            scal_of_cur_step = scaling_of_char(float(latest_certain_foot_pos.y), scaling_data);
        }

        route_it ++;
        if(route_it == route.end())
        {
            break;
        }

    }while(true);

    if(!(latest_certain_foot_pos == route.back()))
    {
        route2->push_back(route.back());
    }
    return route2;
}





direction
compute_dir(int_pair p1, int_pair p2, float walk_step_horiz)
{


    if(p2.x - p1.x >= walk_step_horiz * 0.8f  ){
        return d_right;}
    else if (p1.x - p2.x >= walk_step_horiz * 0.8f){
        return d_left;}
    else{
        if(p2.y < p1.y){
            return d_up;}
        else if (p2.y > p1.y){
            return d_down;}
        else{
            if(p2.x < p1.x){
                return d_left;}
            else if (p2.x > p1.x){
                return d_right;}

        }


    }

}


    
struct walking_finished{};

variant<walking_finished, pair<int_pair, direction> >
update_walking_animation(
    float frame_change_interval,
    pt<AI_substate_walk>  state_walk,
    int_pair player_pos,
    float walk_step_horiz,
    float dt,
    direction cur_dir)
{
    // BEGIN decl
    int_pair new_pos;
    // END

    state_walk->timer += dt;

    if (state_walk->timer <= frame_change_interval)
    {
        return make_pair(player_pos, cur_dir);
    }
    else{
        state_walk->timer -= frame_change_interval;

//              if(state_walk->cur_phase == HIGH_POINT){
//                  state_walk->cur_phase = CONTACT;}
//              else

        if (state_walk->cur_phase == RECOIL)
        {
            state_walk->cur_phase = PASSING;
            return make_pair(player_pos, cur_dir);
        }
        else if (state_walk->cur_phase == PASSING)
        {
            //state_walk->cur_phase = HIGH_POINT;}
            state_walk->cur_phase = CONTACT;
            return make_pair(player_pos, cur_dir);
        }
        else if (state_walk->cur_phase == CONTACT){

            state_walk->cur_phase = RECOIL;

            // BEGIN only in the RECOIL frame, we change foot
            // and update the position
            if(state_walk->cur_foot == hd_right){
                state_walk->cur_foot = hd_left;}
            else{
                state_walk->cur_foot = hd_right;}
                    

            if (state_walk->cur_pos >= state_walk->route.size()){
                return walking_finished();
            }
            else{
                new_pos = state_walk->route[state_walk->cur_pos];
                
                state_walk->cur_pos ++;

                return make_pair(new_pos,
                    compute_dir(player_pos, new_pos, walk_step_horiz));
            }
            // END
        }

    }


}

list<SDL_Event> 
get_sdl_events()
{
    // BEGIN decl
    list<SDL_Event> ret;
    SDL_Event ev;
    // END

    while(SDL_PollEvent(&ev)){
        ret.push_back(ev);}

    return ret;

}







namespace text{

    bool
    is_alnum(char c)
    {
        return ( 65 <= c && c <=90 
            ||
            97 <= c && c <= 122);
    }

    list<string>
    tokenize(string t)
    {
        // BEGIN decl
        list<string> ret;
        int i; 
        char c;
        string cur_word;
        bool previous_was_alnum;
        // END

        cur_word = "";
        previous_was_alnum = true;
        for (i = 0; i < t.size(); i++){
            c = t[i];
            if (is_alnum(c)){
                if (previous_was_alnum){
                    cur_word += c;}
                else{
                    ret.push_back(cur_word);
                    cur_word = "";
                    cur_word += c;
                    previous_was_alnum = true;}}
            else{
                cur_word += c;
                ret.push_back(cur_word);
                cur_word = "";
                previous_was_alnum = false;
            }
        }
        if (cur_word != ""){
            ret.push_back(cur_word);}
        return ret;
    }

    int 
    text_wt_in_pixels(string s, 
        const surf_of_letter_t & surf_of_letter)
    {
        // BEGIN decl
        int wt; int i;
        // END

        wt = 0;
        for (i = 0; i<s.size(); i++){
            wt += map_get(surf_of_letter, s[i])->w;
        }
        return wt;
    }

    void
    print_letter(
        SDL_Surface * l, 
        SDL_Surface * screen,
        int_pair dest_pos,
        rgb col)
    {
        // BEGIN decl
        int x, y;
        Uint32* dest_addr, *src_addr;
        Uint32 raw_pix;
        Uint8 r, g, b, a;
        // END  

        // BEGIN precond
        assert(screen->format->BytesPerPixel == 4);
        assert(l->format->BytesPerPixel == 4);
        // END

        SDL_LockSurface(screen);
        SDL_LockSurface(l);
        for (x = 0; x < l->w ; x++)
        {
            for (y = 0; y < l->h ; y++)
            {
                src_addr = (Uint32 *) (l->pixels) + x + y * l->w;
                raw_pix = *src_addr;

                SDL_GetRGBA(raw_pix, l->format, &r, &g, &b, &a);

                dest_addr = (Uint32 *) (screen->pixels) + (dest_pos.x + x) + (dest_pos.y + y) * screen->w;
                if(a == 0)
                {
                }
                else if (r==0)
                {
                    * dest_addr = SDL_MapRGB(screen->format , r, g, b);
                }
                else// if (r==255)
                {
                    * dest_addr = SDL_MapRGB(screen->format , col.r, col.g, col.b);
                }
            }
        }
        SDL_UnlockSurface(screen);
        SDL_UnlockSurface(l);
    }

    int
    print_line_of_text(string t, int x, int y,
        const surf_of_letter_t & surf_of_letter,
        SDL_Surface * screen,
        bool calc_wt_only,
        rgb col)
    {
        // BEGIN decl
        int i, cur_x;
        SDL_Rect dest_rect;
        char c;
        // END

        cur_x = x;

        for (i = 0; i< t.size(); i++)
        {
            dest_rect.y = y;
            dest_rect.x = cur_x;

            c = t[i];

            if (!calc_wt_only)
            {
//              SDL_BlitSurface( map_get(surf_of_letter, c),
//                  NULL,
//                  screen,
//                  &dest_rect);
                print_letter( 
                    map_get(surf_of_letter, c),
                    screen, 
                    int_pair(cur_x, y),
                    col);
            }

            cur_x += map_get(surf_of_letter, c)->w;
        }
        return cur_x - x;
    }

    void
    print_x_centered_line_of_text(string t, int x_min, int x_max, int y,
        const surf_of_letter_t & surf_of_letter,
        SDL_Surface * screen, rgb col)
    {
        // BEGIN decl
        int avail_wt, wt, final_x;
        // END
        avail_wt = x_max - x_min;
        wt = print_line_of_text(t, x_min, y, surf_of_letter, screen, true, col);
        assert(wt < avail_wt);

        final_x = x_min + (avail_wt - wt)/2;
        print_line_of_text(t, final_x, y, surf_of_letter, screen, false, col);

    }

    int
    draw_text_multiline_variable_ht(string text,
        SDL_Surface* surf,
        int x_left,
        int y_top,
        int x_right,
        const surf_of_letter_t  & surf_of_letter,
        bool calc_ht_only, 
        rgb col)
    {
        // BEGIN decl
        int cur_line_wt; 
        list<string>::const_iterator t;
        int w; 
        int avail_wt;
        list<string> tokens;
        string cur_line;
        int ht;
        char random_letter;
        // END

        tokens = tokenize(text);
        avail_wt = x_right - x_left;
        assert(avail_wt > 0);
        random_letter = text[0];
        cur_line_wt = 0;
        cur_line = "";
        ht = 0;
        foreach( t, tokens){
            w = text_wt_in_pixels(*t, surf_of_letter);
            assert(w < avail_wt );
            if (cur_line_wt + w < avail_wt){
                cur_line_wt +=w;
                cur_line += *t;
            }
            else{
                // BEGIN print cur_line and increment ht
                if (!calc_ht_only)
                {
                    print_x_centered_line_of_text(cur_line, x_left, x_right, y_top + ht, surf_of_letter, surf, col);
                }
                ht += map_get(surf_of_letter, random_letter)->h;
                // END

                cur_line = "";
                cur_line += *t;
                cur_line_wt = w;
            }
        }

        if (cur_line != ""){    
            // BEGIN print cur_line and increment ht
            if (!calc_ht_only){
                print_x_centered_line_of_text(cur_line, x_left, x_right, y_top + ht, surf_of_letter, surf, col);}
            ht += map_get(surf_of_letter, random_letter)->h;
            // END

        }
        return ht;
    }
};

using text::draw_text_multiline_variable_ht;
using text::print_line_of_text;
using text::print_x_centered_line_of_text;



// bool
// item_is_ambiguous(
//     const pt<obj_or_concept> i)
// {
//     pt<phys_obj_with_verbs> phys;

//     if(pt_cast(i, phys))
//     {
//         return ( phys->verbs.size() != 0);
//     }
//     else
//         return false;
// }



void
FACK::render_command_bar( 
    int_pair mouse_screen,
    int_pair mouse_bg,
    const map<pt<PC>, pt<anim_frame> > & cur_frame_of_player) const
{
    // BEGIN decl
    SDL_Rect dest_rect;
    pt<PS_missing_one_item> missing_one;
    pt<PS_missing_two_items> missing_two;
    variant<no_item, pt<obj_or_concept> > ret2;
    pt<obj_or_concept> item;
    string selected_item_text;
    rgb text_color_of_command_bar(120, 140, 200);
    Uint32 bg_color_of_command_bar;
    pt<game_state_flashing_inv_t> flashing;
    pt<container_pick_result> pick_res;
    pt<container_pick_result_obj_and_pos> obj_and_pos;
    pt<container_pick_result_obj> obj;
    pt<container_pick_result_container_drag_area> container_drag_area;
    pt<container_pick_result_closing_area> closing_area;
    special_button_pick_result special_but;
    // END

    bg_color_of_command_bar = SDL_MapRGB(screen->format, 10,10,15);


    dest_rect.x = 0;
    dest_rect.y = screen->h - act_pl->cache->picture->h - calc_command_bar_ht();
    dest_rect.w = screen->w;
    dest_rect.h = calc_command_bar_ht();
    SDL_FillRect(screen, &dest_rect, bg_color_of_command_bar);

    if(!pt_cast(game_state, flashing))
    {

        special_but = special_button_at_pos(mouse_screen);
        if(special_but == SBPR_STAY_FOLLOW)
        {
            selected_item_text = "stay/follow";

            print_x_centered_line_of_text( 
                selected_item_text,
                0, screen->w,
                screen->h -  calc_command_bar_ht() -  act_pl->cache->picture->h +1,
                surf_of_letter,
                screen,
                text_color_of_command_bar);
        }
        else if (special_but == SBPR_CYCLE_PLAYER)
        {
            selected_item_text = "switch active player";

            print_x_centered_line_of_text( 
                selected_item_text,
                0, screen->w,
                screen->h -  calc_command_bar_ht() -  act_pl->cache->picture->h +1,
                surf_of_letter,
                screen,
                text_color_of_command_bar);

        }
        else if (special_but == SBPR_SAVE_LOAD)
        {
            selected_item_text = "Options";

            print_x_centered_line_of_text( 
                selected_item_text,
                0, screen->w,
                screen->h -  calc_command_bar_ht() -  act_pl->cache->picture->h +1,
                surf_of_letter,
                screen,
                text_color_of_command_bar);

        }
        else
        {
            pick_res = item_in_popup_at_screen_pos(mouse_screen);

            ret2 = item_in_room_at_position(
                mouse_bg,
                players, act_pl, cur_frame_of_player);

            if( pt_cast(act_pl->state, missing_one))
            {
                if( pt_cast(pick_res, obj_and_pos) &&
                    obj_and_pos->obj_and_pos.o != missing_one->obj_already_chosen)
                {
                    selected_item_text = obj_and_pos->obj_and_pos.o->readable_name;
                }
                else if( pt_cast(pick_res, obj) &&
                    obj->obj != missing_one->obj_already_chosen)
                {
                    selected_item_text = obj->obj->readable_name;
                }
                else if(pt_cast(pick_res, container_drag_area) ||
                        pt_cast(pick_res, closing_area))
                {
                    selected_item_text = "";
                }
                else if ( var_cast(ret2, item) 
                          && 
                          item != missing_one->obj_already_chosen)
                {
                    selected_item_text = item->readable_name;
                }
                else{
                    selected_item_text = "...";
                }

                print_x_centered_line_of_text( 
                    missing_one->obj_already_chosen->readable_name + " + " + selected_item_text,
                    0, screen->w,
                    screen->h - calc_command_bar_ht() - act_pl->cache->picture->h +1,
                    surf_of_letter,
                    screen,
                    text_color_of_command_bar);
            }
            else if (pt_cast(act_pl->state, missing_two))
            {
                if(pt_cast(pick_res, obj_and_pos))
                {
                    selected_item_text = obj_and_pos->obj_and_pos.o->readable_name;
                }
                else if(pt_cast(pick_res, obj))
                {
                    selected_item_text = obj->obj->readable_name;
                }
                else if(pt_cast(pick_res, container_drag_area) ||
                        pt_cast(pick_res, closing_area))
                {
                    selected_item_text = "";
                }
                else if ( var_cast(ret2, item) )
                {
                    selected_item_text = item->readable_name;
                }
                else
                {
                    selected_item_text = "";
                }
                print_x_centered_line_of_text( 
                    selected_item_text,
                    0, screen->w,
                    screen->h -  calc_command_bar_ht() - act_pl->cache->picture->h +1,
                    surf_of_letter,
                    screen,
                    text_color_of_command_bar);
            }
        }
    }
}


void
draw_verb_dialog(
    pt<phys_obj> item1,
    pt<phys_obj> item2,
    const surf_of_letter_t & surf_of_letter,
    SDL_Surface * screen,
    bool calc_rect_only,
    int_pair mouse,
    SDL_Rect & cancel_rect,
    list<pt<dialog_choice> > & choices)
{
    // BEGIN decl
    int ht_label, avail_ht;
    int y_top, y_bottom;
    int ht_per_verb, ht;
    int left_border, right_border;
    SDL_Rect rect;
    string  text;
    int ht_of_letter, centered_y;
    vector<pt<verb> >::const_iterator v;
    pt<verb> cur_verb;
//     rgb text_color_of_working_verb(200,200,200);
//     rgb text_color_of_not_working_verb(120,120,120);
    rgb color_of_less_important_text(80,120,120);
    rgb color_of_none_of_the_above(250,250,150);
    rgb col;
    list<pt<token_of_verb_text> >::const_iterator tok;
    pt<phys_obj_with_verbs> obj_with_verbs;
    vector<pt<phys_obj> > items;
    vector<pt<phys_obj> >::const_iterator i;
    pt<phys_obj> active_it, passive_it;
    int c;
    int num_choices;
    // END

    // BEGIN clear screen
    if (! calc_rect_only)
        SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 10, 10, 10));
    // END


    // BEGIN draw label
    ht_of_letter = map_get(surf_of_letter, 'a')->h;

    left_border = 10;
    right_border = screen->w - 10;

    ht_label = draw_text_multiline_variable_ht( ( "Please specify what you want to do."),
                                                screen,
                                                left_border,
                                                0,
                                                right_border,
                                                surf_of_letter,
                                                calc_rect_only,
                                                color_of_less_important_text);
    // END



    avail_ht = screen->h - ht_label;

    items = *vector_of(ulist(item1) << item2);



    // BEGIN calc ht_per_verb
    num_choices = 1 /* cancel button */ ;

    foreach(i, items){

        if(pt_cast(*i, obj_with_verbs))
        {
            num_choices += obj_with_verbs->verbs.size();
        }

    }
    if ( (pt_cast(item1, obj_with_verbs) && obj_with_verbs->none_of_the_above)
         ||
         (pt_cast(item2, obj_with_verbs) && obj_with_verbs->none_of_the_above))
    {
        num_choices ++ ;
    }

    ht_per_verb = avail_ht / num_choices;
    // END



    
    choices.clear();

    for(c = 0; c < 2; c++)
    {
        active_it = items[c];
        passive_it = items[1-c];


        if(pt_cast(active_it, obj_with_verbs))
        {
            foreach(v, obj_with_verbs->verbs)
            {
                y_top = ht_label + choices.size() * ht_per_verb;
                y_bottom = ht_label + (choices.size() +1)* ht_per_verb;

                centered_y = y_top + (ht_per_verb - ht_of_letter)/2;

                cur_verb = *v;

                text = "";
                foreach(tok, cur_verb->tokens){
                    text += (*tok)->to_string(obj_with_verbs, passive_it);
                }
                
                col = cur_verb->color;


                print_x_centered_line_of_text(text,
                                              left_border,right_border,
                                              centered_y,
                                              surf_of_letter, screen,
                                              col);

                rect = create_rect(left_border, y_top,  right_border, y_top + ht_per_verb);

                choices.push_back(NEW(dialog_choice_verb_object(cur_verb, obj_with_verbs, passive_it, rect)));


                // BEGIN draw mouseover highlight
                if ( left_border <= mouse.x && mouse.x < right_border
                     &&
                     y_top <= mouse.y && mouse.y < y_bottom)
                {
            
                    rectangleRGBA(screen, 
                                  left_border, y_top, right_border, y_bottom, 
                                  200, 100, 100, 200); 
                }
                // END
            }
        }
    }



    // BEGIN print none_of_the_above, if present
    if ( (pt_cast(item1, obj_with_verbs) && obj_with_verbs->none_of_the_above)
         ||
         (pt_cast(item2, obj_with_verbs) && obj_with_verbs->none_of_the_above))
    {
        y_top = ht_label + (num_choices -2) * ht_per_verb;
        y_bottom = ht_label + ( num_choices -1)* ht_per_verb;

        centered_y = y_top + (ht_per_verb - ht_of_letter)/2;

        text = "Other"; 

        col = color_of_none_of_the_above;


        print_x_centered_line_of_text(text,
                                      left_border,right_border,
                                      centered_y,
                                      surf_of_letter, screen,
                                      col);
        rect = create_rect(left_border, y_top,  right_border, y_top + ht_per_verb);
        
        choices.push_back(NEW(dialog_choice_double_other(rect)));

        // BEGIN draw mouseover highlight
        if ( left_border <= mouse.x && mouse.x < right_border
             &&
             y_top <= mouse.y && mouse.y < y_bottom)
        {
            
            rectangleRGBA(screen, 
                          left_border, y_top, right_border, y_bottom, 
                          200, 100, 100, 200); 
        }
        // END
        
    }
    // END



    // BEGIN print cancel button

    y_top =  ht_label + (num_choices-1) * ht_per_verb;

    centered_y = y_top + (ht_per_verb - ht_of_letter)/2;

    ht = draw_text_multiline_variable_ht( "Cancel",
                                          screen,
                                          left_border,
                                          centered_y,
                                          right_border,
                                          surf_of_letter,
                                          calc_rect_only, 
                                          color_of_less_important_text);
    rect = create_rect( left_border, y_top, right_border, y_top + ht_per_verb);

    cancel_rect = rect;
    // BEGIN draw mouseover highlight
    if ( point_in_rect(mouse, cancel_rect))
    {
        rectangleRGBA(screen, 
                      left_border, y_top, right_border, y_top + ht_per_verb, 
                      200, 100, 100, 200);      
    }
    // END
    // END

}


pt<anim_frame>
update_still_anim(
    pt<PS_still_and_parsing> st,
    float dt)
{
    // BEGIN decl
    pt<anim_frame> cur_fr;
    // END

    if(st->cur_frame >= st->anim->frames.size())
    {
        return st->anim->frames.back();
    }
    else
    {
        cur_fr = st->anim->frames[st->cur_frame];

        st->timer += dt;
        if (st->timer <= cur_fr->duration)
        {
            return cur_fr;
        }
        else
        {
            st->timer -= cur_fr->duration;
            st->cur_frame ++;

            if(st->cur_frame >= st->anim->frames.size())
            {
                return st->anim->frames.back();
            }
            else
            {
                return st->anim->frames[st->cur_frame];
            }

        }
    }
}


void
FACK::execute_commands(
    pt<PC> pl,
    const list<pt<script_cmd> > & commands)
{
    // BEGIN decl
    pt<PS_still_and_parsing> still;
    pt<anim_frame> cur_frame;
    result_exec_next_scr_cmd res;
    bool cast_ok;
    // END

    cast_ok = pt_cast(pl->state, still);
    assert(cast_ok);
    

    if(still->cur_frame >= still->anim->frames.size())
    {
        assert(still->anim->frames.size()>0);
        cur_frame =  still->anim->frames.back();
    }
    else
    {
        cur_frame =  still->anim->frames[still->cur_frame];
    }


    res = exec_next_scr_cmd(*vector_of(commands), 
                            0/*cur cmd*/,
                            pl,
                            cur_frame,
                            false/*do not increm step at start*/,
                            true /* at the end of the script, set the
                                  * player direction left or right,
                                  * unless the script explicitely says
                                  * not to */);

    pl->state = res.new_pl_state;
    pl->pos = res.new_pl_pos;
    pl->cur_dir = res.new_pl_dir;
    
}



struct speech_finished{};

void 
decide_position_for_text(
    string text,
    int_pair player_head,
    int & x_left, 
    int & y_top,
    int & x_right,
    const surf_of_letter_t & surf_of_letter,
    SDL_Surface * screen)
{
    // BEGIN decl
    int ideal_wt, ht;
    int ideal_x_left, ideal_x_right;
    int real_x_left, real_x_right;
    int vert_gap_head_text;
    rgb col(0,0,0);
    // END

    vert_gap_head_text = 10;
    ideal_wt = screen->w * 2 / 3;

    ideal_x_left = player_head.x - ideal_wt/2;
    ideal_x_right = player_head.x + ideal_wt/2;

    if(ideal_x_left < 0)
    {
        real_x_left = 0;
        real_x_right = ideal_wt;
    }
    else if (ideal_x_right >= screen->w)
    {
        real_x_right = screen->w;
        real_x_left = real_x_right - ideal_wt;
    }
    else
    {
        real_x_right = ideal_x_right;
        real_x_left = ideal_x_left;
    }

    ht = draw_text_multiline_variable_ht(
        text, screen, real_x_left, 0, real_x_right, surf_of_letter, true, col);

    if (ht < player_head.y - vert_gap_head_text)
    {
        y_top = player_head.y - vert_gap_head_text -ht;
        x_left = real_x_left;
        x_right = real_x_right;
    }
    else
    {
        ht = draw_text_multiline_variable_ht(
            text, screen, 0, 0, screen->w, surf_of_letter, true, col);

        y_top = std::max(0, player_head.y - ht - vert_gap_head_text);
        x_left = 0;
        x_right = screen->w;
    }

}


variant<speech_finished, sentence_with_location>
update_speech(
    AI_substate_speaking_while_standing & state,
    float dt,
    const surf_of_letter_t & surf_of_letter,
    SDL_Surface * screen,
    pt<anim_frame> & new_frame /*out*/,
    rgb text_color,
    bool time_frozen,
    const pt<PC> player,
    const room_scaling_data & scaling_data,
    int_pair top_left_of_screen_in_bg)
{
    // BEGIN decl
    variant<speech_finished, sentence_with_location> ret;
    float change_seconds;
    string cur_txt;
    int x_left, y_top, x_right;
    pt<anim_frame> cur_frame;
    int_pair player_head_bg_coord;
    int_pair player_head_screen_coord;
    // END

  
    // BEGIN the purpose is to calculate new_frame.
    if(state.cur_frame_it >= state.current_phrase->anim->frames.size())
    {
        // the animation has finished. Return the last frame.
        new_frame = state.current_phrase->anim->frames.back();
    }
    else
    {
        if (time_frozen)
        {
            new_frame = state.current_phrase->anim->frames[state.cur_frame_it];
        }
        else
        {

            // the animation has not finished. See if you have to change
            // frame
            cur_frame = state.current_phrase->anim->frames[state.cur_frame_it];

            state.anim_timer += dt;

            if (state.anim_timer <= cur_frame->duration)
            {
                // I don't have to change frame. Return the cur_frame
                new_frame = cur_frame;
            }
            else
            {
                // I have to change frame, and check AGAIN if the
                // animation has finished.
                state.anim_timer -= cur_frame->duration;
                state.cur_frame_it ++;
                if (state.cur_frame_it >= state.current_phrase->anim->frames.size())
                {
                    // animation finished
                    new_frame = state.current_phrase->anim->frames.back();
                }
                else
                {
                    new_frame = state.current_phrase->anim->frames[state.cur_frame_it];
                }
            }
        }
    }
    // END
       
    player_head_bg_coord.x = player->pos.x;
    player_head_bg_coord.y = player->pos.y - 
        int(float( new_frame->h  ) * 
            scaling_of_char(float(player->pos.y), scaling_data));

    player_head_screen_coord = player_head_bg_coord - top_left_of_screen_in_bg;

    cur_txt = state.current_phrase->str;
    if(time_frozen)
    {
        decide_position_for_text(cur_txt, player_head_screen_coord,
                                 x_left /*out*/,
                                 y_top /*out*/, x_right/*out*/, 
                                 surf_of_letter, screen);
        return sentence_with_location(cur_txt, x_left, y_top, x_right, text_color);
    }
    else
    {
        change_seconds = cur_txt.size() * 0.04f + 0.5f; // @@

        state.speech_timer += dt;

        if (state.speech_timer <= change_seconds)
        {
            decide_position_for_text(cur_txt, player_head_screen_coord, 
                                     x_left /*out*/,
                                     y_top /*out*/, x_right/*out*/, surf_of_letter, screen);

            return sentence_with_location(cur_txt, x_left, y_top, x_right, text_color);
        }
        else
        {
            state.speech_timer -= change_seconds;
            state.current_phrase ++;


            if (state.current_phrase == state.speech.end())
            {

                // the previously calculated new_frame is ok.

                return speech_finished();
            }
            else
            {

                // BEGIN the sentence has changed. We have to change the
                // animation frame as well, because speech is "dominant"
                // over animation. Therefore we have to override the
                // previously calculated new_frame.
                state.cur_frame_it = 0; //state.current_phrase->anim->begin();
                assert(state.current_phrase->anim->frames.size()>0);
                new_frame = state.current_phrase->anim->frames[state.cur_frame_it];
                // END

                decide_position_for_text(cur_txt, player_head_screen_coord, x_left /*out*/,
                    y_top /*out*/, x_right/*out*/, surf_of_letter, screen);
                return sentence_with_location(cur_txt, x_left, y_top, x_right, text_color);
            }
        }

    }
    assert(false);

}


variant<speech_finished, sentence_with_location>
update_speech(
    AI_substate_speaking_while_sitting & state,
    float dt,
    const surf_of_letter_t & surf_of_letter,
    SDL_Surface * screen,
    const pt<anim_frame> const_frame,
    rgb text_color,
    bool time_frozen,
    const pt<PC> player,
    const room_scaling_data & scaling_data,
    int_pair top_left_of_screen_in_bg)
{
    // BEGIN decl
    variant<speech_finished, sentence_with_location> ret;
    float change_seconds;
    string cur_txt;
    int x_left, y_top, x_right;
    pt<anim_frame> cur_frame;
    int_pair player_head_screen_coord;
    int_pair player_head_bg_coord;
    // END

  
       
    player_head_bg_coord.x = player->pos.x;
    // do not scale because I am sitting
    player_head_bg_coord.y = player->pos.y - int(float( const_frame->h  ) );

    player_head_screen_coord = player_head_bg_coord - top_left_of_screen_in_bg;

    cur_txt = *state.current_phrase;
    if(time_frozen)
    {
        decide_position_for_text(cur_txt, player_head_screen_coord, x_left /*out*/,
            y_top /*out*/, x_right/*out*/, surf_of_letter, screen);
        return sentence_with_location(cur_txt, x_left, y_top, x_right, text_color);
    }
    else
    {
        change_seconds = cur_txt.size() * 0.04f + 0.5f;

        state.speech_timer += dt;

        if (state.speech_timer <= change_seconds)
        {
            decide_position_for_text(cur_txt, player_head_screen_coord, x_left /*out*/,
                y_top /*out*/, x_right/*out*/, surf_of_letter, screen);

            return sentence_with_location(cur_txt, x_left, y_top, x_right, text_color);
        }
        else
        {
            state.speech_timer -= change_seconds;
            state.current_phrase ++;


            if (state.current_phrase == state.speech.end())
            {

                // the previously calculated new_frame is ok.

                return speech_finished();
            }
            else
            {
                decide_position_for_text(cur_txt, player_head_screen_coord, x_left /*out*/,
                    y_top /*out*/, x_right/*out*/, surf_of_letter, screen);
                return sentence_with_location(cur_txt, x_left, y_top, x_right, text_color);
            }
        }

    }
    assert(false);

}

template<class T>
void
list_remove_one( T & l, typename T::value_type el)
{
    // BEGIN decl
    typename T::iterator i;
    bool done;
    // END
    done = false;
    for(i = l.begin() ; i != l.end(); i++)
    {
        if (*i == el)
        {
            i = l.erase(i);
            done = true;
            break;
        }
    }
    assert(done);
}


result_exec_next_scr_cmd
end_commands(
    pt<PC> pl,
    int cur_cmd_it,
    bool must_set_player_left_or_right)
{
    // BEGIN decl
    direction dir2;
    pt<still_situation_normal> normal;
    pt<still_situation_sitting> sitting;
    bool ok;
    // END


    if (must_set_player_left_or_right)
    {
        if(pl->cur_dir == d_left)
            dir2 = d_left;
        else
            dir2 = d_right;
    }
    else
    {
        dir2 = pl->cur_dir;
    }


    if(pt_cast(pl->still_situat, normal))
    {
        return result_exec_next_scr_cmd(
            NEW( PS_missing_two_items(
                     map_get(pl->anim_of_norm_still_sit,
                             dir2),
                     0, 
                     0)),
            cur_cmd_it,
            pl->pos,
            dir2);
    }
    else
    {
        ok = pt_cast(pl->still_situat, sitting);
        assert(ok);
        
        return result_exec_next_scr_cmd(
            NEW( PS_missing_two_items(
                     map_get(pl->anim_of_sitting_still_sit,
                             sitting->situation_name),
                     0, 
                     0)),
            cur_cmd_it,
            pl->pos,
            dir2);
    }

}



void
FACK::stand_up_if_sitting(
    pt<PC> pl)
{

    // BEGIN decl
    pt<still_situation_sitting> sitting;
    // END


    // BEGIN automatically stand up from chairs
    if (pt_cast(pl->still_situat, sitting))
    {
        pl->loc->occupied_sitting_places.erase(sitting->occupied_place);
        pl->still_situat = NEW(still_situation_normal());
    }
    // END

}

void
FACK::close_all_open_popups(
    const pt<PC> pl)
{
    // BEGIN decl
    list<pt<popup> >::iterator co;
    // END


    pl->open_popups.clear();
}

// recursive
result_exec_next_scr_cmd
FACK::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)
{
    // BEGIN decl
    direction dir2;
    still_situation still_sit;
    pt<PS_governed_by_AI> gov_ai;
    variant < no_route_found, pt<list<int_pair> > > maybe_route;
    pt<list<int_pair> > route;
    pt<list<int_pair> > route2;
    pt<scr_cmd_walk> cmd_walk;   
    pt<scr_cmd_speak> cmd_speak;   
    pt<scr_cmd_set_sitting_state> set_sitting_still_stat;   
    pt<scr_cmd_passive_anim> cmd_passive_anim;   
    pt<scr_cmd_light_transition> cmd_light_transit;   
    pt<scr_cmd_wait_for_person_to_stop_talking> cmd_wait_stop_talk;   
    pt<scr_cmd_change_light> cmd_change_light;   
    pt<scr_cmd_change_loc> cmd_change_loc;   
    pt<scr_cmd_modify_zone> cmd_modify_zone;   
    pt<scr_cmd_add_to_container> cmd_add_to_cont;   
    pt<scr_cmd_add_to_container_in_pos> cmd_add_to_cont_in_pos;   
    pt<scr_cmd_remove_from_container> cmd_remove_from_cont;
    pt<scr_cmd_modify_layer> cmd_modify_layer;   
    pt<scr_cmd_quick_message> quick_mess;   
    pt<scr_cmd_look_at_fixed_direction> cmd_look_at_dir;   
    speech_t::const_iterator i;
    speech2_t sp2;
    horizontal_dir d;
    pt<script_cmd> cur_cmd;
    pt<still_situation_normal> normal;
    pt<still_situation_sitting> sitting;
    list<string> strings;
    pt<scr_cmd_open_popup> open_popup;
    bool ok;
    pt<container> real_co;
    int_pair pos;
    // END

    if(increm_cmd_at_start)
        cur_cmd_it ++;

    if(cur_cmd_it >= commands.size())
    {
        return end_commands(pl, cur_cmd_it, must_set_player_left_or_right);
    }
    else
    {
        cur_cmd = commands[cur_cmd_it];
        // initialize gov_ai->substate = NEW(...the next substate...)

        if(pt_cast(cur_cmd, cmd_walk))
        {
            if(!( pl->pos == cmd_walk->dest))
            {
                maybe_route = best_route(
                    pl->pos, cmd_walk->dest, *pl->loc->walking_map);

                ok = var_cast(maybe_route, route); 
                assert(ok); 

                route2 = compute_feet_positions(
                    pl->pos, *route, pl->loc->scaling_data,
                    pl->walk_step_horiz, pl->walk_step_vert);
                assert(route2->size()>0);
                dir2 = compute_dir(pl->pos, 
                                   route2->front(), pl->walk_step_horiz);
                
                stand_up_if_sitting(pl);
                close_all_open_popups(pl);

                return result_exec_next_scr_cmd(
                    NEW(PS_governed_by_AI(
                            commands,
                            cur_cmd_it,
                            NEW(AI_substate_walk(*vector_of(*route2))))),
                    cur_cmd_it,
                    pl->pos,
                    dir2);
            }
            else
            {
                return exec_next_scr_cmd(commands, cur_cmd_it, pl, last_frame, true, must_set_player_left_or_right);
            }
        }
        else if(pt_cast(cur_cmd, cmd_speak))
        {
            if(cmd_speak->close_containers == close_any_open_container)
            {
                close_all_open_popups(pl);
            }

            if (pt_cast(pl->still_situat, sitting))
            {
                setof_(
                    i->str,
                    i, 
                    cmd_speak->speech,
                    true,
                    strings);
 
                return result_exec_next_scr_cmd(
                    NEW(PS_governed_by_AI(
                            commands,
                            cur_cmd_it,
                            NEW(AI_substate_speaking_while_sitting(strings, last_frame)))),
                    cur_cmd_it,
                    pl->pos,
                    pl->cur_dir);
            }
            else
            {
                if(pl->cur_dir == d_left)
                {
                    d = hd_left;
                }
                else
                {
                    pl->cur_dir = d_right;
                    d = hd_right;
                }
            
                setof_(
                    anim_and_string( 
                        map_get(pl->anim_of_mood, 
                                i->mood).get_anim(d), i->str),
                    i, 
                    cmd_speak->speech,
                    true,
                    sp2);

                return result_exec_next_scr_cmd(
                    NEW(PS_governed_by_AI(
                            commands,
                            cur_cmd_it,
                            NEW(AI_substate_speaking_while_standing(sp2)))),
                    cur_cmd_it,
                    pl->pos,
                    pl->cur_dir);
            }

        }
        else if(pt_cast(cur_cmd, cmd_passive_anim))
        {
            close_all_open_popups(pl);

            return result_exec_next_scr_cmd(
                NEW(PS_governed_by_AI(
                        commands,
                        cur_cmd_it,
                        NEW(AI_substate_passive_anim(cmd_passive_anim->anim)))),
                cur_cmd_it,
                pl->pos,
                pl->cur_dir);
        }
        else if(pt_cast(cur_cmd, cmd_wait_stop_talk))
        {
            return result_exec_next_scr_cmd(
                NEW(PS_governed_by_AI(
                        commands,
                        cur_cmd_it,
                        NEW(AI_substate_waiting_for_person_to_stop_talking(cmd_wait_stop_talk->person,
                                                                           last_frame)))),
                cur_cmd_it,
                pl->pos,
                pl->cur_dir);
        }
        else if(pt_cast(cur_cmd, cmd_change_light))
        {
            if (cmd_change_light->turn_on)
            {
                // @@ if light was not already switched on in the
                // meantime
                cmd_change_light->loc->active_lights.insert(cmd_change_light->ligh);
            }
            else
            {
                // @@ if light is not already switched off
                cmd_change_light->loc->active_lights.erase(cmd_change_light->ligh);
            }
            return exec_next_scr_cmd(commands, cur_cmd_it, pl, last_frame, true, must_set_player_left_or_right);
        }
        else if(pt_cast(cur_cmd, open_popup))
        {
            pl->open_popups.push_back(open_popup->dr);

            return exec_next_scr_cmd(commands, cur_cmd_it, pl, last_frame, true, must_set_player_left_or_right);
        }
        else if(pt_cast(cur_cmd, quick_mess))
        {
            quick_msg = NEW(quick_message(quick_mess->text));

            return exec_next_scr_cmd(commands, cur_cmd_it, pl, last_frame, true, must_set_player_left_or_right);
        }
        else if(pt_cast(cur_cmd, set_sitting_still_stat))
        {
            if (! in( set_sitting_still_stat->occupied_place, pl->loc->occupied_sitting_places))
            {
                pl->still_situat = NEW(still_situation_sitting(
                                           set_sitting_still_stat->situation_name,
                                           set_sitting_still_stat->occupied_place));
                pl->loc->occupied_sitting_places.insert(set_sitting_still_stat->occupied_place);
                return exec_next_scr_cmd(commands, cur_cmd_it, pl, last_frame, true, must_set_player_left_or_right);
            }
            else
            {
                // @@ output message
                cout << "The place is occupied" << endl;
                return end_commands(pl, cur_cmd_it, must_set_player_left_or_right);
            }
        }
        else if(pt_cast(cur_cmd, cmd_change_loc))
        {
            pl->loc = cmd_change_loc->new_loc;
            pl->pos = cmd_change_loc->position;

            return exec_next_scr_cmd(commands, cur_cmd_it, pl, last_frame, true, must_set_player_left_or_right);
        }
        else if(pt_cast(cur_cmd, cmd_light_transit))
        {

            this->transitions_of_fixed_light.push_back(
                NEW(transition_of_fixed_light( cmd_light_transit->ligh,
                                               cmd_light_transit->time_delta,
                                               cmd_light_transit->start_intensity,
                                               cmd_light_transit->dest_intensity,
                                               cmd_light_transit->switch_off_light_at_the_end)));
            return exec_next_scr_cmd(commands, cur_cmd_it, pl, last_frame, true, must_set_player_left_or_right);
        }
        else if(pt_cast(cur_cmd, cmd_add_to_cont))
        {
            if(contains_recursively(cmd_add_to_cont->cont,
                                    cmd_add_to_cont->object,
                                    real_co /* out */, 
                                    pos /* out */))
            {
                raise_exception("Error in game logic: the item was already in the inventory.");
            }
            else
            {
                cmd_add_to_cont->cont->add_item(cmd_add_to_cont->object);
                
                if (cmd_add_to_cont->cont == act_pl->cache)
                {
                    game_state = NEW(game_state_flashing_inv_t(cmd_add_to_cont->object));
                }
            }
            
            return exec_next_scr_cmd(commands, cur_cmd_it, pl, last_frame, true, must_set_player_left_or_right);

        }
        else if(pt_cast(cur_cmd, cmd_add_to_cont_in_pos))
        {
            if(contains_recursively(cmd_add_to_cont_in_pos->cont,
                                    cmd_add_to_cont_in_pos->object,
                                    real_co /* out */, 
                                    pos /* out */))
            {
                raise_exception("Error in game logic: the item was already in the inventory.");
            }
            else
            {
                cmd_add_to_cont_in_pos->cont->add_item_in_pos(
                    pos_and<pt<obj_or_concept> > (cmd_add_to_cont_in_pos->object,
                                                  cmd_add_to_cont_in_pos->pos));
                
                if (cmd_add_to_cont_in_pos->cont == act_pl->cache)
                {
                    game_state = NEW(game_state_flashing_inv_t(cmd_add_to_cont_in_pos->object));
                }
            }
            
            return exec_next_scr_cmd(commands, cur_cmd_it, pl, last_frame, true, must_set_player_left_or_right);

        }
        else if(pt_cast(cur_cmd, cmd_remove_from_cont))
        {
            cmd_remove_from_cont->cont->remove_item_recursively(cmd_remove_from_cont->object);
            
            return exec_next_scr_cmd(commands, cur_cmd_it, pl, last_frame, true, must_set_player_left_or_right);

        }
        else if(pt_cast(cur_cmd, cmd_modify_zone))
        {
            if(cmd_modify_zone->show == HIDE)
                cmd_modify_zone->zone->visible = false;
            else
                cmd_modify_zone->zone->visible = true;

            return exec_next_scr_cmd(commands, cur_cmd_it, pl, last_frame, true, must_set_player_left_or_right);

        }
        else if(pt_cast(cur_cmd, cmd_modify_layer))
        {
            if(cmd_modify_layer->show == HIDE)
                cmd_modify_layer->layer->visible = false;
            else
                cmd_modify_layer->layer->visible = true;


            return exec_next_scr_cmd(commands, cur_cmd_it, pl, last_frame, true, must_set_player_left_or_right);

        }
        else if(pt_cast(cur_cmd, cmd_look_at_dir))
        {
            pl->cur_dir = cmd_look_at_dir->dir;

            return exec_next_scr_cmd(commands, cur_cmd_it, pl, last_frame, true, 
                                     false /* do not set the player direction left or right at the end of the script */);
        }
        else
        {
            assert(false);
        }

    }
}





update_AI_result
FACK::update_AI_state(
    pt<PC> pl,
    float dt, 
    int_pair top_left_of_screen_in_bg)
{

    // BEGIN decl
    pt<script_cmd> cur_cmd;
    pt<script_cmd> cur_cmd_other;

    pt<scr_cmd_walk> cmd_walk;

    pt<AI_substate_walk> walk;
    pt<AI_substate_waiting_for_person_to_stop_talking> wait_stop_talk;
    pt<AI_substate_speaking_while_standing> speaking_standing;
    pt<AI_substate_speaking_while_sitting> speaking_sitting;

    pt<AI_substate_passive_anim> passive_anim;
    pair<int_pair, direction> new_pos;
    pt<PS_governed_by_AI> gov_ai;
    pt<PS_governed_by_AI> gov_ai_other;
    //pt<obj> it;
    seq_list<pt<bg_hot_zone> >::const_iterator x;
    pt<anim_frame> cur_frame;
    variant<walking_finished, pair<int_pair, direction> > maybe_new_pos;
    variant<speech_finished, sentence_with_location> maybe_sentence;
    pt<game_state_flashing_inv_t> flashing_inv;
    bool ok;
    result_exec_next_scr_cmd res;
    // END


    ok = pt_cast(pl->state, gov_ai);
    assert(ok);

    if (pt_cast(gov_ai->substate, walk))
    {
        cur_frame = map_get( pl->walk_frame_when,
            walk_frame_id( walk->cur_foot, 
                walk->cur_phase, pl->cur_dir));

        if(pt_cast(game_state, flashing_inv))
        {

            return update_AI_result( cur_frame, pl->pos, pl->cur_dir,
                no_sentence(), pl->state);
        }
        else
        {
            maybe_new_pos = update_walking_animation(
                cur_frame->duration, 
                walk /* mod */, pl->pos, pl->walk_step_horiz, dt, pl->cur_dir);
            
            // I have to call this again, because
            // update_walking_animation has changed step_walk
            cur_frame = map_get( pl->walk_frame_when, 
                walk_frame_id( walk->cur_foot, 
                    walk->cur_phase, pl->cur_dir));

            if (var_cast(maybe_new_pos, new_pos))
            {
                return update_AI_result( cur_frame, new_pos.first, 
                    new_pos.second, no_sentence(), pl->state);
            }
            else
            { 
                res = exec_next_scr_cmd(gov_ai->commands, gov_ai->cur_cmd_it, pl, cur_frame, true, 
                                        true /* by default, reset pl direction*/);

                return update_AI_result( cur_frame, res.new_pl_pos, res.new_pl_dir,
                                         no_sentence(), res.new_pl_state);
            }
        }


    }
    else if (pt_cast(gov_ai->substate, passive_anim))
    {
        assert (passive_anim->cur_frame < passive_anim->anim->frames.size());

        cur_frame = passive_anim->anim->frames[passive_anim->cur_frame];

        if (pt_cast(game_state, flashing_inv))
        {

            return update_AI_result( 
                cur_frame, pl->pos,
                pl->cur_dir, no_sentence(), pl->state);
        }
        else
        {
            passive_anim->timer += dt;
            
            if(passive_anim->timer <= cur_frame->duration)
            {
                return update_AI_result( cur_frame,
                                         pl->pos, pl->cur_dir, no_sentence(), pl->state);
            }
            else
            {
                passive_anim->timer -= cur_frame->duration;
                passive_anim->cur_frame ++;
                if (passive_anim->cur_frame >= passive_anim->anim->frames.size())
                {
                    res = exec_next_scr_cmd(gov_ai->commands, gov_ai->cur_cmd_it, pl, 
                                            cur_frame, true, true /* by default, set pl dir left or right */);

                    return update_AI_result( cur_frame /* @ ok?*/,
                                             res.new_pl_pos, res.new_pl_dir,
                                             no_sentence(), res.new_pl_state);
                }
                else
                {
                    cur_frame =   passive_anim->anim->frames[passive_anim->cur_frame];

                    return update_AI_result( cur_frame, pl->pos,
                                             pl->cur_dir, no_sentence(), pl->state);
                }
            }
        }
    }
    else if (pt_cast(gov_ai->substate, speaking_standing))
    {
        
        maybe_sentence = update_speech(*speaking_standing, dt, 
                                       surf_of_letter, screen, cur_frame /*out*/, pl->text_color, 
                                       pt_cast(game_state, flashing_inv) /*time frozen */,
                                       pl, pl->loc->scaling_data,
                                       top_left_of_screen_in_bg);
            
        sentence_with_location sentenc;
        if(var_cast(maybe_sentence, sentenc))
        {

            return update_AI_result(  cur_frame, pl->pos,
                pl->cur_dir, sentenc, pl->state);
        }
        else
        {
            if (pt_cast(game_state, flashing_inv))
            {

                return update_AI_result(  cur_frame, pl->pos, 
                    pl->cur_dir, no_sentence(), pl->state);
            }
            else
            {
                res = exec_next_scr_cmd(gov_ai->commands, gov_ai->cur_cmd_it, pl, 
                                        cur_frame, true, true /* by default, set pl dir left or right */);

                return update_AI_result( cur_frame,
                                         res.new_pl_pos, res.new_pl_dir,
                                         no_sentence(), res.new_pl_state);
            }
        }


    }
    else if (pt_cast(gov_ai->substate, speaking_sitting))
    {
        
        maybe_sentence = update_speech(*speaking_sitting, dt, 
                                       surf_of_letter, screen, speaking_sitting->frame, 
                                       pl->text_color, 
                                       pt_cast(game_state, flashing_inv) /*time frozen */,
                                       pl, pl->loc->scaling_data,
                                       top_left_of_screen_in_bg);
            
        sentence_with_location sentenc;
        if(var_cast(maybe_sentence, sentenc))
        {

            return update_AI_result(  speaking_sitting->frame, pl->pos,
                                      pl->cur_dir, sentenc, pl->state);
        }
        else
        {
            if (pt_cast(game_state, flashing_inv))
            {

                return update_AI_result(  speaking_sitting->frame, pl->pos, 
                                          pl->cur_dir, no_sentence(), pl->state);
            }
            else
            {
                res = exec_next_scr_cmd(gov_ai->commands, gov_ai->cur_cmd_it, pl, 
                                        speaking_sitting->frame, true,
                                        true /* by default, set pl dir left or right */);

                return update_AI_result( speaking_sitting->frame,
                                         res.new_pl_pos, res.new_pl_dir,
                                         no_sentence(), res.new_pl_state);
            }
        }


    }
    else if (pt_cast(gov_ai->substate, wait_stop_talk))
    {
        if(pt_cast(wait_stop_talk->person->state, gov_ai_other))
        {
            if( pt_cast(gov_ai_other->substate, speaking_sitting) 
                ||
                pt_cast(gov_ai_other->substate, speaking_standing))
            {
                // the other person is still talking

                return update_AI_result(  wait_stop_talk->frame, pl->pos,
                    pl->cur_dir, no_sentence(), pl->state);
            }
            else
            {
                res = exec_next_scr_cmd(gov_ai->commands, gov_ai->cur_cmd_it, pl, 
                                        wait_stop_talk->frame, true, 
                                        true /* by default, set pl dir left or right */);

                return update_AI_result( wait_stop_talk->frame,
                                         res.new_pl_pos, res.new_pl_dir,
                                         no_sentence(), res.new_pl_state);
            }
        }
        else
        {
            // the other person is no more in AI state, so he is not
            // talking. Advance.
            res = exec_next_scr_cmd(gov_ai->commands, gov_ai->cur_cmd_it, 
                                    pl, wait_stop_talk->frame, true, 
                                    true /* by default, set pl dir left or right */);

            return update_AI_result( wait_stop_talk->frame,
                                     res.new_pl_pos, res.new_pl_dir,
                                     no_sentence(), res.new_pl_state);
        }


    }
    else
    {
        if(!gov_ai->substate)
            assert(false);
        else
            assert(false);
    }

}





void
FACK::manage_button_up(
    list<SDL_Event>::const_iterator ev)
{
    // BEGIN decl
    // END


}

void
zoomable::render(
    SDL_Surface * screen,
    const pt<game_state_t> game_state) const
{
    // BEGIN decl
    SDL_Rect r;
    int ret;
    // END


    r.x = this->position_in_screen.x;
    r.y = this->position_in_screen.y;

    ret = SDL_BlitSurface(this->picture, NULL, screen, &r);
    assert(ret == 0);
}


void
container::render(
    SDL_Surface * screen,
    const pt<game_state_t> game_state) const
{
    // BEGIN decl
    SDL_Rect r;
    int ret;
    list<pos_and<pt<obj_or_concept> > >::const_iterator i;
    pt<game_state_flashing_inv_t> flashing;
    // END


    r.x = this->position_in_screen.x;
    r.y = this->position_in_screen.y;

    ret = SDL_BlitSurface(this->picture, NULL, screen, &r);
    assert(ret == 0);
    
    foreach(i, this->sorted_items){

        r.x = this->position_in_screen.x + i->pos.x;
        r.y = this->position_in_screen.y + i->pos.y;

        ret = SDL_BlitSurface(i->o->get_inv_surf(),
                              NULL,
                              screen, 
                              &r);
        assert (ret == 0);


        // BEGIN flashing
        if ( pt_cast(game_state, flashing) && 
             flashing->item_that_is_flashing == i->o /* @@ pointer equality */ &&
             int(floor(flashing->timer / 0.3f)) % 2 == 0)
        {
            rectangleRGBA(screen, 

                          this->position_in_screen.x + i->pos.x,
                          this->position_in_screen.y + i->pos.y,
                          
                          this->position_in_screen.x + i->pos.x + i->o->get_inv_surf()->w,
                          this->position_in_screen.y + i->pos.y + i->o->get_inv_surf()->h,


                          200, 100, 100, 200);

        }
        // END

    }

}

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

struct result_is_there_only_one_option_yes : public result_is_there_only_one_option
{
        pt<verb> v;
        pt<phys_obj_with_verbs> obj_with_verb;
        pt<phys_obj> obj_without_verb;
        
        result_is_there_only_one_option_yes(
            pt<verb> v,
            pt<phys_obj_with_verbs> obj_with_verb,
            pt<phys_obj> obj_without_verb)
        {
            this->v = v;
            this->obj_with_verb = obj_with_verb;
            this->obj_without_verb = obj_without_verb;
        }
            
};

struct result_is_there_only_one_option_no : public result_is_there_only_one_option {};

pt<result_is_there_only_one_option>
is_there_only_one_option_overall(
    pt<phys_obj> o1,
    pt<phys_obj> o2)
{
    // BEGIN decl
    pt<phys_obj_with_verbs> obj_with_verbs;
    int count;
    vector<pt<phys_obj> > objs;
    int c;
    pt<phys_obj> active_obj, passive_obj;
    pt<result_is_there_only_one_option> last_option;
    // END

    objs = *vector_of(ulist(o1) << o2);

    // BEGIN find count
    count = 0;
    last_option = NEW(result_is_there_only_one_option_no());

    for(c = 0; c < 2; c++)
    {
        active_obj = objs[c];
        passive_obj = objs[1-c];
        
        if(pt_cast(active_obj, obj_with_verbs))
        {
            count += obj_with_verbs->verbs.size();
            
            if (obj_with_verbs->none_of_the_above)
            {
                count ++;
            }
            last_option = NEW(result_is_there_only_one_option_yes(
                                  obj_with_verbs->verbs.front(),
                                  obj_with_verbs,
                                  passive_obj));
        }
    }
    // END

    assert(count >0);

    if(count == 1)
    {
        return last_option;
    }
    else
    {
        return NEW(result_is_there_only_one_option_no());
    }

}


void
FACK::the_obj_was_clicked(
    pt<obj_or_concept> item_chosen,
    int_pair mouse)
{
    // BEGIN decl
    list<pt<dialog_choice> > choices;
    list<pt<dialog_choice> >::const_iterator cho;

    SDL_Rect cancel_rect;
    pt<PS_missing_two_items> missing_two_items;
    pt<PS_missing_one_item> missing_one_item;
    list<pt<phys_obj_with_verbs> >ambig;
    pt<popup> zoomab;
    list<pt<obj_or_concept> >::const_iterator am;
    // END



    if(pt_cast(item_chosen, zoomab))
    {
        if(!in_list(zoomab, act_pl->open_popups)) // @@ pointer equality
            act_pl->open_popups.push_back(zoomab);
        else
            list_remove_one(act_pl->open_popups, zoomab);
    }
    else
    {
        // an item has been clicked, either in the
        // room or in the inventory

        if (pt_cast(act_pl->state, missing_one_item))
        {
            // BEGIN decl
            pt<concept> conc;
            pt<phys_obj> phys1, phys2;
            pt<phys_obj_with_verbs> obj_with_verbs;
            pt<result_is_there_only_one_option> ret;
            pt<result_is_there_only_one_option_yes> only_one;
            // END

            if (pt_cast(item_chosen, conc) || pt_cast(missing_one_item->obj_already_chosen, conc))
            {
                execute_action_object_object( item_chosen, missing_one_item->obj_already_chosen);
            }
            else
            {
                phys1 = dynamic_pointer_cast<phys_obj> (item_chosen);
                phys2 = dynamic_pointer_cast<phys_obj> (missing_one_item->obj_already_chosen);
                assert(phys1);
                assert(phys2);


                if(pt_cast(phys1, obj_with_verbs) || pt_cast(phys2, obj_with_verbs))
                {
                    ret = is_there_only_one_option_overall(phys1, phys2);

                    if (pt_cast(ret, only_one))
                    {
                        execute_action_verb_object(only_one->v, 
                                                   only_one->obj_without_verb /* obj for which the verb was not chosen*/,
                                                   only_one->obj_with_verb /* obj which had that verb in its verb list */);
                    }
                    else
                    {
                        draw_verb_dialog( 
                            phys1,
                            phys2,
                            surf_of_letter,
                            screen,
                            true /* calc_rect_only */, 
                            mouse, 
                            cancel_rect /* out*/,
                            choices /* out*/);
                    
                        act_pl->state = NEW( PS_choosing_verb(
                                                 phys1,
                                                 phys2 ,
                                                 choices,
                                                 cancel_rect,
                                                 missing_one_item->anim,
                                                 missing_one_item->timer,
                                                 missing_one_item->cur_frame));
                    }
                }
                else // no item is ambiguous 
                { 
                    execute_action_object_object( phys1, phys2);
                }
            }
        }
        else if (pt_cast(act_pl->state, missing_two_items))
        {
            act_pl->state = NEW( PS_missing_one_item(
                                     item_chosen, missing_two_items->anim,
                                     missing_two_items->timer,
                                     missing_two_items->cur_frame));
        }
    }

}

void
FACK::cycle_active_player()
{
    // BEGIN decl
    list<pt<PC> >::const_iterator ch;
    list< list<pt<PC> >::const_iterator  > qwe;
    // END

    setof_( ch, ch, players, *ch == act_pl, qwe);
    assert(qwe.size() == 1);
    ch = qwe.front();
    ch ++;

    if (ch == players.end())
    {
        act_pl = players.front();
    }
    else
    {
        act_pl = *ch;
    }

    active_player_changed(act_pl);

}


SDL_Rect
FACK::find_scrolling_rect(
    int_pair size_of_bg_surf)
{
    // BEGIN decl
    int ht_of_graphic_window, wt_of_graphic_window;
    int ideal_top, ideal_bottom, ideal_left, ideal_right;
    int final_top, final_bottom, final_left, final_right;

    // END

    ht_of_graphic_window = std::min( size_of_bg_surf.y,
                                     screen->h - act_pl->cache->picture->h - calc_command_bar_ht());
    wt_of_graphic_window = std::min( size_of_bg_surf.x,
                                     screen->w);

    ideal_top = act_pl->pos.y - ht_of_graphic_window * 3/4;
    ideal_bottom = act_pl->pos.y + ht_of_graphic_window / 4;
    ideal_left = act_pl->pos.x - wt_of_graphic_window /2;
    ideal_right = act_pl->pos.x + wt_of_graphic_window /2;

    if (ideal_left <0)
    {
        final_left = 0;
        final_right = wt_of_graphic_window;
    }
    else if (ideal_right > size_of_bg_surf.x)
    {
        final_right = size_of_bg_surf.x;
        final_left = final_right - wt_of_graphic_window;
    }
    else
    {
        final_left = ideal_left;
        final_right = ideal_right;
    }
                
    if (ideal_top <0)
    {
        final_top = 0;
        final_bottom = ht_of_graphic_window;
    }
    else if (ideal_bottom > size_of_bg_surf.y)
    {
        final_bottom = size_of_bg_surf.y;
        final_top = final_bottom - ht_of_graphic_window;
    }
    else
    {
        final_top = ideal_top;
        final_bottom = ideal_bottom;
    }

    return create_rect( final_left, final_top, final_right, final_bottom);


}

void
FACK::recompute_on_lights(
    set<pt<light> > & on_lights ) const
{
    // BEGIN decl
    set<pt<light_across_loc> >::const_iterator lia;
    set<pt<light_fixed_in_loc> >::const_iterator lif;
    list<pt<PC> >::const_iterator pl;
    pt<dragging_state_maybe_dragging_obj> maybe_drag_obj;
    list<pos_and<pt<obj_or_concept> > >::const_iterator ob;
    // END

    on_lights.clear();
    foreach(lif, act_pl->loc->active_lights){
        on_lights.insert(*lif);
    }

    foreach(lia, lights_across_loc){
        if(   pt_cast(act_pl->drag_st, maybe_drag_obj)
              &&
              (*lia)->obj_which_emits_the_light == maybe_drag_obj->obj_and_pos.o )
        {
            on_lights.insert( *lia );
        }
        else
        {
            foreach(pl, players){
                if ( (*pl)->loc == act_pl->loc)
                {
                    foreach(ob, (*pl)->cache->sorted_items){
                        if (ob->o == (*lia)->obj_which_emits_the_light )
                        {
                            on_lights.insert( *lia );
                        }
                    }
                }
            }
        }
    }
}       



void
FACK::start()
{
    // BEGIN decl
    pt<container_pick_result> itc;
    pt<PS_missing_two_items> missing_two_items;
    pt<PS_missing_one_item> missing_one_item;
    set<pt<light> > on_lights;

    bool ok;
    pt<sentence_with_location> sen;
    //seq_list<obj_and_pos>::const_iterator op;
    //SDL_Rect dest_rect;
    //bool blit_res;
    bool must_be_scaled;
    pt<still_situation_sitting> sitting;
    pt<AI_substate_speaking_while_sitting> sitting_talking;
    list<pt<layer_unlit_before_anim> >::const_iterator ql;
    list<pt<layer_unlit_after_anim> > unlit_layers_after_anim;
    list<pt<layer_unlit_after_anim> >::const_iterator l;


    pt<layer_lit> bg_layer_lit;
    list<pt<layer_lit> >::const_iterator xx;
    list<pt<anim_frame_and_pos> >::const_iterator xxc;
    list<pt<printable> > lit_layers_and_chars;


    update_AI_result update_AI_res;
    pt<anim_frame_and_pos> frame_and_pos;
    variant<no_sentence, sentence_with_location> maybe_sentence;
    sentence_with_location sentenc;
    float timer, dt;
    int timer_int, dt_int, previous_timer;
    list<SDL_Event> pending_events;
    list<SDL_Event>::const_iterator event;
    int_pair mouse_screen_coords;
    int_pair mouse_bg_coords;

    pt<obj_or_concept> other_item, item_to_disamb;
    pt<phys_obj_with_verbs> just_disambig, still_to_disamb;
    
    //int columns_count, item_wt;

    list<SDL_Surface*> inv_surfs;
    list<SDL_Surface*>::const_iterator sit;
    pt<vector<SDL_Surface *> >inv_surfs_2;
    pt<phys_obj> item_ph;
    variant<no_item, pt<obj_or_concept> > it, it2;
    pt<cfsurf> background;
    list<pt<layer_lit> > lit_layers;
    list<pt<anim_frame_and_pos> > characters;
    variant < no_route_found, pt<list<int_pair> > > maybe_route;
    pt<list<int_pair> > route2;
    pt<vector<int_pair> > route3;
    pt<PS_governed_by_AI> governed_by_AI;
    pt<anim_frame> cur_frame;
    list<int_pair>::const_iterator r;
    vector<int_pair>::const_iterator r3;    
    list<int_pair>::const_iterator r4; 
    pt<list<int_pair> > route4;
    vector<int_pair>::const_iterator r5; 
    pt<vector<int_pair> > route5;
    variant<walking_finished, int_pair> res;
    //vector<pt<obj> >::const_iterator ii;
    SDL_Rect cancel_rect;
    pt<PS_choosing_verb> choosing_verb;


    list<pt<dialog_choice>  > clicked_choices;
    list<pt<dialog_choice>  >::const_iterator cho;

    list<sentence_with_location> sentences_to_display;
    list<sentence_with_location>::const_iterator sent;
    //vector<pt<obj> >::const_iterator iin;
    speech_t speech;
    script_cmds_t commands;


    pt<game_state_normal_t> normal;
    pt<game_state_flashing_inv_t> flashing_inv;

    map<pt<PC>, pt<anim_frame> > cur_frame_of_player;
    pt<anim_frame> stil;
    pt<PS_still_and_parsing> still;
    special_button_pick_result special_but;

    SDL_Rect scrolling_rect;
    int_pair top_left, bottom_right;


    // END


    // BEGIN integrity
//     foreach(ch, players){
//         foreach(iin, (*ch)->inventory){
//             assert(*iin);
//         }
//     }
    // END



    must_exit = false;
    previous_timer =  SDL_GetTicks();

    scrolling_rect = create_rect(0,0, 10,10);

    while( !must_exit) // main loop
    {

        // BEGIN calculate dt, the seconds passed since last frame
        timer_int =  SDL_GetTicks(); // milliseconds
        timer = float(timer_int); 
        dt_int = timer_int - previous_timer ; // milliseconds
        dt = float (dt_int / 1000.f); // dt is expressed in seconds
        previous_timer = timer_int;
        // END




        // BEGIN block 1: manage events
        if (!pt_cast(game_state, flashing_inv))
        {
            pending_events = get_sdl_events();

            SDL_GetMouseState(&mouse_screen_coords.x, &mouse_screen_coords.y);
            mouse_bg_coords = mouse_screen_coords + 
                int_pair(scrolling_rect.x, scrolling_rect.y); 

            foreach(event, pending_events){
                
                gcn_input->pushInput(*event); // inform guichan
                
                if (event->type == SDL_MOUSEBUTTONUP)
                {
                    // BEGIN decl
                    pt<dragging_state_maybe_dragging_obj> maybe_drag_obj;
                    pt<dragging_state_dragging_open_popup> drag_open_popup;
                    // END
                    mouse_screen_coords = int_pair(event->button.x, event->button.y);
                    mouse_bg_coords =  mouse_screen_coords +
                        int_pair(scrolling_rect.x, scrolling_rect.y);

                    if(pt_cast(act_pl->drag_st, maybe_drag_obj))
                    {
                        if(mouse_screen_coords == maybe_drag_obj->orig_mouse_pos)
                        {
                            maybe_drag_obj->orig_container->add_item_in_pos(
                                maybe_drag_obj->obj_and_pos);

                            the_obj_was_clicked(maybe_drag_obj->obj_and_pos.o, mouse_screen_coords);
                        }
                        else
                        {
                            drop_item(maybe_drag_obj, mouse_screen_coords);
                        }
                        

                    }
                    else if(pt_cast(act_pl->drag_st, drag_open_popup))
                    {
                        drag_open_popup->pop->position_in_screen = mouse_screen_coords - 
                            drag_open_popup->offset_of_mouse_in_obj;

                        act_pl->open_popups.push_back(drag_open_popup->pop);

                    }
                    act_pl->drag_st = NEW(dragging_state_not_dragging());
                }
                else if ( event->type == SDL_MOUSEBUTTONDOWN ) 
                {
                    mouse_screen_coords = int_pair(event->button.x, event->button.y);
                    mouse_bg_coords = mouse_screen_coords +
                        int_pair(scrolling_rect.x, scrolling_rect.y);

                    if (event->button.button == SDL_BUTTON_LEFT)
                    {
                        special_but = special_button_at_pos(mouse_screen_coords);
                        if(special_but == SBPR_CYCLE_PLAYER)
                        {
                            cycle_active_player();
                        }
                        else if (special_but == SBPR_STAY_FOLLOW)
                        {
                            quick_msg = NEW(quick_message("Not yet implemented."));
                        }
                        else if(special_but == SBPR_SAVE_LOAD)
                        {
                            if(gcn_options_window->isVisible())
                            {
                                gcn_options_window->setVisible( false);
                                gcn_save_window->setVisible( false);
                                gcn_load_window->setVisible( false);
                            }
                            else
                            {
                                gcn_options_window->setVisible( true);
                                gcn_top_container->moveToTop(gcn_options_window.get());
                            }
                        }
                        else
                        {
                            if (pt_cast(act_pl->state, missing_one_item) 
                                || pt_cast(act_pl->state, missing_two_items))
                            {
                                // BEGIN decl
                                pt<container_pick_result_obj_and_pos> obj_and_pos_clicked;
                                pt<container_pick_result_obj> obj_clicked;
                                pt<container_pick_result_container_drag_area> drag_cont;
                                pt<container_pick_result_closing_area> close_cont;
                                pt<container> cont;
                                // END

                                itc = item_in_popup_at_screen_pos(mouse_screen_coords);


                                if(pt_cast(itc, obj_and_pos_clicked))
                                {
                                    cont = dynamic_pointer_cast<container>(obj_and_pos_clicked->pop);
                                    assert(cont);

                                    act_pl->drag_st = 
                                        NEW(dragging_state_maybe_dragging_obj(
                                                obj_and_pos_clicked->obj_and_pos, 
                                                ( (mouse_screen_coords - obj_and_pos_clicked->pop->position_in_screen) - 
                                                  obj_and_pos_clicked->obj_and_pos.pos) /* offset_of_mouse_in_obj */,
                                                cont,
                                                mouse_screen_coords /* orig_mouse_pos */));

                                    cont->remove_item_not_recursively(obj_and_pos_clicked->obj_and_pos.o);

                                }
                                else if (pt_cast(itc, obj_clicked))
                                {
                                    the_obj_was_clicked(obj_clicked->obj, mouse_screen_coords);
                                }
                                else if (pt_cast(itc, close_cont))
                                {
                                    list_remove_one(act_pl->open_popups, close_cont->pop);
                                }
                                else if(pt_cast(itc, drag_cont))
                                {
                                    act_pl->drag_st = 
                                        NEW(dragging_state_dragging_open_popup(
                                                mouse_screen_coords - drag_cont->pop->position_in_screen /* offset_of_mouse_in_obj */,
                                                drag_cont->pop));

                                    list_remove_one(act_pl->open_popups, drag_cont->pop);
                                }
                                else
                                {
                                    // BEGIN decl
                                    pt<obj_or_concept> obj_or_conc;
                                    // END

                                    it2 = item_in_room_at_position( mouse_bg_coords,
                                                                    players,
                                                                    act_pl,
                                                                    cur_frame_of_player);

                                    if(var_cast(it2, obj_or_conc))
                                    {
                                        the_obj_was_clicked(obj_or_conc, mouse_screen_coords);
                                    }
                                    else
                                    {
                                        // he clicked in the void with the left mouse button

                                    }
                                }
                            }
                            else if (pt_cast(act_pl->state, choosing_verb))
                            {
                                if (point_in_rect( int_pair(event->button.x, 
                                                            event->button.y), 
                                                   choosing_verb->cancel_rect))
                                {
                                    act_pl->state = NEW( PS_missing_two_items(
                                                             choosing_verb->anim,
                                                             choosing_verb->timer,
                                                             choosing_verb->cur_frame));
                                }
                                else
                                {
                                    setof(  cho,
                                            choosing_verb->choices,
                                            point_in_rect( int_pair(event->button.x,
                                                                    event->button.y),
                                                           (*cho)->rect),
                                            clicked_choices);

                                    if(clicked_choices.size() >0)
                                    {
                                        // BEGIN decl
                                        pt<dialog_choice_verb_object> choice_verb_obj;
                                        // END


                                        if(pt_cast(clicked_choices.front(), choice_verb_obj))
                                        {
                                            // the user disambiguated the item
                                            execute_action_verb_object(
                                                choice_verb_obj->v, 
                                                choice_verb_obj->passive_obj /* no verb was chosen*/,
                                                choice_verb_obj->obj_for_which_the_verb_was_chosen /* verb was chosen */); 
                                        }
                                        else
                                        {
                                            assert(dynamic_pointer_cast<dialog_choice_double_other>(clicked_choices.front()));
                                            execute_action_double_none_of_the_above(
                                                choosing_verb->obj_one,
                                                choosing_verb->obj_two);
                                        
                                        }
                                    }
                                }
                            }
                            else if (pt_cast(act_pl->state, governed_by_AI))
                            {
                                // ignore the click
                            }
                            else{
                                assert(false); // unmanaged parser state
                            }            
                        }
                    }
                    else
                    {
                        // he did not press the left mouse button, but
                        // some other mouse button (right probably).
                        mouse_screen_coords = int_pair(event->button.x, event->button.y);
                        mouse_bg_coords = mouse_screen_coords +
                            int_pair(scrolling_rect.x, scrolling_rect.y);

                

                        if(!pt_cast(act_pl->state, governed_by_AI))
                        {
                            // BEGIN move character to clicked point
                            if(is_walkable(*act_pl->loc->walking_map, 
                                           mouse_bg_coords.x,
                                           mouse_bg_coords.y))
                            {
                                commands.clear();
                                commands << NEW(scr_cmd_walk(mouse_bg_coords));
                                execute_commands(act_pl, commands);
                            }
                            // END
                        }
                    }
                }

            } // foreach
        }

        // END of block1: manage events.










        // BEGIN block 2: update the life of characters and layers

        gcn_gui->logic();

        recompute_on_lights(on_lights /* out */);

        characters.clear();
        sentences_to_display.clear();
        cur_frame_of_player.clear();

        if(  pt_cast(act_pl->state, missing_one_item) ||
             pt_cast(act_pl->state, missing_two_items ) ||
             pt_cast(act_pl->state, governed_by_AI))
        {
            // BEGIN decl
            list<pt<PC> >::const_iterator ch;
            // END

            foreach(ch, players){

                if (pt_cast((*ch)->state,  still))
                {
                    cur_frame_of_player[*ch] = update_still_anim(still, dt);

                    if (act_pl->loc == (*ch)->loc)
                    {
                        must_be_scaled =  !pt_cast((*ch)->still_situat, sitting );

                        characters.push_back(NEW( anim_frame_and_pos( 
                                                      map_get(cur_frame_of_player, *ch),
                                                      (*ch)->pos.x, 
                                                      (*ch)->pos.y,
                                                      must_be_scaled)));
                    }
                }
                else 
                {
                    ok = pt_cast((*ch)->state, governed_by_AI);
                    assert(ok);


                    update_AI_res = update_AI_state( *ch, dt, 
                                                     int_pair(scrolling_rect.x,
                                                              scrolling_rect.y));

                    // BEGIN this is always necessary here, because
                    // the AI step could have relocated a torch!
                    recompute_on_lights(on_lights /* out*/);
                    // END

                    cur_frame_of_player[*ch] = update_AI_res.frame;
                    (*ch)->state = update_AI_res.new_player_state;
                    (*ch)->cur_dir = update_AI_res.dir;
                    (*ch)->pos = update_AI_res.pos;
                                    
                    if((*ch)->loc == act_pl->loc && update_AI_res.frame)
                    {
                        must_be_scaled =  !pt_cast((*ch)->still_situat, sitting );

                        characters.push_back(NEW(anim_frame_and_pos(
                                                     update_AI_res.frame,
                                                     update_AI_res.pos.x, 
                                                     update_AI_res.pos.y,
                                                     must_be_scaled)));
                            
                    }

                    if ((*ch)->loc == act_pl->loc && var_cast(update_AI_res.maybe_sentence, sentenc))
                    {
                        sentences_to_display.push_back(sentenc);
                    }
                }
            }


            setof_(
                (*ql)->get_cur_frame(dt),
                ql,
                act_pl->loc->sorted_unlit_layers_before_anim ,
                (*ql)->visible,
                unlit_layers_after_anim);


            scrolling_rect = find_scrolling_rect( int_pair(
                                                      unlit_layers_after_anim.front()->lit_versions.front().surf->apparent_wt,
                                                      unlit_layers_after_anim.front()->lit_versions.front().surf->apparent_ht));


            setof_ ( 
                lit_layer_of_unlit_layer(**l, 
                                         on_lights,
                                         timer,
                                         scrolling_rect), 
                l, 
                unlit_layers_after_anim, 
                true, 
                lit_layers);


            bg_layer_lit = lit_layers.front(); 
            lit_layers.pop_front();

            lit_layers_and_chars.clear();
            foreach(xx, lit_layers){
                lit_layers_and_chars.push_back(*xx);
            }
            foreach(xxc, characters){
                lit_layers_and_chars.push_back(*xxc);
            }

            // BEGIN update quick message
            if(quick_msg)
            {
                quick_msg->timer -= dt;
                if(quick_msg->timer <0)
                {
                    quick_msg = pt<quick_message>();
                }
            }
            // END


            update_light_transitions(dt);
        }

        // END block 2: update the life.









        // BEGIN block 3: render (layers, chars, dialogs, drawers, etc).
        if (pt_cast(act_pl->state, missing_one_item) ||
            pt_cast(act_pl->state, missing_two_items ) ||
            pt_cast(act_pl->state, governed_by_AI))
        {

            // BEGIN decl
            pt<dragging_state_maybe_dragging_obj> maybe_drag_obj;
            pt<dragging_state_dragging_open_popup> drag_open_popup;
            list<pt<popup> >::const_iterator zo;
           
            // END





            render_layers_and_chars_in_correct_order(
                lit_layers_and_chars, *bg_layer_lit->surf, screen, 
                act_pl->loc->scaling_data,
                scrolling_rect,
                on_lights);


            // BEGIN render special buttons
            {
                // BEGIN decl
                SDL_Rect r;
                bool ret;
                // END

                r.x = special_buttons_icon_pos.x;
                r.y = special_buttons_icon_pos.y;
                ret = SDL_BlitSurface(special_buttons_icon,
                                      NULL,
                                      screen, 
                                      &r);
                assert (ret == 0);
            }
            // END

            render_command_bar( mouse_screen_coords,
                                mouse_bg_coords,
                                cur_frame_of_player); // before containers

            act_pl->cache->render(screen, game_state);

            foreach(zo, act_pl->open_popups){
                (*zo)->render(screen, game_state);
            }

            if(pt_cast(act_pl->drag_st, maybe_drag_obj))
            {
                // BEGIN decl
                SDL_Rect r;
                int_pair cur_obj_pos;
                bool ret;
                // END

                cur_obj_pos = mouse_screen_coords - maybe_drag_obj->offset_of_mouse_in_obj;
                r.x = cur_obj_pos.x;
                r.y = cur_obj_pos.y;
                ret = SDL_BlitSurface(maybe_drag_obj->obj_and_pos.o->get_inv_surf(),
                                      NULL,
                                      screen, 
                                      &r);
                assert (ret == 0);

            }
            else if (pt_cast(act_pl->drag_st, drag_open_popup))
            {
                drag_open_popup->pop->position_in_screen = 
                    mouse_screen_coords - drag_open_popup->offset_of_mouse_in_obj;

                drag_open_popup->pop->render(screen, game_state);
            }

            foreach(sent, sentences_to_display){

                draw_text_multiline_variable_ht(
                    sent->text, screen, sent->x_left, sent->y_top, 
                    sent->x_right, surf_of_letter, 
                    false /*actually draw*/,
                    sent->color);
            }

            // BEGIN render quick message
            if(quick_msg)
            {
                print_x_centered_line_of_text(
                    quick_msg->text,
                    0, screen->w,
                    screen->h - act_pl->cache->picture->h - calc_command_bar_ht() * 2 /* y */,
                    surf_of_letter, screen, 
                    rgb(150, 150, 210));
            }
            // END

        }
        else if(pt_cast(act_pl->state, choosing_verb))
        { 
            // BEGIN decl
            list<pt<dialog_choice> > choices;
            // END


            draw_verb_dialog( choosing_verb->obj_one,
                              choosing_verb->obj_two,
                              surf_of_letter, 
                              screen, 
                              false /* actually draw */, 
                              mouse_screen_coords, 
                              cancel_rect /* out*/,
                              choices /* out*/);
        }
        gcn_gui->draw();

        // END block 3












        // BEGIN update game state
        if(pt_cast(game_state, flashing_inv))
        {
            flashing_inv->timer -= dt;
            if(flashing_inv->timer <= 0)
            {
                game_state = NEW(game_state_normal_t());
            }
        }
        // END





        SDL_Flip(screen);
    }

    SDL_Quit();
}

FACK::FACK(int argc, char ** argv)
{

    // BEGIN decl
    Uint32 videoflags;
    int button_ht;
    seq_list<pt<gcn::Widget> > options_widgets;
    seq_list<pt<gcn::Widget> >::const_iterator x, w;
    list<int> widths;
    int maxw;
    // END

    if((SDL_Init(SDL_INIT_VIDEO)==-1)) { 
        raise_exception("Could not initialize SDL." /*, SDL_GetError()*/);
    }

                                                                                              
    videoflags = choose_some_video_flags();        
        
    //BEGIN set video mode          
    if ( (argc > 1) &&  (strcmp(argv[1], "-full") == 0) ) {
        videoflags |= SDL_FULLSCREEN;}

    this->screen = SDL_SetVideoMode(320, 240, 32, videoflags);
    if (!screen) {
        raise_exception("Couldn't set 320x200x32 video mode. " /* SDL_GetError()*/);
    }
    //END 


    // BEGIN init guichan

    list_model = NEW(dir_watcher_list_model());
    gcn_gui = NEW(gcn::Gui());
    button_ht = 20;

    SDL_EnableUNICODE(1); // necessary for gcn::TextField to work!

    gcn_save_cont = NEW(gcn::Container());
    gcn_save_cont->setSize(300,150);
    gcn_save_cont->setOpaque(false);

    gcn_load_cont = NEW(gcn::Container());
    gcn_load_cont->setSize(screen->w - 20,
                           screen->h * 3 /4 );
    gcn_load_cont->setOpaque(false);

    gcn_options_cont = NEW(gcn::Container());
    gcn_options_cont->setOpaque(false);

    gcn_save_window = NEW(gcn::Window("Save"));
    gcn_save_window->setContent(gcn_save_cont.get());
    


    gcn_options_window = NEW(gcn::Window("Options"));
    gcn_options_window->setContent(gcn_options_cont.get());
    gcn_options_window->setPosition(100, 20);


    gcn_load_window = NEW(gcn::Window("Load"));
    gcn_load_window->setContent(gcn_load_cont.get());
    gcn_load_window->resizeToContent();

    gcn_top_container = NEW(gcn::Container());
    gcn_top_container->setDimension(gcn::Rectangle(0, 0, screen->w, screen->h));
    gcn_top_container->setOpaque(false);
    gcn_top_container->add(gcn_save_window.get());
    gcn_top_container->add(gcn_load_window.get());
    gcn_top_container->add(gcn_options_window.get());


    // save dialog
    
    gcn_save_text_field = NEW(gcn::TextField("quick save"));
    gcn_save_text_field->setSize(200, 20);
    gcn_save_cont->add(gcn_save_text_field.get());

    gcn_save_button = NEW(gcn::Button("Save"));
    gcn_save_button->setEventId("save_button_event");
    gcn_save_button->setPosition(0, button_ht );
    gcn_save_button->addActionListener(this);
    gcn_save_cont->add(gcn_save_button.get());

    gcn_cancel_save_button = NEW(gcn::Button("Cancel"));
    gcn_cancel_save_button->setEventId("cancel_save_button_event");
    gcn_cancel_save_button->setPosition(0, 2 * button_ht );
    gcn_cancel_save_button->addActionListener(this);
    gcn_save_cont->add(gcn_cancel_save_button.get());


    //  options dialog
    gcn_options_save_button = NEW(gcn::Button("Save"));
    gcn_options_save_button->setEventId("gcn_options_save_button");
    gcn_options_save_button->addActionListener(this);
    gcn_options_cont->add(gcn_options_save_button.get());


    gcn_options_load_button = NEW(gcn::Button("Load"));
    gcn_options_load_button->setPosition(0, button_ht );
    gcn_options_load_button->setEventId("gcn_options_load_button");
    gcn_options_load_button->addActionListener(this);
    gcn_options_cont->add(gcn_options_load_button.get());

    gcn_options_fullscreen_button = NEW(gcn::Button("Toggle full screen"));
    gcn_options_fullscreen_button->setPosition(0, 2 * button_ht );
    gcn_options_fullscreen_button->setEventId("gcn_options_fullscreen_button");
    gcn_options_fullscreen_button->addActionListener(this);
    gcn_options_cont->add(gcn_options_fullscreen_button.get());

    gcn_options_cancel_button = NEW(gcn::Button("Cancel"));
    gcn_options_cancel_button->setPosition(0, 3 * button_ht);
    gcn_options_cancel_button->setEventId("gcn_options_cancel_button");
    gcn_options_cancel_button->addActionListener(this);
    gcn_options_cont->add(gcn_options_cancel_button.get());


    gcn_options_quit_button = NEW(gcn::Button("Quit game"));
    gcn_options_quit_button->setPosition(0, 4 * button_ht);
    gcn_options_quit_button->setEventId("gcn_options_quit_button");
    gcn_options_quit_button->addActionListener(this);
    gcn_options_cont->add(gcn_options_quit_button.get());


    options_widgets =  seq_list<pt<gcn::Widget> > () << 
        gcn_options_quit_button <<
        gcn_options_cancel_button << gcn_options_fullscreen_button <<
        gcn_options_load_button << gcn_options_save_button;

    setof_ ( (*w)->getWidth(),
             w,
             options_widgets,
             true,
             widths);

    maxw = max( widths);

    gcn_options_cont->setSize(maxw, 120);

    foreach( x, options_widgets){

        (*x)->setWidth(maxw);
    }

    // load dialog
    gcn_load_listbox = NEW(gcn::ListBox( list_model.get() ));

    gcn_load_scroll_area = NEW(gcn::ScrollArea(gcn_load_listbox.get()));
    gcn_load_scroll_area->setSize(gcn_load_cont->getWidth(), 
                                  gcn_load_cont->getHeight() - 32);
    gcn_load_listbox->setSize(gcn_load_cont->getWidth() - gcn_load_scroll_area->getScrollbarWidth() -2, 
                              gcn_load_cont->getHeight() - 32);


    gcn_cancel_load_button = NEW(gcn::Button("Cancel"));
    gcn_cancel_load_button->setEventId("gcn_cancel_load_button");
    gcn_cancel_load_button->addActionListener(this);
    gcn_cancel_load_button->setPosition(0, gcn_load_cont->getHeight() - 30);

    gcn_load_cont->add(gcn_load_scroll_area.get());
    gcn_load_cont->add(gcn_cancel_load_button.get());

    // 


    gcn_load_window->resizeToContent();
    gcn_save_window->resizeToContent();
    gcn_options_window->resizeToContent();

    gcn_load_window->setVisible(false);
    gcn_save_window->setVisible(false);
    gcn_options_window->setVisible(false);




    gcn_graphics = NEW(gcn::SDLGraphics());
    gcn_graphics->setTarget(screen);

    gcn_image_loader = NEW(gcn::SDLImageLoader());
    gcn::Image::setImageLoader(gcn_image_loader.get()); 

    gcn_input = NEW(gcn::SDLInput());

    gcn_gui->setGraphics(gcn_graphics.get());
    gcn_gui->setInput(gcn_input.get());
    gcn_gui->setTop(gcn_top_container.get());


    gcn_font = NEW(gcn::ImageFont("data/fixedfont.bmp", " abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.;:"));

    gcn::Widget::setGlobalFont(gcn_font.get());

    // END

    this->game_state = NEW(game_state_normal_t());

    printf ("screen: pitch %d bytespp %d\n", screen->pitch, screen->format->BytesPerPixel);
}



SDL_Surface * can_appear_closed_in_inv_no::get_inv_surf()
{
    assert(false);
}

SDL_Surface * can_appear_closed_in_inv_yes::get_inv_surf()
{
    return inv_surf;
}





bool 
anim_frame::point_in_surf(
    int_pair p /* point to be sampled (screen coords) */,
    int_pair pl /* position of the hot spot of the animation frame on the screen (screen coords) */,
    float scaling /* the scaling that will be applied to the frame */) const
{
    // BEGIN decl
    int_pair r, l, j;
    rgbaf pix;
    // END

    r = p - pl;

    l = int_pair( int( float(r.x)/scaling ), int( float(r.y)/scaling)  );

    j = l + this->hot_spot;
    

    if ( 0 <= j.x && j.x < this->w 
         &&
         0 <= j.y && j.y < this->h)
    {
        pix = get_pixel( j.x, j.y);

        return (pix.a != 0.0f /* @@ dangerous to check for float equality? */ );
    }
    else
    {
        return false;
    }

}


void
layer_lit::print_with_transparency(
    cfsurf & background,
    const room_scaling_data& d,
    set<pt<light> > active_lights)
{
    surf->blit_with_src_alpha( background); 

}

void
anim_frame_and_pos::print_with_transparency(
    cfsurf & background,
    const room_scaling_data& d,
    const set<pt<light> > active_lights)
{
    // BEGIN decl
    float scal;
    float light_fact;
    float sum;
    set<pt<light> >::const_iterator l;
    map<pt<light>, float> normalized_weight_of_light;
    // END

    if (this->must_be_scaled)
    {
        scal = scaling_of_char( this->position_y, d);
    }
    else
    {
        scal = 1.0f;
    }

    // BEGIN find normalized_weight_of_light
    sum = 0.0f;
    foreach(l, active_lights){
        sum += (*l)->weight;
    }

    foreach(l, active_lights){
        normalized_weight_of_light[*l] = (*l)->weight / sum;
    }
    // END

    
    light_fact = 0.0f;
    foreach(l, active_lights){
        light_fact += 
            (*l)->pl_illum->get_illum_factor_at( this->position_x, this->position_y)
            *
            map_get( normalized_weight_of_light, *l);
    }

    blit_char(*this, scal, light_fact, background);
    
}


pt<layer_unlit_after_anim>
layer_unlit_anim::get_cur_frame(float dt)
{
    timer += dt;
    if (timer >= frame_change_interval)
    {
        timer -= frame_change_interval;
        cur_frame ++;
        if(cur_frame == anim.end())
        {
            cur_frame = anim.begin();
        }

    }
    return NEW(layer_unlit_after_anim(*cur_frame, y_walkbehind));

}


void
FACK::define_dialog_aux(
    const dialog_t & dialog,
    pt<PC> first_player, 
    pt<PC> second_player, 
    script_cmds_t & steps_first,
    script_cmds_t & steps_second) const
{
    // BEGIN decl
    dialog_t::const_iterator i;
    pt<PC> who_speaks_next;
    // END

    who_speaks_next = first_player;
    foreach(i, dialog){
        if(who_speaks_next == first_player)
        {
            steps_first << NEW(scr_cmd_speak( *i, close_any_open_container));
            steps_second << NEW(scr_cmd_wait_for_person_to_stop_talking(first_player));

            who_speaks_next = second_player;
        }
        else
        {
            steps_second << NEW(scr_cmd_speak(*i, close_any_open_container ));
            steps_first << NEW(scr_cmd_wait_for_person_to_stop_talking(second_player));

            who_speaks_next = first_player;

        }
    }
}




pt<animation>
anim_right_left::get_anim(horizontal_dir dir) const
{
    if (dir == hd_right)
    {
        return this->right;
    }
    else
    {
        return this->left;
    }

}






void
write_string(
    ostream& o, string s)
{

     o << s.length() << ":" << s;
}


string 
read_string(
    istream & i)
{
    // BEGIN decl
    size_t len;
    string ret;
    int c;
    char colon;
    char ch;
    // END


    i >> len;
    i >> colon;
    assert(colon == ':');

    ret = "";
    for (c = 0; c < len; c++)
    {
        i >> ch;
        ret += ch;
    }

    return ret;

}



// void
// FACK::save_game()
// {
//     // BEGIN decl
//     long version;
//     ofstream file;
//     seq_list<pt<PC> >::const_iterator p;
//     // END

//     version = 1;

//     file.open("savegame.binary");



//     file <<  version << " ";


//     this->game_state->serialize(file);


//     file << " ";
//     write_string(file, act_pl->get_persistent_id());
//     file << " ";
    
//     foreach(p, players){
//      (*p)->save(file);

//     }


//     this->save(file /*mod*/);
// }


// void
// FACK::load_game(
//     const list<pt<obj> > & objects,
//     const list<pt<location> > & locations,
//     const list<pt<PC> > & players)
// {
//     // BEGIN decl
//     ifstream file;
//     long version;
//     seq_list<pt<PC> >::const_iterator p;
//     seq_list<pt<PC> > pp;
//     string pl_pid;
//     // END
    
//     file.open("savegame.binary");
//     file >> version;
//     assert(version == 1);

//     game_state = game_state_t::deserialize(file, objects);
    

//     pl_pid = read_string(file);

//     setof(p, players, (*p)->get_persistent_id() == pl_pid, pp);
//     act_pl = pp.front();

//     foreach(p, players){
//      (*p)->load(file, objects, locations);
//     }


//     this->load(file);

// }
// void
// PC::save(
//     ofstream& file)
// {
//     // BEGIN decl
//     vector<pt<obj> >::const_iterator i;
//     // END

//     file << " " << pos.x << " " << pos.y << " " << inv_scrolling << " ";


//     write_string(file, loc->get_persistent_id());

//     file <<  /*" " << cur_dir << */
//      " " << inventory.size();

//     foreach(i, inventory){
        
//      file << " ";
//      write_string(file, (*i)->get_persistent_id());
//     }

// }

// void
// PC::load(
//     ifstream& file,
//     const list<pt<obj> >& objects,
//     const list<pt<location> > & locations)
// {
//     // BEGIN decl
//     int i_size, i;
//     string loc_id, item_id;
//     list<pt<location> > xx;
//     list<pt<location> >::const_iterator l;
//     list<pt<obj> > ss;
//     list<pt<obj> >::const_iterator x;
//     // END

//     inventory.clear();

//     file >> pos.x >> pos.y >>  inv_scrolling ;

//     loc_id = read_string(file);
//     setof(l, locations, (*l)->get_persistent_id() == loc_id, xx);
//     this->loc = xx.front();



//     //file >> c >> cur_dir;


//     file >> i_size;

//     for(i = 0; i< i_size; i++)
//     {
//      item_id = read_string(file);
//      setof(x, objects, (*x)->get_persistent_id() == item_id, ss);
//      inventory.push_back(ss.front());
//     }

// }

        
// void 
// game_state_flashing_inv_t::serialize(
//     ostream& file)const 
// {
//     write_string(file, "flashing");

//     file << " " << item->get_persistent_id() << " " << timer << " " << paused;

// }
// void 
// game_state_flashing_inv_t::deserialize_once_subtype_known(
//     istream& file,
//     const list<pt<obj> > & objects) 
// {
//     // BEGIN decl

//     string loc_id, item_id;
//     list<pt<location> > xx;
//     list<pt<location> >::const_iterator l;
//     list<pt<obj> > ss;
//     list<pt<obj> >::const_iterator x;
//     // END

//     // BEGIN init item
//     setof(x, objects, (*x)->get_persistent_id() == read_string(file), ss);
//     this->item = ss.front();

//     // END


//     file >> timer >> paused;
// }
        
// void 
// game_state_normal_t::serialize(
//     ostream& file)const 
// {
//     write_string(file, "normal");

//     file << " " <<paused;

// }
// void 
// game_state_normal_t::deserialize_once_subtype_known(
//     istream& file,
//     const list<pt<obj> > & objects) 
// {

//     file >> paused;
// }


// pt<game_state_t>
// game_state_t::deserialize(
//     istream& file,
//     const list<pt<obj> > & objs)
// {
//     // BEGIN decl
//     pt<game_state_t> ret;
//     string id;
//     // END

//     id = read_string(file);

//     if(id == "flashing")
//     {
//      ret = NEW(game_state_flashing_inv_t());
//     }
//     else
//     {
//      assert(id == "normal");
//      ret = NEW(game_state_normal_t());
//     }
//     ret->deserialize_once_subtype_known(file, objs);
//     return ret;

// }




int_pair
int_pair::operator-(
    const int_pair& p) const
{
    return int_pair(x - p.x, y-p.y);
}
int_pair
int_pair::operator+(
    const int_pair& p) const
{
    return int_pair(x + p.x, y + p.y);
}


// SDL_Rect
// FACK::calc_inv_rect() const
// {
//     SDL_Rect r;

//     r.w = inv_icon->w;
//     r.h = inv_icon->h;

//     r.x = 0;
//     r.y = screen->h - 2* width_of_scroll_arrow - 2 - map_get(surf_of_letter, 'a')->h - inv_icon->h;

//     return r;

// }

    
template<class T>
void
vector2<T>::fill_with(
    const T& val)
{
    // BEGIN decl.
    int i;
    // END
    for( i= 0; i < w * h ; i++)
    {
        v[i] = val;
    }
}


void
container::add_item( 
    const pt<obj_or_concept> i)
{
    sorted_items.push_back(pos_and<pt<obj_or_concept> >(
                               i, int_pair(drop_in_area.x + drop_in_area.w/3,
                                           drop_in_area.y + drop_in_area.h /3)));
}


void
container::remove_item_not_recursively(
    const pt<obj_or_concept> item)
{
    // BEGIN decl
    list<pos_and<pt<obj_or_concept> > >::iterator i;
    // END

    foreach(i, sorted_items)
    {
        if (i->o == item) 
        {
            i = sorted_items.erase(i);
            return;
        }
    }

    assert(false);
}


bool
container::remove_item_aux(
    const pt<obj_or_concept> item)
{
    // BEGIN decl
    list<pos_and<pt<obj_or_concept> > >::iterator i;
    // END

    foreach(i, sorted_items)
    {
        if (i->o == item) 
        {
            i = sorted_items.erase(i);
            return true;
        }
    }
    return false;

}

bool
container::remove_item_rec_aux(
    const pt<obj_or_concept> item)
{
    // BEGIN decl
    list<pos_and<pt<obj_or_concept> > >::const_iterator i;
    pt<container> container;
    bool ret, found;
    // END

    ret =  remove_item_aux(item);

    if(ret)
    {
        return true;
    }
    else
    {
        found = false;
        foreach(i, sorted_items){
            if (pt_cast(i->o, container))
            {
                ret = container->remove_item_rec_aux(item);

                if(ret)
                    found = true;
            }
        }
        return found;
    }

}


void
container::remove_item_recursively(
    const pt<obj_or_concept> item)
{
    bool found;

    found = remove_item_rec_aux(item);

    if(!found)
        assert(false);

}
void
container::add_item_in_pos(
    pos_and<pt<obj_or_concept> > obj_and_pos)
{
    sorted_items.push_back(obj_and_pos);
}

bool
FACK::contains_recursively(
    pt<container> cont,
    pt<obj_or_concept> o,
    pt<container> & real_cont,
    int_pair & pos )
{
    // BEGIN decl
    list<pos_and<pt<obj_or_concept> > >::const_iterator i;
    pt<container> container, con;
    int_pair po;
    // END

    if(contains_not_recursively(cont, o, po /* out */))
    {
        real_cont = cont;
        pos = po;
        return true;
    }
    else
    {
        foreach(i, cont->sorted_items){
            if (pt_cast(i->o, container))
            {
                if(contains_recursively(container, 
                                        o,
                                        con /* out */, 
                                        po /* out */))
                {
                    real_cont = con;
                    pos = po;
                    return true;
                }
            }
        }

//      real_cont = pt<container>(0);
//      pos = int_pair(-1, -1);
        return false;
    }
}

bool
FACK::contains_not_recursively(
    pt<container> cont,
    pt<obj_or_concept> o,
    int_pair & pos) 
{
    // BEGIN decl
    list<pos_and<pt<obj_or_concept> > >::const_iterator i;
    // END

    foreach(i, cont->sorted_items){
        if (i->o == o )
        {
            pos = i->pos;
            return true;
        }
    }

    pos = int_pair(-1, -1);
    return false;
}


bool
container::can_contain_this_obj(pt<obj_or_concept> o)const
{
    // BEGIN decl
    pt<phys_obj> phys;
    pt<concept> conc;
    pt<container> cont;
    pt<zoomable> zoomab;
    // END

    if(type == CAN_CONTAIN_ANYTHING)
        return true;
    else if (pt_cast(o, zoomab))
    {
        return true;
    }
    else
    {
        if(pt_cast(o, cont))
        {
            return cont->type == type;
        }
        else
        {
            return ( (type == PHYS_OBJECTS && pt_cast(o, phys))
                     ||
                     (type == CONCEPTS && pt_cast(o, conc)));
        }
    }

}

bool
container::can_be_moved_across_containers()const
{
    return pick_up_info->can_be_moved_across_containers();
}
bool
phys_obj::can_be_moved_across_containers()const
{
    return pick_up_info->can_be_moved_across_containers();
}

SDL_Rect
create_rect(
    int x1, int y1, int x2, int y2)
{
    // BEGIN decl
    SDL_Rect r;
    // END

    // BEGIN precond
    assert(x2 >= x1);
    assert(y2 >= y1);
    // END

    r.x = x1; r.y = y1;
    r.w = x2 - x1;
    r.h = y2 - y1;
    return r;
}

special_button_pick_result
FACK::special_button_at_pos(
    int_pair pos) const
{
    if(point_in_rect(pos, this->zone_save_load_game))
    {
        return SBPR_SAVE_LOAD;
    }
    else if (point_in_rect(pos, this->zone_cycle_active_player))
    {
        return SBPR_CYCLE_PLAYER;
    }
    else if (point_in_rect(pos, this->zone_toggle_stay_follow))
    {
        return SBPR_STAY_FOLLOW;
    }
    else
    {
        return SBPR_NOTHING;
    }
}

bool
zoomable_zone::point_in_zone(int_pair point) const
{
    return point_in_rect(point, rect); 

}


void
FACK::update_light_transitions( float dt )
{
    // BEGIN decl
    list<pt<transition_of_fixed_light> > ::iterator t;
    pt<transition_of_fixed_light> tr;
    float m;
    set<pt<location> >::iterator lo;
    // END


    for(t = transitions_of_fixed_light.begin();
        t != transitions_of_fixed_light.end();
        t++)
    {
        tr = *t;
        assert( tr->cur_timer < tr->end_timer);

        tr->cur_timer += dt;

        if (tr->cur_timer >= tr->end_timer)
        {
            tr->ligh->weight = tr->end_intensity;

            t = transitions_of_fixed_light.erase(t);

            if(tr->switch_off_light_at_the_end)
            {
                foreach( lo, locations){
                    if(in( tr->ligh, (*lo)->active_lights))
                    {
                        (*lo)->active_lights.erase(tr->ligh);
                        cout << "Erased light from loc" << endl;
                    }
                }
            }
        }
        else
        {
            m = (tr->end_intensity - tr->start_intensity)/ tr->end_timer;

            tr->ligh->weight = 
                tr->start_intensity + m * tr->cur_timer;

        }

    }
}


pt<circle_t>
FACK::circle_of_light(pt<light> l) const
{
    // BEGIN decl
    list<pt<PC> >::const_iterator p;
    pt<PC> pl;
    int_pair center, pos;
    pt<light_across_loc> torch;
    pt<dragging_state_maybe_dragging_obj> maybe_drag_obj;
    // END

    if(!pt_cast(l, torch))
    {
        return pt<circle_t>();
    }
    else
    {
        pl = pt<PC>();

        foreach(p, players){

            if( contains_not_recursively( (*p)->cache,
                                          torch->obj_which_emits_the_light,
                                          pos /*out*/))
            {
                pl = *p;
                break;
            }
            else if (pt_cast( (*p)->drag_st, maybe_drag_obj))
            {
                if (maybe_drag_obj->obj_and_pos.o ==  torch->obj_which_emits_the_light )
                {
                    pl = *p;
                    break;
                }
            }
        }
        assert(pl);

        center = pl->pos; 

        return NEW(circle_t( torch->light_radius, center));
    }
}


void 
FACK::action(const string& eventId)
{

    if (eventId == "cancel_save_button_event")
    {
        gcn_save_window->setVisible(false);
    }
    else if (eventId == "gcn_options_quit_button")
    {
        must_exit = true;
    }
    else if (eventId == "gcn_options_save_button")
    {
        gcn_save_window->setVisible(true);
        gcn_top_container->moveToTop(gcn_save_window.get());
        gcn_options_window->setVisible(false);
    }
    else if (eventId == "gcn_options_load_button")
    {
        list_model->rescan_dir();
        gcn_load_window->setVisible(true);
        gcn_top_container->moveToTop(gcn_load_window.get());
        gcn_options_window->setVisible(false);
    }
    else if (eventId == "gcn_options_fullscreen_button")
    {
        SDL_WM_ToggleFullScreen(screen);

    }
    else if (eventId == "gcn_cancel_load_button")
    {
        gcn_load_window->setVisible(false);
    }
    else if (eventId == "gcn_options_cancel_button")
    {
        gcn_options_window->setVisible(false);
    }
    
    

}


dir_watcher_list_model::dir_watcher_list_model()
{
    rescan_dir();
}

int
dir_watcher_list_model::getNumberOfElements()
{
    return strings.size();
}

string
dir_watcher_list_model::getElementAt(int i)
{
    return strings[i];
}


void
dir_watcher_list_model::rescan_dir()
{
    // BEGIN decl
    boost::filesystem::directory_iterator itr;
    string::size_type q;
    // END

    strings.clear();

    boost::filesystem::directory_iterator end_itr; // default construction yields past-the-end
    
    for ( itr = boost::filesystem::directory_iterator( boost::filesystem::current_path() );
          itr != end_itr;
          ++itr )
    {
        if (boost::filesystem::is_directory(*itr))
        {

        }
        else
        {
            q = itr->leaf().find(".savegame");
            if (q != string::npos)
            {
                strings.push_back(itr->leaf());
            }
        }
    }
}

---