/*
  Maelstrom: Open Source version of the classic game by Ambrosia Software
  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>

  This software is provided 'as-is', without any express or implied
  warranty.  In no event will the authors be held liable for any damages
  arising from the use of this software.

  Permission is granted to anyone to use this software for any purpose,
  including commercial applications, and to alter it and redistribute it
  freely, subject to the following restrictions:

  1. The origin of this software must not be misrepresented; you must not
     claim that you wrote the original software. If you use this software
     in a product, an acknowledgment in the product documentation would be
     appreciated but is not required.
  2. Altered source versions must be plainly marked as such, and must not be
     misrepresented as being the original software.
  3. This notice may not be removed or altered from any source distribution.
*/

#ifndef _object_h
#define _object_h


/* The screen object class */
class Object {

public:
	Object(int X, int Y, int Xvec, int Yvec, Blit *blit, int PhaseTime);
	virtual ~Object();

	/* Flags */
	virtual int IsPlayer(void) {
		return(0);
	}
	virtual int IsDangerous(void) {
		return(solid);
	}
	virtual int IsRock(void) {
		return(0);
	}
	virtual int IsSmallRock(void) {
		return(0);
	}
	virtual int IsMediumRock(void) {
		return(0);
	}
	virtual int IsLargeRock(void) {
		return(0);
	}
	virtual int IsExploding(void) {
		return(Exploding);
	}
	virtual int IsGhost(void) {
		return(0);
	}
	virtual int Alive(void) {
		return(1);
	}

	/* Settings */
	void Set_Blit(Blit *blit) {
		myblit = blit;
		if ( myblit->isSmall )
			xsize = ysize = 16;
		else
			xsize = ysize = 32;
	}
	virtual void Set_Points(int points) {
		Points = points;
	}
	virtual void Set_HitPoints(int hp) {
		HitPoints = hp;
	}
	virtual void Set_TTL(int ttl) {
		/* We use ttl+1 because of the way Move() checks TTL */
		TTL = ttl+1;
	}
	virtual void IncrScore(int pts) {
		return;
	}
	virtual void IncrFrags(void) {
		return;
	}

	/* Shot and hit detection */
	virtual Shot *ShotHit(Rect *hitRect) {
		/* This function is called to see if we shot something */
		return(NULL);
	}
	virtual int Collide(Object *object, bool exact = true) {
		/* Set up the location rectangles */
		Rect *R1=&HitRect, *R2=&object->HitRect;

		if ( ! solid || ! object->solid )
			return(0);

		/* No collision if no overlap */
		if ( ! Overlap(R1, R2) )
			return(0);

		/* See if that's enough to check collision */
		if ( ! exact )
			return(1);

		/* Check the bitmasks to see if the sprites really intersect */
		int  xoff1, xoff2;
		int  roff;
		unsigned char *mask1, *mask2;
		int checkwidth, checkheight, w;

		/* -- Load the ptrs to the sprite masks */
		mask1 = myblit->mask[phase];
		mask2 = (object->myblit)->mask[object->phase];

		/* See where the sprites are relative to eachother, x-Axis */
		if ( R2->left < R1->left ) {
			/* The second sprite is left of the first one */
			checkwidth = (R2->right-R1->left);
			xoff2 = R1->left-R2->left;
			xoff1 = 0;
		} else {
			/* The first sprite is left of the second one */
			checkwidth = (R1->right-R2->left);
			xoff1 = R2->left-R1->left;
			xoff2 = 0;
		}

		/* See where the sprites are relative to eachother, y-Axis */
		if ( R2->top < R1->top ) {
			/* The second sprite is above of the first one */
			checkheight = (R2->bottom-R1->top);
			mask2 += (R1->top-R2->top)*object->xsize;
		} else {
			/* The first sprite is on top of the second one */
			checkheight = (R1->bottom-R2->top);
			mask1 += (R2->top-R1->top)*xsize;
		}

		/* Do the actual mask hit detection */
		while ( checkheight-- ) {
			for ( roff=0, w=checkwidth; w; --w, ++roff ) {
				if ( mask1[xoff1+roff] && mask2[xoff2+roff] )
					return(1);
			}
			mask1 += xsize;
			mask2 += object->xsize;
		}
		return(0);
	}
	/* Should be called in main loop -- return (-1) if dead */
	virtual int HitBy(Object *ship) {
		Shot *shot;
		while ( shootable && (shot=ship->ShotHit(&HitRect)) ) {
			if ( BeenShot(ship, shot) > 0 )
				return(-1);
		}
		if ( Collide(ship) && (BeenRunOver(ship) > 0) )
			return(-1);
		return(0);
	}

	/* We've been shot!  (returns 1 if we are dead) */
	virtual int BeenShot(Object *ship, Shot *shot) {
		if ( (HitPoints -= shot->damage) <= 0 ) {
			ship->IncrScore(Points);
			if ( IsPlayer() )
				ship->IncrFrags();
			return(Explode());
		} else {
			HitSound();
			Accelerate(shot->xvel/2, shot->yvel/2);
		}
		return(0);
	}

	/* We've been run over!  (returns 1 if we are dead) */
	virtual int BeenRunOver(Object *ship) {
		if ( ship->IsPlayer() )
			ship->BeenDamaged(PLAYER_HITS);
		if ( (HitPoints -= 1) <= 0 ) {
			ship->IncrScore(Points);
			return(Explode());
		} else {
			HitSound();
			ship->Accelerate(xvec/2, yvec/2);
		}
		return(0);
	}

	/* We've been globally damaged!  (returns 1 if we are dead) */
	virtual int BeenDamaged(int damage) {
		if ( (HitPoints -= damage) <= 0 ) {
			return(Explode());
		} else
			HitSound();
		return(0);
	}

	/* We expired (returns -1 if we are dead) */
	virtual int BeenTimedOut(void) {
		return(-1);
	}

	/* What happens when we have been shot up or crashed into */
	/* Returns 1 if we die here, instead of go into explosion */
	virtual int Explode(void);

	/* Movement */
	void GetPos(int *X, int *Y) {
		*X = x;
		*Y = y;
	}
	virtual void SetPos(int X, int Y) {
		/* Set new X position */
		x = X;
		if ( x > playground.right )
			x = playground.left + (x-playground.right);
		else if ( x < playground.left )
			x = playground.right - (playground.left-x);

		/* Set new Y position */
		y = Y;
		if ( y > playground.bottom )
			y = playground.top + (y-playground.bottom);
		else if ( y < playground.top )
			y = playground.bottom - (playground.top-y);

		/* Set the new HitRect */
		HitRect.left = myblit->hitRect.left+(x>>SPRITE_PRECISION);
		HitRect.right = myblit->hitRect.right+(x>>SPRITE_PRECISION);
		HitRect.top = myblit->hitRect.top+(y>>SPRITE_PRECISION);
		HitRect.bottom = myblit->hitRect.bottom+(y>>SPRITE_PRECISION);
	}
	virtual void Shake() {
		int shakeX = FastRandom(SHAKE_FACTOR);
		int shakeY = FastRandom(SHAKE_FACTOR);
		int Xvec = ((xvec < 0) ? shakeX : -shakeX);
		int Yvec = ((yvec < 0) ? shakeY : -shakeY);
		Accelerate(Xvec, Yvec);
	}
	void Accelerate(int Xvec, int Yvec) {
		if ( Exploding )
			return;
		xvec += Xvec;
		if ( abs(xvec) > VEL_MAX )
			xvec = ((xvec > 0) ? VEL_MAX : -VEL_MAX);
		yvec += Yvec;
		if ( abs(yvec) > VEL_MAX )
			yvec = ((yvec > 0) ? VEL_MAX : -VEL_MAX);
	}
	virtual void Phase(void) {
		if ( phasetime != NO_PHASE_CHANGE ) {
			if ( nextphase++ >= phasetime ) {
				nextphase = 0;
				if ( ++phase >= myblit->numFrames )
					phase = 0;
			}
		}
	}
	/* This function returns 0, or -1 if the sprite died */
	virtual int Move(int Frozen);

	UITexture *GetSprite() {
		return myblit->sprite[phase];
	}
	virtual void BlitSprite(void);

	/* Sound functions */
	virtual void HitSound(void);
	virtual void ExplodeSound(void);

	/* Player access functions (not used here) */
	virtual void SetSpecial(unsigned char Spec) {
	}
	virtual void IncrShieldLevel(int level) {
	}
	virtual void Multiplier(int multiplier) {
	}
	virtual void IncrBonus(int bonus) {
	}
	virtual void IncrLives(int lives) {
	}

protected:
	int Points;
	int x, y;
	int xvec, yvec;
	int xsize, ysize;
	int solid;
	int shootable;
	int HitPoints;
	int TTL;

	int phase;
	int phasetime;
	int nextphase;
	Blit *myblit;
	Rect HitRect;
	Rect playground;
	int Exploding;

	/* See if two rectangles overlap */
	int Overlap(Rect *R1, Rect *R2) {
	/* If the top of R1 is below the bottom of R2, they can't overlap */
		if ( (R1->top > R2->bottom) ||
	/* If the bottom R1 is above the top of R2, they can't overlap */
		     (R1->bottom < R2->top) ||
	/* If the left of R1 is greater than the right of R2, no overlap */
		     (R1->left > R2->right) ||
	/* If the right of R1 is less than the left of R2, no overlap */
		     (R1->right < R2->left) )
			return(0);

		/* They must overlap */
		return(1);
	}
};

/* These macros are useful for manipulating the high speed object arrays
   in use for dynamically keeping track of objects on the screen.
*/
#define OBJ_LOOP(index, range)	for ( index=(range-1); index >= 0; --index )

/* Free a slot in the middle of the array, fill the slot with the object
   at the end of the array, and shrink the size of the array.
*/
#define OBJ_KILL(array, index, numobj, type) \
			if ( index != --numobj ) {		\
				type *tmp = array[index];	\
				array[index] = array[numobj];	\
				array[numobj] = tmp;		\
			}

/* The Objects!! */
extern Object *gSprites[MAX_SPRITES];

#endif /* _object_h */
