testing.h

Go to the documentation of this file.

#include "cgame.h"

#include <sstream>

namespace Testing {
class CFPSGraphicalObserver : public CTextLabel, public IObserver {
public:
  CFPSGraphicalObserver(CPoint &pos, CFont *font) : CTextLabel("", pos, font) { }

  virtual void update(CModel *model) {
    std::stringstream streamer;

    streamer << "FPS: " << ((CFPSTimer *) model)->get_fps();

    set_text(streamer.str());
  }

  virtual int do_handle_event(CEvent &event) {
    if (event.get_type() == CEvent::TYPE_KEY_DOWN) {
      if (event.get_key_ascii_value() == 'f') {
              set_visible(!visible());
        return 1;
      }
    }
    return 0;
  }
};

class CPhysicsTickerModel : public ITickable, public CModel {
private:
  /* Acceleration vector of physics system, in pixels/msec^2. */
  double x_acc;
  double y_acc;
  /* Velocity vector of physics system, in pixels/msec. */
  double x_vel;
  double y_vel;
  /* Position of the box, in pixels. */
  double x;
  double y;
  /* Width and height of the box, in pixels. */
  int width, height;
  /* Width and height of the screen, in pixels. */
  int scr_width, scr_height;

public:
  CPhysicsTickerModel(CPoint &pos, int scr_width, int scr_height) : x(pos.x), y(pos.y),
    scr_width(scr_width), scr_height(scr_height) {

    x_acc = 0;
    y_acc = 0.0005;

    x_vel = 0.1;
    y_vel = 0;
  }

  void set_box_size(const CPoint &size) {
    width = size.x;
    height = size.y;
  }

  CPoint get_box_pos() {
    return CPoint((int) x, (int) y);
  }

  virtual void reverse_direction() {
    x_vel = -x_vel;
    y_vel = -y_vel;
  }

  virtual void tick(unsigned long time) {
    int old_x = (int) x;
    int old_y = (int) y;

    y_vel += (y_acc * time);
    x_vel += (x_acc * time);
    x += (x_vel * time);
    y += (y_vel * time);
    
    if (x + width > scr_width) {
      x_vel = -x_vel;
      x = scr_width - width;
    } else if (x < 0) {
      x_vel = -x_vel;
      x = 0;
    }

    if (y + height > scr_height) {
      y_vel = -y_vel;
      y = scr_height - height;
    } else if (y < 0) {
      y_vel = -y_vel;
      y = 0;
    }

    int new_x = (int) x;
    int new_y = (int) y;

    if (old_x != new_x || old_y != new_y) {
      notify();
    }
  }
};

class CPhysicsTickerObserver : public CColoredPanel, public IObserver {
  CPhysicsTickerModel *ticker;
  CTextLabel *label1;
  CFPSGraphicalObserver *panel1_fps_display;
  CFont *font;
  char reverse_direction_key;

public:
  CPhysicsTickerObserver(CPhysicsTickerModel *n_ticker, CPanel &parent,
                         CFont *font, CColor n_color, CRect &bounding_rect, char reverse_direction_key) : ticker(n_ticker), reverse_direction_key(reverse_direction_key),
    font(font), CColoredPanel(bounding_rect, n_color)
  {
    parent.add(*this);

    ticker->set_box_size(get_size());
    ticker->attach(this);

    CPoint text_point(5, 5);
    std::stringstream streamer;
    streamer << "Box " << reverse_direction_key;
    label1 = new CTextLabel(streamer.str().c_str(), text_point, font);

    add(*label1);

    CPoint fps_point(5, 20);

    panel1_fps_display = new CFPSGraphicalObserver(fps_point, font);
    CGame::get_instance().timer.attach(panel1_fps_display);

    add(*panel1_fps_display);    
  }

  virtual ~CPhysicsTickerObserver() {
    delete label1;
    delete panel1_fps_display;
  }

  virtual void update(CModel *model) {
    if (model == ticker) {
      set_pos(ticker->get_box_pos());
    }
  }

  virtual int do_handle_event(CEvent &event) {
    if (event.get_type() == CEvent::TYPE_KEY_DOWN) {
      if (event.get_key_ascii_value() == reverse_direction_key) {
        ticker->reverse_direction();
        return 1;
      }
    }
    return 0;
  }
};

void add_components(CGame &g, int num_boxes) {
  for (int i = 1; i < num_boxes+1; i++) {
    CPoint start(i*20, i*20);
    CPhysicsTickerModel *model = new CPhysicsTickerModel(start, 640, 480);

    CRect rect(0, 0, 100, 100);
    /* I actually ran into this color formula through a bug, but it
    makes for some very pretty color sequences so I decided to keep
    it. */
    CColor color(150-(i+3)*20, 150-(i+3)*30, 150-(i+3)*40);
    /* The '1' key on the keyboard. */
    const char KEY_ONE = '1';
    CPhysicsTickerObserver *view = new CPhysicsTickerObserver(model, g, g.get_font_small(),
   color, rect, KEY_ONE+(i-1));

    g.tickables.push_back(model);
  }

  CPoint displayer_pos(5,5);

  CFPSGraphicalObserver *fps_displayer = new CFPSGraphicalObserver(displayer_pos, g.get_font_large());

  g.timer.attach(fps_displayer);
  g.add(*fps_displayer);
}
}

---