bouncy.h

Go to the documentation of this file.

/***************************************************************************
                          bouncy.h  -  description
                             -------------------
    begin                : Tue Jun 10 2003
    copyright            : (C) 2003 by Tyler Montbriand
    email                : tsm@accesscomm.ca
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 ***************************************************************************/
#ifndef __BOUNCY_H__
#define __BOUNCY_H__

#include <spritelib/sprite.h>
#include "screen.h"

#define BOUNCY_VELOCITY 300

inline Sfxp v1_final(int m1, int m2, Sfxp v1, Sfxp v2)
{
  return(((v1*(m1-m2))+(v2*2*m2))/(m1+m2));
}

inline Sfxp v2_final(int m1, int m2, Sfxp v1, Sfxp v2)
{
  return(((v1*2*m1)+ (v2*(m2-m1)))/(m1+m2));
}

inline void ElasticCollide2(Sprite *spr1, Sprite *spr2)
{
  int m1=1, m2=1;
  SfxpCoord v1f,v2f;

  /* Calculate angle between objects  */
  Sfxp a=((spr2->Pos())-(spr1->Pos())).Trajectory();

  /* Calculate initial velocities of objects */
  Sfxp v1=spr1->Vel().Magnitude();
  /* Velocity is relative */
  Sfxp v2=spr2->Vel().Magnitude()-v1;

  /* Calculate final velocities */
  Sfxp v1f_=v1_final(m1,m2,v1,v2);
  Sfxp v2f_=v2_final(m1,m2,v1,v2);

  /* Put the velocities back in terms of X and Y */
  v1f.Vector(v1f_,a);
  v2f.Vector(v2f_,a);
  
  /* Set the new velocities */
  spr1->SetVel(v1f);
  spr2->SetVel(v2f);      
}

inline void MoveApart(Sprite *spr1, Sprite *spr2)
{
  if(spr1->CanCollide(spr2))
  {  
    bitmask *b1=spr1->GetBitmask();
    Sfxp x1=spr1->Xfxp();
    Sfxp y1=spr1->Yfxp();

    bitmask *b2=spr2->GetBitmask();
    Sfxp x2=spr2->Xfxp();
    Sfxp y2=spr2->Yfxp();

    Sfxp dx=x2-x1;
    Sfxp dy=y2-y1;

    while(bitmask_overlap(b1,b2,FROM_SFXP(dx),FROM_SFXP(dy)))
    {
      x1-=(dx/20);
      y1-=(dy/20);

      x2+=(dx/20);
      y2+=(dy/20);

      dx=x2-x1;
      dy=y2-y1;                  
    }
    spr1->MoveTo(x1,y1);
    spr2->MoveTo(x2,y2);
  }   
}


class Bouncy:public Sprite
{
public:
  virtual void OnCollide(const Sprite *spr, ColType index)
  {
    MoveApart(this,(Sprite *)spr);
    ElasticCollide2(this,(Sprite *)spr);
    AdvanceFrame();
  }

  Bouncy():Sprite()
  {
    SetFlags(SPRITE_DELETEABLE);
    MoveTo(TO_SFXP(rand()%SCREEN_W),TO_SFXP(rand()%SCREEN_H));
    vel.Vector(BOUNCY_VELOCITY,DEG_TO_AFXP(rand()%360));
  }

  virtual void Update(Sint32 dtick)
  {
    if(Xfxp()<XMin())
    {
      pos.SetFxp(XMin(),Yfxp());
      ReverseXVelocity();
      AdvanceFrame();
    }
    else if(Xfxp()>=XMax())
    {
      pos.SetFxp(XMax(),Yfxp());      
      ReverseXVelocity();
      AdvanceFrame();      
    }

    if(Yfxp()<YMin())
    {
      pos.SetFxp(Xfxp(),YMin());
      ReverseYVelocity();
      AdvanceFrame();      
    }
    else if(Yfxp()>YMax())
    {
      pos.SetFxp(Xfxp(),YMax());
      ReverseYVelocity();
      AdvanceFrame();      
    }

    Sprite::Update(dtick);    
  }
  
protected:
  inline Sfxp XMin()  const { return(0);  }
  inline Sfxp YMin()  const { return(0);  }
  inline Sfxp XMax()  const { return(TO_SFXP(SCREEN_W)-TO_SFXP(frames.w));  }
  inline Sfxp YMax()  const { return(TO_SFXP(SCREEN_H)-TO_SFXP(frames.h));  }

  inline void AdvanceFrame()
  {
    frame+=TO_SFXP(1);
    frame%=TO_SFXP(frames.x*frames.y);
    CalcFrame();
  }
};


#endif/*__BOUNCY_H__*/

---