Codebase list bumprace / upstream/1.5.4 src / particles.c
upstream/1.5.4

Tree @upstream/1.5.4 (Download .tar.gz)

particles.c @upstream/1.5.4 — raw · history · blame 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
#include "bumprace.h"
#include "math.h"
#include "stdlib.h"

#define PARTICLE_LIFETIME 13
#define PARTICLES_OF_EXHAUST 300
typedef struct
{
  float Lifetime;     // Lifetime of the current Particle
  float X;          // X coordinate
  float Y;          // Y coordinate
  float dX;         // delta X for each Particle frame
  float dY;         // delta Y for each Particle frame
  int R, G, B;      // Red, Green, and Blue for Particle
} Particle;

Particle particles[ 300 ];

int NullParticle=0;   // The NullParticle is the # of the last legal particle.
                    // Cannot reach PARTICLES_OF_EXHAUST!

#define PARTICLE_COLORS 5
int ParticleColorsR[] = { 255, 255, 200, 200, 80 };
int ParticleColorsG[] = { 255, 190, 90, 20,  0};
int ParticleColorsB[] = { 0, 0 ,   0,   50,   255 };

void UndrawParticles()
{
  int i;
  for( i = 0; i < NullParticle; i++ )
  {
    Particle* ThisParticle = &particles[ i ];
      if( (int)ThisParticle->X >= 0 )
        if( (int)ThisParticle->X < 800 )
          if( (int)ThisParticle->Y >= 0 )
            if( (int)ThisParticle->Y < 600 )
	      PutBackPixel( Screen, (int)ThisParticle->X, (int)ThisParticle->Y );
  }
}

void HandleParticles()
{
  int i;

  for( i = 0; i < NullParticle; i++ )
  {
    Particle* ThisParticle = &particles[ i ];

    ThisParticle->Lifetime-=game_speed/(float)1000;
    if( ThisParticle->Lifetime <= 0 )
    {
      // Delete this particle
      if( i != NullParticle -1 )
      {
        // We aren't the end particle, so we have to preserve the end.
        Particle* OtherParticle = &particles[ NullParticle - 1 ];
        *ThisParticle = *OtherParticle; // Default: Memberwise Assignment
      }
      NullParticle--;
      i--; // Do this cell once more...
    }
    else
    {
      int MorphColor;

      // Move this particle
      ThisParticle->X += ThisParticle->dX*game_speed;
      ThisParticle->Y += ThisParticle->dY*game_speed;
      ThisParticle->dY+= gravity/(float)2000;
      // printf("%f\t%f\n",ThisParticle->dX*game_speed,ThisParticle->dY*game_speed);

      MorphColor = 0;
      switch( (int)ThisParticle->Lifetime )
      {
        case 25:
        case 20: MorphColor = 1; break;
	case 8:
        case 2: MorphColor = -1; break;
      }
      ThisParticle->R += MorphColor;
      ThisParticle->G += MorphColor;
      ThisParticle->B += MorphColor;
      // Strangely enough, it looks better *WITHOUT* the logical constraints!
      //	    if (ThisParticle->R>255) ThisParticle->R=255;
      //	    if (ThisParticle->R<0) ThisParticle->R=0;
      //	    if (ThisParticle->G>255) ThisParticle->G=255;
      //	    if (ThisParticle->G<0) ThisParticle->G=0;
      //	    if (ThisParticle->B>255) ThisParticle->B=255;
      //	    if (ThisParticle->B<0) ThisParticle->B=0;
    }
  }
}

void DisplayParticles()
{
  int i;

  lock();
  for( i = 0; i < NullParticle; i++ ){
    Particle* ThisParticle = &particles[ i ];
    int X, Y;
    X = ThisParticle->X;
    Y = ThisParticle->Y;
    if( ThisParticle->X >= 0 ) 
      if( ThisParticle->X < 800 ) 
        if( ThisParticle->Y >= 0 ) 
          if( ThisParticle->Y < 600 ){
            PutPixel( Screen, ThisParticle->X, ThisParticle->Y,
	    SDL_MapRGB(Screen->format,ThisParticle->R, ThisParticle->G, ThisParticle->B) );
	  }
  } 
  unlock();
}

void NewParticles(float turn, int X, int Y, float spread_percent)
{
      if(( NullParticle < PARTICLES_OF_EXHAUST )&&(particle))
	{
	  int ColorIndex;
	  int Percent; // Damn. C is really really finicky about declarations! Urusai!

	  Particle* ThisParticle = &particles[ NullParticle ];
	  ThisParticle->Lifetime = PARTICLE_LIFETIME + abrand( -5, 5 );
	  ThisParticle->X = X + 15;
	  ThisParticle->Y = Y + 15;
	  
	  ColorIndex = abrand( 0, PARTICLE_COLORS-1 );
	  ThisParticle->R = ParticleColorsR[ ColorIndex ];
	  ThisParticle->G = ParticleColorsG[ ColorIndex ];
	  ThisParticle->B = ParticleColorsB[ ColorIndex ];
	  // Introduce Orthogonal (y, -x) Component
	Percent = abrand( -spread_percent/2, spread_percent/2 );
	turn+=190;
	turn+=Percent;
	if (turn>360) turn-=360;
	ThisParticle->dX =  sin(turn*0.01745)*(precision);
	ThisParticle->dY = -cos(turn*0.01745)*(precision);

	// scale particle speed
	// (because I'm having such difficulty finding a good scaling value...)
	ThisParticle->dX /= (float)2000;
	ThisParticle->dY /= (float)2000;

	NullParticle++;
     
    }
}