GameRunner.hh

Go to the documentation of this file.

 
#include "Serialize.hh"
#include "Graph.hh"
#include "GameApi.hh"
#include "State.hh"
 
ArrayRender *FindRender(GameApi::Env &e, int bm_id);
 
struct SpritePriv;
 
Sprite *sprite_from_handle(GameApi::Env &e, SpritePriv &env, BitmapHandle *handle, int bbm_choose=-1);
 
struct PolyPriv
{
  std::map<int, ArrayRender*> rend;
  std::map<int, StateBitmaps*> states;
  ~PolyPriv();
};
 
 
struct SpritePriv
{
  //ArrayRender rend;
  //MOVED To env: std::map<int, ArrayRender*> renders;
  std::map<int, Sprite*> sprites;
  std::map<int, Sprite*> sprites2;
  std::vector<Sprite**> arrays;
  ~SpritePriv();
};
 
 
#if 0
class Sequencer2
{
  // ranges [0..x] are described by two events, 0, and x.
public:
  // time
  virtual int NumEvents() const=0;
  virtual EventInfo Event(int i) const=0;
 
  virtual int NumLinks() const=0;
  virtual LinkageInfo Linkage(int i) const=0;
  virtual LinkInfo Links(int i) const=0;
  // positions
  virtual int NumPositions() const=0;
  virtual PosInfo Positions(int i) const=0;
  // states
  virtual int NumStates() const=0;
  virtual StateInfo2 States(int i) const=0;
};
#endif
 
StateBitmaps * PrepareFaceCollPolyHandle(FaceCollPolyHandle *handle, int bbm_choose);
 
 
class GameRunner
{
public:
  GameRunner(GameApi::Env &e, Sequencer2 &seq, int start_state) :  seq(seq), start_state(start_state), current_time(0.0),e(e) { }
  void run();
private: 
  int MoveToNextState(int state, float time)
  {
    return state;
  }
  void Alloc()
  {
    int s = seq.NumStates();
    for(int st=0;st<s;st++)
      {
    StateInfo2 si = seq.States(st);
    std::vector<ArrayRender*> *vec = new std::vector<ArrayRender*>;
    state_rends.push_back(vec);
    if (si.enable_obj_array)
      {
        int c = si.enable_obj_array->Size();
        for(int i=0;i<c;i++)
          {
        vec->push_back(new ArrayRender(g_low));
          }
      }
    PrepareState(st);
      }
  }
  void PrepareState(int state)
  {
    StateInfo2 st = seq.States(current_state);
    if (st.enable_obj_array)
      for(int i=0;i<st.enable_obj_array->Size();i++)
    {
      if (st.enable_obj_array->Index(i))
        { // object number i is enabled in this state
          PosInfo p = seq.Positions(i);
          Point pos(0.0,0.0,0.0);
          int link_id = p.link_id;
          LinkInfo linkinfo = seq.Links(link_id);
          FaceCollPolyHandle *polygon_start = linkinfo.polygon_start;
          //FaceCollPolyHandle *polygon_end = linkinfo.polygon_end;
          BitmapHandle *bitmap_start = linkinfo.bitmap_start;
          //BitmapHandle *bitmap_end = linkinfo.bitmap_end;
          if (polygon_start)
             {
               StateBitmaps *state_bm = PrepareFaceCollPolyHandle(polygon_start, 0); // TODO bbm_choose
               polys.states[i] = state_bm;
             }
          else if (bitmap_start)
        {
          ::Sprite *sprite = sprite_from_handle(e, sprites, bitmap_start, -1);
          if (!sprite) { std::cout << "preparesprite in running the game\n" << std::endl; return; }
          PrepareSprite(*sprite, *FindRender(e,i));
        }
        }
      
    }
  }
  bool BetweenEvents(const LinkageInfo &li)
  {
    int start_event = li.start_event;
    int end_event = li.end_event;
    EventInfo e = seq.Event(start_event);
    EventInfo e2 = seq.Event(end_event);
    if (e.time < current_time && current_time < e2.time) 
      return true;
    return false;
  }
 
  void UpdateActivatedEvents(float time_delta, std::vector<int> key_pressed, std::vector<int> key_released)
  {
    //float newtime = time + time_delta;
    int s = seq.NumEvents();
    for(int i=0;i<s;i++)
      {
    //EventInfo ei = seq.Event(i);
    
      }
  }
  float EventInterpolatePos(LinkageInfo li)
  {
    int start_event = li.start_event;
    int end_event = li.end_event;
    EventInfo e = seq.Event(start_event);
    EventInfo e2 = seq.Event(end_event);
    float time = current_time - e.time;
    float pos = time / (e2.time - e.time); // 0.0 .. 1.0
    return pos;
 
  }
 
  void RenderState(int state)
  {
    StateInfo2 st = seq.States(current_state);
    if (st.enable_obj_array)
      for(int i=0;i<st.enable_obj_array->Size();i++)
    {
      if (st.enable_obj_array->Index(i))
        { // object number i is enabled in this state
          PosInfo p = seq.Positions(i);
          Point pos(0.0,0.0,0.0);
          int link_id = p.link_id;
          LinkageInfo linkage = seq.Linkage(link_id);
          if (BetweenEvents(linkage))
        {
          float val = EventInterpolatePos(linkage);
          if (p.curve)
            {
              std::vector<float> c = p.curve->Count();
              switch(c.size())
            {
            case 0: // Point
              {
            pos = p.curve->Map(NULL, 0);
            break;
              }
            case 1: // Curve : float->Point
              {
                pos = p.curve->Map(&val, 1);
                break;
              }
            default:
              {
                std::cout << "ERROR: bad curve dimension\n" << std::endl;
                break;
              }
            };
 
            }
           LinkInfo linkinfo = seq.Links(link_id);
           FaceCollPolyHandle *polygon_start = linkinfo.polygon_start;
           //FaceCollPolyHandle *polygon_end = linkinfo.polygon_end;
           BitmapHandle *bitmap_start = linkinfo.bitmap_start;
           //BitmapHandle *bitmap_end = linkinfo.bitmap_end;
           if (polygon_start)
             {
               StateBitmaps *state_bm = polys.states[i];
               state_bm->Render(0); // TODO 0..
             }
           else if (bitmap_start)
             {
               ::Sprite *sprite = sprites.sprites[i];
               Point2d p = { pos.x, pos.y };
               float z = 0.0;
               Program *prog = 0;
               RenderSprite(*sprite, 0, p, z, *FindRender(e,i), prog);
             }
        }
        }
    }
  }
 
private:
  Sequencer2 &seq;
  int start_state;
 
  std::map<int, EventInfo> activated_events;
  //float time;
 
  float current_time;
  int current_state;
  std::vector< std::vector<ArrayRender*>* > state_rends;
  SpritePriv sprites;
  PolyPriv polys;
  GameApi::Env &e;
};