flyhard-0.42/src/shop.cpp

/*
    shop.cpp - implements the shop function, which lets you buy nifty equipment
                (and badly needs cleaning up)
    Copyright (C) 2006,2008 Mark boyd

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be fun to play,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License along
    with this program; if not, write to the Free Software Foundation, Inc.,
    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/

#include "game.h"
#include "etc.h"
#include "text.h"
#include "shop.h"
#include "weapons.h"

//Positions of various UI elements in the shop.
namespace pos
{
  const int btn_width=100, btn_height=20; //standard button size
  const int connector_gap=20; //width of the gap between dep. buttons and object buttons.
  const int top_margin=30;    //Gap between top of rect and highest button
  const int bottom_margin=5;
  const int right_margin=5;
  const int left_margin=5;
  const int btn_ygap=5;       //Vertical gap between buttons
  const int btn_xgap=5;

  //TODO: this should depend on how much screen height we've got to work with
  const int max_visible_obj_btns=10; //If there are more than this, scrolling happens.

  SDL_Rect big_rect;  //Rect which the shop is allowed to draw in.  All other
                      //values are derived from this (and the constants).


  SDL_Rect left_panel;
  SDL_Rect right_panel;

  int obj_btn_left, obj_btn_right, obj_btn1_top;
  int obj_btn_scroll_top;

  int dep_btn_left, dep_btn_right, dep_btn1_top;
  int connector_x;

  SDL_Rect prev_rect, next_rect;
  std::vector<SDL_Rect> scroll_rects;
  std::vector<SDL_Rect> obj_rects; //use these of there is no scrolling

  int square; //scale factor for the big ship picture.

  int bottom_margin_y;  //y coord of the top of the bottom margin
  int right_margin_x;

  int desc_x, desc_y;

  void init(SDL_Rect *_big_rect)
  {
    big_rect=*_big_rect;

    left_panel=big_rect; left_panel.w=left_panel.w*2/3;
    right_panel=big_rect; right_panel.x=left_panel.x+left_panel.w; right_panel.w=big_rect.w-left_panel.w;

    obj_btn_left=right_panel.x;
    obj_btn_right=obj_btn_left+btn_width;
    obj_btn_scroll_top = top_margin+btn_height;

    dep_btn_left=right_panel.x-btn_width-connector_gap;
    dep_btn_right=dep_btn_left+btn_width;

    obj_btn1_top=dep_btn1_top=big_rect.y+top_margin;
    connector_x=(dep_btn_left+btn_width+obj_btn_left)/2;

    //scroll rects
    {
    scroll_rects.clear();
    int w_left=pos::obj_btn_left;
    int w_top=pos::obj_btn_scroll_top;
    int w_gap=pos::btn_ygap;
    int w_height=pos::btn_height;
    int w_width=pos::btn_width;

    for(int i=0; i<pos::max_visible_obj_btns-3; ++i) //-3 to make room for "prev" and "next" buttons.
    {
      SDL_Rect r={w_left,w_top+i*(w_height+w_gap), w_width, w_height};
      scroll_rects.push_back(r);
    }

    SDL_Rect rp={w_left,w_top-(w_height+w_gap)*3/2, w_width, w_height};
    prev_rect=rp;

    SDL_Rect rn={w_left,w_top+(w_height+w_gap)*(2*pos::max_visible_obj_btns-5)/2, w_width, w_height};
    next_rect=rn;
    }

    //obj rects
    {
      obj_rects.clear();

      int w_left=pos::obj_btn_left;
      int w_top=pos::obj_btn1_top;
      int w_gap=pos::btn_ygap;
      int w_height=pos::btn_height;
      int w_width=pos::btn_width;

      for(int i=0; i<pos::max_visible_obj_btns; ++i)
      {
        SDL_Rect r={w_left,w_top+i*(w_height+w_gap), w_width, w_height};
        obj_rects.push_back(r);
      }
    }

    SDL_Surface *ship_bmp=game::the_game->m_bmp_pool.get_bitmap("ship.png");
    square=std::min(pos::left_panel.w, pos::left_panel.h)*8/(10*std::max(ship_bmp->w, ship_bmp->h));

    bottom_margin_y=big_rect.y+big_rect.h-bottom_margin;
    right_margin_x = big_rect.x+big_rect.w-right_margin;

    desc_x=left_panel.x+left_panel.w*9/10;
    desc_y=right_panel.y+right_panel.h*2/3;
  }
}

bool point_in_rect(int x, int y, SDL_Rect rect)
{
  return (rect.x<x && x<rect.x+rect.w && rect.y<y && y< rect.y+rect.h);
}


namespace
{

  //the shop is in fact a department store :)
  enum department_id
  {
    D_WEAPONS,
    D_SYSTEMS,
    D_ENGINE,
  };

  department_id cur_department;
  int mount_width, mount_height;
}

void draw_button(SDL_Surface *surface, const std::string &text, SDL_Rect &rect, Uint32 colour)
{
  Uint32 white=SDL_MapRGB(surface->format, 255,255,255);

  SDL_FillRect(surface, &rect, colour);
  text::draw_centre(text, surface, rect.x+rect.w/2, rect.y+rect.h/2, white);
}


class department
{
public:
  department(int num_objects, SDL_Rect *button_rect)
  {
    m_num_objects=num_objects;
    m_scroll=0;
    m_selected=-1;
    m_button_rect=button_rect;
  }

  virtual void draw_stuff(){};

  void draw_obj_buttons(SDL_Surface *surface);
  void handle_click(int x, int y);

  virtual ~department(){} //Not really needed, shuts compiler up.


private:
  virtual void vhandle_click(int x,int y){};
  virtual std::string name(int)=0;

  int m_scroll;
  SDL_Rect *m_button_rect;

protected:
  int m_num_objects;
  int m_selected;
};

void department::draw_obj_buttons(SDL_Surface *surface)
{
  Uint32 button_col    =SDL_MapRGB(surface->format,  32, 32,64);
  Uint32 button_sel_col=SDL_MapRGB(surface->format,  64, 64,128);
  Uint32 white=SDL_MapRGB(surface->format, 255,255,255);

  if (m_num_objects > pos::max_visible_obj_btns)
  {
    //Draw with scrolling.
    for(int i=0; i<pos::scroll_rects.size(); ++i)
    {
      SDL_Rect r = pos::scroll_rects[i];
      SDL_FillRect(surface, &r, (i+m_scroll==m_selected)?button_sel_col:button_col);
      text::draw_centre(name(i+m_scroll), surface, r.x+r.w/2, r.y+r.h/2, white);

      int y=r.y+r.h/2;
      SDL_Rect r2={pos::connector_x,y-1, r.x-pos::connector_x, 2};
      SDL_FillRect(surface, &r2, button_col);
    }

    {
          int connector_y=m_button_rect->y+pos::btn_height/2;
          int top=std::min(pos::scroll_rects[0].y+pos::scroll_rects[0].h/2, connector_y);
          int bottom=std::max(pos::scroll_rects.back().y+pos::scroll_rects.back().h/2, connector_y);
          SDL_Rect r_conn={pos::connector_x-1, top, 2, bottom-top};
          SDL_FillRect(surface, &r_conn, button_col);
    }

    //prev/next buttons
    draw_button(surface, "Prev", pos::prev_rect, button_col);
    draw_button(surface, "Next", pos::next_rect, button_col);
  }
  else
  {

    //simple case: draw normally
    for(int i=0; i<m_num_objects; ++i)
    {
      SDL_Rect r = pos::obj_rects[i];
      SDL_FillRect(surface, &r, (i==m_selected)?button_sel_col:button_col);
      text::draw_centre(name(i), surface, r.x+r.w/2, r.y+r.h/2, white);

      int y=r.y+r.h/2;
      SDL_Rect r2={pos::connector_x,y-1, r.x-pos::connector_x, 2};
      SDL_FillRect(surface, &r2, button_col);
    }

    if (m_num_objects)
    {
      int connector_y=m_button_rect->y+pos::btn_height/2;
      int top=std::min(pos::obj_rects[0].y+pos::btn_height/2, connector_y);
      int bottom=std::max(pos::obj_rects[m_num_objects-1].y+pos::btn_height/2, connector_y);
      SDL_Rect r_conn={pos::connector_x-1, top, 2, bottom-top};
      SDL_FillRect(surface, &r_conn, button_col);
    }

  }
}

void department::handle_click(int click_x, int click_y)
{
  if (m_num_objects > pos::max_visible_obj_btns)
  {
    for(int i=0; i<pos::scroll_rects.size(); ++i)
      if(point_in_rect(click_x, click_y, pos::scroll_rects[i]))
      {
        m_selected=i+m_scroll;
      }

    //next/prev?
    if(point_in_rect(click_x, click_y, pos::prev_rect))
    {
      m_scroll=std::max(0, m_scroll-1);
    }
    if(point_in_rect(click_x, click_y,pos::next_rect))
    {
      m_scroll=std::min<int>(m_num_objects-(pos::max_visible_obj_btns-3), m_scroll+1);
    }
  }
  else
  {
    for(int i=0; i<m_num_objects; ++i)
      if(point_in_rect(click_x, click_y, pos::obj_rects[i]))
      {
        m_selected=i;
      }
  }

  vhandle_click(click_x, click_y);
}

//The departments hold whatever is different about different equipment types
//(common stuff goes in department)
class weapons_dpt:public department
{
public:
  weapons_dpt(SDL_Rect *br):department(weapon_types().size(),br)
  {
    m_selected_mount=-1;
  }

  std::string name(int i){return weapon_types()[i].name;}


  void draw_stuff(SDL_Surface* surface)
  {
    Uint32 white=SDL_MapRGB(surface->format, 255,255,255);

    //draw weapon mounts
    const int x_centre=pos::left_panel.x+pos::left_panel.w/2;
    const int y_centre=pos::left_panel.y+pos::left_panel.h/2;

    SDL_Surface *mount_bmp=game::the_game->m_bmp_pool.get_bitmap("weapon_point.png");
    mount_width=mount_bmp->w; mount_height=mount_bmp->h;
    int rot_size=3*(mount_bmp->w+mount_bmp->h)/2;
    if (rot_size%2)rot_size++;
    for (int i=0; i<game::the_game->m_weapon_mounts.size(); ++i)
    {
          const weapon_mount &m=game::the_game->m_weapon_mounts[i];

          //rotate the mount bitmap into a new bitmap;
          SDL_Surface *rotated;
          rotated=create_surface(rot_size, rot_size);
          rotate(mount_bmp, rotated, m.angle);


          SDL_Rect from={0,0, rotated->w,rotated->h};
          SDL_Rect to={int(x_centre+m.loc_x*pos::square-rotated->w/2),
                      int(y_centre+m.loc_y*pos::square-rotated->h/2),
                      rotated->w,rotated->h};
          SDL_BlitSurface(rotated, &from, surface, &to);

          SDL_FreeSurface(rotated);

          if (weapon_types()[m.type].shop_graphic)
          {
            SDL_Surface *weapon_bmp=game::the_game->m_bmp_pool.get_bitmap(weapon_types()[m.type].shop_graphic);

            rot_size=3*(weapon_bmp->w+weapon_bmp->h)/2;
            if (rot_size%2)rot_size++;

            rotated=create_surface(rot_size, rot_size);
            rotate(weapon_bmp, rotated, m.angle);
            SDL_Rect from={0,0, rotated->w,rotated->h};
            SDL_Rect to={int(x_centre+m.loc_x*pos::square-rotated->w/2),
                        int(y_centre+m.loc_y*pos::square-rotated->h/2),
                        rotated->w,rotated->h};
            SDL_BlitSurface(rotated, &from, surface, &to);

            SDL_FreeSurface(rotated);

          }
    }

        //Generic statussy things
        if (m_selected_mount>=0 && m_selected_mount < game::the_game->m_weapon_mounts.size())
        {
          const weapon_mount &wm=game::the_game->m_weapon_mounts[m_selected_mount];
          text::draw(std::string("Selected Mount: ")+wm.name+" ("+weapon_types()[wm.type].name+")",
                    surface, pos::left_margin, pos::bottom_margin_y-10, white);
          //todo: highlight selected mount?
        }

        //TODO: nasty magic numbers!!
        if (m_selected >=0 && m_selected < weapon_types().size())
        {
          int x=pos::desc_x;
          int y=pos::desc_y;
          const weapon_type &wt=weapon_types()[m_selected];
          text::draw(std::string("Selected Weapon: ")+wt.name, surface, x,y, white);
          y+=20;
          text::draw(wt.description, surface, x, y, white);
          y+=15;
          text::draw("Cost:        "+int2str(wt.cost), surface, x, y, white);
          y+=15;
          text::draw("Damage:      "+int2str(wt.damage), surface, x, y, white);
          y+=15;
          text::draw("Reload Time: "+int2str(wt.reload), surface, x, y, white);
          y+=15;
          text::draw("Recoil     : "+int2str(int(wt.recoil*100)), surface, x, y, white);
          y+=15;
          text::draw("Mass     : "+int2str(wt.mass), surface, x, y, white);
        }

  }

  void handle_buy()
  {


    if (m_selected_mount>=0 && m_selected_mount < game::the_game->m_weapon_mounts.size())
    {
      //This works in all cases because WT_NOTHING has a cost of 0.
      int trade_cost = weapon_types()[m_selected].cost -
          weapon_types()[game::the_game->m_weapon_mounts[m_selected_mount].type].cost;

      if(m_selected >=0 && m_selected < weapon_types().size()
          && game::the_game->m_player_status.money >= trade_cost)
      {
        game::the_game->m_player_status.money -=  trade_cost;
        game::the_game->m_weapon_mounts[m_selected_mount].type = weapon_id(m_selected);
      }
    }
  }

  void handle_sell()
  {
    if(m_selected_mount>=0 && m_selected_mount < game::the_game->m_weapon_mounts.size())
    {
      game::the_game->m_player_status.money +=  weapon_types()[game::the_game->m_weapon_mounts[m_selected_mount].type].cost;
      game::the_game->m_weapon_mounts[m_selected_mount].type = WT_NOTHING;
    }
  }

  void vhandle_click(int click_x, int click_y)
  {
    //todo: unduplicate these two
    const int x_centre=pos::left_panel.x+pos::left_panel.w/2;
    const int y_centre=pos::left_panel.y+pos::left_panel.h/2;

        //clicked on weapon mount?
        for (int i=0; i<game::the_game->m_weapon_mounts.size(); ++i)
        {
          const weapon_mount &m=game::the_game->m_weapon_mounts[i];
          float rel_x=click_x-(x_centre+m.loc_x*pos::square);
          float rel_y=click_y-(y_centre+m.loc_y*pos::square);
          float rot_x=1.0*rel_x*cos(-m.angle) - 1.0*rel_y*sin(-m.angle);
          float rot_y=1.0*rel_x*sin(-m.angle) - 1.0*rel_y*cos(-m.angle);
          if (-mount_width/2  < rot_x && rot_x < mount_width/2 &&
              -mount_height/2 < rot_y && rot_y < mount_height/2)
          {
            m_selected_mount=i;
          }
        }
  }

private:
  int m_selected_mount;
};

class engines_dpt:public department
{
public:
  engines_dpt(SDL_Rect *br):department(engine_types().size(),br){}
  std::string name(int i){return engine_types()[i].name;}

  void draw_stuff(SDL_Surface *surface)
  {
    Uint32 white=SDL_MapRGB(surface->format, 255,255,255);
    const float gravity = game::the_game->m_arena->gravity();
    const engine_type &et = engine_types()[game::the_game->m_engine];

    //TODO: unduplicate x_centre, y_centre
    const int x_centre=pos::left_panel.x+pos::left_panel.w/2;
    const int y_centre=pos::left_panel.y+pos::left_panel.h/2;
    int x=x_centre-100;
    int y=y_centre-100;
    int y_gap=15;

    text::draw(std::string("Current Engine: ")+et.name, surface, x,y, white);
    y+=y_gap;
    text::draw(std::string("Thrust: ")+int2str(int(et.thrust)), surface,x,y,white);
    y+=y_gap;
    text::draw(std::string("Weight(normal/loaded): ")+int2str(int(gravity*calc_ship_mass()))+
                        "/"+int2str(int(gravity*(calc_ship_mass()+ball_mass))), surface,x,y,white);
    y+=2*y_gap;
    text::draw(std::string("Ship Mass: ")+int2str(calc_ship_mass()), surface,x,y,white);
    y+=2*y_gap;
    text::draw(std::string("Ship Acceleration: ")+int2str(int(et.thrust/calc_ship_mass())), surface,x,y,white);


    if (m_selected>=0 && m_selected < m_num_objects)
    {
          const engine_type &eng=engine_types()[m_selected];
          int x=pos::left_panel.x+pos::left_panel.w*9/10;
          int y=pos::right_panel.y+pos::right_panel.h*2/3;
          int y_gap=15;

          text::draw(std::string("Selected Engine: ")+eng.name, surface, x,y, white);
          y+=2*y_gap;
          text::draw(eng.description, surface, x, y, white);
          y+=y_gap;
          text::draw("Cost:        "+int2str(eng.cost), surface, x, y, white);
          y+=y_gap;
          text::draw("Thrust:      "+int2str(int(eng.thrust*100)), surface, x, y, white);
          y+=y_gap;
          text::draw("Mass:        "+int2str(eng.mass), surface, x, y, white);
          y+=y_gap;
    }
  }

  void handle_buy()
  {
    if(m_selected>=0 && m_selected<m_num_objects
       && game::the_game->m_player_status.money >= engine_types()[m_selected].cost)
    {
      game::the_game->m_player_status.money +=  engine_types()[game::the_game->m_engine].cost;
      game::the_game->m_player_status.money -=  engine_types()[m_selected].cost;
      game::the_game->m_engine = engine_id(m_selected);
    }
  }
};

class systems_dpt:public department
{
public:
  systems_dpt(SDL_Rect *br):department(system_types().size(),br)
  {
    m_selected_slot=-1;

    m_mount_bmp=game::the_game->m_bmp_pool.get_bitmap("s_system_mount.png");
    for(int i=0; i<system_slots; ++i)
    {
      int gap=2;
      int x_centre=pos::left_panel.x+pos::left_panel.w/2;
      int y_centre=pos::left_panel.y+pos::left_panel.h/2;
      int x=x_centre+int( (1.0*(i%4)-1.5)*(m_mount_bmp->w+2*gap)-m_mount_bmp->w/2 );
      int y=y_centre+int( (i/4-2)*(m_mount_bmp->h+2*gap)-m_mount_bmp->h/2 );
      SDL_Rect r={x,y,m_mount_bmp->w,m_mount_bmp->h};
      m_mount_rects.push_back(r);
    }
  }

  std::string name(int i){return system_types()[i].name;}

  void draw_stuff(SDL_Surface *surface)
  {
        Uint32 button_col    =SDL_MapRGB(surface->format,  32, 32,64);
        Uint32 white=SDL_MapRGB(surface->format, 255,255,255);

        //system mounts
        for(int i=0; i<m_mount_rects.size(); ++i)
        {
          if (i==m_selected_slot)
          {
            SDL_FillRect(surface, &(m_mount_rects[i]), button_col);
          }

          SDL_Rect from={0,0,m_mount_rects[i].w, m_mount_rects[i].h};
          SDL_BlitSurface(m_mount_bmp, &from, surface, &(m_mount_rects[i]));

          if (system_types()[game::the_game->m_systems[i]].shop_graphic)
          {
            SDL_Surface *bmp=game::the_game->m_bmp_pool.get_bitmap(system_types()[game::the_game->m_systems[i]].shop_graphic);
            SDL_Rect src={0,0,bmp->w, bmp->h};
            SDL_Rect dest={m_mount_rects[i].x+(m_mount_rects[i].w-bmp->w)/2,
                           m_mount_rects[i].y+(m_mount_rects[i].h-bmp->h)/2, bmp->w, bmp->h};
            SDL_BlitSurface(bmp, &src, surface, &dest);
          }
        }


        //Current system
        //TODO: move constants into pos!
        if(m_selected>=0 && m_selected<m_num_objects)
        {
          const system_type &st=system_types()[m_selected];
          int x=pos::desc_x;
          int y=pos::desc_y;
          int y_gap=15;

          text::draw(std::string("Selected System: ")+st.name, surface, x,y, white);
          y+=2*y_gap;
          text::draw(st.description, surface, x, y, white);
          y+=y_gap;
          text::draw("Cost:  "+int2str(st.cost), surface, x, y, white);
          y+=y_gap;
          text::draw("Mass:  "+int2str(st.mass), surface, x, y, white);
          y+=y_gap;
        }
  }

  void vhandle_click(int x, int y)
  {
    for(int i=0; i<m_mount_rects.size(); ++i)
      if(point_in_rect(x, y, m_mount_rects[i]))
      {
        m_selected_slot=i;
      }
  }

  void handle_buy()
  {
    if(m_selected_slot>=0 && m_selected_slot < system_slots
       && m_selected>=0 && m_selected < m_num_objects
       && game::the_game->m_player_status.money >= system_types()[m_selected].cost)
        {
          game::the_game->m_player_status.money +=  system_types()[game::the_game->m_systems[m_selected_slot]].cost; //autosell existing item
          game::the_game->m_player_status.money -=  system_types()[m_selected].cost;
          game::the_game->m_systems[m_selected_slot]=system_id(m_selected);
        }
  }

  void handle_sell()
  {
    if(m_selected_slot>=0 && m_selected_slot < system_slots)
    {
      game::the_game->m_player_status.money +=  system_types()[game::the_game->m_systems[m_selected_slot]].cost;
      game::the_game->game::the_game->m_systems[m_selected_slot] = ST_EMPTY;
    }
  }

private:
  int m_selected_slot;
  std::vector<SDL_Rect> m_mount_rects;
  SDL_Surface *m_mount_bmp;
};


//Draw ship, centred at coords, scaled by "square"
void draw_ship_background(SDL_Surface *screen, int x_centre, int y_centre, int square)
{
  Uint32 black=SDL_MapRGB(screen->format, 0,0,0);
  SDL_Surface *ship_bmp=game::the_game->m_bmp_pool.get_bitmap("ship.png");
  SDL_Surface *tile=create_surface(square,square);

  const int left=x_centre-(square*ship_bmp->w)/2;
  const int top =y_centre-(square*ship_bmp->h)/2;

  SDL_Rect from={0,0,square,square};
  SDL_Rect to=from;
  SDL_FillRect(screen, 0, black);
  SDL_LockSurface(ship_bmp);
  for(int x=0; x<ship_bmp->w; ++x)
    for(int y=0; y<ship_bmp->h; ++y)
    {
      Uint8 r,g,b,a;
      SDL_GetRGBA(getpixel(ship_bmp, x, y), ship_bmp->format, &r,&g,&b,&a);
      float darken=0.4;
      r=int(darken*r);g=int(darken*g);b=int(darken*b);
      SDL_FillRect(tile, 0, SDL_MapRGBA(tile->format, r, g, b, a));
      SDL_UpdateRect(tile,0,0,0,0);
      to.x=left+x*square; to.y=top+y*square;
      SDL_BlitSurface(tile, &from, screen, &to);
    }
  SDL_UnlockSurface(ship_bmp);

  SDL_FreeSurface(tile);
}


//Here's the main shop function.
void shop(SDL_Surface *screen, SDL_Rect *draw_rect)
{
  SDL_ShowCursor(SDL_ENABLE);

  //initialise stuff
  cur_department = D_WEAPONS;

  Uint32 black=SDL_MapRGB(screen->format, 0,0,0);
  Uint32 button_col    =SDL_MapRGB(screen->format,  32, 32,64);
  Uint32 button_sel_col=SDL_MapRGB(screen->format,  64, 64,128);

  pos::init(draw_rect);

  //centre of left_panel
  const int x_centre=(pos::left_panel.x+pos::left_panel.w)/2;
  const int y_centre=(pos::left_panel.y+pos::left_panel.h)/2;

  const int btn_sep=pos::btn_height+pos::btn_ygap;
  SDL_Rect weapons_btn={pos::dep_btn_left,pos::dep_btn1_top          , pos::btn_width,pos::btn_height};
  SDL_Rect systems_btn={pos::dep_btn_left,pos::dep_btn1_top+btn_sep  , pos::btn_width,pos::btn_height};
  SDL_Rect engine_btn ={pos::dep_btn_left,pos::dep_btn1_top+2*btn_sep, pos::btn_width,pos::btn_height};

  SDL_Rect buy,sell,exit;
  {
    int y=pos::bottom_margin_y-pos::btn_height,  w=pos::btn_width/2,  h=pos::btn_height;
    SDL_Rect b ={pos::right_margin_x-3*(w+pos::btn_xgap), y,w,h}; buy=b;
    SDL_Rect s ={pos::right_margin_x-2*(w+pos::btn_xgap), y,w,h}; sell=s;
    SDL_Rect e ={pos::right_margin_x-1*(w+pos::btn_xgap), y,w,h}; exit=e;
  }


  weapons_dpt weapons(&weapons_btn);
  engines_dpt engines(&engine_btn);
  systems_dpt systems(&systems_btn);


  //main loop
  const int frame=40;
  bool abort=false;
  do
  {

      bool click=false;
      int click_x=0, click_y=0;
      int time=SDL_GetTicks();

      //Get input
      SDL_Event event;
      while (SDL_PollEvent(&event))
      {
        if (event.type==SDL_KEYDOWN)
        {
          if (event.key.keysym.sym==SDLK_ESCAPE) abort=true;;
        }
        else if (event.type==SDL_MOUSEBUTTONDOWN)
        {
          click=true;
          click_x=event.button.x;
          click_y=event.button.y;
        }
        if (event.type==SDL_KEYUP) //todo: unduplicate this!
        {
          if (event.key.keysym.sym==SDLK_UP) game::the_game->m_key_flags.up=false;
          if (event.key.keysym.sym==SDLK_LEFT) game::the_game->m_key_flags.left=false;
          if (event.key.keysym.sym==SDLK_RIGHT) game::the_game->m_key_flags.right=false;
          if (event.key.keysym.sym==SDLK_z) game::the_game->m_key_flags.tractor=false;
          if (event.key.keysym.sym==SDLK_SPACE) game::the_game->m_key_flags.fire=false;
        }
      }


    //Draw stuff...
    draw_ship_background(screen, x_centre, y_centre, pos::square);

    //shop department buttons
    draw_button(screen, "Weapons", weapons_btn, (cur_department==D_WEAPONS)?button_sel_col:button_col);
    draw_button(screen, "Systems", systems_btn, (cur_department==D_SYSTEMS)?button_sel_col:button_col);
    draw_button(screen, "Engine", engine_btn,   (cur_department==D_ENGINE)?button_sel_col:button_col);
    {
      int connector_y=(cur_department==D_WEAPONS)?(weapons_btn.y+weapons_btn.h/2):
                      (cur_department==D_SYSTEMS)?(systems_btn.y+systems_btn.h/2):
                                                  (engine_btn.y+engine_btn.h/2);
      SDL_Rect r={pos::dep_btn_right, connector_y-1, pos::connector_gap/2, 2};
      SDL_FillRect(screen, &r, button_col);
    }

    switch(cur_department)
    {
    case D_WEAPONS:
      weapons.draw_stuff(screen);
      weapons.draw_obj_buttons(screen);
      break;

      case D_ENGINE:
        engines.draw_stuff(screen);
        engines.draw_obj_buttons(screen);
        break;

      case D_SYSTEMS:
        systems.draw_stuff(screen);
        systems.draw_obj_buttons(screen);
        break;
    }

    //buy/sell/exit butons
    draw_button(screen, "Buy",  buy, button_col);
    draw_button(screen, "Sell", sell, button_col);
    draw_button(screen, "Exit", exit, button_col);


    if (click)
    {
      if (point_in_rect(click_x, click_y, weapons_btn)) cur_department=D_WEAPONS;
      if (point_in_rect(click_x, click_y, systems_btn)) cur_department=D_SYSTEMS;
      if (point_in_rect(click_x, click_y, engine_btn)) cur_department=D_ENGINE;

      switch(cur_department)
      {
      case D_WEAPONS:
        weapons.handle_click(click_x, click_y);
        if (point_in_rect(click_x, click_y, buy))
          weapons.handle_buy();

        if (point_in_rect(click_x, click_y, sell))
          weapons.handle_sell();

        break;

      case D_SYSTEMS:
        systems.handle_click(click_x, click_y);

        if (point_in_rect(click_x, click_y, buy))
          systems.handle_buy();

        if (point_in_rect(click_x, click_y, sell))
          systems.handle_sell();

        //stuff may need updating
        game::the_game->m_player_status.max_energy=calc_ship_battery();
        break;

      case D_ENGINE:
        engines.handle_click(click_x, click_y);

        if (point_in_rect(click_x, click_y, buy))
          engines.handle_buy();

        break;
      }

    if (point_in_rect(click_x, click_y, exit)) abort=true;
    }


    update_player_status(screen);
    SDL_UpdateRect(screen,0,0,0,0);

    SDL_Delay(std::max<int>(0, time+frame-SDL_GetTicks()));

  }while(!abort);
  //End of main loop


  game::the_game->m_player_status.in_shop=false;
  SDL_ShowCursor(SDL_DISABLE);

  //clear screen
  SDL_FillRect(screen, 0, black);
  SDL_UpdateRect(screen, 0,0,0,0);
}