gered/fruit-popper
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity
fruit-popper/ENTITIES.PAS

1122 lines
35 KiB
Plaintext
Raw Normal View History

initial commit of "completed" sources, binaries and assets as of july 4th, 2021
2021-07-07 17:10:18 -04:00
{$A+,B-,E+,F-,G+,I-,N+,P-,Q-,R-,S-,T-,V-,X+}
unit Entities;
interface
uses FixedP, MathFP;
const
PLAYER_WALK_SPEED = FP_0_6;
PLAYER_TACK_PUSH_FORCE = FP_8;
ENTITY_FRICTION = FP_0_2;
FORCE_FRICTION = FP_0_7;
PRICK_RADIUS = 4;
SCORE_UP_PARTICLE_SPEED = -trunc(0.075 * FP_FLOAT_SHIFT);
OW_PARTICLE_SPEED = -trunc(0.1 * FP_FLOAT_SHIFT);
{ cooldowns/times are all specified in terms of frame ticks }
STAB_COOLDOWN = 80;
STABBED_DEBUFF_TIME = 5000;
SPLASHED_DEBUFF_TIME = 5000;
type
Direction = (South, North, East, West);
{ used to statically define an animation sequence }
AnimationDesc = record
frames : array[0..5] of word; { 6 frames total ever ... }
count : word; { number of frames (max of 6) }
delay : word; { frame timer/delay between switching to next frame }
time : word; { total time. = count * delay }
loops : bytebool; { true = animation loops }
base : word; { spritesheet index of first frame. if
multi-directional, this should be the index of the
first frame for the south direction }
dirLength : word; { number of frames from the start of one direction
to the start of the next direction. if not a
multi-directional animation, this must be set to 0 }
end;
PAnimationDesc = ^AnimationDesc;
{ state needed for a currently running animation sequence. will be used
in conjunction with an AnimationDesc that defines the animation sequence
itself }
AnimationState = record
complete : bytebool; { true = current animation sequence is complete }
frameIndex : word; { index of the current animation sequence frame }
time : word; { current frame timer }
end;
PAnimationState = ^AnimationState;
{ general entity properties. an instance of this should be included
in the actual entity's specific record-type. not all entity types
actually use all of these properties. }
Entity = record
position : Vec2FP;
velocity : Vec2FP;
force : Vec2FP;
direction : Direction;
animation : AnimationState;
noCollision : bytebool;
end;
{ particle entity properties. sprite-animation-based particles
have their lifetime directly linked to the length of the animation.
TODO: non-sprite-animation-based particles. }
Particle = record
active : bytebool;
entity : Entity;
animation : PAnimationDesc; { if non-nil, particle is a
sprite-animation-based particle }
end;
FruitKind = (Tomato, Grapes);
FruitState = (Plant, Growing, Grown, Popped);
{ fruit entity properties }
Fruit = record
entity : Entity;
kind : FruitKind;
state : FruitState;
{ the meaning of these two values depends on the 'state' value }
counter : word;
value : word;
isGold : bytebool;
end;
PlayerState = (Idle, Walking, Stabbing, Victory, Defeat);
{ holds player state. duh. }
Player = record
entity : Entity;
fruitPref : FruitKind;
state : PlayerState;
stabCooldown : word;
stabbedDebuffTime : word;
splashedDebuffTime : word;
skipRenderFlag : bytebool;
score : word;
end;
PPlayer = ^Player;
procedure ResetAnimationState(var animation : AnimationState);
function GetAnimationFrame(const state : AnimationState;
const desc : AnimationDesc;
direction : Direction) : word;
procedure UpdateAnimation(var entity : Entity;
const animation : AnimationDesc);
function DoEntitiesOverlap(const a, b : Entity) : boolean;
function DoesEntityOverlap(const entity : Entity;
x1, y1, x2, y2 : integer) : boolean;
function IsEntityPositionValid(const entity : Entity) : boolean;
function MoveEntity(var entity : Entity) : boolean;
function IsEntityStopped(const entity : Entity) : boolean;
procedure UpdateEntity(var entity : Entity);
procedure SetPlayerState(var player : Player; state : PlayerState);
procedure GetThumbTackPointCoords(const player : Player; var out_x, out_y : integer);
procedure GetThumbTackRenderCoords(const player : Player; var out_x, out_y : integer);
procedure UpdatePlayer(var player : Player);
procedure InitPlayer(var player : Player; x, y : integer; fruit: FruitKind);
procedure MovePlayer(var player : Player; dir : Direction);
procedure StabPlayer(var player : Player);
procedure DoThumbTackStabAt(px, py : integer; player : PPlayer);
function SpawnRandomFruit : integer;
procedure PopAllFruit(kind : FruitKind; player : PPlayer);
procedure PopFruitAt(x, y : integer; player : PPlayer);
procedure UpdateAllFruit;
function GetUnusedParticleIndex : integer;
function SpawnTomatoSplash(x, y : integer) : integer;
function SpawnGrapesSplash(x, y : integer) : integer;
function SpawnPlantSplash(x, y : integer) : integer;
function SpawnStabFlash(x, y : integer) : integer;
function SpawnScoreUp(x, y : integer; kind : FruitKind) : integer;
function SpawnOw(x, y : integer) : integer;
procedure UpdateAllParticles;
implementation
uses Math, Toolbox, Maps, Assets, Shared;
procedure ResetAnimationState(var animation : AnimationState);
{ resets the given animation state, so it can be used to start an
animation sequence from the very beginning }
begin
with animation do begin
complete := false;
frameIndex := 0;
time := 0;
end;
end;
function GetAnimationFrame(const state : AnimationState;
const desc : AnimationDesc;
direction : Direction) : word;
{ returns the current spritesheet bitmap index that should be blitted
to draw an entity based on it's animation state and facing direction }
begin
with desc do begin
GetAnimationFrame := frames[state.frameIndex]
+ (ord(direction) * dirLength)
+ base;
end;
end;
procedure UpdateAnimation(var entity : Entity;
const animation : AnimationDesc);
{ cycles the entity's animation state. the passed AnimationDesc should be
the corresponding animation descriptor/definition for the animation state
that the entity is currently in }
begin
with entity.animation do begin
if not complete then begin
inc(time, frameTicks);
if time >= animation.delay then begin
{ move to next frame in the current animation sequence }
time := 0;
if frameIndex = (animation.count-1) then begin
{ we're at the last frame in the current animation sequence }
if not animation.loops then begin
complete := true;
end else
frameIndex := 0;
end else
inc(frameIndex);
end;
end;
end;
end;
{ ------------------------------------------------------------------------ }
function DoEntitiesOverlap(const a, b : Entity) : boolean;
{ returns true if the given entities overlap fully or partially }
const
EDGE = 2;
var
ax1, ay1, ax2, ay2 : integer;
bx1, by1, bx2, by2 : integer;
begin
DoEntitiesOverlap := false;
with a.position do begin
ax1 := FixToInt(x)+EDGE;
ay1 := FixToInt(y)+EDGE;
ax2 := ax1 + (ENTITY_SIZE-1)-EDGE;
ay2 := ay1 + (ENTITY_SIZE-1)-EDGE;
end;
with b.position do begin
bx1 := FixToInt(x)+EDGE;
by1 := FixToInt(y)+EDGE;
bx2 := bx1 + (ENTITY_SIZE-1)-EDGE;
by2 := by1 + (ENTITY_SIZE-1)-EDGE;
end;
if (ay1 < by1) and (ay2 < by1) then
exit;
if (ay1 > by2) and (ay2 > by2) then
exit;
if (ax1 < bx1) and (ax2 < bx1) then
exit;
if (ax1 > bx2) and (ax2 > bx2) then
exit;
DoEntitiesOverlap := true;
end;
function DoesEntityOverlap(const entity : Entity;
x1, y1, x2, y2 : integer) : boolean;
{ returns true if the entity partially or fully overlaps with the given
area (specified in pixel coordinates) }
const
EDGE = 2;
var
ex1, ey1, ex2, ey2 : integer;
begin
DoesEntityOverlap := false;
with entity.position do begin
ex1 := FixToInt(x)+EDGE;
ey1 := FixToInt(y)+EDGE;
ex2 := ex1 + (ENTITY_SIZE-1)-EDGE;
ey2 := ey1 + (ENTITY_SIZE-1)-EDGE;
end;
if (ey1 < y1) and (ey2 < y1) then
exit;
if (ey1 > y2) and (ey2 > y2) then
exit;
if (ex1 < x1) and (ex2 < x1) then
exit;
if (ex1 > x2) and (ex2 > x2) then
exit;
DoesEntityOverlap := true;
end;
function IsEntityPositionValid(const entity : Entity) : boolean;
{ returns true if the given entity is currently located in a position
that is "valid", meaning completely free of collisions with anything. }
begin
IsEntityPositionValid := true;
with entity.position do begin
{ any collision with the map? either collidable tiles or fruit ... }
if IsMapCollision(FixToInt(x), FixToInt(y)) then
IsEntityPositionValid := false
else begin
{ TODO: this seems a bit clumsy ...? }
{ make sure we don't compare against ourself. since this function
operates on generic Entity's, we kinda have to check this way }
if @entity = @player1.entity then begin
IsEntityPositionValid := (not DoEntitiesOverlap(entity,
player2.entity));
end else begin
IsEntityPositionValid := (not DoEntitiesOverlap(entity,
player1.entity));
end;
end;
end;
end;
function MoveEntity(var entity : Entity) : boolean;
{ updates the entity's X and Y position based on their current movement
velocity and any force velocity. checks for map collisions and prevents
movement along the X and/or Y axis if any collisions are found. returns
true if the entity collided against something. }
const
{ number of movement+collision sub-steps to divide this movement into }
NUM_STEPS = 2;
{ reciprocal (also as fixed point) just so that we can use Vec2FP_Scale }
STEP_SCALE = trunc((1 / NUM_STEPS) * FP_FLOAT_SHIFT);
var
stepVelocity : Vec2FP;
i : integer;
begin
MoveEntity := false;
with entity do begin
{ calculate the sub-step velocity for the below loop ... }
Vec2FP_Add(stepVelocity, velocity, force);
if (stepVelocity.x = 0) and (stepVelocity.y = 0) then exit;
{ if this entity skips collision checks, just move it and return }
if noCollision then begin
Vec2FP_AddTo(position, stepVelocity);
exit;
end;
{ we're dividing the movement and collision checks into sub-steps!
this is a possibly-hacky solution to fix issues with any frame-timings
that might result in us (without using sub-steps) moving entities
more than 1 pixel per loop. this could cause problems! e.g. the player
might not be able to move into a 1-tile-wide gap because their
movement keeps skipping over 1 pixel too much ... }
Vec2FP_ScaleThis(stepVelocity, STEP_SCALE);
for i := 1 to NUM_STEPS do begin
{ add velocity X to player's position, then test for collisions using
this new position. if a collision occurs, we cannot move the player
in the X direction by this amount, so we back it out }
inc(position.x, stepVelocity.x);
if not IsEntityPositionValid(entity) then begin
MoveEntity := true;
dec(position.x, stepVelocity.x);
end;
{ same thing for the velocity Y now. note that, if no collision occured
in the X direction, the position that is tested for here will also
include the velocity X component ... }
inc(position.y, stepVelocity.y);
if not IsEntityPositionValid(entity) then begin
MoveEntity := true;
dec(position.y, stepVelocity.y);
end;
end;
end;
end;
function IsEntityStopped(const entity : Entity) : boolean;
{ returns true if the entity's movement velocity is slow enough that they
could be considered stopped. this does not take into account the entity's
force velocity }
const
THRESHOLD = trunc(0.05 * FP_FLOAT_SHIFT);
begin
with entity.velocity do begin
IsEntityStopped := (abs(x) < THRESHOLD) and (abs(y) < THRESHOLD);
end;
end;
procedure UpdateEntity(var entity : Entity);
{ updates general entity state. this includes applying velocity/force
vectors to the entity's position and also applying friction to those
velocity/force vecotrs too }
begin
{ move entity in the direction of their velocity and any combined force
that is currently being applied to them. also handles collision. }
MoveEntity(entity);
with entity do begin
{ slow both the velocity and force down by friction }
{ TODO: probably for the force vector, we should use something other
than friction ... ? some per-force specific value maybe? }
Vec2FP_ScaleThis(velocity, ENTITY_FRICTION);
Vec2FP_ScaleThis(force, FORCE_FRICTION);
end;
end;
{ ------------------------------------------------------------------------ }
procedure SetPlayerState(var player : Player; state : PlayerState);
{ switches the player state to the one specified, also resetting the
player's current animation state }
begin
if state = player.state then exit;
player.state := state;
ResetAnimationState(player.entity.animation);
end;
procedure GetThumbTackPointCoords(const player : Player;
var out_x, out_y : integer);
{ computes the pixel coordinate of where the player's thumb tack's point
should be (assuming they are currently stabbing). }
var
dir : Direction;
begin
{ lol, perhaps just computing, say, 8-16 pixels out in a line directly
centered on the player and outward in their facing direction and using
that as the point coordinate would be best ... ?
this all seems silly now that i've written it ... }
with player.entity do begin
dir := direction;
with position do begin
out_x := FixToInt(x)
+ thumbTackRenderOffsetsX[ord(dir)]
+ thumbTackPointOffsetsX[ord(dir)];
out_y := FixToInt(y)
+ thumbTackRenderOffsetsY[ord(dir)]
+ thumbTackPointOffsetsY[ord(dir)];
end;
end;
end;
procedure GetThumbTackRenderCoords(const player : Player;
var out_x, out_y : integer);
{ computes the pixel coordinate of where the player's thumb tack sprite
should be (assuming they are currently stabbing). }
var
dir : Direction;
begin
with player.entity do begin
dir := direction;
with position do begin
out_x := FixToInt(x) + thumbTackRenderOffsetsX[ord(dir)];
out_y := FixToInt(y) + thumbTackRenderOffsetsY[ord(dir)];
end;
end;
end;
procedure UpdatePlayer(var player : Player);
{ updates player (and general entity) state. this includes entity
movement, as well as player animation state }
var
animation : ^AnimationDesc;
i : integer;
px, py : integer;
dir : Direction;
begin
with player do begin
{ do general entity updates first ... this will handle movement via
any velocity/force vectors }
UpdateEntity(entity);
if state = Stabbing then begin
if (entity.animation.frameIndex = 0)
and (entity.animation.time = 0)
and (not entity.animation.complete) then begin
{ only for the very first frame of the stabbing animation,
check for any fruit that collide with the thumb tack's pointy
end and should be popped }
dir := entity.direction;
with entity.position do begin
GetThumbTackPointCoords(player, px, py);
DoThumbTackStabAt(px, py, @player);
end;
end;
if entity.animation.complete then begin
{ keep player in the stabbing state until that animation has
completed. }
SetPlayerState(player, Idle);
stabCooldown := STAB_COOLDOWN;
{ stab/attack cooldown time quadrupled when afflicted by either
the 'stabbed' or 'splashed' cooldown }
if (stabbedDebuffTime > 0) or (splashedDebuffTime > 0) then
stabCooldown := stabCooldown * 4;
end;
end else if (state <> Victory) and (state <> Defeat) then begin
{ set player idle/walking based on their velocity.
note that this check ignores their force velocity! }
if IsEntityStopped(entity) then
SetPlayerState(player, Idle)
else
SetPlayerState(player, Walking);
end;
UpdateAnimation(entity, playerAnimations[ord(state)]);
{ update cooldowns / debuff timers }
if stabCooldown > 0 then
if stabCooldown > frameTicks then
dec(stabCooldown, frameTicks)
else
stabCooldown := 0;
if stabbedDebuffTime > 0 then
if stabbedDebuffTime > frameTicks then
dec(stabbedDebuffTime, frameTicks)
else
stabbedDebuffTime := 0;
if splashedDebuffTime > 0 then
if splashedDebuffTime > frameTicks then
dec(splashedDebuffTime, frameTicks)
else
splashedDebuffTime := 0;
if (stabbedDebuffTime > 0) or (splashedDebuffTime > 0) then
skipRenderFlag := not skipRenderFlag;
end;
end;
procedure InitPlayer(var player : Player; x, y : integer; fruit: FruitKind);
begin
MemFill(@player, 0, SizeOf(Player));
player.entity.position.x := IntToFix(x);
player.entity.position.y := IntToFix(y);
player.entity.direction := South;
player.fruitPref := fruit;
case fruit of
Tomato: tomatoPlayer := @player;
Grapes: grapesPlayer := @player;
end;
SetPlayerState(player, Idle);
end;
procedure MovePlayer(var player : Player; dir : Direction);
{ sets the given player in motion in the given direction. this function
does not actually adjust the players position in any way. it only sets
their velocity }
var
speed : fixed;
begin
with player do begin
if stabCooldown > 0 then exit;
if (state <> Idle) and (state <> Walking) then exit;
{ movement speed is halved when afflicted by 'splashed' }
if splashedDebuffTime > 0 then
speed := FixMul(PLAYER_WALK_SPEED, FP_0_5)
{ movement speed is cut by 30% when afflicted by 'stabbed' }
else if stabbedDebuffTime > 0 then
speed := FixMul(PLAYER_WALK_SPEED, FP_0_7)
else
speed := PLAYER_WALK_SPEED;
case dir of
North: begin
with entity do begin
dec(velocity.y, speed);
direction := North;
end;
end;
South: begin
with entity do begin
inc(velocity.Y, speed);
direction := South;
end;
end;
West: begin
with entity do begin
dec(velocity.x, speed);
direction := West;
end;
end;
East: begin
with entity do begin
inc(velocity.x, speed);
direction := East;
end;
end;
end;
end;
end;
procedure StabPlayer(var player : Player);
{ switches the player into the 'stabbing' state, which will start the
animation as well as bring out the player's thumb tack (during the
next player update anyway) }
begin
with player do begin
if stabCooldown > 0 then exit;
if (state <> Idle) and (state <> Walking) then exit;
SetPlayerState(player, Stabbing);
end;
end;
procedure DoThumbTackStabAt(px, py : integer; player : PPlayer);
{ determines what, if anything, a thumb tack stab with the pixel coordinates
of the point provided, collided with and what should happen. the player
passed should be the player who owns the thumb tack. }
var
otherPlayer : PPlayer;
dir : Direction;
begin
{ always pop any fruit / destroy any plants at this position }
PopFruitAt(px, py, player);
{ did we also hit the other player? }
{ determine which player is which ... }
if player = @player1 then
otherPlayer := @player2
else
otherPlayer := @player1;
{ now check if this thumb tack point collided with that other player }
if DoesEntityOverlap(otherPlayer^.entity,
px - PRICK_RADIUS,
py - PRICK_RADIUS,
px + PRICK_RADIUS,
py + PRICK_RADIUS) then begin
{ we hit the other player. push the other player in the direction
that this player is facing }
dir := player^.entity.direction;
with otherPlayer^.entity do begin
case dir of
North: AngleToVec2DFP(BIN_ANGLE_270, force);
South: AngleToVec2DFP(BIN_ANGLE_90, force);
West: AngleToVec2DFP(BIN_ANGLE_180, force);
East: AngleToVec2DFP(0, force);
end;
Vec2FP_ScaleThis(force, PLAYER_TACK_PUSH_FORCE);
end;
{ also apply the 'stabbed' debuff to the other player }
otherPlayer^.stabbedDebuffTime := STABBED_DEBUFF_TIME;
{ finally, spawn a 'ow' particle as another indication that a player
was stabbed }
with otherPlayer^.entity.position do begin
SpawnOw(FixToInt(x), FixToInt(y));
end;
end;
end;
{ ------------------------------------------------------------------------ }
procedure SetFruitState(var fruit : Fruit; state : FruitState);
begin
if state = fruit.state then exit;
fruit.state := state;
fruit.counter := 0;
fruit.value := 0;
ResetAnimationState(fruit.entity.animation);
end;
function GetPlantRandomLifeTime : word;
const
MINIMUM_TIME = 3000;
STEP_SIZE = 2000;
begin
GetPlantRandomLifeTime := MINIMUM_TIME
+ ((1+random(5)) * STEP_SIZE)
- random(STEP_SIZE);
end;
function SpawnRandomFruit : integer;
{ spawns a new fruit (starting it off as a plant) in any random available
dirt tile on the map. spawning may fail (if a free dirt tile could not
be found randomly). returns the dirtTiles index of the new fruit, or
-1 if spawning failed }
var
idx : integer;
begin
SpawnRandomFruit := -1;
{ find a random spot to spawn a new fruit in }
idx := GetRandomUnusedDirtTileIndex;
if idx = -1 then exit;
SpawnRandomFruit := idx;
with dirtTiles[idx] do begin
{ important! this marks the dirt tile as being 'used' }
hasFruit := true;
inc(numActiveDirtTiles);
{ zero out the fruit, and then fill in its starter properties }
MemFill(@fruit, 0, SizeOf(fruit));
SetFruitState(fruit, Plant);
if random(2) = 0 then
fruit.kind := Tomato
else
fruit.kind := Grapes;
fruit.value := GetPlantRandomLifeTime;
fruit.isGold := (random(100) < GOLD_FRUIT_SPAWN_CHANCE);
fruit.entity.position.x := IntToFix(x*16);
fruit.entity.position.y := IntToFix(y*16);
end;
end;
procedure PopFruitIn(var tile : DirtTile; player : PPlayer);
{ switches any fruit entity located within the given dirt tile into the
'popped' state, as well as starting up any relevant animations. if
there is no fruit in this tile, or the fruit is not in the 'grown'
state yet, nothing happens. the player passed in here will be the one
given 'credit' for popping the fruit (or if nil, no credit is given to
any player). }
var
fx, fy : integer;
begin
with tile do begin
if not hasFruit then exit;
case fruit.state of
Plant, Growing: begin
{ no score credit for stabbing a fruit plant, or a growing
but not yet full grown fruit. just despawn it. }
hasFruit := false;
dec(numActiveDirtTiles);
with fruit.entity.position do begin
SpawnPlantSplash(FixToInt(x), FixToInt(y));
end;
end;
Grown: begin
{ stabbing fully grown fruit }
SetFruitState(fruit, Popped);
with fruit.entity.position do begin
fx := FixToInt(x);
fy := FixToInt(y);
{ if the stabbing player's fruit choice matches the popped
fruit, then give the player score credit }
if fruit.kind = player^.fruitPref then begin
SpawnScoreUp(fx, fy, fruit.kind);
inc(player^.score);
end;
if fruit.isGold then
PopAllFruit(fruit.kind, player);
SpawnStabFlash(fx, fy);
end;
end;
end;
end;
end;
procedure PopAllFruit(kind : FruitKind; player : PPlayer);
var
idx : integer;
begin
for idx := 0 to numDirtTiles-1 do begin
with dirtTiles[idx] do begin
if not hasFruit then continue;
if (fruit.kind = kind) and (fruit.state = Grown) then begin
PopFruitIn(dirtTiles[idx], player);
end;
end;
end;
end;
procedure PopFruitAt(x, y : integer; player : PPlayer);
{ switches any fruit located near the given x/y coordinates into the
'popped' state, assuming that the fruit are already in the 'grown'
state (otherwise, they will not be changed). these x/y coordinates
would normally be the pixel coordinates corresponding to a player's
thumb tack point. the player passed in here will be the one given
'credit' for popping the fruit (or if nil, no credit is given to
any player). }
var
left, right, top, bottom : integer;
cx, cy : integer;
dirtTile : PDirtTile;
begin
{ get the map tile x/y region to check for dirt tiles within }
left := (x - PRICK_RADIUS) div TILE_SIZE;
right := (x + PRICK_RADIUS) div TILE_SIZE;
top := (y - PRICK_RADIUS) div TILE_SIZE;
bottom := (y + PRICK_RADIUS) div TILE_SIZE;
if left < 0 then left := 0;
if right > MAP_RIGHT then right := MAP_RIGHT;
if top < 0 then top := 0;
if bottom > MAP_BOTTOM then bottom := MAP_BOTTOM;
{ for all dirt tiles located within this region, pop the fruit
in them }
for cy := top to bottom do begin
for cx := left to right do begin
dirtTile := dirtTileMapping[(cy * SCREEN_MAP_WIDTH) + cx];
if dirtTile <> nil then begin
PopFruitIn(dirtTile^, player);
end;
end;
end;
end;
procedure UpdateAllFruit;
{ updates the state of all fruit currently active within dirtTiles }
const
GROW_STEP_TIME = 40;
SPRITE_MAX_SIZE = 16;
var
i, fx, fy : integer;
begin
{ periodically spawn more fruit }
if (fruitSpawnTimer >= 1000)
and (numActiveDirtTiles < map.header.maxFruit) then begin
SpawnRandomFruit;
fruitSpawnTimer := 0;
end;
for i := 0 to numDirtTiles-1 do begin
with dirtTiles[i] do begin
if not hasFruit then continue;
case fruit.state of
Plant: begin
{ count time into the plant has been a plant for 'value' time
at which point it should 'grow' into a fruit }
with fruit do begin
inc(counter, frameTicks);
if counter >= value then begin
SetFruitState(fruit, Growing);
value := 2;
end;
end;
end;
Growing: begin
{ the fruit "grows" by scaling it's size up from zero to it's
normal pixel sprite size. the size increments by 1 every
so often }
with fruit do begin
if value < SPRITE_MAX_SIZE then begin
inc(counter, frameTicks);
if counter >= GROW_STEP_TIME then begin
inc(value);
counter := 0;
end;
end else begin
SetFruitState(fruit, Grown);
end;
end;
end;
Grown: begin
end;
Popped: begin
{ when the popped "animation" (not really an animation, just
abusing a 1-frame sequence with long delay as a timer)
completes, we can deactivate this dirt tile and fruit }
if fruit.entity.animation.complete then begin
hasFruit := false;
dec(numActiveDirtTiles);
with fruit.entity.position do begin
fx := FixToInt(x);
fy := FixToInt(y);
end;
if fruit.kind = Tomato then begin
SpawnTomatoSplash(fx, fy);
{ if the grapes-preference player is nearby this tomato
splash, then spawn an extra tomato splash at their exact
position and afflict them with the 'splashed' debuff }
with grapesPlayer^ do begin
if DoesEntityOverlap(entity,
fx-32,
fy-32,
fx+48,
fy+48) then begin
with entity.position do
SpawnTomatoSplash(FixToInt(x), FixToInt(y));
splashedDebuffTime := SPLASHED_DEBUFF_TIME;
end;
end;
end else begin
SpawnGrapesSplash(fx, fy);
{ if the tomato-preference player is nearby this grapes
splash, then spawn an extra grapes splash at their exact
position and afflict them with the 'splashed' debuff }
with tomatoPlayer^ do begin
if DoesEntityOverlap(entity,
fx-32,
fy-32,
fx+48,
fy+48) then begin
with entity.position do
SpawnGrapesSplash(FixToInt(x), FixToInt(y));
splashedDebuffTime := SPLASHED_DEBUFF_TIME;
end;
end;
end;
continue;
end;
end;
end;
with fruit do begin
UpdateAnimation(entity, fruitAnimations[ord(state)]);
end;
end;
end;
end;
{ ------------------------------------------------------------------------ }
function GetUnusedParticleIndex : integer;
{ returns the index of the next unused/inactive particle. returns -1 if
there is no free index }
var
i : integer;
begin
GetUnusedParticleIndex := -1;
for i := 0 to MAX_PARTICLES-1 do begin
if not particles[i].active then begin
GetUnusedParticleIndex := i;
exit;
end;
end;
end;
function InitNewParticle(x, y : integer) : integer;
var
i : integer;
begin
InitNewParticle := -1;
i := GetUnusedParticleIndex;
if i = -1 then exit;
MemFill(@particles[i], 0, SizeOf(Particle));
with particles[i] do begin
active := true;
with entity do begin
noCollision := true;
position.x := IntToFix(x);
position.y := IntToFix(y);
end;
end;
InitNewParticle := i;
end;
function SpawnTomatoSplash(x, y : integer) : integer;
{ spawns a new 'tomato splash' particle at the given coordinates.
returns the index of the spawned particle if successful, or -1 if there
was no free particle index }
var
i : integer;
begin
SpawnTomatoSplash := -1;
i := InitNewParticle(x, y);
if i = -1 then exit;
with particles[i] do begin
animation := @tomatoSplashAnimation;
end;
SpawnTomatoSplash := i;
end;
function SpawnGrapesSplash(x, y : integer) : integer;
{ spawns a new 'grapes splash' particle at the given coordinates.
returns the index of the spawned particle if successful, or -1 if there
was no free particle index }
var
i : integer;
begin
SpawnGrapesSplash := -1;
i := InitNewParticle(x, y);
if i = -1 then exit;
with particles[i] do begin
animation := @grapesSplashAnimation;
end;
SpawnGrapesSplash := i;
end;
function SpawnPlantSplash(x, y : integer) : integer;
{ spawns a new 'plant splash' (for when a plant is destroyed) particle at
the given coordinates. returns the index of the spawned particle if
successful, or -1 if there was no free particle index }
var
i : integer;
begin
SpawnPlantSplash := -1;
i := InitNewParticle(x, y);
if i = -1 then exit;
with particles[i] do begin
animation := @plantDestroyAnimation;
end;
SpawnPlantSplash := i;
end;
function SpawnStabFlash(x, y : integer) : integer;
{ spawns a new 'stab flash' particle at the given coordinates.
returns the index of the spawned particle if successful, or -1 if there
was no free particle index }
var
i : integer;
begin
SpawnStabFlash := -1;
i := InitNewParticle(x, y);
if i = -1 then exit;
with particles[i] do begin
animation := @stabFlashAnimation;
end;
SpawnStabFlash := i;
end;
function SpawnScoreUp(x, y : integer; kind : FruitKind) : integer;
{ spawns a new '+1' score particle at the given coordinates, for the
specified fruit (affects how it is displayed).
returns the index of the spawned particle if successful, or -1 if there
was no free particle index }
var
i : integer;
begin
SpawnScoreUp := -1;
i := InitNewParticle(x, y);
if i = -1 then exit;
with particles[i] do begin
if kind = Tomato then
animation := @tomatoScoreUpAnimation
else
animation := @grapesScoreUpAnimation;
with entity do begin
velocity.y := SCORE_UP_PARTICLE_SPEED;
end;
end;
SpawnScoreUp := i;
end;
function SpawnOw(x, y : integer) : integer;
{ spawns a new 'ow' particle (to indicate a player was stabbed) at the given
coordinates.
returns the index of the spawned particle if successful, or -1 if there
was no free particle index }
var
i : integer;
begin
SpawnOw := -1;
i := InitNewParticle(x, y);
if i = -1 then exit;
with particles[i] do begin
animation := @owAnimation;
with entity do begin
velocity.y := OW_PARTICLE_SPEED;
end;
end;
SpawnOw := i;
end;
procedure UpdateAllParticles;
var
i : word;
begin
for i := 0 to MAX_PARTICLES-1 do begin
with particles[i] do begin
if not active then continue;
MoveEntity(entity);
if animation <> nil then begin
{ particle is a "sprite-animated" particle type.
this means its lifetime is tied to the animation. update it's
animation, and when it is complete, kill the particle }
if entity.animation.complete then
active := false
else
UpdateAnimation(entity, animation^);
end else begin
{ TODO: "pixel" particle types ... }
end;
end;
end;
end;
end.
Reference in a new issue Copy permalink