|
|
// |
|
|
// Bomber By Kazys Stepanas |
|
|
// |
|
|
|
|
|
|
|
|
//-------------------------------------------------------------------------------------------------- |
|
|
// Globals. |
|
|
//-------------------------------------------------------------------------------------------------- |
|
|
global bgCol = CA.B_BLACK; |
|
|
global quit = false; |
|
|
global lastTouchedBlock = -1; |
|
|
global player; |
|
|
|
|
|
global gameLevel = 1; |
|
|
|
|
|
global blocks = table(count = 0); |
|
|
global powerups = table(count = 0); |
|
|
global enemies = table(count = 0); |
|
|
global blockDeadZone = table(x1 = 31, y1 = 8, x2 = 39, y2 = 14); |
|
|
global enemyDeadZone = table(x1 = 22, y1 = 7, x2 = 45, y2 = 16); |
|
|
|
|
|
// Thing types. |
|
|
global T_Space = 0; |
|
|
global T_Player = 1; |
|
|
global T_Bomb = 2; |
|
|
global T_Explosion = 3; |
|
|
global T_Block = 4; |
|
|
global T_Grid = 5; |
|
|
global T_Powerup = 6; |
|
|
global T_Enemy = 7; |
|
|
|
|
|
// Powerup types. |
|
|
global PT_Bomb = 1; |
|
|
global PT_Size = 2; |
|
|
global PT_Life = 3; |
|
|
|
|
|
// Dead zone types. |
|
|
global DT_None = 0; |
|
|
global DT_Block = 1; |
|
|
global DT_Enemy = 2; |
|
|
|
|
|
//-------------------------------------------------------------------------------------------------- |
|
|
// Grid control. |
|
|
//-------------------------------------------------------------------------------------------------- |
|
|
global grid = table(startX = 0, startY = 0, spaceX = 1, spaceY = 1, rows = 0, cols = 0); |
|
|
|
|
|
//-------------------------------------------------------------------------------------------------- |
|
|
// Constants |
|
|
//-------------------------------------------------------------------------------------------------- |
|
|
global screen = table(w = 80, h = 23); |
|
|
global statusY = 24; |
|
|
|
|
|
global bombFuse = 1.25; |
|
|
global explodeTime = 0.75; |
|
|
global explodeCycle = 0.05; |
|
|
global maxPlayerBombs = 10; |
|
|
global maxPlayerSize = 5; |
|
|
global maxPowerups = 20; |
|
|
global maxLives = 5; |
|
|
global startLives = 3; |
|
|
|
|
|
global scoreBlock = 10; |
|
|
global scoreNME = 50; |
|
|
|
|
|
global nmeMoveTime = 1.0; |
|
|
global powerupChance = 40; |
|
|
global maxLevel = 10; |
|
|
global maxBlockHits = 3; |
|
|
|
|
|
//-------------------------------------------------------------------------------------------------- |
|
|
// Graphics |
|
|
//-------------------------------------------------------------------------------------------------- |
|
|
global playerPix = "\2"; |
|
|
global playerDeadPix = "\5"; |
|
|
global bombPix = "\15"; |
|
|
global expPix = "+"; |
|
|
global gridPix = "\178"; |
|
|
global block1Pix = "\176"; |
|
|
global block2Pix = "\177"; |
|
|
global block3Pix = "\219"; |
|
|
global nmePix = "\232"; |
|
|
global lifePix = "\3"; |
|
|
global bombSizePix = "#"; |
|
|
global bombExtraPix = "*"; |
|
|
global spacePix = " "; |
|
|
|
|
|
//-------------------------------------------------------------------------------------------------- |
|
|
// Colours |
|
|
//-------------------------------------------------------------------------------------------------- |
|
|
global bgColour = 0; |
|
|
global fgColour = CA.F_RED | CA.F_GREEN; |
|
|
|
|
|
global playerColour = CA.F_GREEN | CA.F_BLUE;// | CA.F_INTENSITY; |
|
|
global gridColour = CA.F_RED; |
|
|
global blockColour = CA.F_RED | CA.F_GREEN | CA.F_INTENSITY; |
|
|
global nmeColour = CA.F_RED | CA.F_BLUE; |
|
|
global powerupColour = CA.F_GREEN | CA.F_INTENSITY; |
|
|
global puLifeColour = CA.F_RED; |
|
|
|
|
|
global statusColour = CA.F_RED | CA.F_GREEN; |
|
|
|
|
|
global bombColour = CA.F_BLUE | CA.F_INTENSITY; |
|
|
global expColourCount = 5; |
|
|
global expColours = array(expColourCount); |
|
|
|
|
|
global readyColour = CA.F_RED; |
|
|
|
|
|
expColours[0] = CA.F_RED | CA.F_INTENSITY; |
|
|
expColours[1] = CA.F_BLUE|CA.F_RED; |
|
|
expColours[2] = CA.F_RED|CA.F_GREEN | CA.F_INTENSITY; |
|
|
expColours[3] = CA.F_RED; |
|
|
expColours[4] = CA.F_RED|CA.F_GREEN; |
|
|
|
|
|
|
|
|
//-------------------------------------------------------------------------------------------------- |
|
|
//-------------------------------------------------------------------------------------------------- |
|
|
global IsPointWithin = function(a_ptx, a_pty, a_rx1, a_ry1, a_rx2, a_ry2) |
|
|
{ |
|
|
return (a_ptx >= a_rx1 and a_ptx <= a_rx2 and a_pty >= a_ry1 and a_pty <= a_ry2); |
|
|
}; |
|
|
|
|
|
global OverlapRect = function(a_r1x1, a_r1y1, a_r1x2, a_r1y2, a_r2x1, a_r2y1, a_r2x2, a_r2y2) |
|
|
{ |
|
|
// Test one rect against the other. |
|
|
if (IsPointWithin(a_r2x1, a_r2y1, a_r1x1, a_r1y1, a_r1x2, a_r1y2) or |
|
|
IsPointWithin(a_r2x1, a_r2y2, a_r1x1, a_r1y1, a_r1x2, a_r1y2) or |
|
|
IsPointWithin(a_r2x2, a_r2y2, a_r1x1, a_r1y1, a_r1x2, a_r1y2) or |
|
|
IsPointWithin(a_r2x2, a_r2y1, a_r1x1, a_r1y1, a_r1x2, a_r1y2)) |
|
|
{ |
|
|
return true; |
|
|
} |
|
|
|
|
|
// Test the other rect. |
|
|
if (IsPointWithin(a_r1x1, a_r1y1, a_r2x1, a_r2y1, a_r2x2, a_r2y2) or |
|
|
IsPointWithin(a_r1x1, a_r1y2, a_r2x1, a_r2y1, a_r2x2, a_r2y2) or |
|
|
IsPointWithin(a_r1x2, a_r1y2, a_r2x1, a_r2y1, a_r2x2, a_r2y2) or |
|
|
IsPointWithin(a_r1x2, a_r1y1, a_r2x1, a_r2y1, a_r2x2, a_r2y2)) |
|
|
{ |
|
|
return true; |
|
|
} |
|
|
|
|
|
return false; |
|
|
}; |
|
|
|
|
|
global ScreenClampX = function(a_x) |
|
|
{ |
|
|
if (a_x < 0) |
|
|
{ |
|
|
return 0; |
|
|
} |
|
|
else if (a_x >= screen.w) |
|
|
{ |
|
|
return screen.w-1; |
|
|
} |
|
|
|
|
|
return a_x; |
|
|
}; |
|
|
|
|
|
global ScreenClampY = function(a_y) |
|
|
{ |
|
|
if (a_y < 0) |
|
|
{ |
|
|
return 0; |
|
|
} |
|
|
else if (a_y >= screen.h) |
|
|
{ |
|
|
return screen.h-1; |
|
|
} |
|
|
|
|
|
return a_y; |
|
|
}; |
|
|
|
|
|
global ScreenClamp = function() |
|
|
{ |
|
|
.x = ScreenClampX(.x); |
|
|
.y = ScreenClampY(.y); |
|
|
}; |
|
|
|
|
|
global BombAt = function(a_x, a_y) |
|
|
{ |
|
|
for (i = 0; i < player.nextBomb; i=i+1) |
|
|
{ |
|
|
bomb = player.bombs[i]; |
|
|
if (bomb.x == a_x and bomb.y == a_y) |
|
|
{ |
|
|
return true; |
|
|
} |
|
|
} |
|
|
return false; |
|
|
}; |
|
|
|
|
|
global PointOverlap = function(a_x1, a_y1, a_x2, a_y2) |
|
|
{ |
|
|
return IsPointWithin(.x, .y, a_x1, a_y1, a_x2, a_y2); |
|
|
}; |
|
|
|
|
|
//-------------------------------------------------------------------------------------------------- |
|
|
// Player object. |
|
|
//-------------------------------------------------------------------------------------------------- |
|
|
global Player = function() |
|
|
{ |
|
|
newPlayer = table(x = -1, y = -1); |
|
|
newPlayer.bombSize = 1; |
|
|
newPlayer.bombFuse = bombFuse; |
|
|
newPlayer.bombs = array(maxPlayerBombs); |
|
|
newPlayer.maxBombs = 1; |
|
|
newPlayer.nextBomb = 0; |
|
|
newPlayer.threadId = -1; |
|
|
newPlayer.lastCanMoveThing = null; |
|
|
newPlayer.dead = false; |
|
|
newPlayer.lives = startLives; |
|
|
newPlayer.score = 0; |
|
|
newPlayer.threadId = -1; |
|
|
|
|
|
//------------------------------------ |
|
|
//------------------------------------ |
|
|
newPlayer.Draw = function() |
|
|
{ |
|
|
CATTRIB(bgColour | playerColour); |
|
|
if (!.dead) |
|
|
{ |
|
|
XYTEXT(.x, .y, playerPix); |
|
|
} |
|
|
else |
|
|
{ |
|
|
XYTEXT(.x, .y, playerDeadPix); |
|
|
} |
|
|
}; |
|
|
|
|
|
//------------------------------------ |
|
|
//------------------------------------ |
|
|
newPlayer.DrawStatus = function() |
|
|
{ |
|
|
CATTRIB(bgColour | puLifeColour | CA.F_INTENSITY); |
|
|
XYTEXT(0, statusY, format("%s : %d ", lifePix, .lives)); |
|
|
CATTRIB(bgColour | powerupColour); |
|
|
XYTEXT(10, statusY, format("%s : %d ", bombExtraPix, .maxBombs)); |
|
|
XYTEXT(20, statusY, format("%s : %d ", bombSizePix, .bombSize)); |
|
|
CATTRIB(bgColour | statusColour); |
|
|
XYTEXT(50, statusY, format("Score : %d ", .score)); |
|
|
}; |
|
|
|
|
|
newPlayer.AddScore = function(a_add) |
|
|
{ |
|
|
.score = .score + a_add; |
|
|
.DrawStatus(); |
|
|
}; |
|
|
|
|
|
//------------------------------------ |
|
|
//------------------------------------ |
|
|
newPlayer.CanMove = function(a_x, a_y) |
|
|
{ |
|
|
thing = GetThingAt(a_x, a_y, false); |
|
|
.lastCanMoveThing = thing; |
|
|
return thing.type == T_Space or thing.type == T_Explosion or |
|
|
thing.type == T_Powerup or thing.type == T_Enemy; |
|
|
}; |
|
|
|
|
|
//------------------------------------ |
|
|
//------------------------------------ |
|
|
newPlayer.Move = function(a_dx, a_dy) |
|
|
{ |
|
|
if (!.dead) |
|
|
{ |
|
|
oldX = .x; |
|
|
oldY = .y; |
|
|
newX = ScreenClampX(.x + a_dx); |
|
|
newY = ScreenClampY(.y + a_dy); |
|
|
|
|
|
if (.CanMove(newX, newY)) |
|
|
{ |
|
|
.x = newX; |
|
|
.y = newY; |
|
|
if (.lastCanMoveThing.type == T_Powerup) |
|
|
{ |
|
|
.lastCanMoveThing.thing.Pickup(); |
|
|
} |
|
|
else if (.lastCanMoveThing.type == T_Explosion or .lastCanMoveThing.type == T_Enemy) |
|
|
{ |
|
|
.Kill(); |
|
|
} |
|
|
|
|
|
RefreshXY(oldX, oldY); |
|
|
RefreshXY(.x, .y); |
|
|
} |
|
|
} |
|
|
}; |
|
|
|
|
|
//------------------------------------ |
|
|
//------------------------------------ |
|
|
newPlayer.Kill = function() |
|
|
{ |
|
|
.dead = true; |
|
|
RefreshXY(.x, .y); |
|
|
}; |
|
|
|
|
|
//------------------------------------ |
|
|
//------------------------------------ |
|
|
newPlayer.DropBomb = function() |
|
|
{ |
|
|
if (!.dead and .nextBomb < .maxBombs and !BombAt(.x, .y)) |
|
|
{ |
|
|
newBomb = Bomb(.x, .y, .bombSize, .bombFuse, this); |
|
|
.bombs[.nextBomb] = newBomb; |
|
|
.nextBomb = .nextBomb + 1; |
|
|
newBomb.Draw(); |
|
|
} |
|
|
}; |
|
|
|
|
|
//------------------------------------ |
|
|
//------------------------------------ |
|
|
newPlayer.FreeBomb = function(a_bomb) |
|
|
{ |
|
|
found = false; |
|
|
limit = .nextBomb; |
|
|
for (i = 0; i < limit; i=i+1) |
|
|
{ |
|
|
if (.bombs[i] == a_bomb) |
|
|
{ |
|
|
found = true; |
|
|
.nextBomb = .nextBomb - 1; |
|
|
} |
|
|
if (found) |
|
|
{ |
|
|
if (i+1 < limit) |
|
|
{ |
|
|
.bombs[i] = .bombs[i+1]; |
|
|
} |
|
|
else |
|
|
{ |
|
|
.bombs[i] = null; |
|
|
} |
|
|
} |
|
|
} |
|
|
}; |
|
|
|
|
|
//------------------------------------ |
|
|
//------------------------------------ |
|
|
newPlayer.StartThread = function() |
|
|
{ |
|
|
this:stateSet(.IdleState); |
|
|
}; |
|
|
|
|
|
//------------------------------------ |
|
|
//------------------------------------ |
|
|
newPlayer.IdleState = function() |
|
|
{ |
|
|
while (!quit) |
|
|
{ |
|
|
pressed = false; |
|
|
if (ISPRESSED(38)) |
|
|
{ |
|
|
.Move(0, -1); |
|
|
pressed = true; |
|
|
} |
|
|
else if (ISPRESSED(40)) |
|
|
{ |
|
|
.Move(0, 1); |
|
|
pressed = true; |
|
|
} |
|
|
else if (ISPRESSED(39)) |
|
|
{ |
|
|
.Move(1, 0); |
|
|
pressed = true; |
|
|
} |
|
|
else if (ISPRESSED(37)) |
|
|
{ |
|
|
.Move(-1, 0); |
|
|
pressed = true; |
|
|
} |
|
|
else if (ISPRESSED(' ')) |
|
|
{ |
|
|
.DropBomb(); |
|
|
pressed = true; |
|
|
} |
|
|
|
|
|
if (pressed) |
|
|
{ |
|
|
sleep(0.075); |
|
|
} |
|
|
else if (.dead) |
|
|
{ |
|
|
this:stateSet(.DeadState); |
|
|
} |
|
|
else |
|
|
{ |
|
|
yield(); |
|
|
} |
|
|
} |
|
|
}; |
|
|
|
|
|
//------------------------------------ |
|
|
//------------------------------------ |
|
|
newPlayer.DeadState = function() |
|
|
{ |
|
|
sleep(explodeTime); |
|
|
if (.lives > 0) |
|
|
{ |
|
|
.lives = .lives - 1; |
|
|
} |
|
|
if (.maxBombs > 1) |
|
|
{ |
|
|
.maxBombs = .maxBombs - 1; |
|
|
} |
|
|
if (.bombSize > 1) |
|
|
{ |
|
|
.bombSize = .bombSize - 1; |
|
|
} |
|
|
.DrawStatus(); |
|
|
|
|
|
while (!quit) |
|
|
{ |
|
|
if (.lives > 0 and ISPRESSED(' ')) |
|
|
{ |
|
|
while (!quit) |
|
|
{ |
|
|
pos = .GetStartPos(); |
|
|
thing = GetThingAt(pos.x, pos.y, false); |
|
|
if (thing.type == T_Enemy) |
|
|
{ |
|
|
thing.thing.Kill(); |
|
|
} |
|
|
sleep(0.2); |
|
|
|
|
|
oldX = .x; |
|
|
oldY = .y; |
|
|
.x = pos.x; |
|
|
.y = pos.y; |
|
|
|
|
|
.dead = false; |
|
|
RefreshXY(oldX, oldY); |
|
|
RefreshXY(.x, .y); |
|
|
this:stateSet(.IdleState); |
|
|
} |
|
|
} |
|
|
yield(); |
|
|
} |
|
|
}; |
|
|
|
|
|
//------------------------------------ |
|
|
//------------------------------------ |
|
|
newPlayer.Overlap = PointOverlap; |
|
|
|
|
|
//------------------------------------ |
|
|
//------------------------------------ |
|
|
newPlayer.Cheat = function() |
|
|
{ |
|
|
.lives = 5; |
|
|
.maxBombs = 10; |
|
|
.bombSize = 5; |
|
|
.DrawStatus(); |
|
|
}; |
|
|
|
|
|
newPlayer.GetStartPos = function() |
|
|
{ |
|
|
// Position near centre. |
|
|
ptx = grid.startX + (grid.rows/2)*grid.spaceX; |
|
|
pty = grid.startY + (grid.cols/2)*grid.spaceY; |
|
|
return table(x = ptx, y = pty); |
|
|
}; |
|
|
|
|
|
pos = newPlayer.GetStartPos(); |
|
|
newPlayer.x = pos.x; |
|
|
newPlayer.y = pos.y; |
|
|
|
|
|
newPlayer.Start = function() |
|
|
{ |
|
|
.threadId = this:thread(.StartThread); |
|
|
}; |
|
|
|
|
|
newPlayer.Stop = function() |
|
|
{ |
|
|
threadKill(.threadId); |
|
|
}; |
|
|
|
|
|
return newPlayer; |
|
|
}; |
|
|
|
|
|
//-------------------------------------------------------------------------------------------------- |
|
|
// Bomb object. |
|
|
//-------------------------------------------------------------------------------------------------- |
|
|
global Bomb = function(a_x, a_y, a_size, a_fuse, a_owner) |
|
|
{ |
|
|
newBomb = table(x = a_x, y = a_y, size = a_size, fuse = a_fuse, owner = a_owner); |
|
|
newBomb.explode = false; |
|
|
newBomb.expMinX = 0; |
|
|
newBomb.expMaxX = 0; |
|
|
newBomb.expMinY = 0; |
|
|
newBomb.expMaxY = 0; |
|
|
newBomb.visible = true; |
|
|
newBomb.threadId = -1; |
|
|
|
|
|
newBomb.CountDown = function() |
|
|
{ |
|
|
this:stateSet(.FuseState); |
|
|
}; |
|
|
|
|
|
newBomb.Explode = function() |
|
|
{ |
|
|
this:stateSetOnThread(.threadId, .ExplodeState); |
|
|
}; |
|
|
|
|
|
newBomb.FuseState = function() |
|
|
{ |
|
|
sleep(.fuse); |
|
|
this:stateSet(.ExplodeState); |
|
|
}; |
|
|
|
|
|
newBomb.ExplodeState = function() |
|
|
{ |
|
|
.expMinX = ScreenClampX(.x - .size); |
|
|
.expMaxX = ScreenClampX(.x + .size); |
|
|
.expMinY = ScreenClampY(.y - .size); |
|
|
.expMaxY = ScreenClampY(.y + .size); |
|
|
|
|
|
.explode = true; |
|
|
.visible = false; |
|
|
.KillStuff(); |
|
|
.visible = true; |
|
|
.Draw(); |
|
|
count = 1+g_count; |
|
|
|
|
|
inc = explodeCycle/explodeTime; |
|
|
for (i = 0; i < explodeTime; i = i + inc) |
|
|
{ |
|
|
sleep(explodeCycle); |
|
|
.Draw(); |
|
|
} |
|
|
|
|
|
.visible = false; |
|
|
RefreshRect(.expMinX, .expMinY, .expMaxX - .expMinX + 1, .expMaxY - .expMinY + 1); |
|
|
if (.owner != null) |
|
|
{ |
|
|
.owner.FreeBomb(this); |
|
|
} |
|
|
exit(); |
|
|
}; |
|
|
|
|
|
newBomb.KillStuff = function() |
|
|
{ |
|
|
// Kill stuff. |
|
|
for (x = .x; x >= .expMinX; x=x-1) |
|
|
{ |
|
|
if (!.TryKill(GetThingAt(x, .y, true))) |
|
|
{ |
|
|
.expMinX = x; |
|
|
break; |
|
|
} |
|
|
} |
|
|
for (x = .x+1; x <= .expMaxX; x=x+1) |
|
|
{ |
|
|
if (!.TryKill(GetThingAt(x, .y, true))) |
|
|
{ |
|
|
.expMaxX = x; |
|
|
break; |
|
|
} |
|
|
} |
|
|
|
|
|
for (y = .y; y >= .expMinY; y=y-1) |
|
|
{ |
|
|
if (!.TryKill(GetThingAt(.x, y, true))) |
|
|
{ |
|
|
.expMinY = y; |
|
|
break; |
|
|
} |
|
|
} |
|
|
for (y = .y+1; y <= .expMaxY; y=y+1) |
|
|
{ |
|
|
if (!.TryKill(GetThingAt(.x, y, true))) |
|
|
{ |
|
|
.expMaxY = y; |
|
|
break; |
|
|
} |
|
|
} |
|
|
}; |
|
|
|
|
|
newBomb.TryKill = function(a_thing) |
|
|
{ |
|
|
if (a_thing.type == T_Block) |
|
|
{ |
|
|
a_thing.thing.Kill(); |
|
|
return false; |
|
|
} |
|
|
else if (a_thing.type == T_Bomb and a_thing.thing != this) |
|
|
{ |
|
|
a_thing.thing.Explode(); |
|
|
} |
|
|
else if (a_thing.type == T_Player or a_thing.type == T_Enemy) |
|
|
{ |
|
|
a_thing.thing.Kill(); |
|
|
} |
|
|
return true; |
|
|
}; |
|
|
|
|
|
newBomb.Draw = function() |
|
|
{ |
|
|
if (.visible) |
|
|
{ |
|
|
if (.explode) |
|
|
{ |
|
|
CATTRIB(bgColour | expColours[randint(0, expColourCount)]); |
|
|
for (x = .expMinX; x <= .expMaxX; x=x+1) |
|
|
{ |
|
|
if (IsSpaceOnGrid(x, .y)) |
|
|
{ |
|
|
XYTEXT(x, .y, expPix); |
|
|
} |
|
|
} |
|
|
|
|
|
for (y = .expMinY; y <= .expMaxY; y=y+1) |
|
|
{ |
|
|
if (IsSpaceOnGrid(.x, y)) |
|
|
{ |
|
|
XYTEXT(.x, y, expPix); |
|
|
} |
|
|
} |
|
|
} |
|
|
else |
|
|
{ |
|
|
CATTRIB(bgColour | bombColour); |
|
|
XYTEXT(.x, .y, bombPix); |
|
|
} |
|
|
} |
|
|
}; |
|
|
|
|
|
newBomb.Overlap = function(a_x1, a_y1, a_x2, a_y2) |
|
|
{ |
|
|
if (.explode) |
|
|
{ |
|
|
return OverlapRect(.expMinX, .y, .expMaxX, .y+1, a_x1, a_y1, a_x2, a_y2) and OverlapRect(.x, .expMinY, .x+1, .expMaxY, a_x1, a_y1, a_x2, a_y2); |
|
|
} |
|
|
return IsPointWithin(.x, .y, a_x1, a_y1, a_x2, a_y2); |
|
|
}; |
|
|
|
|
|
newBomb.FuseThread = function() |
|
|
{ |
|
|
sleep(.fuse); |
|
|
.Explode(); |
|
|
}; |
|
|
|
|
|
newBomb.threadId = newBomb:thread(newBomb.CountDown); |
|
|
newBomb:thread(newBomb.FuseThread); |
|
|
return newBomb; |
|
|
}; |
|
|
|
|
|
//-------------------------------------------------------------------------------------------------- |
|
|
// Block code. |
|
|
//-------------------------------------------------------------------------------------------------- |
|
|
global Block = function(a_x, a_y) |
|
|
{ |
|
|
newBlock = table(x = a_x, y = a_y, visible = true); |
|
|
newBlock.hits = 1; |
|
|
|
|
|
newBlock.Draw = function() |
|
|
{ |
|
|
if (.visible) |
|
|
{ |
|
|
CATTRIB(bgColour | blockColour); |
|
|
if (.hits == 3) |
|
|
{ |
|
|
XYTEXT(.x, .y, block3Pix); |
|
|
} |
|
|
else if (.hits == 2) |
|
|
{ |
|
|
XYTEXT(.x, .y, block2Pix); |
|
|
} |
|
|
else |
|
|
{ |
|
|
XYTEXT(.x, .y, block1Pix); |
|
|
} |
|
|
} |
|
|
}; |
|
|
|
|
|
newBlock.Overlap = PointOverlap; |
|
|
|
|
|
newBlock.KillThread = function() |
|
|
{ |
|
|
yield(); |
|
|
yield(); |
|
|
if (.visible) |
|
|
{ |
|
|
.visible = false; |
|
|
player.AddScore(scoreBlock); |
|
|
if (randint(0, 100) < powerupChance) |
|
|
{ |
|
|
AddPowerup(.x, .y); |
|
|
} |
|
|
} |
|
|
}; |
|
|
|
|
|
newBlock.Kill = function() |
|
|
{ |
|
|
.hits = .hits - 1; |
|
|
if (.hits == 0) |
|
|
{ |
|
|
this:thread(.KillThread); |
|
|
} |
|
|
RefreshXY(.x, .y); |
|
|
}; |
|
|
|
|
|
return newBlock; |
|
|
}; |
|
|
|
|
|
global CreateBlocks = function(a_num) |
|
|
{ |
|
|
global maxBlockHits; |
|
|
global blocks = table(count = 0, blocks = array(a_num)); |
|
|
for (i = 0; i < a_num; i=i+1) |
|
|
{ |
|
|
pos = GetRandomFreePos(DT_Block, true); |
|
|
if (pos.x != -1 and pos.y != -1) |
|
|
{ |
|
|
thing = GetThingAt(pos.x, pos.y, false); |
|
|
if (thing.type == DT_Block) |
|
|
{ |
|
|
if (thing.thing.hits < maxBlockHits) |
|
|
{ |
|
|
thing.thing.hits = thing.thing.hits + 1; |
|
|
} |
|
|
} |
|
|
else |
|
|
{ |
|
|
blocks.blocks[i] = Block(pos.x, pos.y); |
|
|
blocks.count = i; |
|
|
} |
|
|
} |
|
|
} |
|
|
blocks.count = a_num; |
|
|
}; |
|
|
|
|
|
//-------------------------------------------------------------------------------------------------- |
|
|
// Powerup. |
|
|
//-------------------------------------------------------------------------------------------------- |
|
|
global Powerup = function(a_x, a_y, a_type) |
|
|
{ |
|
|
newPu = table(x = a_x, y = a_y, type = a_type); |
|
|
|
|
|
if (a_type == PT_Bomb) |
|
|
{ |
|
|
newPu.Draw = function() |
|
|
{ |
|
|
CATTRIB(bgColour | powerupColour); |
|
|
XYTEXT(.x, .y, bombExtraPix); |
|
|
}; |
|
|
|
|
|
newPu.Pickup = function() |
|
|
{ |
|
|
if (player.maxBombs < maxPlayerBombs) |
|
|
{ |
|
|
player.maxBombs = player.maxBombs + 1; |
|
|
} |
|
|
player.DrawStatus(); |
|
|
RemovePowerup(this); |
|
|
}; |
|
|
} |
|
|
else if (a_type == PT_Size) |
|
|
{ |
|
|
newPu.Draw = function() |
|
|
{ |
|
|
CATTRIB(bgColour | powerupColour); |
|
|
XYTEXT(.x, .y, bombSizePix); |
|
|
}; |
|
|
|
|
|
newPu.Pickup = function() |
|
|
{ |
|
|
if (player.bombSize < maxPlayerSize) |
|
|
{ |
|
|
player.bombSize = player.bombSize + 1; |
|
|
} |
|
|
player.DrawStatus(); |
|
|
RemovePowerup(this); |
|
|
}; |
|
|
} |
|
|
else if (a_type == PT_Life) |
|
|
{ |
|
|
newPu.Draw = function() |
|
|
{ |
|
|
CATTRIB(bgColour | puLifeColour); |
|
|
XYTEXT(.x, .y, lifePix); |
|
|
}; |
|
|
|
|
|
newPu.Pickup = function() |
|
|
{ |
|
|
if (player.lives < maxLives) |
|
|
{ |
|
|
player.lives = player.lives + 1; |
|
|
} |
|
|
player.DrawStatus(); |
|
|
RemovePowerup(this); |
|
|
}; |
|
|
} |
|
|
else |
|
|
{ |
|
|
newPu.Draw = function() |
|
|
{ |
|
|
}; |
|
|
|
|
|
newPu.Pickup = function() |
|
|
{ |
|
|
RemovePowerup(this); |
|
|
}; |
|
|
} |
|
|
|
|
|
newPu.Overlap = PointOverlap; |
|
|
|
|
|
return newPu; |
|
|
}; |
|
|
|
|
|
//-------------------------------------------------------------------------------------------------- |
|
|
// Powerup management. |
|
|
//-------------------------------------------------------------------------------------------------- |
|
|
global RandomPowerupType = function() |
|
|
{ |
|
|
int = randint(0, 100); |
|
|
|
|
|
if (int < 49) |
|
|
{ |
|
|
return PT_Bomb; |
|
|
} |
|
|
if (int < 98) |
|
|
{ |
|
|
return PT_Size; |
|
|
} |
|
|
|
|
|
return PT_Life; |
|
|
}; |
|
|
|
|
|
global AddPowerup = function(a_x, a_y) |
|
|
{ |
|
|
if (powerups.count < maxPowerups) |
|
|
{ |
|
|
powerups.powerups[powerups.count] = Powerup(a_x, a_y, RandomPowerupType()); |
|
|
powerups.count = powerups.count + 1; |
|
|
RefreshXY(a_x, a_y); |
|
|
} |
|
|
}; |
|
|
|
|
|
global RemovePowerup = function(a_pu) |
|
|
{ |
|
|
found = false; |
|
|
count = powerups.count; |
|
|
for (i = 0; i < count; i = i + 1) |
|
|
{ |
|
|
if (powerups.powerups[i] == a_pu) |
|
|
{ |
|
|
found = true; |
|
|
powerups.powerups[i] = null; |
|
|
powerups.count = powerups.count - 1; |
|
|
} |
|
|
if (found) |
|
|
{ |
|
|
if (i+1 < count) |
|
|
{ |
|
|
powerups.powerups[i] = powerups.powerups[i+1]; |
|
|
} |
|
|
else |
|
|
{ |
|
|
powerups.powerups[i] = null; |
|
|
} |
|
|
} |
|
|
} |
|
|
}; |
|
|
|
|
|
global InitPowerups = function() |
|
|
{ |
|
|
global powerups = table(count = 0, powerups = array(maxPowerups)); |
|
|
}; |
|
|
|
|
|
//-------------------------------------------------------------------------------------------------- |
|
|
// Enemies. |
|
|
//-------------------------------------------------------------------------------------------------- |
|
|
global CreateEnemies = function(a_num) |
|
|
{ |
|
|
global enemies = table(count = 0, enemies = array(a_num)); |
|
|
|
|
|
for (i = 0; i < a_num; i=i+1) |
|
|
{ |
|
|
pos = GetRandomFreePos(DT_Enemy, false); |
|
|
if (pos.x != -1 and pos.y != -1) |
|
|
{ |
|
|
enemies.enemies[i] = Enemy(pos.x, pos.y); |
|
|
enemies.count = i+1; |
|
|
} |
|
|
} |
|
|
}; |
|
|
|
|
|
global Enemy = function(a_x, a_y) |
|
|
{ |
|
|
newEnemy = table(x = a_x, y = a_y, dead = false); |
|
|
newEnemy.lastCanMoveThing = null; |
|
|
newEnemy.lastPos = table(x = a_x, y = a_y); |
|
|
newEnemy.threadId = -1; |
|
|
|
|
|
//------------------------------------ |
|
|
//------------------------------------ |
|
|
newEnemy.Draw = function() |
|
|
{ |
|
|
if (!.dead) |
|
|
{ |
|
|
CATTRIB(bgColour | nmeColour); |
|
|
XYTEXT(.x, .y, nmePix); |
|
|
} |
|
|
}; |
|
|
|
|
|
//------------------------------------ |
|
|
//------------------------------------ |
|
|
newEnemy.Kill = function() |
|
|
{ |
|
|
player.AddScore(scoreNME); |
|
|
.dead = true; |
|
|
if (randint(0, 100) < powerupChance) |
|
|
{ |
|
|
AddPowerup(.x, .y); |
|
|
} |
|
|
RefreshXY(.x, .y); |
|
|
}; |
|
|
|
|
|
//------------------------------------ |
|
|
//------------------------------------ |
|
|
newEnemy.Overlap = PointOverlap; |
|
|
|
|
|
//------------------------------------ |
|
|
// Movement. |
|
|
//------------------------------------ |
|
|
newEnemy.CanMove = function(a_x, a_y) |
|
|
{ |
|
|
if (a_x < 0 or a_x >= screen.w or a_y < 0 or a_y > screen.h) |
|
|
{ |
|
|
return false; |
|
|
} |
|
|
|
|
|
thing = GetThingAt(a_x, a_y, false); |
|
|
.lastCanMoveThing = thing; |
|
|
return thing.type == T_Space or thing.type == T_Exlposion or |
|
|
thing.type == T_Powerup or thing.type == T_Player; |
|
|
}; |
|
|
|
|
|
//------------------------------------ |
|
|
//------------------------------------ |
|
|
newEnemy.MoveX = function() |
|
|
{ |
|
|
// Is the player on the same column? |
|
|
if (.y == player.y) |
|
|
{ |
|
|
// Are we within a grid spacing? |
|
|
if (player.x - .x <= grid.spaceX + 1) |
|
|
{ |
|
|
if (.x < player.x) |
|
|
{ |
|
|
start = .x+1; |
|
|
end = player.x+1; |
|
|
moveX = start; |
|
|
} |
|
|
else |
|
|
{ |
|
|
start = player.x+1; |
|
|
end = .x; |
|
|
moveX = end-1; |
|
|
} |
|
|
// Do we have a clear path. |
|
|
moveOk = true; |
|
|
for (x = start; moveOk and x < end; x=x+1) |
|
|
{ |
|
|
if (!.CanMove(x, .y)) |
|
|
{ |
|
|
moveOk = false; |
|
|
} |
|
|
} |
|
|
if (moveOk and .CanMove(moveX, .y)) |
|
|
{ |
|
|
.MoveTo(moveX, .y); |
|
|
return true; |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
mx = 1; |
|
|
if (player.x < .x) |
|
|
{ |
|
|
mx = -1; |
|
|
} |
|
|
if ((.x+mx != .lastPos.x or .y != .lastPos.y) and .CanMove(.x+mx, .y)) |
|
|
{ |
|
|
.MoveTo(.x+mx, .y); |
|
|
return true; |
|
|
} |
|
|
return false; |
|
|
}; |
|
|
|
|
|
//------------------------------------ |
|
|
//------------------------------------ |
|
|
newEnemy.MoveY = function() |
|
|
{ |
|
|
// Is the player on the same row? |
|
|
if (.x == player.x) |
|
|
{ |
|
|
// Are we within a grid spacing? |
|
|
if (player.y - .y <= grid.spaceY + 1) |
|
|
{ |
|
|
if (.y < player.y) |
|
|
{ |
|
|
start = .y+1; |
|
|
end = player.y+1; |
|
|
moveY = start; |
|
|
} |
|
|
else |
|
|
{ |
|
|
start = player.y+1; |
|
|
end = .y; |
|
|
moveY = end-1; |
|
|
} |
|
|
// Do we have a clear path. |
|
|
moveOk = true; |
|
|
for (y = start; moveOk and y < end; y=y+1) |
|
|
{ |
|
|
if (!.CanMove(.x, y)) |
|
|
{ |
|
|
moveOk = false; |
|
|
} |
|
|
} |
|
|
if (moveOk and .CanMove(.x, moveY)) |
|
|
{ |
|
|
.MoveTo(.x, moveY); |
|
|
return true; |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
my = 1; |
|
|
if (player.y < .y) |
|
|
{ |
|
|
my = -1; |
|
|
} |
|
|
if ((.x != .lastPos.x or .y+my != .lastPos.y) and .CanMove(.x, .y+my)) |
|
|
{ |
|
|
.MoveTo(.x, .y+my); |
|
|
return true; |
|
|
} |
|
|
return false; |
|
|
}; |
|
|
|
|
|
//------------------------------------ |
|
|
//------------------------------------ |
|
|
newEnemy.MoveTo = function(a_x, a_y) |
|
|
{ |
|
|
.lastPos.x = .x; |
|
|
.lastPos.y = .y; |
|
|
|
|
|
thing = GetThingAt(a_x, a_y, false); |
|
|
|
|
|
.x = a_x; |
|
|
.y = a_y; |
|
|
|
|
|
if (thing.type == T_Player) |
|
|
{ |
|
|
player.Kill(); |
|
|
} |
|
|
else if (thing.type == T_Explosion) |
|
|
{ |
|
|
.Kill(); |
|
|
} |
|
|
|
|
|
RefreshXY(.lastPos.x, .lastPos.y); |
|
|
RefreshXY(.x, .y); |
|
|
}; |
|
|
|
|
|
//------------------------------------ |
|
|
//------------------------------------ |
|
|
newEnemy.Move = function() |
|
|
{ |
|
|
moved = false; |
|
|
if (!player.dead) |
|
|
{ |
|
|
// Try move towards the player. |
|
|
preferX = abs(player.x - .x) > abs(player.y - .y); |
|
|
if (preferX) |
|
|
{ |
|
|
moved = .MoveX(); |
|
|
if (!moved) |
|
|
{ |
|
|
moved = .MoveY(); |
|
|
} |
|
|
} |
|
|
else |
|
|
{ |
|
|
moved = .MoveY(); |
|
|
if (!moved) |
|
|
{ |
|
|
moved = .MoveX(); |
|
|
} |
|
|
} |
|
|
|
|
|
// Try move away from the last position. |
|
|
if (!moved) |
|
|
{ |
|
|
testX = 2*.x - .lastPos.x; |
|
|
testY = 2*.y - .lastPos.y; |
|
|
if (.CanMove(testX, testY)) |
|
|
{ |
|
|
.MoveTo(testX, testY); |
|
|
moved = true; |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
if (!moved and (.lastPos.x != .x or .lastPos.y != .y) and .CanMove(.lastPos.x, .lastPos.y)) |
|
|
{ |
|
|
.MoveTo(.lastPos.x, .lastPos.y); |
|
|
} |
|
|
}; |
|
|
|
|
|
//------------------------------------ |
|
|
// Thread functions and states. |
|
|
//------------------------------------ |
|
|
newEnemy.Start = function() |
|
|
{ |
|
|
.threadId = this:thread(.IdleState); |
|
|
}; |
|
|
|
|
|
//------------------------------------ |
|
|
//------------------------------------ |
|
|
newEnemy.IdleState = function() |
|
|
{ |
|
|
while (!quit and !.dead) |
|
|
{ |
|
|
sleep(nmeMoveTime); |
|
|
.Move(); |
|
|
} |
|
|
}; |
|
|
|
|
|
newEnemy.Start(); |
|
|
|
|
|
return newEnemy; |
|
|
}; |
|
|
|
|
|
//-------------------------------------------------------------------------------------------------- |
|
|
// Refresh functions. |
|
|
//-------------------------------------------------------------------------------------------------- |
|
|
global Refresh = function() |
|
|
{ |
|
|
CATTRIB(bgColour | fgColour); |
|
|
CLS(); |
|
|
|
|
|
// Draw blocks. |
|
|
for (b = 0; b < blocks.count; b=b+1) |
|
|
{ |
|
|
blocks.blocks[b].Draw(); |
|
|
} |
|
|
|
|
|
// Draw powerups. |
|
|
for (p = 0; p < powerups.count; p=p+1) |
|
|
{ |
|
|
powerups.powerups[p].Draw(); |
|
|
} |
|
|
|
|
|
// Draw enemies. |
|
|
for (e = 0; e < enemies.count; e=e+1) |
|
|
{ |
|
|
enemies.enemies[e].Draw(); |
|
|
} |
|
|
|
|
|
// Draw bombs. |
|
|
for (b = 0; b < player.nextBomb; b=b+1) |
|
|
{ |
|
|
player.bombs[b].Draw(); |
|
|
} |
|
|
|
|
|
player.Draw(); |
|
|
player.DrawStatus(); |
|
|
|
|
|
DrawGrid(); |
|
|
}; |
|
|
|
|
|
global RefreshXY = function(a_x, a_y) |
|
|
{ |
|
|
RefreshRect(a_x, a_y, 1, 1); |
|
|
}; |
|
|
|
|
|
global RefreshRect = function(a_x, a_y, a_w, a_h) |
|
|
{ |
|
|
// Clear the area. |
|
|
xLimit = a_x + a_w; |
|
|
yLimit = a_y + a_h; |
|
|
CATTRIB(bgColour | fgColour); |
|
|
for (x = a_x; x < xLimit; x=x+1) |
|
|
{ |
|
|
for (y = a_y; y < yLimit; y=y+1) |
|
|
{ |
|
|
XYTEXT(x, y, spacePix); |
|
|
} |
|
|
} |
|
|
|
|
|
// Draw blocks. |
|
|
for (b = 0; b < blocks.count; b=b+1) |
|
|
{ |
|
|
blk = blocks.blocks[b]; |
|
|
if (blk.Overlap(a_x, a_y, xLimit, yLimit)) |
|
|
{ |
|
|
blk.Draw(); |
|
|
} |
|
|
} |
|
|
|
|
|
// Draw powerups. |
|
|
for (p = 0; p < powerups.count; p=p+1) |
|
|
{ |
|
|
pu = powerups.powerups[p]; |
|
|
if (pu.Overlap(a_x, a_y, xLimit, yLimit)) |
|
|
{ |
|
|
pu.Draw(); |
|
|
} |
|
|
} |
|
|
|
|
|
// Draw enemies. |
|
|
for (e = 0; e < enemies.count; e=e+1) |
|
|
{ |
|
|
nme = enemies.enemies[e]; |
|
|
if (nme.Overlap(a_x, a_y, xLimit, yLimit)) |
|
|
{ |
|
|
nme.Draw(); |
|
|
} |
|
|
} |
|
|
|
|
|
// Draw bombs. |
|
|
for (b = 0; b < player.nextBomb; b=b+1) |
|
|
{ |
|
|
bomb = player.bombs[b]; |
|
|
if (bomb.Overlap(a_x, a_y, xLimit, yLimit)) |
|
|
{ |
|
|
bomb.Draw(); |
|
|
} |
|
|
} |
|
|
|
|
|
if (player.Overlap(a_x, a_y, xLimit, yLimit)) |
|
|
{ |
|
|
player.Draw(); |
|
|
} |
|
|
|
|
|
DrawGridRect(a_x, a_y, a_w, a_h); |
|
|
}; |
|
|
|
|
|
//-------------------------------------------------------------------------------------------------- |
|
|
// Grid control. |
|
|
//-------------------------------------------------------------------------------------------------- |
|
|
global Grid = function(a_startX, a_startY, a_spaceX, a_spaceY) |
|
|
{ |
|
|
grid.startX = a_startX; |
|
|
grid.startY = a_startY; |
|
|
grid.spaceX = a_spaceX; |
|
|
grid.spaceY = a_spaceY; |
|
|
|
|
|
grid.rows = (screen.w-grid.startX) / (grid.spaceX + 1); |
|
|
grid.cols = (screen.h-grid.startY) / (grid.spaceY + 1); |
|
|
|
|
|
if ((screen.w-grid.startX) % (grid.spaceX + 1) != 0) |
|
|
{ |
|
|
grid.rows = grid.rows + 1; |
|
|
} |
|
|
|
|
|
if ((screen.h-grid.startY) % (grid.spaceY + 1) != 0) |
|
|
{ |
|
|
grid.cols = grid.cols + 1; |
|
|
} |
|
|
}; |
|
|
|
|
|
global DrawGrid = function() |
|
|
{ |
|
|
DrawGridRect(0, 0, screen.w, screen.h); |
|
|
}; |
|
|
|
|
|
global DrawGridRect = function(a_startX, a_startY, a_w, a_h) |
|
|
{ |
|
|
xLimit = a_startX + a_w; |
|
|
yLimit = a_startY + a_h; |
|
|
CATTRIB(bgColour | gridColour); |
|
|
for (x = a_startX; x < xLimit; x=x+1) |
|
|
{ |
|
|
for (y = a_startY; y < yLimit; y=y+1) |
|
|
{ |
|
|
if (!IsSpaceOnGrid(x, y)) |
|
|
{ |
|
|
XYTEXT(x, y, gridPix); |
|
|
} |
|
|
} |
|
|
} |
|
|
}; |
|
|
|
|
|
global IsSpaceOnGrid = function(a_x, a_y) |
|
|
{ |
|
|
return (a_x - grid.startX) % (grid.spaceX+1) == 0 or (a_y - grid.startY) % (grid.spaceY+1) == 0; |
|
|
}; |
|
|
|
|
|
global IsFreePos = function(a_x, a_y, a_allowBlocks) |
|
|
{ |
|
|
thing = GetThingAt(a_x, a_y, true); |
|
|
return thing.type == T_Space or (a_allowBlocks and thing.type == T_Block); |
|
|
}; |
|
|
|
|
|
global GetThingAt = function(a_x, a_y, a_ignoreExplosion) |
|
|
{ |
|
|
if (!IsSpaceOnGrid(a_x, a_y)) |
|
|
{ |
|
|
return table(thing = grid, type = T_Grid); |
|
|
} |
|
|
|
|
|
// Test blocks |
|
|
for (b = 0; b < blocks.count; b=b+1) |
|
|
{ |
|
|
blk = blocks.blocks[b]; |
|
|
if (blk.visible and blk.x == a_x and blk.y == a_y) |
|
|
{ |
|
|
return table(thing = blk, type = T_Block); |
|
|
} |
|
|
} |
|
|
|
|
|
// Test enemies. |
|
|
for (e = 0; e < enemies.count; e=e+1) |
|
|
{ |
|
|
nme = enemies.enemies[e]; |
|
|
if (!nme.dead and nme.x == a_x and nme.y == a_y) |
|
|
{ |
|
|
return table(thing = nme, type = T_Enemy); |
|
|
} |
|
|
} |
|
|
|
|
|
// Test player pos. |
|
|
if (!player.dead and a_x == player.x and a_y == player.y) |
|
|
{ |
|
|
return table(thing = player, type = T_Player); |
|
|
} |
|
|
|
|
|
// Test bombs. |
|
|
for (b = 0; b < player.nextBomb; b=b+1) |
|
|
{ |
|
|
bomb = player.bombs[b]; |
|
|
if (!bomb.explode) |
|
|
{ |
|
|
if (bomb.x == a_x and bomb.y == a_y) |
|
|
{ |
|
|
return table(thing = bomb, type = T_Bomb); |
|
|
} |
|
|
} |
|
|
else if (!a_ignoreExplosion and bomb.Overlap(a_x, a_y, a_x+1, a_y+1)) |
|
|
{ |
|
|
return table(thing = bomb, type = T_Explosion); |
|
|
} |
|
|
} |
|
|
|
|
|
// Test powerups. |
|
|
for (p = 0; p < powerups.count; p=p+1) |
|
|
{ |
|
|
pu = powerups.powerups[p]; |
|
|
if (pu.x == a_x and pu.y == a_y) |
|
|
{ |
|
|
return table(thing = pu, type = T_Powerup); |
|
|
} |
|
|
} |
|
|
|
|
|
return table(thing = null, type = T_Space); |
|
|
}; |
|
|
|
|
|
global InDeadZone = function(a_dtType, a_x, a_y) |
|
|
{ |
|
|
if (a_dtType == DT_Block) |
|
|
{ |
|
|
return IsPointWithin(a_x, a_y, blockDeadZone.x1, blockDeadZone.y1, blockDeadZone.x2, blockDeadZone.y2); |
|
|
} |
|
|
if (a_dtType == DT_Enemy) |
|
|
{ |
|
|
return IsPointWithin(a_x, a_y, enemyDeadZone.x1, enemyDeadZone.y1, enemyDeadZone.x2, enemyDeadZone.y2); |
|
|
} |
|
|
return false; |
|
|
}; |
|
|
|
|
|
global GetRandomFreePos1 = function(a_deadZoneType, a_allowBlocks, a_tries) |
|
|
{ |
|
|
row = randint(0, grid.rows); |
|
|
col = randint(0, grid.cols); |
|
|
|
|
|
px = row*grid.spaceX + grid.startX; |
|
|
py = col*grid.spaceY + grid.startY; |
|
|
|
|
|
if (a_deadZoneType != DT_None and InDeadZone(a_deadZoneType, px, py)) |
|
|
{ |
|
|
return GetRandomFreePos1(a_deadZoneType, a_tries); |
|
|
} |
|
|
|
|
|
if (IsFreePos(px, py)) |
|
|
{ |
|
|
return table(x = px, y = py); |
|
|
} |
|
|
|
|
|
while (py < screen.h) |
|
|
{ |
|
|
py=py+1; |
|
|
if ((a_deadZoneType == DT_None or !InDeadZone(a_deadZoneType, px, py)) and IsFreePos(px, py)) |
|
|
{ |
|
|
return table(x = px, y = py); |
|
|
} |
|
|
} |
|
|
|
|
|
if (tries < 5) |
|
|
{ |
|
|
return GetRandomFreePos1(a_tries+1); |
|
|
} |
|
|
return table(x = -1, y = -1); |
|
|
}; |
|
|
|
|
|
global GetRandomFreePos = function(a_deadZoneType, a_allowBlocks) |
|
|
{ |
|
|
return GetRandomFreePos1(a_deadZoneType, a_allowBlocks, 0); |
|
|
}; |
|
|
|
|
|
//-------------------------------------------------------------------------------------------------- |
|
|
// Initialisation. |
|
|
//-------------------------------------------------------------------------------------------------- |
|
|
RenderRect = function(a_rect) |
|
|
{ |
|
|
CATTRIB(bgColour | gridColour); |
|
|
for (i = a_rect.x1; i <= a_rect.x2; i=i+1) |
|
|
{ |
|
|
for (j = a_rect.y1; j <= a_rect.y2; j=j+1) |
|
|
{ |
|
|
XYTEXT(i, j, "o"); |
|
|
} |
|
|
} |
|
|
}; |
|
|
|
|
|
MemThread = function() |
|
|
{ |
|
|
while (!quit) |
|
|
{ |
|
|
CATTRIB(bgColour | statusColour); |
|
|
XYTEXT(65, statusY, format("Mem: %d ", sysGetMemoryUsage())); |
|
|
sleep(1.0); |
|
|
} |
|
|
}; |
|
|
|
|
|
//-------------------------------------------------------------------------------------------------- |
|
|
// Level thread. |
|
|
//-------------------------------------------------------------------------------------------------- |
|
|
global GameOver = function() |
|
|
{ |
|
|
CATTRIB(bgColour | statusColour); |
|
|
CLS(); |
|
|
|
|
|
local score = player.score; |
|
|
KillAll(); |
|
|
|
|
|
sleep(0.3); |
|
|
|
|
|
global quit; |
|
|
while (!quit) |
|
|
{ |
|
|
CATTRIB(bgColour | expColours[randint(0, expColourCount)]); |
|
|
x = 8; |
|
|
y = 8; |
|
|
XYTEXT(x, y, "__________________________________________________________"); y=y+1; |
|
|
XYTEXT(x, y, " __ __ "); y=y+1; |
|
|
XYTEXT(x, y, " / ) / ) "); y=y+1; |
|
|
XYTEXT(x, y, " / __ _ _ __ / / __ )__ "); y=y+1; |
|
|
XYTEXT(x, y, " / --, / ) / / ) /___) / / | / /___) / )"); y=y+1; |
|
|
XYTEXT(x, y, "_(____/___(___(_/_/__/_(___ ____(____/____|/__(___ _/_____"); y=y+1; |
|
|
|
|
|
CATTRIB(bgColour | statusColour); |
|
|
XYTEXT(0, statusY, format("Score : %d", score)); |
|
|
|
|
|
if (threadTime() < 1000 and ISPRESSED(' ')) |
|
|
{ |
|
|
stateSet(TitleScreenState); |
|
|
} |
|
|
else if (ISPRESSED(27)) |
|
|
{ |
|
|
quit = true; |
|
|
} |
|
|
|
|
|
sleep(randfloat(0.03, 0.3)); |
|
|
} |
|
|
|
|
|
global player = null; |
|
|
global blocks = null; |
|
|
global enemies = null; |
|
|
|
|
|
stateSet(TitleScreenState); |
|
|
}; |
|
|
|
|
|
global GameState = function() |
|
|
{ |
|
|
global maxLevel; |
|
|
global player; |
|
|
global blocks; |
|
|
global enemies; |
|
|
global gameLevel; |
|
|
Grid(3, 2, 5, 5); |
|
|
if (player == null or player.lives <= 0) |
|
|
{ |
|
|
player = Player(); |
|
|
} |
|
|
pos = player.GetStartPos(); |
|
|
player.x = pos.x; |
|
|
player.y = pos.y; |
|
|
|
|
|
global nmeMoveTime = 1.0 - gameLevel*0.1; |
|
|
|
|
|
InitPowerups(); |
|
|
CreateBlocks(min(10 + 10*gameLevel, 99)); |
|
|
CreateEnemies(5*gameLevel); |
|
|
yield(); |
|
|
Refresh(); |
|
|
|
|
|
yield(); |
|
|
player.Start(); |
|
|
|
|
|
local done = false; |
|
|
while (!quit and !done) |
|
|
{ |
|
|
local count; |
|
|
|
|
|
done = true; |
|
|
if (ISPRESSED(27)) |
|
|
{ |
|
|
global quit = true; |
|
|
break; |
|
|
} |
|
|
/* |
|
|
// Check blocks. |
|
|
count = blocks.count; |
|
|
for (i = 0; done and i < count; i=i+1) |
|
|
{ |
|
|
blk = blocks.blocks[i]; |
|
|
if (blk.visible) |
|
|
{ |
|
|
done = false; |
|
|
} |
|
|
} |
|
|
*/ |
|
|
// Check enemies. |
|
|
count = enemies.count; |
|
|
for (i = 0; done and i < count; i=i+1) |
|
|
{ |
|
|
nme = enemies.enemies[i]; |
|
|
if (!nme.dead) |
|
|
{ |
|
|
done = false; |
|
|
} |
|
|
} |
|
|
|
|
|
// Check bombs. |
|
|
done = done and player.nextBomb == 0; |
|
|
|
|
|
// Check for lives. |
|
|
done = done or player.lives <= 0; |
|
|
|
|
|
sleep(0.3); |
|
|
} |
|
|
|
|
|
player.Stop(); |
|
|
|
|
|
if (!quit) |
|
|
{ |
|
|
if (player.lives <= 0) |
|
|
{ |
|
|
stateSet(GameOver); |
|
|
} |
|
|
global gameLevel; |
|
|
gameLevel=gameLevel+1; |
|
|
stateSet(LevelState); |
|
|
} |
|
|
|
|
|
KillAll(); |
|
|
}; |
|
|
|
|
|
global LevelState = function() |
|
|
{ |
|
|
global maxLevel; |
|
|
global gameLevel; |
|
|
|
|
|
if (gameLevel > maxLevel) |
|
|
{ |
|
|
gameLevel = maxLevel; |
|
|
} |
|
|
|
|
|
CATTRIB(bgColour | statusColour); |
|
|
CLS(); |
|
|
|
|
|
sleep(0.3); |
|
|
|
|
|
global quit; |
|
|
while (!quit) |
|
|
{ |
|
|
CATTRIB(bgColour | expColours[randint(0, expColourCount)]); |
|
|
x = 17; |
|
|
y = 8; |
|
|
XYTEXT(x, y, "___________________________________________"); y=y+1; |
|
|
XYTEXT(x, y, " ____ ___ "); y=y+1; |
|
|
XYTEXT(x, y, " / ) / ( ) "); y=y+1; |
|
|
XYTEXT(x, y, " /___ / __ __ __ / / "); y=y+1; |
|
|
XYTEXT(x, y, " / | /___) / ) / / / / / "); y=y+1; |
|
|
XYTEXT(x, y, "_/_____|__(___ _(___(_(___/___(___/__o_____"); y=y+1; |
|
|
XYTEXT(x, y, " / "); y=y+1; |
|
|
XYTEXT(x, y, " (_ / "); y=y+1; |
|
|
|
|
|
if (threadTime() > 1000 and ISPRESSED(' ')) |
|
|
{ |
|
|
CLS(); |
|
|
sleep(0.5); |
|
|
stateSet(GameState); |
|
|
} |
|
|
else if (ISPRESSED(27)) |
|
|
{ |
|
|
quit = true; |
|
|
} |
|
|
|
|
|
sleep(randfloat(0.03, 0.3)); |
|
|
} |
|
|
|
|
|
KillAll(); |
|
|
}; |
|
|
|
|
|
global KillAll = function() |
|
|
{ |
|
|
// Kill all threads. |
|
|
global player; |
|
|
global enemies; |
|
|
global blocks; |
|
|
|
|
|
if (player) |
|
|
{ |
|
|
local count = player.nextBomb; |
|
|
for (i = 0; i < count; i=i+1) |
|
|
{ |
|
|
threadKill(player.bombs[i].threadId); |
|
|
} |
|
|
threadKill(player.threadId); |
|
|
} |
|
|
|
|
|
if (enemies) |
|
|
{ |
|
|
count = enemies.count; |
|
|
for (i = 0; i < count; i=i+1) |
|
|
{ |
|
|
threadKill(enemies.enemies[i].threadId); |
|
|
} |
|
|
} |
|
|
}; |
|
|
|
|
|
global TitleScreenState = function() |
|
|
{ |
|
|
CATTRIB(bgColour | statusColour); |
|
|
CLS(); |
|
|
sleep(0.3); |
|
|
while (!quit) |
|
|
{ |
|
|
CATTRIB(bgColour | expColours[randint(0, expColourCount)]); |
|
|
x = 17; |
|
|
y = 8; |
|
|
XYTEXT(x, y, "_________________________________________"); y=y+1; |
|
|
XYTEXT(x, y, " ____ "); y=y+1; |
|
|
XYTEXT(x, y, " / ) / "); y=y+1; |
|
|
XYTEXT(x, y, " /__ / __ _ _ /__ __ )__ "); y=y+1; |
|
|
XYTEXT(x, y, " / ) / ) / / ) / ) /___) / )"); y=y+1; |
|
|
XYTEXT(x, y, "_/____/___(___/_/_/__/_(___/_(___ _/_____"); y=y+1; |
|
|
XYTEXT(x, y, "_________________________________________"); y=y+1; |
|
|
|
|
|
if (ISPRESSED(27)) |
|
|
{ |
|
|
global quit = true; |
|
|
break; |
|
|
} |
|
|
else if (ISPRESSED(' ')) |
|
|
{ |
|
|
global gameLevel = 1; |
|
|
stateSet(LevelState); |
|
|
} |
|
|
sleep(randfloat(0.03, 0.3)); |
|
|
} |
|
|
|
|
|
KillAll(); |
|
|
exit(); |
|
|
}; |
|
|
|
|
|
CURSOR(0, 0); // bool visible, percentage visible |
|
|
CATTRIB(fgColour | bgColour); |
|
|
|
|
|
thread(MemThread); |
|
|
|
|
|
quit = false; |
|
|
CLS(); |
|
|
|
|
|
stateSet(TitleScreenState);
|
|
|
|
