ClassicSimulator.cpp

/*	Quantum Minigolf, a computer game illustrating quantum mechanics
	Copyright (C) 2007 Friedemann Reinhard <friedemann.reinhard@gmail.com>

	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 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 this program; if not, write to the Free Software
	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/


#include "ClassicSimulator.h"

ClassicSimulator::ClassicSimulator (int width, int height,
				    Renderer * renderer, int holex, int holey,
				    int holer)
{
  this->width = width;
  this->height = height;
  this->renderer = renderer;

  this->holex = holex;
  this->holey = holey;
  this->holer = holer;
}

ClassicSimulator::~ClassicSimulator (void)
{

}

void
ClassicSimulator::setPosition (float x, float y)
{
  pos[0] = x;
  pos[1] = y;
}

void
ClassicSimulator::setVelocity (float vx, float vy)
{
  vel[0] = vx, vel[1] = vy;
}


//propagate - propagation of the classical ball during dt milliseconds
//
// it propagates the ball in mini-steps, each moving forward oonly one pixel
// according to the following scheme
//
//      1. move the ball one pixel ("trial move")
//  2. check for a wall collision (either with the hole or the
//     "hard" part of the potential)
//         In case of a collision, undo the trial move and change the velocity
//  3. Modify the velocity according to the soft potential
//  4. apply friction
//  5. goto 1
int
ClassicSimulator::propagate (Uint32 dt)
{

  float speed = sqrt (vel[0] * vel[0] + vel[1] * vel[1]);

  // determine, how much 1-pixel will be neccessary during dt
  int steps = (int) (speed * dt);
  float t, tic = 1 / speed;	// tic: time increment during a 1-pixel step

  // normalized components of the velocity
  float nvx = vel[0] / speed;
  float nvy = vel[1] / speed;

  float slow = .001, shrink;

  Uint32 *sdat = (Uint32 *) (soft->pixels);
  Uint32 *hdat = (Uint32 *) (hard->pixels);

  bool hit = false;		// have we hit a wall ?

  int x, y, xx, yy, xl, xu, yl, yu;
  float wx, wy, wn;		// direction of the wall normal and wall vector length at a collision
  unsigned char pot = 0, mops;
  unsigned char lpot, rpot, upot, dpot;	//potentials left /right / up /down the current position
  // used to compute potential gradient;
  bool inhole;

  // do steps iterations, each tic long, moving each time one pixel
  // tic may change during the propagation due to a changing speed !
  for (t = 0; t < dt; t += tic)
    {

      //check whether we are in the hole
      inhole = (holer * holer >
		(pos[0] - holex) * (pos[0] - holex) +
		(pos[1] - holey) * (pos[1] - holey));

      // move the ball forward one pixel, check for collision
      pos[0] += nvx;
      pos[1] += nvy;
      x = (int) (pos[0]);
      y = (int) (pos[1]);
      if (pos[0] < 5)
	pos[0] = 5;
      if (pos[0] > width - 5)
	pos[0] = width - 5;
      if (pos[1] < 5)
	pos[1] = 5;
      if (pos[1] > height - 5)
	pos[1] = height - 5;

      // check whether we have left the hole, if so, simulate a wall
      // collision to reflect from the hole wall
      if (inhole && (holer * holer <
		     (pos[0] - holex) * (pos[0] - holex) +
		     (pos[1] - holey) * (pos[1] - holey)))
	{
	  hit = true;
	  wx = pos[0] - holex;
	  wy = pos[1] - holey;
	  wn = sqrt (wx * wx + wy * wy);
	  wx /= wn;
	  wy /= wn;
	}
      // check whether we have collided with a potential wall
      SDL_GetRGB (hdat[y * width + x], hard->format, &pot, &mops, &mops);
      if (pot == 255)
	{			// collision detected, determine the wall normal
	  // by taking the potential-weighted position average
	  // in the 8x8 square around as
	  hit = true;
	  wx = 0;
	  wy = 0;
	  xl = x - 3;
	  if (xl < 0)
	    xl = 0;
	  xu = x + 4;
	  if (xu > width)
	    xu = width;
	  yl = y - 3;
	  if (xl < 0)
	    yl = 0;
	  yu = y + 4;
	  if (yu > height)
	    yu = height;

	  for (xx = xl; xx < xu; xx++)
	    {
	      for (yy = yl; yy < yu; yy++)
		{
		  SDL_GetRGB (hdat[yy * width + xx], hard->format,
			      &pot, &mops, &mops);
		  wx += pot * (x - xx);
		  wy += pot * (y - yy);
		}
	    }
	  wn = sqrt (wx * wx + wy * wy);
	  wx /= wn;
	  wy /= wn;
	}
      // we have been hit and know the wall normal
      // => undo test move to get off from the wall
      if (hit)
	{
	  pos[0] -= nvx;
	  pos[1] -= nvy;
	  x = (int) (pos[0]);
	  y = (int) (pos[1]);

	  float sp = vel[0] * wx + vel[1] * wy;
	  float cvx = vel[0] - sp * wx;
	  float cvy = vel[1] - sp * wy;
	  vel[0] = -wx * sp + cvx;
	  vel[1] = -wy * sp + cvy;

	  nvx = vel[0] / speed;
	  nvy = vel[1] / speed;
	  hit = false;
	}

      //change velocity according to potential gradient
      if (y > 0 && y < height - 1 && x > 0 && x < width - 1)
	{
	  SDL_GetRGB (sdat[y * width + x - 1], soft->format, &lpot, &mops,
		      &mops);
	  SDL_GetRGB (sdat[y * width + x + 1], soft->format, &rpot, &mops,
		      &mops);
	  SDL_GetRGB (sdat[(y - 1) * width + x], soft->format, &upot, &mops,
		      &mops);
	  SDL_GetRGB (sdat[(y + 1) * width + x], soft->format, &dpot, &mops,
		      &mops);
	  vel[0] -= .002 / 1.2 * tic * (rpot - lpot);
	  vel[1] += .002 / 1.2 * tic * (upot - dpot);
	}

      //simulate friction and update tic length due to changed speed
      speed = sqrt (vel[0] * vel[0] + vel[1] * vel[1]);
      shrink = 1 - tic * slow / speed;
      if (shrink <= 0)
	shrink = 0;
      speed *= shrink;
      vel[0] *= shrink;
      vel[1] *= shrink;
      if (speed == 0)
	tic = 1e4;
      else
	tic = 1 / speed;
    }

  if (speed == 0)
    return 1;
  else
    return 0;
}