2020-01-01 21:29:24 +01:00
|
|
|
#include "Logic.h"
|
2020-02-10 01:53:01 +01:00
|
|
|
#include "Script.h"
|
2020-01-01 21:29:24 +01:00
|
|
|
#include "Network.h"
|
|
|
|
|
|
|
|
extern int temp;
|
2020-02-10 01:53:01 +01:00
|
|
|
extern scriptclass script;
|
2020-01-01 21:29:24 +01:00
|
|
|
|
2020-04-01 23:48:11 +02:00
|
|
|
void titlelogic()
|
2020-01-01 21:29:24 +01:00
|
|
|
{
|
|
|
|
//Misc
|
|
|
|
//map.updatetowerglow();
|
|
|
|
help.updateglow();
|
|
|
|
|
|
|
|
map.bypos -= 2;
|
|
|
|
map.bscroll = -2;
|
|
|
|
|
|
|
|
if (game.menucountdown > 0)
|
|
|
|
{
|
|
|
|
game.menucountdown--;
|
|
|
|
if (game.menucountdown == 0)
|
|
|
|
{
|
|
|
|
if (game.menudest == "mainmenu")
|
|
|
|
{
|
|
|
|
music.play(6);
|
|
|
|
}
|
|
|
|
else if (game.menudest == "gameover2")
|
|
|
|
{
|
2020-04-02 01:36:35 +02:00
|
|
|
music.playef(11);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
else if (game.menudest == "timetrialcomplete3")
|
|
|
|
{
|
2020-04-02 01:36:35 +02:00
|
|
|
music.playef(3);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
game.createmenu(game.menudest);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-04-01 23:48:11 +02:00
|
|
|
void maplogic()
|
2020-01-01 21:29:24 +01:00
|
|
|
{
|
|
|
|
//Misc
|
|
|
|
help.updateglow();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-04-01 23:48:11 +02:00
|
|
|
void gamecompletelogic()
|
2020-01-01 21:29:24 +01:00
|
|
|
{
|
|
|
|
//Misc
|
|
|
|
map.updatetowerglow();
|
|
|
|
help.updateglow();
|
2020-04-01 23:48:11 +02:00
|
|
|
graphics.crewframe = 0;
|
2020-01-01 21:29:24 +01:00
|
|
|
|
|
|
|
map.tdrawback = true;
|
|
|
|
|
|
|
|
game.creditposition--;
|
2020-01-17 02:14:56 +01:00
|
|
|
if (game.creditposition <= -game.creditmaxposition)
|
2020-01-01 21:29:24 +01:00
|
|
|
{
|
2020-01-17 02:14:56 +01:00
|
|
|
game.creditposition = -game.creditmaxposition;
|
2020-01-01 21:29:24 +01:00
|
|
|
map.bscroll = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
map.bypos += 1;
|
|
|
|
map.bscroll = +1;
|
|
|
|
}
|
|
|
|
|
2020-04-01 23:48:11 +02:00
|
|
|
if (graphics.fademode == 1)
|
2020-01-01 21:29:24 +01:00
|
|
|
{
|
|
|
|
//Fix some graphical things
|
2020-04-01 23:48:11 +02:00
|
|
|
graphics.showcutscenebars = false;
|
|
|
|
graphics.cutscenebarspos = 0;
|
2020-01-01 21:29:24 +01:00
|
|
|
//Return to game
|
|
|
|
game.gamestate = 7;
|
2020-04-01 23:48:11 +02:00
|
|
|
graphics.fademode = 4;
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-04-01 23:48:11 +02:00
|
|
|
void gamecompletelogic2()
|
2020-01-01 21:29:24 +01:00
|
|
|
{
|
|
|
|
//Misc
|
|
|
|
map.updatetowerglow();
|
|
|
|
help.updateglow();
|
|
|
|
|
|
|
|
game.creditposdelay--;
|
|
|
|
if (game.creditposdelay <= 0)
|
|
|
|
{
|
|
|
|
game.creditposdelay = 1;
|
|
|
|
game.creditposx++;
|
|
|
|
if (game.creditposx > 40)
|
|
|
|
{
|
|
|
|
game.creditposy++;
|
|
|
|
game.creditposx = 0;
|
|
|
|
if (game.creditposy > 30) game.creditposy = 30;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-04-01 23:48:11 +02:00
|
|
|
if (graphics.fademode == 1)
|
2020-01-01 21:29:24 +01:00
|
|
|
{
|
|
|
|
//Fix some graphical things
|
2020-04-01 23:48:11 +02:00
|
|
|
graphics.showcutscenebars = false;
|
|
|
|
graphics.cutscenebarspos = 0;
|
2020-01-01 21:29:24 +01:00
|
|
|
//Fix the save thingy
|
|
|
|
game.deletequick();
|
|
|
|
int tmp=music.currentsong;
|
|
|
|
music.currentsong=4;
|
2020-03-31 02:16:02 +02:00
|
|
|
game.savetele();
|
2020-01-01 21:29:24 +01:00
|
|
|
music.currentsong=tmp;
|
|
|
|
//Return to game
|
|
|
|
map.colstate = 10;
|
|
|
|
game.gamestate = 1;
|
2020-04-01 23:48:11 +02:00
|
|
|
graphics.fademode = 4;
|
2020-04-02 01:36:35 +02:00
|
|
|
music.playef(18);
|
2020-01-01 21:29:24 +01:00
|
|
|
game.createmenu("gamecompletecontinue");
|
|
|
|
map.nexttowercolour();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-04-01 23:48:11 +02:00
|
|
|
void towerlogic()
|
2020-01-01 21:29:24 +01:00
|
|
|
{
|
|
|
|
//Logic for the tower level
|
|
|
|
map.updatetowerglow();
|
|
|
|
help.updateglow();
|
|
|
|
|
|
|
|
if(!game.completestop)
|
|
|
|
{
|
|
|
|
if (map.cameramode == 0)
|
|
|
|
{
|
|
|
|
//do nothing!
|
|
|
|
//a trigger will set this off in the game
|
|
|
|
map.cameramode = 1;
|
|
|
|
map.bscroll = 0;
|
|
|
|
}
|
|
|
|
else if (map.cameramode == 1)
|
|
|
|
{
|
|
|
|
//move normally
|
|
|
|
if(map.scrolldir==0)
|
|
|
|
{
|
|
|
|
map.ypos -= 2;
|
|
|
|
map.bypos -= 1;
|
|
|
|
map.bscroll = -1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
map.ypos += 2;
|
|
|
|
map.bypos += 1;
|
|
|
|
map.bscroll = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (map.cameramode == 2)
|
|
|
|
{
|
|
|
|
//do nothing, but cycle colours (for taking damage)
|
|
|
|
map.bscroll = 0;
|
|
|
|
}
|
|
|
|
else if (map.cameramode == 4)
|
|
|
|
{
|
|
|
|
int i = obj.getplayer();
|
|
|
|
map.cameraseek = map.ypos - (obj.entities[i].yp - 120);
|
|
|
|
|
|
|
|
map.cameraseek = map.cameraseek / 10;
|
|
|
|
map.cameraseekframe = 10;
|
|
|
|
|
|
|
|
map.cameramode = 5;
|
|
|
|
|
|
|
|
map.bscroll = map.cameraseek/2;
|
|
|
|
}
|
|
|
|
else if (map.cameramode == 5)
|
|
|
|
{
|
|
|
|
//actually do it
|
|
|
|
if (map.spikeleveltop > 0) map.spikeleveltop-=2;
|
|
|
|
if (map.spikelevelbottom > 0) map.spikelevelbottom-=2;
|
|
|
|
if (map.cameraseekframe > 0)
|
|
|
|
{
|
|
|
|
int i = obj.getplayer();
|
|
|
|
map.ypos -= map.cameraseek;
|
|
|
|
if (map.cameraseek > 0)
|
|
|
|
{
|
|
|
|
if (map.ypos < obj.entities[i].yp - 120)
|
|
|
|
{
|
|
|
|
map.ypos = obj.entities[i].yp - 120;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (map.ypos > obj.entities[i].yp - 120)
|
|
|
|
{
|
|
|
|
map.ypos = obj.entities[i].yp - 120;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
map.cameraseekframe--;
|
|
|
|
map.bypos = map.ypos / 2;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
int i = obj.getplayer();
|
|
|
|
map.ypos = obj.entities[i].yp - 120;
|
|
|
|
map.bypos = map.ypos / 2;
|
|
|
|
map.cameramode = 0;
|
|
|
|
map.colsuperstate = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
map.bscroll = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (map.ypos <= 0)
|
|
|
|
{
|
|
|
|
map.ypos = 0;
|
|
|
|
map.bypos = 0;
|
|
|
|
map.bscroll = 0;
|
|
|
|
}
|
|
|
|
if (map.minitowermode)
|
|
|
|
{
|
|
|
|
if (map.ypos >= 568)
|
|
|
|
{
|
|
|
|
map.ypos = 568;
|
|
|
|
map.bypos = map.ypos / 2;
|
|
|
|
map.bscroll = 0;
|
|
|
|
} //100-29 * 8 = 568
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (map.ypos >= 5368)
|
|
|
|
{
|
|
|
|
map.ypos = 5368; //700-29 * 8 = 5368
|
|
|
|
map.bypos = map.ypos / 2.0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (game.lifeseq > 0)
|
|
|
|
{
|
|
|
|
if (map.cameramode == 2)
|
|
|
|
{
|
|
|
|
map.cameraseekframe = 20;
|
|
|
|
map.cameramode = 4;
|
|
|
|
map.resumedelay = 4;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (map.cameraseekframe <= 0)
|
|
|
|
{
|
|
|
|
if (map.resumedelay <= 0)
|
|
|
|
{
|
2020-03-31 02:16:02 +02:00
|
|
|
game.lifesequence();
|
2020-01-01 21:29:24 +01:00
|
|
|
if (game.lifeseq == 0) map.cameramode = 1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
map.resumedelay--;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (game.deathseq != -1)
|
|
|
|
{
|
2020-01-17 13:47:34 +01:00
|
|
|
map.colsuperstate = 1;
|
2020-01-01 21:29:24 +01:00
|
|
|
map.cameramode = 2;
|
2020-03-31 02:16:02 +02:00
|
|
|
game.deathsequence();
|
2020-01-01 21:29:24 +01:00
|
|
|
game.deathseq--;
|
|
|
|
if (game.deathseq <= 0)
|
|
|
|
{
|
|
|
|
if (game.nodeathmode)
|
|
|
|
{
|
|
|
|
game.deathseq = 1;
|
2020-03-31 02:16:02 +02:00
|
|
|
game.gethardestroom();
|
2020-01-01 21:29:24 +01:00
|
|
|
//start depressing sequence here...
|
2020-04-01 23:48:11 +02:00
|
|
|
if (game.gameoverdelay <= -10 && graphics.fademode==0) graphics.fademode = 2;
|
|
|
|
if (graphics.fademode == 1) script.resetgametomenu();
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (game.currentroomdeaths > game.hardestroomdeaths)
|
|
|
|
{
|
|
|
|
game.hardestroomdeaths = game.currentroomdeaths;
|
|
|
|
game.hardestroom = map.roomname;
|
|
|
|
}
|
|
|
|
|
|
|
|
game.gravitycontrol = game.savegc;
|
2020-04-01 23:48:11 +02:00
|
|
|
graphics.textboxremove();
|
2020-03-31 10:09:42 +02:00
|
|
|
map.resetplayer();
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
//State machine for game logic
|
2020-03-31 02:16:02 +02:00
|
|
|
game.updatestate();
|
2020-01-01 21:29:24 +01:00
|
|
|
|
|
|
|
|
|
|
|
//Time trial stuff
|
|
|
|
if (game.intimetrial)
|
|
|
|
{
|
|
|
|
if (game.timetrialcountdown > 0)
|
|
|
|
{
|
|
|
|
game.hascontrol = true;
|
|
|
|
game.timetrialcountdown--;
|
|
|
|
if (game.timetrialcountdown > 30)
|
|
|
|
{
|
|
|
|
game.hascontrol = false;
|
|
|
|
}
|
2020-04-02 01:36:35 +02:00
|
|
|
if(game.timetrialcountdown == 120) music.playef(21);
|
|
|
|
if(game.timetrialcountdown == 90) music.playef(21);
|
|
|
|
if(game.timetrialcountdown == 60) music.playef(21);
|
2020-01-01 21:29:24 +01:00
|
|
|
if (game.timetrialcountdown == 30)
|
|
|
|
{
|
|
|
|
switch(game.timetriallevel)
|
|
|
|
{
|
|
|
|
case 0:
|
|
|
|
music.play(1);
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
music.play(3);
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
music.play(2);
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
music.play(1);
|
|
|
|
break;
|
|
|
|
case 4:
|
|
|
|
music.play(12);
|
|
|
|
break;
|
|
|
|
case 5:
|
|
|
|
music.play(15);
|
|
|
|
break;
|
|
|
|
}
|
2020-04-02 01:36:35 +02:00
|
|
|
music.playef(22);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//Have we lost the par?
|
|
|
|
if (!game.timetrialparlost)
|
|
|
|
{
|
|
|
|
if ((game.minutes * 60) + game.seconds > game.timetrialpar)
|
|
|
|
{
|
|
|
|
game.timetrialparlost = true;
|
|
|
|
int i = obj.getplayer();
|
|
|
|
if (i > -1)
|
|
|
|
{
|
|
|
|
obj.entities[i].tile = 144;
|
|
|
|
}
|
2020-04-02 01:36:35 +02:00
|
|
|
music.playef(2);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//Update entities
|
|
|
|
|
|
|
|
if(!game.completestop)
|
|
|
|
{
|
|
|
|
for (int i = obj.nentity - 1; i >= 0; i--)
|
|
|
|
{
|
2020-03-31 02:46:36 +02:00
|
|
|
obj.updateentities(i); // Behavioral logic
|
|
|
|
obj.updateentitylogic(i); // Basic Physics
|
|
|
|
obj.entitymapcollision(i); // Collisions with walls
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
|
2020-03-31 02:46:36 +02:00
|
|
|
obj.entitycollisioncheck(); // Check ent v ent collisions, update states
|
2020-01-01 21:29:24 +01:00
|
|
|
//special for tower: is the player touching any spike blocks?
|
|
|
|
int player = obj.getplayer();
|
2020-04-01 23:48:11 +02:00
|
|
|
if(obj.checktowerspikes(player) && graphics.fademode==0)
|
2020-01-01 21:29:24 +01:00
|
|
|
{
|
|
|
|
game.deathseq = 30;
|
|
|
|
}
|
|
|
|
|
|
|
|
//Right so! Screenwraping for tower:
|
|
|
|
if (map.minitowermode)
|
|
|
|
{
|
|
|
|
if (map.scrolldir == 1)
|
|
|
|
{
|
|
|
|
//This is minitower 1!
|
|
|
|
player = obj.getplayer();
|
|
|
|
if (game.door_left > -2 && obj.entities[player].xp < -14)
|
|
|
|
{
|
|
|
|
obj.entities[player].xp += 320;
|
2020-03-31 10:09:42 +02:00
|
|
|
map.gotoroom(48, 52);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
if (game.door_right > -2 && obj.entities[player].xp >= 308)
|
|
|
|
{
|
|
|
|
obj.entities[player].xp -= 320;
|
|
|
|
obj.entities[player].yp -= (71*8);
|
2020-03-31 10:09:42 +02:00
|
|
|
map.gotoroom(game.roomx + 1, game.roomy+1);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
//This is minitower 2!
|
|
|
|
player = obj.getplayer();
|
|
|
|
if (game.door_left > -2 && obj.entities[player].xp < -14)
|
|
|
|
{
|
|
|
|
if (obj.entities[player].yp > 300)
|
|
|
|
{
|
|
|
|
obj.entities[player].xp += 320;
|
|
|
|
obj.entities[player].yp -= (71 * 8);
|
2020-03-31 10:09:42 +02:00
|
|
|
map.gotoroom(50, 54);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
obj.entities[player].xp += 320;
|
2020-03-31 10:09:42 +02:00
|
|
|
map.gotoroom(50, 53);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (game.door_right > -2 && obj.entities[player].xp >= 308)
|
|
|
|
{
|
|
|
|
obj.entities[player].xp -= 320;
|
2020-03-31 10:09:42 +02:00
|
|
|
map.gotoroom(52, 53);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
//Always wrap except for the very top and very bottom of the tower
|
|
|
|
if(map.ypos>=500 && map.ypos <=5000)
|
|
|
|
{
|
|
|
|
for (int i = 0; i < obj.nentity; i++)
|
|
|
|
{
|
|
|
|
if (obj.entities[i].xp <= -10)
|
|
|
|
{
|
|
|
|
obj.entities[i].xp += 320;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (obj.entities[i].xp > 310)
|
|
|
|
{
|
|
|
|
obj.entities[i].xp -= 320;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
//Do not wrap! Instead, go to the correct room
|
|
|
|
player = obj.getplayer();
|
|
|
|
if (game.door_left > -2 && obj.entities[player].xp < -14)
|
|
|
|
{
|
|
|
|
obj.entities[player].xp += 320;
|
|
|
|
obj.entities[player].yp -= (671 * 8);
|
2020-03-31 10:09:42 +02:00
|
|
|
map.gotoroom(108, 109);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
if (game.door_right > -2 && obj.entities[player].xp >= 308)
|
|
|
|
{
|
|
|
|
obj.entities[player].xp -= 320;
|
2020-03-31 10:09:42 +02:00
|
|
|
map.gotoroom(110, 104);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if(game.lifeseq==0)
|
|
|
|
{
|
|
|
|
int player = obj.getplayer();
|
|
|
|
if(!map.invincibility)
|
|
|
|
{
|
|
|
|
if (obj.entities[player].yp-map.ypos <= 0)
|
|
|
|
{
|
|
|
|
game.deathseq = 30;
|
|
|
|
}
|
|
|
|
else if (obj.entities[player].yp-map.ypos >= 208)
|
|
|
|
{
|
|
|
|
game.deathseq = 30;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (obj.entities[player].yp-map.ypos <= 0)
|
|
|
|
{
|
|
|
|
map.ypos-=10;
|
|
|
|
map.bypos = map.ypos / 2;
|
|
|
|
map.bscroll = 0;
|
|
|
|
}
|
|
|
|
else if (obj.entities[player].yp-map.ypos >= 208)
|
|
|
|
{
|
|
|
|
map.ypos+=2;
|
|
|
|
map.bypos = map.ypos / 2;
|
|
|
|
map.bscroll = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (obj.entities[player].yp - map.ypos <= 40)
|
|
|
|
{
|
|
|
|
map.spikeleveltop++;
|
|
|
|
if (map.spikeleveltop >= 8) map.spikeleveltop = 8;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (map.spikeleveltop > 0) map.spikeleveltop--;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (obj.entities[player].yp - map.ypos >= 164)
|
|
|
|
{
|
|
|
|
map.spikelevelbottom++;
|
|
|
|
if (map.spikelevelbottom >= 8) map.spikelevelbottom = 8;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (map.spikelevelbottom > 0) map.spikelevelbottom--;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
//now! let's clean up removed entities
|
|
|
|
obj.cleanup();
|
|
|
|
|
|
|
|
//Looping around, room change conditions!
|
|
|
|
}
|
|
|
|
|
2020-03-31 21:38:52 +02:00
|
|
|
if (game.teleport_to_new_area) script.teleport();
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
|
2020-04-01 23:48:11 +02:00
|
|
|
void gamelogic()
|
2020-01-01 21:29:24 +01:00
|
|
|
{
|
|
|
|
//Misc
|
|
|
|
help.updateglow();
|
|
|
|
|
|
|
|
if (game.alarmon)
|
|
|
|
{
|
|
|
|
game.alarmdelay--;
|
|
|
|
if (game.alarmdelay <= 0)
|
|
|
|
{
|
|
|
|
music.playef(19);
|
|
|
|
game.alarmdelay = 20;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (obj.nearelephant)
|
|
|
|
{
|
|
|
|
obj.upset++;
|
|
|
|
if (obj.upset == 300)
|
|
|
|
{
|
|
|
|
obj.upsetmode = true;
|
|
|
|
//change player to sad
|
|
|
|
int i = obj.getplayer();
|
|
|
|
obj.entities[i].tile = 144;
|
2020-04-02 01:36:35 +02:00
|
|
|
music.playef(2);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
if (obj.upset > 301) obj.upset = 301;
|
|
|
|
}
|
|
|
|
else if (obj.upsetmode)
|
|
|
|
{
|
|
|
|
obj.upset--;
|
|
|
|
if (obj.upset <= 0)
|
|
|
|
{
|
|
|
|
obj.upset = 0;
|
|
|
|
obj.upsetmode = false;
|
|
|
|
//change player to happy
|
|
|
|
int i = obj.getplayer();
|
|
|
|
obj.entities[i].tile = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
obj.upset = 0;
|
|
|
|
}
|
|
|
|
|
2020-03-31 02:16:02 +02:00
|
|
|
game.lifesequence();
|
2020-01-01 21:29:24 +01:00
|
|
|
|
|
|
|
|
|
|
|
if (game.deathseq != -1)
|
|
|
|
{
|
|
|
|
for (int i = 0; i < obj.nentity; i++)
|
|
|
|
{
|
2020-02-04 03:53:30 +01:00
|
|
|
if (game.roomx == 111 && game.roomy == 107 && !map.custommode)
|
2020-01-01 21:29:24 +01:00
|
|
|
{
|
|
|
|
if (obj.entities[i].type == 1)
|
|
|
|
{
|
|
|
|
if (obj.entities[i].xp < 152)
|
|
|
|
{
|
|
|
|
obj.entities[i].xp = 152;
|
|
|
|
obj.entities[i].newxp = 152;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (obj.entities[i].type == 2 && obj.entities[i].state == 3)
|
|
|
|
{
|
|
|
|
//Ok! super magical exception for the room with the intention death for the shiny trinket
|
|
|
|
//fix this when the maps are finalised
|
Fix Prize for the Reckless quicksand fix kludge
If you died in Prize for the Reckless, which is at (11,7), and respawned
in the same room, tile 59 (a solid invisible tile) would be placed at
[18,9] to prevent the moving platform from going back through the
quicksand.
Unfortunately, the way that this kludge was added is poor.
First, the conditional makes it so that it doesn't happen in ONLY
(11,7). Instead of being behind a positive conditional, the tile is
placed in the else-branch of an if-conditional that checks for the
normal case, i.e. if the current room is NOT (11,7), thus being a
negative conditional.
In other words, the positive conditional is "game.roomx == 111 &&
game.roomy == 107". To negate it, all you would have to do is
"!(game.roomx == 111 && game.roomy == 107)".
However, whoever wrote this decided to go one step further, and actually
DISTRIBUTE the negative into both statements. This would be fine, except
if they actually got it right. You see, according to De Morgan's laws,
when you distribute a negative across multiple statements you not only
have to negate the statements themselves, but you have to negate all the
CONJUNCTIONS, too. In other words, you have to change all "and"s into
"or"s and all "or"s into "and"s.
Instead of making the conditional "game.roomx != 111 || game.roomy !=
107", the person who wrote this forgot to replace the "and" with an
"or". Thus, it is "game.roomx != 111 && game.roomy != 107" instead. As a
result, if we re-negate this and take a look at the positive
conditional, i.e. the conditional that results in the else-branch
executing, it turns out to be "game.roomx == 111 || game.roomy == 107".
This ends up forming a cross-shape of rooms where this kludge happens.
As long as your room is either on the line x=11 or on the line y=7, this
kludge will execute.
You can see this if you go to Boldly To Go, since it is (11,13), which
is on the line x=11. Checkpoint in that room, then touch a disappearing
platform, wait for it to fully disappear, then die. Then an invisible
tile will be placed to the left of the spikes on the ceiling.
Anyway, to fix this, it's simple. Just change the "and" in the negative
conditional to an "or".
The second problem was that this kludge was happening in custom levels.
So I've added a map.custommode check to it. I made sure not to make the
same mistake originally made, i.e. I made sure to use an "or" instead of
an "and". Thus, when you re-negate the negative conditional and turn it
into the positive conditional, it reads: "game.roomx == 111 &&
game.roomy == 107 && !map.custommode".
2020-02-02 11:26:49 +01:00
|
|
|
if (game.roomx != 111 || game.roomy != 107 || map.custommode)
|
2020-01-01 21:29:24 +01:00
|
|
|
{
|
|
|
|
obj.entities[i].state = 4;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
obj.entities[i].state = 4;
|
|
|
|
map.settile(18, 9, 59);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (obj.entities[i].type == 2 && obj.entities[i].state == 2)
|
|
|
|
{
|
|
|
|
//ok, unfortunate case where the disappearing platform hasn't fully disappeared. Accept a little
|
|
|
|
//graphical uglyness to avoid breaking the room!
|
2020-03-31 02:46:36 +02:00
|
|
|
while (obj.entities[i].state == 2) obj.updateentities(i);
|
2020-01-01 21:29:24 +01:00
|
|
|
obj.entities[i].state = 4;
|
|
|
|
}
|
|
|
|
else if (map.finalstretch && obj.entities[i].type == 2)
|
|
|
|
{
|
|
|
|
//for the final level. probably something 99% of players won't see.
|
2020-03-31 02:46:36 +02:00
|
|
|
while (obj.entities[i].state == 2) obj.updateentities(i);
|
2020-01-01 21:29:24 +01:00
|
|
|
obj.entities[i].state = 4;
|
|
|
|
}
|
|
|
|
else if (obj.entities[i].type == 23 && game.swnmode && game.deathseq<15)
|
|
|
|
{
|
|
|
|
//if playing SWN, get the enemies offscreen.
|
|
|
|
obj.entities[i].xp += obj.entities[i].vx*5;
|
|
|
|
obj.entities[i].yp += obj.entities[i].vy*5;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (game.swnmode)
|
|
|
|
{
|
|
|
|
//if playing SWN game a, push the clock back to the nearest 10 second interval
|
|
|
|
if (game.swngame == 0)
|
|
|
|
{
|
|
|
|
game.swnpenalty();
|
|
|
|
}
|
|
|
|
else if (game.swngame == 1)
|
|
|
|
{
|
|
|
|
game.swnstate = 0;
|
|
|
|
game.swnstate2 = 0;
|
|
|
|
game.swnstate3 = 0;
|
|
|
|
game.swnstate4 = 0;
|
|
|
|
game.swndelay = 0;
|
|
|
|
if (game.swntimer >= game.swnrecord)
|
|
|
|
{
|
2020-04-02 01:36:35 +02:00
|
|
|
if (game.swnmessage == 0) music.playef(25);
|
2020-01-01 21:29:24 +01:00
|
|
|
game.swnmessage = 1;
|
|
|
|
game.swnrecord = game.swntimer;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-31 02:16:02 +02:00
|
|
|
game.deathsequence();
|
2020-01-01 21:29:24 +01:00
|
|
|
game.deathseq--;
|
|
|
|
if (game.deathseq <= 0)
|
|
|
|
{
|
|
|
|
if (game.nodeathmode)
|
|
|
|
{
|
|
|
|
game.deathseq = 1;
|
2020-03-31 02:16:02 +02:00
|
|
|
game.gethardestroom();
|
2020-01-01 21:29:24 +01:00
|
|
|
//start depressing sequence here...
|
2020-04-01 23:48:11 +02:00
|
|
|
if (game.gameoverdelay <= -10 && graphics.fademode==0) graphics.fademode = 2;
|
|
|
|
if (graphics.fademode == 1) script.resetgametomenu();
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (game.swnmode)
|
|
|
|
{
|
|
|
|
//if playing SWN game b, reset the clock
|
|
|
|
if (game.swngame == 1)
|
|
|
|
{
|
|
|
|
game.swntimer = 0;
|
|
|
|
game.swnmessage = 0;
|
|
|
|
game.swnrank = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-31 02:16:02 +02:00
|
|
|
game.gethardestroom();
|
2020-01-01 21:29:24 +01:00
|
|
|
game.hascontrol = true;
|
|
|
|
|
|
|
|
|
|
|
|
game.gravitycontrol = game.savegc;
|
2020-04-01 23:48:11 +02:00
|
|
|
graphics.textboxremove();
|
2020-03-31 10:09:42 +02:00
|
|
|
map.resetplayer();
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
//Update colour thingy
|
|
|
|
if (map.finalmode)
|
|
|
|
{
|
|
|
|
if (map.final_colormode)
|
|
|
|
{
|
|
|
|
if (map.final_colorframe > 0)
|
|
|
|
{
|
|
|
|
map.final_colorframedelay--;
|
|
|
|
if (map.final_colorframedelay <= 0)
|
|
|
|
{
|
|
|
|
if (map.final_colorframe == 1)
|
|
|
|
{
|
|
|
|
map.final_colorframedelay = 40;
|
|
|
|
temp = 1+int(fRandom() * 6);
|
|
|
|
if (temp == map.final_mapcol) temp = (temp + 1) % 6;
|
|
|
|
if (temp == 0) temp = 6;
|
2020-03-31 10:09:42 +02:00
|
|
|
map.changefinalcol(temp);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
else if (map.final_colorframe == 2)
|
|
|
|
{
|
|
|
|
map.final_colorframedelay = 15;
|
|
|
|
temp = 1+int(fRandom() * 6);
|
|
|
|
if (temp == map.final_mapcol) temp = (temp + 1) % 6;
|
|
|
|
if (temp == 0) temp = 6;
|
2020-03-31 10:09:42 +02:00
|
|
|
map.changefinalcol(temp);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//State machine for game logic
|
2020-03-31 02:16:02 +02:00
|
|
|
game.updatestate();
|
2020-01-01 21:29:24 +01:00
|
|
|
if (game.startscript)
|
|
|
|
{
|
|
|
|
script.load(game.newscript);
|
|
|
|
game.startscript = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
//Intermission 1 Logic
|
|
|
|
//Player can't walk off a screen with SCM on it until they've left
|
|
|
|
if (game.supercrewmate)
|
|
|
|
{
|
|
|
|
if (game.roomx == 41 + game.scmprogress) //he's in the same room
|
|
|
|
{
|
|
|
|
int i = obj.getplayer();
|
|
|
|
if (obj.entities[i].ax > 0 && obj.entities[i].xp > 280)
|
|
|
|
{
|
|
|
|
obj.entities[i].ax = 0;
|
|
|
|
obj.entities[i].dir = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//SWN Minigame Logic
|
|
|
|
if (game.swnmode) //which game?
|
|
|
|
{
|
|
|
|
if(game.swngame==0) //intermission, survive 60 seconds game
|
|
|
|
{
|
|
|
|
game.swntimer -= 1;
|
|
|
|
if (game.swntimer <= 0)
|
|
|
|
{
|
|
|
|
music.niceplay(8);
|
|
|
|
game.swngame = 5;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2020-03-31 02:46:36 +02:00
|
|
|
obj.generateswnwave(0);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if(game.swngame==1) //super gravitron game
|
|
|
|
{
|
|
|
|
game.swntimer += 1;
|
|
|
|
if (game.swntimer > game.swnrecord) game.swnrecord = game.swntimer;
|
|
|
|
|
|
|
|
if (game.swntimer >= 150 && game.swnrank == 0)
|
|
|
|
{
|
|
|
|
game.swnrank = 1;
|
|
|
|
if (game.swnbestrank < 1)
|
|
|
|
{
|
2020-04-02 22:44:45 +02:00
|
|
|
NETWORK_unlockAchievement("vvvvvvsupgrav5");
|
2020-01-01 21:29:24 +01:00
|
|
|
game.swnbestrank = 1;
|
|
|
|
game.swnmessage = 2+30;
|
2020-04-02 01:36:35 +02:00
|
|
|
music.playef(26);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (game.swntimer >= 300 && game.swnrank == 1)
|
|
|
|
{
|
|
|
|
game.swnrank = 2;
|
|
|
|
if (game.swnbestrank < 2)
|
|
|
|
{
|
2020-04-02 22:44:45 +02:00
|
|
|
NETWORK_unlockAchievement("vvvvvvsupgrav10");
|
2020-01-01 21:29:24 +01:00
|
|
|
game.swnbestrank = 2;
|
|
|
|
game.swnmessage = 2+30;
|
2020-04-02 01:36:35 +02:00
|
|
|
music.playef(26);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (game.swntimer >= 450 && game.swnrank == 2)
|
|
|
|
{
|
|
|
|
game.swnrank = 3;
|
|
|
|
if (game.swnbestrank < 3)
|
|
|
|
{
|
2020-04-02 22:44:45 +02:00
|
|
|
NETWORK_unlockAchievement("vvvvvvsupgrav15");
|
2020-01-01 21:29:24 +01:00
|
|
|
game.swnbestrank = 3;
|
|
|
|
game.swnmessage = 2+30;
|
2020-04-02 01:36:35 +02:00
|
|
|
music.playef(26);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (game.swntimer >= 600 && game.swnrank == 3)
|
|
|
|
{
|
|
|
|
game.swnrank = 4;
|
|
|
|
if (game.swnbestrank < 4)
|
|
|
|
{
|
2020-04-02 22:44:45 +02:00
|
|
|
NETWORK_unlockAchievement("vvvvvvsupgrav20");
|
2020-01-01 21:29:24 +01:00
|
|
|
game.swnbestrank = 4;
|
|
|
|
game.swnmessage = 2+30;
|
2020-04-02 01:36:35 +02:00
|
|
|
music.playef(26);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (game.swntimer >= 900 && game.swnrank == 4)
|
|
|
|
{
|
|
|
|
game.swnrank = 5;
|
|
|
|
if (game.swnbestrank < 5)
|
|
|
|
{
|
2020-04-02 22:44:45 +02:00
|
|
|
NETWORK_unlockAchievement("vvvvvvsupgrav30");
|
2020-01-01 21:29:24 +01:00
|
|
|
game.swnbestrank = 5;
|
|
|
|
game.swnmessage = 2+30;
|
2020-04-02 01:36:35 +02:00
|
|
|
music.playef(26);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (game.swntimer >= 1800 && game.swnrank == 5)
|
|
|
|
{
|
|
|
|
game.swnrank = 6;
|
|
|
|
if (game.swnbestrank < 6)
|
|
|
|
{
|
2020-04-02 22:44:45 +02:00
|
|
|
NETWORK_unlockAchievement("vvvvvvsupgrav60");
|
2020-01-01 21:29:24 +01:00
|
|
|
game.swnbestrank = 6;
|
|
|
|
game.swnmessage = 2+30;
|
2020-04-02 01:36:35 +02:00
|
|
|
music.playef(26);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-31 02:46:36 +02:00
|
|
|
obj.generateswnwave(1);
|
2020-01-01 21:29:24 +01:00
|
|
|
|
|
|
|
game.swncoldelay--;
|
|
|
|
if(game.swncoldelay<=0)
|
|
|
|
{
|
|
|
|
game.swncolstate = (game.swncolstate+1)%6;
|
|
|
|
game.swncoldelay = 30;
|
2020-04-01 23:48:11 +02:00
|
|
|
graphics.rcol = game.swncolstate;
|
2020-01-01 21:29:24 +01:00
|
|
|
obj.swnenemiescol(game.swncolstate);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (game.swngame == 2) //introduce game a
|
|
|
|
{
|
|
|
|
game.swndelay--;
|
|
|
|
if (game.swndelay <= 0)
|
|
|
|
{
|
|
|
|
game.swngame = 0;
|
|
|
|
game.swndelay = 0;
|
|
|
|
game.swntimer = (60 * 30) - 1;
|
|
|
|
//game.swntimer = 15;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (game.swngame == 3) //extend line
|
|
|
|
{
|
|
|
|
obj.entities[obj.getlineat(84 - 32)].w += 24;
|
|
|
|
if (obj.entities[obj.getlineat(84 - 32)].w > 332)
|
|
|
|
{
|
|
|
|
obj.entities[obj.getlineat(84 - 32)].w = 332;
|
|
|
|
game.swngame = 2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (game.swngame == 4) //create top line
|
|
|
|
{
|
|
|
|
game.swngame = 3;
|
2020-03-31 02:46:36 +02:00
|
|
|
obj.createentity(-8, 84 - 32, 11, 8); // (horizontal gravity line)
|
2020-01-01 21:29:24 +01:00
|
|
|
music.niceplay(2);
|
|
|
|
game.swndeaths = game.deathcounts;
|
|
|
|
}
|
|
|
|
else if (game.swngame == 5) //remove line
|
|
|
|
{
|
|
|
|
obj.entities[obj.getlineat(148 + 32)].xp += 24;
|
|
|
|
if (obj.entities[obj.getlineat(148 + 32)].xp > 320)
|
|
|
|
{
|
|
|
|
obj.entities[obj.getlineat(148 + 32)].active = false;
|
|
|
|
game.swnmode = false;
|
|
|
|
game.swngame = 6;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (game.swngame == 6) //Init the super gravitron
|
|
|
|
{
|
|
|
|
game.swngame = 7;
|
|
|
|
music.niceplay(3);
|
|
|
|
}
|
|
|
|
else if (game.swngame == 7) //introduce game b
|
|
|
|
{
|
|
|
|
game.swndelay--;
|
|
|
|
if (game.swndelay <= 0)
|
|
|
|
{
|
|
|
|
game.swngame = 1;
|
|
|
|
game.swndelay = 0;
|
|
|
|
game.swntimer = 0;
|
|
|
|
game.swncolstate = 3;
|
|
|
|
game.swncoldelay = 30;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//Time trial stuff
|
|
|
|
if (game.intimetrial)
|
|
|
|
{
|
|
|
|
|
|
|
|
if (game.timetrialcountdown > 0)
|
|
|
|
{
|
|
|
|
game.timetrialparlost = false;
|
|
|
|
game.hascontrol = true;
|
|
|
|
game.timetrialcountdown--;
|
|
|
|
if (game.timetrialcountdown > 30)
|
|
|
|
{
|
|
|
|
game.hascontrol = false;
|
|
|
|
}
|
2020-04-02 01:36:35 +02:00
|
|
|
if(game.timetrialcountdown == 120) music.playef(21);
|
|
|
|
if(game.timetrialcountdown == 90) music.playef(21);
|
|
|
|
if(game.timetrialcountdown == 60) music.playef(21);
|
2020-01-01 21:29:24 +01:00
|
|
|
if (game.timetrialcountdown == 30)
|
|
|
|
{
|
|
|
|
switch(game.timetriallevel)
|
|
|
|
{
|
|
|
|
case 0:
|
|
|
|
music.play(1);
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
music.play(3);
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
music.play(2);
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
music.play(1);
|
|
|
|
break;
|
|
|
|
case 4:
|
|
|
|
music.play(12);
|
|
|
|
break;
|
|
|
|
case 5:
|
|
|
|
music.play(15);
|
|
|
|
break;
|
|
|
|
}
|
2020-04-02 01:36:35 +02:00
|
|
|
music.playef(22);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//Have we lost the par?
|
|
|
|
if (!game.timetrialparlost)
|
|
|
|
{
|
|
|
|
if ((game.minutes * 60) + game.seconds > game.timetrialpar)
|
|
|
|
{
|
|
|
|
game.timetrialparlost = true;
|
|
|
|
int i = obj.getplayer();
|
|
|
|
if (i > -1)
|
|
|
|
{
|
|
|
|
obj.entities[i].tile = 144;
|
|
|
|
}
|
2020-04-02 01:36:35 +02:00
|
|
|
music.playef(2);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//Update entities
|
|
|
|
//Ok, moving platform fuckers
|
|
|
|
if(!game.completestop)
|
|
|
|
{
|
|
|
|
if(obj.vertplatforms)
|
|
|
|
{
|
|
|
|
for (int i = obj.nentity - 1; i >= 0; i--)
|
|
|
|
{
|
|
|
|
if (obj.entities[i].isplatform)
|
|
|
|
{
|
|
|
|
if(abs(obj.entities[i].vx) < 0.000001f)
|
|
|
|
{
|
|
|
|
obj.removeblockat(obj.entities[i].xp, obj.entities[i].yp);
|
|
|
|
|
2020-03-31 02:46:36 +02:00
|
|
|
obj.updateentities(i); // Behavioral logic
|
|
|
|
obj.updateentitylogic(i); // Basic Physics
|
|
|
|
obj.entitymapcollision(i); // Collisions with walls
|
2020-01-01 21:29:24 +01:00
|
|
|
|
|
|
|
obj.createblock(0, obj.entities[i].xp, obj.entities[i].yp, obj.entities[i].w, obj.entities[i].h);
|
|
|
|
if (game.supercrewmate)
|
|
|
|
{
|
2020-03-31 02:46:36 +02:00
|
|
|
obj.movingplatformfix(i);
|
|
|
|
obj.scmmovingplatformfix(i);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2020-03-31 02:46:36 +02:00
|
|
|
obj.movingplatformfix(i);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if(obj.horplatforms)
|
|
|
|
{
|
|
|
|
for (int ie = obj.nentity - 1; ie >= 0; ie--)
|
|
|
|
{
|
|
|
|
if (obj.entities[ie].isplatform)
|
|
|
|
{
|
|
|
|
if(abs(obj.entities[ie].vy) < 0.000001f)
|
|
|
|
{
|
|
|
|
obj.removeblockat(obj.entities[ie].xp, obj.entities[ie].yp);
|
|
|
|
|
2020-03-31 02:46:36 +02:00
|
|
|
obj.updateentities(ie); // Behavioral logic
|
|
|
|
obj.updateentitylogic(ie); // Basic Physics
|
|
|
|
obj.entitymapcollision(ie); // Collisions with walls
|
2020-01-01 21:29:24 +01:00
|
|
|
|
2020-03-31 02:46:36 +02:00
|
|
|
obj.hormovingplatformfix(ie);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//is the player standing on a moving platform?
|
|
|
|
int i = obj.getplayer();
|
2020-03-31 02:46:36 +02:00
|
|
|
float j = obj.entitycollideplatformfloor(i);
|
2020-01-01 21:29:24 +01:00
|
|
|
if (j > -1000)
|
|
|
|
{
|
|
|
|
obj.entities[i].newxp = obj.entities[i].xp + j;
|
2020-03-31 02:46:36 +02:00
|
|
|
obj.entitymapcollision(i);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2020-03-31 02:46:36 +02:00
|
|
|
j = obj.entitycollideplatformroof(i);
|
2020-01-01 21:29:24 +01:00
|
|
|
if (j > -1000)
|
|
|
|
{
|
|
|
|
obj.entities[i].newxp = obj.entities[i].xp + j;
|
2020-03-31 02:46:36 +02:00
|
|
|
obj.entitymapcollision(i);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (int ie = obj.nentity - 1; ie >= 0; ie--)
|
|
|
|
{
|
|
|
|
if (!obj.entities[ie].isplatform)
|
|
|
|
{
|
2020-03-31 02:46:36 +02:00
|
|
|
obj.updateentities(ie); // Behavioral logic
|
|
|
|
obj.updateentitylogic(ie); // Basic Physics
|
|
|
|
obj.entitymapcollision(ie); // Collisions with walls
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-31 02:46:36 +02:00
|
|
|
obj.entitycollisioncheck(); // Check ent v ent collisions, update states
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
//now! let's clean up removed entities
|
|
|
|
obj.cleanup();
|
|
|
|
|
|
|
|
//Using warplines?
|
2020-04-02 22:44:45 +02:00
|
|
|
if (obj.customwarpmode) {
|
|
|
|
//Rewritten system for mobile update: basically, the new logic is to
|
|
|
|
//check if the player is leaving the map, and if so do a special check against
|
|
|
|
//warp lines for collision
|
|
|
|
obj.customwarpmodehon = false;
|
|
|
|
obj.customwarpmodevon = false;
|
|
|
|
|
|
|
|
int i = obj.getplayer();
|
|
|
|
if ((game.door_down > -2 && obj.entities[i].yp >= 226-16) || (game.door_up > -2 && obj.entities[i].yp < -2+16) || (game.door_left > -2 && obj.entities[i].xp < -14+16) || (game.door_right > -2 && obj.entities[i].xp >= 308-16)){
|
|
|
|
//Player is leaving room
|
|
|
|
obj.customwarplinecheck(i);
|
|
|
|
}
|
|
|
|
|
|
|
|
if(obj.customwarpmodehon){ map.warpy=true;
|
|
|
|
}else{ map.warpy=false; }
|
|
|
|
if(obj.customwarpmodevon){ map.warpx=true;
|
|
|
|
}else{ map.warpx=false; }
|
|
|
|
}
|
2020-01-01 21:29:24 +01:00
|
|
|
|
|
|
|
//Finally: Are we changing room?
|
|
|
|
if (map.warpx && map.warpy)
|
|
|
|
{
|
|
|
|
for (int i = 0; i < obj.nentity; i++)
|
|
|
|
{
|
|
|
|
if(obj.entities[i].type<50){ //Don't warp warp lines
|
|
|
|
if (obj.entities[i].size < 12) //Don't wrap SWN enemies
|
|
|
|
{
|
|
|
|
if (obj.entities[i].xp <= -10)
|
|
|
|
{
|
|
|
|
obj.entities[i].xp += 320;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (obj.entities[i].xp > 310)
|
|
|
|
{
|
|
|
|
obj.entities[i].xp -= 320;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (int i = 0; i < obj.nentity; i++)
|
|
|
|
{
|
|
|
|
|
|
|
|
if(obj.entities[i].type<50){ //Don't warp warp lines
|
|
|
|
if (obj.entities[i].size < 12) //Don't wrap SWN enemies
|
|
|
|
{
|
|
|
|
if (obj.entities[i].yp <= -12)
|
|
|
|
{
|
|
|
|
obj.entities[i].yp += 232;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (obj.entities[i].yp > 226)
|
|
|
|
{
|
|
|
|
obj.entities[i].yp -= 232;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (map.warpx)
|
|
|
|
{
|
|
|
|
for (int i = 0; i < obj.nentity; i++)
|
|
|
|
{
|
|
|
|
if(obj.entities[i].type<50){ //Don't warp warp lines
|
|
|
|
if (obj.entities[i].size < 12) //Don't wrap SWN enemies
|
|
|
|
{
|
|
|
|
if (game.roomx == 118 && game.roomy == 102 && obj.entities[i].rule==1 && !map.custommode)
|
|
|
|
{
|
|
|
|
//ascii snakes
|
|
|
|
if (obj.entities[i].xp <= -80)
|
|
|
|
{
|
|
|
|
obj.entities[i].xp += 400;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (obj.entities[i].xp > 320)
|
|
|
|
{
|
|
|
|
obj.entities[i].xp -= 400;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (obj.entities[i].xp <= -10)
|
|
|
|
{
|
|
|
|
obj.entities[i].xp += 320;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (obj.entities[i].xp > 310)
|
|
|
|
{
|
|
|
|
obj.entities[i].xp -= 320;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int player = obj.getplayer();
|
|
|
|
if (game.door_down > -2 && obj.entities[player].yp >= 238)
|
|
|
|
{
|
|
|
|
obj.entities[player].yp -= 240;
|
2020-03-31 10:09:42 +02:00
|
|
|
map.gotoroom(game.roomx, game.roomy + 1);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
if (game.door_up > -2 && obj.entities[player].yp < -2)
|
|
|
|
{
|
|
|
|
obj.entities[player].yp += 240;
|
2020-03-31 10:09:42 +02:00
|
|
|
map.gotoroom(game.roomx, game.roomy - 1);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (map.warpy)
|
|
|
|
{
|
|
|
|
for (int i = 0; i < obj.nentity; i++)
|
|
|
|
{
|
|
|
|
if(obj.entities[i].type<50){ //Don't warp warp lines
|
|
|
|
if (obj.entities[i].yp <= -12)
|
|
|
|
{
|
|
|
|
obj.entities[i].yp += 232;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (obj.entities[i].yp > 226)
|
|
|
|
{
|
|
|
|
obj.entities[i].yp -= 232;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (int i = 0; i < obj.nentity; i++)
|
|
|
|
{
|
|
|
|
|
|
|
|
if(obj.entities[i].type<50){ //Don't warp warp lines
|
|
|
|
if(obj.entities[i].rule!=0)
|
|
|
|
{
|
|
|
|
if (obj.entities[i].xp <= -30)
|
|
|
|
{
|
|
|
|
obj.entities[i].xp += 350;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (obj.entities[i].xp > 320)
|
|
|
|
{
|
|
|
|
obj.entities[i].xp -= 350;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int player = obj.getplayer();
|
|
|
|
if (game.door_left > -2 && obj.entities[player].xp < -14)
|
|
|
|
{
|
|
|
|
obj.entities[player].xp += 320;
|
2020-03-31 10:09:42 +02:00
|
|
|
map.gotoroom(game.roomx - 1, game.roomy);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
if (game.door_right > -2 && obj.entities[player].xp >= 308)
|
|
|
|
{
|
|
|
|
obj.entities[player].xp -= 320;
|
2020-03-31 10:09:42 +02:00
|
|
|
map.gotoroom(game.roomx + 1, game.roomy);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
//Normal! Just change room
|
|
|
|
int player = obj.getplayer();
|
|
|
|
if (game.door_down > -2 && obj.entities[player].yp >= 238)
|
|
|
|
{
|
|
|
|
obj.entities[player].yp -= 240;
|
2020-03-31 10:09:42 +02:00
|
|
|
map.gotoroom(game.roomx, game.roomy + 1);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
if (game.door_up > -2 && obj.entities[player].yp < -2)
|
|
|
|
{
|
|
|
|
obj.entities[player].yp += 240;
|
2020-03-31 10:09:42 +02:00
|
|
|
map.gotoroom(game.roomx, game.roomy - 1);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
if (game.door_left > -2 && obj.entities[player].xp < -14)
|
|
|
|
{
|
|
|
|
obj.entities[player].xp += 320;
|
2020-03-31 10:09:42 +02:00
|
|
|
map.gotoroom(game.roomx - 1, game.roomy);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
if (game.door_right > -2 && obj.entities[player].xp >= 308)
|
|
|
|
{
|
|
|
|
obj.entities[player].xp -= 320;
|
2020-03-31 10:09:42 +02:00
|
|
|
map.gotoroom(game.roomx + 1, game.roomy);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//Warp tokens
|
|
|
|
if (map.custommode){
|
|
|
|
if (game.teleport)
|
|
|
|
{
|
|
|
|
int edi=obj.entities[game.edteleportent].behave;
|
|
|
|
int edj=obj.entities[game.edteleportent].para;
|
|
|
|
int edi2, edj2;
|
|
|
|
edi2 = (edi-(edi%40))/40;
|
|
|
|
edj2 = (edj-(edj%30))/30;
|
|
|
|
|
2020-03-31 10:09:42 +02:00
|
|
|
map.warpto(100+edi2, 100+edj2, obj.getplayer(), edi%40, (edj%30)+2);
|
2020-01-01 21:29:24 +01:00
|
|
|
game.teleport = false;
|
|
|
|
|
|
|
|
if (game.teleport == false)
|
|
|
|
{
|
|
|
|
game.flashlight = 6;
|
|
|
|
game.screenshake = 25;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}else{
|
|
|
|
if (game.teleport)
|
|
|
|
{
|
|
|
|
if (game.roomx == 117 && game.roomy == 102)
|
|
|
|
{
|
|
|
|
int i = obj.getplayer();
|
|
|
|
obj.entities[i].yp = 225;
|
2020-03-31 10:09:42 +02:00
|
|
|
map.gotoroom(119, 100);
|
2020-01-01 21:29:24 +01:00
|
|
|
game.teleport = false;
|
|
|
|
}
|
|
|
|
else if (game.roomx == 119 && game.roomy == 100)
|
|
|
|
{
|
|
|
|
int i = obj.getplayer();
|
|
|
|
obj.entities[i].yp = 225;
|
2020-03-31 10:09:42 +02:00
|
|
|
map.gotoroom(119, 103);
|
2020-01-01 21:29:24 +01:00
|
|
|
game.teleport = false;
|
|
|
|
}
|
|
|
|
else if (game.roomx == 119 && game.roomy == 103)
|
|
|
|
{
|
|
|
|
int i = obj.getplayer();
|
|
|
|
obj.entities[i].xp = 0;
|
2020-03-31 10:09:42 +02:00
|
|
|
map.gotoroom(116, 103);
|
2020-01-01 21:29:24 +01:00
|
|
|
game.teleport = false;
|
|
|
|
}
|
|
|
|
else if (game.roomx == 116 && game.roomy == 103)
|
|
|
|
{
|
|
|
|
int i = obj.getplayer();
|
|
|
|
obj.entities[i].yp = 225;
|
2020-03-31 10:09:42 +02:00
|
|
|
map.gotoroom(116, 100);
|
2020-01-01 21:29:24 +01:00
|
|
|
game.teleport = false;
|
|
|
|
}
|
|
|
|
else if (game.roomx == 116 && game.roomy == 100)
|
|
|
|
{
|
|
|
|
int i = obj.getplayer();
|
|
|
|
obj.entities[i].xp = 0;
|
2020-03-31 10:09:42 +02:00
|
|
|
map.gotoroom(114, 102);
|
2020-01-01 21:29:24 +01:00
|
|
|
game.teleport = false;
|
|
|
|
}
|
|
|
|
else if (game.roomx == 114 && game.roomy == 102)
|
|
|
|
{
|
|
|
|
int i = obj.getplayer();
|
|
|
|
obj.entities[i].yp = 225;
|
2020-03-31 10:09:42 +02:00
|
|
|
map.gotoroom(113, 100);
|
2020-01-01 21:29:24 +01:00
|
|
|
game.teleport = false;
|
|
|
|
}
|
|
|
|
else if (game.roomx == 116 && game.roomy == 104)
|
|
|
|
{
|
|
|
|
//pre warp zone here
|
2020-03-31 10:09:42 +02:00
|
|
|
map.warpto(107, 101, obj.getplayer(), 14, 16);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
else if (game.roomx == 107 && game.roomy == 101)
|
|
|
|
{
|
2020-03-31 10:09:42 +02:00
|
|
|
map.warpto(105, 119, obj.getplayer(), 5, 26);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
else if (game.roomx == 105 && game.roomy == 118)
|
|
|
|
{
|
2020-03-31 10:09:42 +02:00
|
|
|
map.warpto(101, 111, obj.getplayer(), 34, 6);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
else if (game.roomx == 101 && game.roomy == 111)
|
|
|
|
{
|
|
|
|
//There are lots of warp tokens in this room, so we have to distinguish!
|
|
|
|
switch(game.teleportxpos)
|
|
|
|
{
|
|
|
|
case 1:
|
2020-03-31 10:09:42 +02:00
|
|
|
map.warpto(108, 108, obj.getplayer(), 4, 27);
|
2020-01-01 21:29:24 +01:00
|
|
|
break;
|
|
|
|
case 2:
|
2020-03-31 10:09:42 +02:00
|
|
|
map.warpto(101, 111, obj.getplayer(), 12, 27);
|
2020-01-01 21:29:24 +01:00
|
|
|
break;
|
|
|
|
case 3:
|
2020-03-31 10:09:42 +02:00
|
|
|
map.warpto(119, 111, obj.getplayer(), 31, 7);
|
2020-01-01 21:29:24 +01:00
|
|
|
break;
|
|
|
|
case 4:
|
2020-03-31 10:09:42 +02:00
|
|
|
map.warpto(114, 117, obj.getplayer(), 19, 16);
|
2020-01-01 21:29:24 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (game.roomx == 108 && game.roomy == 106)
|
|
|
|
{
|
2020-03-31 10:09:42 +02:00
|
|
|
map.warpto(119, 111, obj.getplayer(), 4, 27);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
else if (game.roomx == 100 && game.roomy == 111)
|
|
|
|
{
|
2020-03-31 10:09:42 +02:00
|
|
|
map.warpto(101, 111, obj.getplayer(), 24, 6);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
else if (game.roomx == 119 && game.roomy == 107)
|
|
|
|
{
|
|
|
|
//Secret lab, to super gravitron
|
2020-03-31 10:09:42 +02:00
|
|
|
map.warpto(119, 108, obj.getplayer(), 19, 10);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
if (game.teleport == false)
|
|
|
|
{
|
|
|
|
game.flashlight = 6;
|
|
|
|
game.screenshake = 25;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
int j;
|
|
|
|
if (game.roomchange)
|
|
|
|
{
|
|
|
|
//We've changed room? Let's bring our companion along!
|
|
|
|
game.roomchange = false;
|
|
|
|
if (game.companion > 0)
|
|
|
|
{
|
|
|
|
int i = obj.getplayer();
|
|
|
|
//ok, we'll presume our companion has been destroyed in the room change. So:
|
|
|
|
switch(game.companion)
|
|
|
|
{
|
|
|
|
case 6:
|
2020-03-31 02:46:36 +02:00
|
|
|
obj.createentity(obj.entities[i].xp, 121.0f, 15.0f,1); //Y=121, the floor in that particular place!
|
2020-04-02 00:32:21 +02:00
|
|
|
j = obj.getcompanion();
|
2020-01-01 21:29:24 +01:00
|
|
|
obj.entities[j].vx = obj.entities[i].vx;
|
|
|
|
obj.entities[j].dir = obj.entities[i].dir;
|
|
|
|
break;
|
|
|
|
case 7:
|
|
|
|
if (game.roomy <= 105) //don't jump after him!
|
|
|
|
{
|
|
|
|
if (game.roomx == 110)
|
|
|
|
{
|
2020-03-31 02:46:36 +02:00
|
|
|
obj.createentity(320, 86, 16, 1); //Y=86, the ROOF in that particular place!
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2020-03-31 02:46:36 +02:00
|
|
|
obj.createentity(obj.entities[i].xp, 86.0f, 16.0f, 1); //Y=86, the ROOF in that particular place!
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
2020-04-02 00:32:21 +02:00
|
|
|
j = obj.getcompanion();
|
2020-01-01 21:29:24 +01:00
|
|
|
obj.entities[j].vx = obj.entities[i].vx;
|
|
|
|
obj.entities[j].dir = obj.entities[i].dir;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 8:
|
|
|
|
if (game.roomy >= 104) //don't jump after him!
|
|
|
|
{
|
|
|
|
if (game.roomx == 102)
|
|
|
|
{
|
2020-03-31 02:46:36 +02:00
|
|
|
obj.createentity(310, 177, 17, 1);
|
2020-04-02 00:32:21 +02:00
|
|
|
j = obj.getcompanion();
|
2020-01-01 21:29:24 +01:00
|
|
|
obj.entities[j].vx = obj.entities[i].vx;
|
|
|
|
obj.entities[j].dir = obj.entities[i].dir;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2020-03-31 02:46:36 +02:00
|
|
|
obj.createentity(obj.entities[i].xp, 177.0f, 17.0f, 1);
|
2020-04-02 00:32:21 +02:00
|
|
|
j = obj.getcompanion();
|
2020-01-01 21:29:24 +01:00
|
|
|
obj.entities[j].vx = obj.entities[i].vx;
|
|
|
|
obj.entities[j].dir = obj.entities[i].dir;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 9:
|
|
|
|
if (!map.towermode) //don't go back into the tower!
|
|
|
|
{
|
|
|
|
if (game.roomx == 110 && obj.entities[i].xp<20)
|
|
|
|
{
|
2020-03-31 02:46:36 +02:00
|
|
|
obj.createentity(100, 185, 18, 15, 0, 1);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2020-03-31 02:46:36 +02:00
|
|
|
obj.createentity(obj.entities[i].xp, 185.0f, 18.0f, 15, 0, 1);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
2020-04-02 00:32:21 +02:00
|
|
|
j = obj.getcompanion();
|
2020-01-01 21:29:24 +01:00
|
|
|
obj.entities[j].vx = obj.entities[i].vx;
|
|
|
|
obj.entities[j].dir = obj.entities[i].dir;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 10:
|
|
|
|
//intermission 2, choose colour based on lastsaved
|
|
|
|
if (game.roomy == 51)
|
|
|
|
{
|
|
|
|
if (obj.flags[59] == 0)
|
|
|
|
{
|
2020-04-01 23:48:11 +02:00
|
|
|
obj.createentity(225.0f, 169.0f, 18, graphics.crewcolour(game.lastsaved), 0, 10);
|
2020-04-02 00:32:21 +02:00
|
|
|
j = obj.getcompanion();
|
2020-01-01 21:29:24 +01:00
|
|
|
obj.entities[j].vx = obj.entities[i].vx;
|
|
|
|
obj.entities[j].dir = obj.entities[i].dir;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (game.roomy >= 52)
|
|
|
|
{
|
|
|
|
if (obj.flags[59] == 1)
|
|
|
|
{
|
2020-04-01 23:48:11 +02:00
|
|
|
obj.createentity(160.0f, 177.0f, 18, graphics.crewcolour(game.lastsaved), 0, 18, 1);
|
2020-04-02 00:32:21 +02:00
|
|
|
j = obj.getcompanion();
|
2020-01-01 21:29:24 +01:00
|
|
|
obj.entities[j].vx = obj.entities[i].vx;
|
|
|
|
obj.entities[j].dir = obj.entities[i].dir;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
obj.flags[59] = 1;
|
2020-04-01 23:48:11 +02:00
|
|
|
obj.createentity(obj.entities[i].xp, -20.0f, 18.0f, graphics.crewcolour(game.lastsaved), 0, 10, 0);
|
2020-04-02 00:32:21 +02:00
|
|
|
j = obj.getcompanion();
|
2020-01-01 21:29:24 +01:00
|
|
|
obj.entities[j].vx = obj.entities[i].vx;
|
|
|
|
obj.entities[j].dir = obj.entities[i].dir;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 11:
|
|
|
|
//Intermission 1: We're using the SuperCrewMate instead!
|
|
|
|
if(game.roomx-41==game.scmprogress)
|
|
|
|
{
|
|
|
|
switch(game.scmprogress)
|
|
|
|
{
|
|
|
|
case 0:
|
2020-04-01 23:48:11 +02:00
|
|
|
obj.createentity(76, 161, 24, graphics.crewcolour(game.lastsaved), 2);
|
2020-01-01 21:29:24 +01:00
|
|
|
break;
|
|
|
|
case 1:
|
2020-04-01 23:48:11 +02:00
|
|
|
obj.createentity(10, 169, 24, graphics.crewcolour(game.lastsaved), 2);
|
2020-01-01 21:29:24 +01:00
|
|
|
break;
|
|
|
|
case 2:
|
2020-04-01 23:48:11 +02:00
|
|
|
obj.createentity(10, 177, 24, graphics.crewcolour(game.lastsaved), 2);
|
2020-01-01 21:29:24 +01:00
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
if (game.scmmoveme)
|
|
|
|
{
|
2020-04-01 23:48:11 +02:00
|
|
|
obj.createentity(obj.entities[obj.getplayer()].xp, 185, 24, graphics.crewcolour(game.lastsaved), 2);
|
2020-01-01 21:29:24 +01:00
|
|
|
game.scmmoveme = false;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2020-04-01 23:48:11 +02:00
|
|
|
obj.createentity(10, 177, 24, graphics.crewcolour(game.lastsaved), 2);
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 4:
|
2020-04-01 23:48:11 +02:00
|
|
|
obj.createentity(10, 185, 24, graphics.crewcolour(game.lastsaved), 2);
|
2020-01-01 21:29:24 +01:00
|
|
|
break;
|
|
|
|
case 5:
|
2020-04-01 23:48:11 +02:00
|
|
|
obj.createentity(10, 185, 24, graphics.crewcolour(game.lastsaved), 2);
|
2020-01-01 21:29:24 +01:00
|
|
|
break;
|
|
|
|
case 6:
|
2020-04-01 23:48:11 +02:00
|
|
|
obj.createentity(10, 185, 24, graphics.crewcolour(game.lastsaved), 2);
|
2020-01-01 21:29:24 +01:00
|
|
|
break;
|
|
|
|
case 7:
|
2020-04-01 23:48:11 +02:00
|
|
|
obj.createentity(10, 41, 24, graphics.crewcolour(game.lastsaved), 2);
|
2020-01-01 21:29:24 +01:00
|
|
|
break;
|
|
|
|
case 8:
|
2020-04-01 23:48:11 +02:00
|
|
|
obj.createentity(10, 169, 24, graphics.crewcolour(game.lastsaved), 2);
|
2020-01-01 21:29:24 +01:00
|
|
|
break;
|
|
|
|
case 9:
|
2020-04-01 23:48:11 +02:00
|
|
|
obj.createentity(10, 169, 24, graphics.crewcolour(game.lastsaved), 2);
|
2020-01-01 21:29:24 +01:00
|
|
|
break;
|
|
|
|
case 10:
|
2020-04-01 23:48:11 +02:00
|
|
|
obj.createentity(10, 129, 24, graphics.crewcolour(game.lastsaved), 2);
|
2020-01-01 21:29:24 +01:00
|
|
|
break;
|
|
|
|
case 11:
|
2020-04-01 23:48:11 +02:00
|
|
|
obj.createentity(10, 129, 24, graphics.crewcolour(game.lastsaved), 2);
|
2020-01-01 21:29:24 +01:00
|
|
|
break;
|
|
|
|
case 12:
|
2020-04-01 23:48:11 +02:00
|
|
|
obj.createentity(10, 65, 24, graphics.crewcolour(game.lastsaved), 2);
|
2020-01-01 21:29:24 +01:00
|
|
|
break;
|
|
|
|
case 13:
|
2020-04-01 23:48:11 +02:00
|
|
|
obj.createentity(10, 177, 24, graphics.crewcolour(game.lastsaved));
|
2020-01-01 21:29:24 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (game.scmmoveme)
|
|
|
|
{
|
|
|
|
obj.entities[obj.getscm()].xp = obj.entities[obj.getplayer()].xp;
|
|
|
|
game.scmmoveme = false;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
game.activeactivity = obj.checkactivity();
|
|
|
|
|
|
|
|
if (game.activetele)
|
|
|
|
{
|
|
|
|
int i = obj.getplayer();
|
|
|
|
obj.settemprect(i);
|
|
|
|
if (help.intersects(game.teleblock, obj.temprect))
|
|
|
|
{
|
|
|
|
game.readytotele += 25;
|
|
|
|
if (game.readytotele >= 255) game.readytotele = 255;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
game.readytotele -= 50;
|
|
|
|
if (game.readytotele < 0) game.readytotele = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (game.readytotele > 0)
|
|
|
|
{
|
|
|
|
game.readytotele -= 50;
|
|
|
|
if (game.readytotele < 0) game.readytotele = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (game.teleport_to_new_area)
|
2020-03-31 21:38:52 +02:00
|
|
|
script.teleport();
|
2020-01-01 21:29:24 +01:00
|
|
|
}
|