zdoom/raze-gles
0
0
Fork 0
mirror of https://github.com/ZDoom/raze-gles.git synced 2024-11-10 23:02:03 +00:00
Code Issues Projects Releases Packages Wiki Activity

- premap stuff.

Browse source 
# Conflicts:
#	source/glbackend/glbackend.cpp
This commit is contained in:
Christoph Oelckers 2020-05-20 22:18:03 +02:00
parent ed9b418db7
commit 16bad04da8
10 changed files with 2487 additions and 42 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
source/games/duke/CMakeLists.txt
View file

@ -18,6 +18,9 @@ set( PCH_SOURCES
src/player_d.cpp
src/player_r.cpp
src/player_w.cpp
src/premap.cpp
src/premap_d.cpp
src/premap_r.cpp
src/sectors.cpp
src/sectors_d.cpp
src/sectors_r.cpp
@ -30,7 +33,6 @@ set( PCH_SOURCES
src/zz_cheats.cpp
src/zz_cmdline.cpp
src/zz_common.cpp
src/zz_config.cpp
src/zz_d_menu.cpp
src/zz_demo.cpp
src/zz_game.cpp

2
source/games/duke/src/global.h
View file

@ -131,7 +131,7 @@ G_EXTERN int32_t g_maxPlayerHealth;
G_EXTERN int32_t g_mirrorCount;
G_EXTERN int32_t g_mostConcurrentPlayers;
G_EXTERN int32_t g_musicSize;
G_EXTERN int32_t g_playerSpawnCnt;
G_EXTERN int32_t numplayersprites;
G_EXTERN int32_t g_scriptDebug;
G_EXTERN int32_t g_showShareware;
G_EXTERN int32_t g_spriteDeleteQueuePos;

8
source/games/duke/src/player.h
View file

@ -113,7 +113,11 @@ typedef struct {
vec3_t pos;
struct { int ox, oy, oz; };
};
union
{
int16_t oa;
int16_t ang;
};
union
{
int16_t sect;
@ -189,6 +193,7 @@ typedef struct player_struct {
void addhoriz(int v) { q16horiz += (v << FRACBITS); }
void addhorizoff(int v) { q16horiz += (v << FRACBITS); }
void sethoriz(int v) { q16horiz = (v << FRACBITS); }
void sethorizoff(int v) { q16horizoff = (v << FRACBITS); }
int gethoriz() { return q16horiz >> FRACBITS; }
int gethorizof() { return q16horizoff >> FRACBITS; }
int gethorizsum() { return (q16horiz + q16horizoff) >> FRACBITS; }
@ -297,6 +302,9 @@ typedef struct player_struct {
#define at57c detonate_time
#define at58e drink_timer
#define at592 eat_timer
#define raat5f1 drug_stat[0]
#define raat5f3 drug_stat[1]
#define raat5f5 drug_stat[2]
// KEEPINSYNC lunatic/_defs_game.lua
typedef struct

485
source/games/duke/src/premap.cpp Normal file
View file

@ -0,0 +1,485 @@
//-------------------------------------------------------------------------
/*
Copyright (C) 1996, 2003 - 3D Realms Entertainment
Copyright (C) 2017-2019 Nuke.YKT
This file is part of Duke Nukem 3D version 1.5 - Atomic Edition
Duke Nukem 3D is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
Original Source: 1996 - Todd Replogle
Prepared for public release: 03/21/2003 - Charlie Wiederhold, 3D Realms
*/
//-------------------------------------------------------------------------
#include "ns.h"
#include "global.h"
BEGIN_DUKE_NS
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void pickrandomspot(short snum)
{
struct player_struct *p;
short i;
p = &ps[snum];
if( ud.multimode > 1 && ud.coop != 1)
i = krand()%numplayersprites;
else i = snum;
p->bobposx = p->oposx = p->posx = po[i].ox;
p->bobposy = p->oposy = p->posy = po[i].oy;
p->oposz = p->posz = po[i].oz;
p->setang(po[i].oa);
p->cursectnum = po[i].os;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void resetplayerstats(int snum)
{
struct player_struct *p;
p = &ps[snum];
gFullMap = 0;
p->dead_flag = 0;
p->wackedbyactor = -1;
p->falling_counter = 0;
p->quick_kick = 0;
p->subweapon = 0;
p->last_full_weapon = 0;
p->ftq = 0;
p->fta = 0;
p->tipincs = 0;
p->buttonpalette = 0;
p->actorsqu =-1;
p->invdisptime = 0;
p->refresh_inventory= 0;
p->last_pissed_time = 0;
p->holster_weapon = 0;
p->pycount = 0;
p->pyoff = 0;
p->opyoff = 0;
p->loogcnt = 0;
//p->angvel = 0;
p->weapon_sway = 0;
// p->select_dir = 0;
p->extra_extra8 = 0;
p->show_empty_weapon= 0;
p->dummyplayersprite=-1;
p->crack_time = 0;
p->hbomb_hold_delay = 0;
p->transporter_hold = 0;
p->wantweaponfire = -1;
p->hurt_delay = 0;
p->hurt_delay2 = 0;
p->footprintcount = 0;
p->footprintpal = 0;
p->footprintshade = 0;
p->jumping_toggle = 0;
p->sethoriz(140); //!!
//p->oq16horiz = p->q16horiz;
p->sethorizoff(0);
p->bobcounter = 0;
p->on_ground = 0;
p->player_par = 0;
p->return_to_center = 9;
p->airleft = 15*26;
p->rapid_fire_hold = 0;
p->toggle_key_flag = 0;
p->access_spritenum = -1;
if(ud.multimode > 1 && ud.coop != 1 )
p->got_access = 7;
else p->got_access = 0;
p->random_club_frame= 0;
pus = 1;
p->on_warping_sector = 0;
p->spritebridge = 0;
p->palette = 0;
if(p->steroids_amount < 400 )
{
p->steroids_amount = 0;
p->inven_icon = 0;
}
p->heat_on = 0;
p->jetpack_on = 0;
p->holoduke_on = -1;
p->look_ang = 512 - ((ud.level_number&1)<<10);
p->rotscrnang = 0;
p->orotscrnang = 1; // JBF 20031220
p->newowner =-1;
p->jumping_counter = 0;
p->hard_landing = 0;
p->posxv = 0; //!!
p->posyv = 0;
p->poszv = 0;
p->fric.x = 0;
p->fric.y = 0;
p->somethingonplayer =-1;
p->one_eighty_count = 0;
p->cheat_phase = 0;
p->on_crane = -1;
if(p->curr_weapon == PISTOL_WEAPON)
p->kickback_pic = isRR()? 22 : 5;
else p->kickback_pic = 0;
p->weapon_pos = 6;
p->walking_snd_toggle= 0;
p->weapon_ang = 0;
p->knuckle_incs = 1;
p->fist_incs = 0;
p->knee_incs = 0;
setpal(p);
p->stairs = 0;
//p->fogtype = 0;
p->noise_x = 0;
p->noise_y = 0;
p->make_noise = 0;
p->noise_radius = 0;
if (isRR() && ud.multimode > 1 && ud.coop != 1)
{
p->keys[0] = 1;
p->keys[1] = 1;
p->keys[2] = 1;
p->keys[3] = 1;
p->keys[4] = 1;
}
else
{
p->keys[0] = 0;
p->keys[1] = 0;
p->keys[2] = 0;
p->keys[3] = 0;
p->keys[4] = 0;
}
wupass = 0;
//p->at582 = 0;
p->drunkang = 1647;
p->eatang = 1647;
p->drink_amt = 0;
p->eat = 0;
p->drink_timer = 4096;
p->eat_timer = 4096;
p->shotgun_state[0] = 0;
p->shotgun_state[1] = 0;
p->detonate_time = 0;
p->detonate_count = 0;
p->recoil = 0;
p->yehaa_timer = 0;
chickenphase = 0;
if (p->OnMotorcycle)
{
p->OnMotorcycle = 0;
p->gotweapon.Clear(MOTORCYCLE_WEAPON);
p->curr_weapon = isRRRA()? SLINGBLADE_WEAPON : KNEE_WEAPON; // just in case this is made available for the other games
}
p->lotag800kill = 0;
p->moto_do_bump = 0;
p->MotoOnGround = 1;
p->moto_underwater = 0;
p->MotoSpeed = 0;
p->TiltStatus = 0;
p->moto_drink = 0;
p->VBumpTarget = 0;
p->VBumpNow =0;
p->moto_bump_fast = 0;
p->TurbCount = 0;
p->moto_on_mud = 0;
p->moto_on_oil = 0;
if (p->OnBoat)
{
p->OnBoat = 0;
p->gotweapon.Clear(BOAT_WEAPON);
p->curr_weapon = isRRRA()? SLINGBLADE_WEAPON : KNEE_WEAPON; // just in case this is made available for the other games
}
p->NotOnWater = 0;
p->SeaSick = 0;
p->nocheat = 0;
p->DrugMode = 0;
p->drug_stat[0] = 0;
p->drug_stat[1] = 0;
p->drug_stat[2] = 0;
p->drug_aspect = 0;
resetlanepics();
if (numplayers < 2)
{
ufospawn = isRRRA()? 3 : std::min(ud.m_player_skill*4+1, 32);
ufocnt = 0;
hulkspawn = ud.m_player_skill + 1;
}
else
{
ufospawn = isRRRA()? 0 :32;
ufocnt = 0;
hulkspawn = isRRRA()? 0 :2;
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void resetweapons(int snum)
{
short weapon;
struct player_struct *p;
p = &ps[snum];
for ( weapon = PISTOL_WEAPON; weapon < MAX_WEAPONS; weapon++ )
p->gotweapon.Clear(weapon);
for ( weapon = PISTOL_WEAPON; weapon < MAX_WEAPONS; weapon++ )
p->ammo_amount[weapon] = 0;
p->weapon_pos = 6;
p->kickback_pic = 5;
p->curr_weapon = PISTOL_WEAPON;
p->gotweapon.Set(PISTOL_WEAPON);
p->gotweapon.Set(KNEE_WEAPON);
p->ammo_amount[PISTOL_WEAPON] = 48;
p->gotweapon.Set(HANDREMOTE_WEAPON);
p->last_weapon = -1;
p->show_empty_weapon= 0;
p->last_pissed_time = 0;
p->holster_weapon = 0;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void resetinventory(short snum)
{
struct player_struct *p;
p = &ps[snum];
p->inven_icon = 0;
p->boot_amount = 0;
p->scuba_on = 0;p->scuba_amount = 0;
p->heat_amount = 0;p->heat_on = 0;
p->jetpack_on = 0;p->jetpack_amount = 0;
p->shield_amount = max_armour_amount;
p->holoduke_on = -1;
p->holoduke_amount = 0;
p->firstaid_amount = 0;
p->steroids_amount = 0;
p->inven_icon = 0;
if (ud.multimode > 1 && ud.coop != 1)
{
p->keys[0] = 1;
p->keys[1] = 1;
p->keys[2] = 1;
p->keys[3] = 1;
p->keys[4] = 1;
}
else
{
p->keys[0] = 0;
p->keys[1] = 0;
p->keys[2] = 0;
p->keys[3] = 0;
p->keys[4] = 0;
}
p->drunkang = 1647;
p->eatang = 1647;
p->drink_amt = 0;
p->eat = 0;
p->drink_timer = 0;
p->eat_timer = 0;
p->shotgun_state[0] = 0;
p->shotgun_state[1] = 0;
p->detonate_time = 0;
p->detonate_count = 0;
p->recoil = 0;
p->yehaa_timer = 0;
resetlanepics();
if (numplayers < 2)
{
ufospawn = ud.m_player_skill*4+1;
if (ufospawn > 32)
ufospawn = 32;
ufocnt = 0;
hulkspawn = ud.m_player_skill + 1;
}
else
{
ufospawn = 32;
ufocnt = 0;
hulkspawn = 2;
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void resetprestat(short snum,char g)
{
struct player_struct *p;
short i;
p = &ps[snum];
spriteqloc = 0;
for(i=0;i<spriteqamount;i++) spriteq[i] = -1;
p->hbomb_on = 0;
p->cheat_phase = 0;
p->pals.f = 0;
p->toggle_key_flag = 0;
p->secret_rooms = 0;
p->max_secret_rooms = 0;
p->actors_killed = 0;
p->max_actors_killed = 0;
p->lastrandomspot = 0;
p->weapon_pos = 6;
p->kickback_pic = 5;
p->last_weapon = -1;
p->weapreccnt = 0;
p->show_empty_weapon= 0;
p->holster_weapon = 0;
p->last_pissed_time = 0;
p->one_parallax_sectnum = -1;
p->visibility = ud.const_visibility;
screenpeek = myconnectindex;
numanimwalls = 0;
numcyclers = 0;
animatecnt = 0;
parallaxtype = 0;
randomseed = 17L;
ud.pause_on = 0;
ud.camerasprite =-1;
ud.eog = 0;
tempwallptr = 0;
camsprite =-1;
earthquaketime = 0;
WindTime = 0;
WindDir = 0;
fakebubba_spawn = 0;
RRRA_ExitedLevel = 0;
BellTime = 0;
g_bellSprite = 0;
//numinterpolations = 0;
//startofdynamicinterpolations = 0;
if( ( (g&MODE_EOL) != MODE_EOL && numplayers < 2) || (ud.coop != 1 && numplayers > 1) )
{
resetweapons(snum);
resetinventory(snum);
}
else if(p->curr_weapon == HANDREMOTE_WEAPON)
{
p->ammo_amount[HANDBOMB_WEAPON]++;
p->curr_weapon = HANDBOMB_WEAPON;
}
p->timebeforeexit = 0;
p->customexitsound = 0;
p->stairs = 0;
//if (!isRRRA()) p->fogtype = 0;
p->noise_x = 131072;
p->noise_y = 131072;
p->make_noise = 0;
p->noise_radius = 0;
if (ud.multimode > 1 && ud.coop != 1)
{
p->keys[0] = 1;
p->keys[1] = 1;
p->keys[2] = 1;
p->keys[3] = 1;
p->keys[4] = 1;
}
else
{
p->keys[0] = 0;
p->keys[1] = 0;
p->keys[2] = 0;
p->keys[3] = 0;
p->keys[4] = 0;
}
p->drunkang = 1647;
p->eatang = 1647;
p->drink_amt = 0;
p->eat = 0;
p->drink_timer = 0;
p->eat_timer = 0;
p->shotgun_state[0] = 0;
p->shotgun_state[1] = 0;
p->detonate_time = 0;
p->detonate_count = 0;
p->recoil = 0;
p->yehaa_timer = 0;
resetlanepics();
if (numplayers < 2)
{
ufospawn = ud.m_player_skill*4+1;
if (ufospawn > 32)
ufospawn = 32;
ufocnt = 0;
hulkspawn = ud.m_player_skill + 1;
}
else
{
ufospawn = 32;
ufocnt = 0;
hulkspawn = 2;
}
}
END_DUKE_NS

2
source/games/duke/src/premap.h
View file

@ -38,7 +38,7 @@ void G_UpdateScreenArea(void);
void P_RandomSpawnPoint(int playerNum);
void P_ResetInventory(int playerNum);
void P_ResetPlayer(int playerNum);
void P_ResetStatus(int playerNum);
void resetplayerstats(int playerNum);
void P_ResetWeapons(int playerNum);
void G_ClearFIFO(void);
void G_ResetInterpolations(void);

777
source/games/duke/src/premap_d.cpp Normal file
View file

@ -0,0 +1,777 @@
//-------------------------------------------------------------------------
/*
Copyright (C) 1996, 2003 - 3D Realms Entertainment
Copyright (C) 2000, 2003 - Matt Saettler (EDuke Enhancements)
This file is part of Enhanced Duke Nukem 3D version 1.5 - Atomic Edition
Duke Nukem 3D is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
Original Source: 1996 - Todd Replogle
Prepared for public release: 03/21/2003 - Charlie Wiederhold, 3D Realms
EDuke enhancements integrated: 04/13/2003 - Matt Saettler
Note: EDuke source was in transition. Changes are in-progress in the
source as it is released.
*/
//-------------------------------------------------------------------------
#include "ns.h"
#include "global.h"
#include "build.h"
#include "names.h"
BEGIN_DUKE_NS
inline void tloadtile(int tilenum, int palnum = 0)
{
markTileForPrecache(tilenum, palnum);
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
static void cachespritenum(int i)
{
int maxc;
int j;
int pal = sprite[i].pal;
if(ud.monsters_off && badguy(&sprite[i])) return;
maxc = 1;
switch(sprite[i].picnum)
{
case HYDRENT:
tloadtile(BROKEFIREHYDRENT);
for(j = TOILETWATER; j < (TOILETWATER+4); j++)
tloadtile(j, pal);
break;
case TOILET:
tloadtile(TOILETBROKE);
for(j = TOILETWATER; j < (TOILETWATER+4); j++)
tloadtile(j, pal);
break;
case STALL:
tloadtile(STALLBROKE);
for(j = TOILETWATER; j < (TOILETWATER+4); j++)
tloadtile(j, pal);
break;
case RUBBERCAN:
maxc = 2;
break;
case TOILETWATER:
maxc = 4;
break;
case FEMPIC1:
maxc = 44;
break;
case LIZTROOP:
case LIZTROOPRUNNING:
case LIZTROOPSHOOT:
case LIZTROOPJETPACK:
case LIZTROOPONTOILET:
case LIZTROOPDUCKING:
for(j = LIZTROOP; j < (LIZTROOP+72); j++)
tloadtile(j, pal);
for(j=HEADJIB1;j<LEGJIB1+3;j++)
tloadtile(j, pal);
maxc = 0;
break;
case WOODENHORSE:
maxc = 5;
for(j = HORSEONSIDE; j < (HORSEONSIDE+4); j++)
tloadtile(j, pal);
break;
case NEWBEAST:
case NEWBEASTSTAYPUT:
maxc = 90;
break;
case BOSS1:
case BOSS2:
case BOSS3:
maxc = 30;
break;
case OCTABRAIN:
case OCTABRAINSTAYPUT:
case COMMANDER:
case COMMANDERSTAYPUT:
maxc = 38;
break;
case RECON:
maxc = 13;
break;
case PIGCOP:
case PIGCOPDIVE:
maxc = 61;
break;
case SHARK:
maxc = 30;
break;
case LIZMAN:
case LIZMANSPITTING:
case LIZMANFEEDING:
case LIZMANJUMP:
for(j=LIZMANHEAD1;j<LIZMANLEG1+3;j++)
tloadtile(j, pal);
maxc = 80;
break;
case APLAYER:
maxc = 0;
if(ud.multimode > 1)
{
maxc = 5;
for(j = 1420;j < 1420+106; j++)
tloadtile(j, pal);
}
break;
case ATOMICHEALTH:
maxc = 14;
break;
case DRONE:
maxc = 10;
break;
case EXPLODINGBARREL:
case SEENINE:
case OOZFILTER:
maxc = 3;
break;
case NUKEBARREL:
case CAMERA1:
maxc = 5;
break;
}
for(j = sprite[i].picnum; j < (sprite[i].picnum+maxc); j++)
tloadtile(j, pal);
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
static void cachegoodsprites(void)
{
int i;
if (ud.screen_size >= 8)
{
tloadtile(BOTTOMSTATUSBAR);
if (ud.multimode > 1)
{
tloadtile(FRAGBAR);
for (i = MINIFONT; i < MINIFONT + 63; i++)
tloadtile(i);
}
}
tloadtile(VIEWSCREEN);
for(i=FOOTPRINTS;i<FOOTPRINTS+3;i++)
tloadtile(i);
for( i = BURNING; i < BURNING+14; i++)
tloadtile(i);
for( i = BURNING2; i < BURNING2+14; i++)
tloadtile(i);
for( i = CRACKKNUCKLES; i < CRACKKNUCKLES+4; i++)
tloadtile(i);
for( i = FIRSTGUN; i < FIRSTGUN+3 ; i++ )
tloadtile(i);
for( i = EXPLOSION2; i < EXPLOSION2+21 ; i++ )
tloadtile(i);
tloadtile(BULLETHOLE);
for( i = FIRSTGUNRELOAD; i < FIRSTGUNRELOAD+8 ; i++ )
tloadtile(i);
tloadtile(FOOTPRINTS);
for( i = JIBS1; i < (JIBS5+5); i++)
tloadtile(i);
for( i = SCRAP1; i < (SCRAP1+19); i++)
tloadtile(i);
for( i = SMALLSMOKE; i < (SMALLSMOKE+4); i++)
tloadtile(i);
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void cacheit(void)
{
int i, j;
cachegoodsprites();
for (i = 0; i < numwalls; i++)
{
tloadtile(wall[i].picnum, wall[i].pal);
if (wall[i].overpicnum >= 0)
tloadtile(wall[i].overpicnum, wall[i].pal);
}
for (i = 0; i < numsectors; i++)
{
tloadtile(sector[i].floorpicnum, sector[i].floorpal);
tloadtile(sector[i].ceilingpicnum, sector[i].ceilingpal);
if (sector[i].ceilingpicnum == LA)
{
tloadtile(LA + 1);
tloadtile(LA + 2);
}
}
j = headspritesect[i];
while (j >= 0)
{
if (sprite[j].xrepeat != 0 && sprite[j].yrepeat != 0 && (sprite[j].cstat & 32768) == 0)
cachespritenum(j);
j = nextspritesect[j];
}
precacheMarkedTiles();
}
#if 0
void resetweapons_w(int snum)
{
resetweapons(snum);
OnEvent(EVENT_RESETWEAPONS, -1, snum, -1);
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void prelevel(int g)
{
short i, nexti, j, startwall, endwall, lotaglist;
short lotags[65];
show2dsector.Zero();
memset(show2dwall,0, sizeof(show2dwall));
memset(show2dsprite,0, sizeof(show2dsprite));
resetprestat(0,g);
numclouds = 0;
for(i=0;i<numsectors;i++)
{
sector[i].extra = 256;
switch(sector[i].lotag)
{
case 20:
case 22:
if( sector[i].floorz > sector[i].ceilingz)
sector[i].lotag |= 32768;
continue;
}
if(sector[i].ceilingstat&1)
{
setupbackdrop(sector[i].ceilingpicnum);
if(sector[i].ceilingpicnum == CLOUDYSKIES && numclouds < 127)
clouds[numclouds++] = i;
if(ps[0].one_parallax_sectnum == -1)
ps[0].one_parallax_sectnum = i;
}
if(sector[i].lotag == 32767) //Found a secret room
{
ps[0].max_secret_rooms++;
continue;
}
if(sector[i].lotag == -1)
{
ps[0].exitx = wall[sector[i].wallptr].x;
ps[0].exity = wall[sector[i].wallptr].y;
continue;
}
}
i = headspritestat[0];
while(i >= 0)
{
nexti = nextspritestat[i];
LoadActor(i, -1, -1);
if(sprite[i].lotag == -1 && (sprite[i].cstat&16) )
{
ps[0].exitx = SX;
ps[0].exity = SY;
}
else switch(PN)
{
case GPSPEED:
sector[SECT].extra = SLT;
deletesprite(i);
break;
case CYCLER:
if(numcyclers >= MAXCYCLERS)
gameexit("\nToo many cycling sectors.");
cyclers[numcyclers][0] = SECT;
cyclers[numcyclers][1] = SLT;
cyclers[numcyclers][2] = SS;
cyclers[numcyclers][3] = sector[SECT].floorshade;
cyclers[numcyclers][4] = SHT;
cyclers[numcyclers][5] = (SA == 1536);
numcyclers++;
deletesprite(i);
break;
}
i = nexti;
}
for(i=0;i < MAXSPRITES;i++)
{
if(sprite[i].statnum < MAXSTATUS)
{
if(PN == SECTOREFFECTOR && SLT == 14)
continue;
spawn(-1,i);
}
}
for(i=0;i < MAXSPRITES;i++)
if(sprite[i].statnum < MAXSTATUS)
{
if( PN == SECTOREFFECTOR && SLT == 14 )
spawn(-1,i);
}
lotaglist = 0;
i = headspritestat[0];
while(i >= 0)
{
switch(PN)
{
case DIPSWITCH:
case DIPSWITCH2:
case ACCESSSWITCH:
case PULLSWITCH:
case HANDSWITCH:
case SLOTDOOR:
case LIGHTSWITCH:
case SPACELIGHTSWITCH:
case SPACEDOORSWITCH:
case FRANKENSTINESWITCH:
case LIGHTSWITCH2:
case POWERSWITCH1:
case LOCKSWITCH1:
case POWERSWITCH2:
break;
case DIPSWITCH+1:
case DIPSWITCH2+1:
case PULLSWITCH+1:
case HANDSWITCH+1:
case SLOTDOOR+1:
case LIGHTSWITCH+1:
case SPACELIGHTSWITCH+1:
case SPACEDOORSWITCH+1:
case FRANKENSTINESWITCH+1:
case LIGHTSWITCH2+1:
case POWERSWITCH1+1:
case LOCKSWITCH1+1:
case POWERSWITCH2+1:
for(j=0;j<lotaglist;j++)
if( SLT == lotags[j] )
break;
if( j == lotaglist )
{
lotags[lotaglist] = SLT;
lotaglist++;
if(lotaglist > 64)
gameexit("\nToo many switches (64 max).");
j = headspritestat[3];
while(j >= 0)
{
if(sprite[j].lotag == 12 && sprite[j].hitag == SLT)
hittype[j].temp_data[0] = 1;
j = nextspritestat[j];
}
}
break;
}
i = nextspritestat[i];
}
mirrorcnt = 0;
for( i = 0; i < numwalls; i++ )
{
walltype *wal;
wal = &wall[i];
if(wal->overpicnum == MIRROR && (wal->cstat&32) != 0)
{
j = wal->nextsector;
if(mirrorcnt > 63)
gameexit("\nToo many mirrors (64 max.)");
if ( (j >= 0) && sector[j].ceilingpicnum != MIRROR )
{
sector[j].ceilingpicnum = MIRROR;
sector[j].floorpicnum = MIRROR;
mirrorwall[mirrorcnt] = i;
mirrorsector[mirrorcnt] = j;
mirrorcnt++;
continue;
}
}
if(numanimwalls >= MAXANIMWALLS)
gameexit("\nToo many 'anim' walls (max 512.)");
animwall[numanimwalls].tag = 0;
animwall[numanimwalls].wallnum = 0;
switch(wal->overpicnum)
{
case FANSHADOW:
case FANSPRITE:
wall->cstat |= 65;
animwall[numanimwalls].wallnum = i;
numanimwalls++;
break;
case W_FORCEFIELD:
if(waloff[W_FORCEFIELD] == 0)
for(j=0;j<3;j++)
tloadtile(W_FORCEFIELD+j);
case W_FORCEFIELD+1:
case W_FORCEFIELD+2:
if(wal->shade > 31)
wal->cstat = 0;
else wal->cstat |= 85+256;
if(wal->lotag && wal->nextwall >= 0)
wall[wal->nextwall].lotag =
wal->lotag;
case BIGFORCE:
animwall[numanimwalls].wallnum = i;
numanimwalls++;
continue;
}
wal->extra = -1;
switch(wal->picnum)
{
case WATERTILE2:
for(j=0;j<3;j++)
if(waloff[wal->picnum+j] == 0)
tloadtile(wal->picnum+j);
break;
case TECHLIGHT2:
case TECHLIGHT4:
if(waloff[wal->picnum] == 0)
tloadtile(wal->picnum);
break;
case W_TECHWALL1:
case W_TECHWALL2:
case W_TECHWALL3:
case W_TECHWALL4:
animwall[numanimwalls].wallnum = i;
// animwall[numanimwalls].tag = -1;
numanimwalls++;
break;
case SCREENBREAK6:
case SCREENBREAK7:
case SCREENBREAK8:
if(waloff[SCREENBREAK6] == 0)
for(j=SCREENBREAK6;j<SCREENBREAK9;j++)
tloadtile(j);
animwall[numanimwalls].wallnum = i;
animwall[numanimwalls].tag = -1;
numanimwalls++;
break;
case FEMPIC1:
case FEMPIC2:
case FEMPIC3:
wal->extra = wal->picnum;
animwall[numanimwalls].tag = -1;
if(ud.lockout)
{
if(wal->picnum == FEMPIC1)
wal->picnum = BLANKSCREEN;
else wal->picnum = SCREENBREAK6;
}
animwall[numanimwalls].wallnum = i;
animwall[numanimwalls].tag = wal->picnum;
numanimwalls++;
break;
case SCREENBREAK1:
case SCREENBREAK2:
case SCREENBREAK3:
case SCREENBREAK4:
case SCREENBREAK5:
case SCREENBREAK9:
case SCREENBREAK10:
case SCREENBREAK11:
case SCREENBREAK12:
case SCREENBREAK13:
case SCREENBREAK14:
case SCREENBREAK15:
case SCREENBREAK16:
case SCREENBREAK17:
case SCREENBREAK18:
case SCREENBREAK19:
animwall[numanimwalls].wallnum = i;
animwall[numanimwalls].tag = wal->picnum;
numanimwalls++;
break;
}
}
//Invalidate textures in sector behind mirror
for(i=0;i<mirrorcnt;i++)
{
startwall = sector[mirrorsector[i]].wallptr;
endwall = startwall + sector[mirrorsector[i]].wallnum;
for(j=startwall;j<endwall;j++)
{
wall[j].picnum = MIRROR;
wall[j].overpicnum = MIRROR;
}
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void enterlevel(char g)
{
short i,j;
long l;
char levname[256];
if( (g&MODE_DEMO) != MODE_DEMO ) ud.recstat = ud.m_recstat;
ud.respawn_monsters = ud.m_respawn_monsters;
ud.respawn_items = ud.m_respawn_items;
ud.respawn_inventory = ud.m_respawn_inventory;
ud.monsters_off = ud.m_monsters_off;
ud.coop = ud.m_coop;
ud.marker = ud.m_marker;
ud.ffire = ud.m_ffire;
#ifdef WW2
//sprintf(g_szBuf,"ENTERLEVEL L=%d V=%d",ud.level_number, ud.volume_number);
//AddLog(g_szBuf);
// variables are set by pointer...
OnEvent(EVENT_ENTERLEVEL, -1, -1, -1);
#endif
if( (g&MODE_DEMO) == 0 && ud.recstat == 2)
ud.recstat = 0;
FX_StopAllSounds();
clearsoundlocks();
FX_SetReverb(0);
i = ud.screen_size;
ud.screen_size = 0;
dofrontscreens();
vscrn();
ud.screen_size = i;
#ifndef VOLUMEONE
if( boardfilename[0] != 0 && ud.m_level_number == 7 && ud.m_volume_number == 0 )
{
if ( loadboard( boardfilename,&ps[0].posx, &ps[0].posy, &ps[0].posz, &ps[0].ang,&ps[0].cursectnum ) == -1 )
{
initprintf("Map %s not found!\n",boardfilename);
//gameexit(tempbuf);
return 1;
} else {
char *p;
strcpy(levname, boardfilename);
p = Bstrrchr(levname,'.');
if (!p) strcat(levname,".mhk");
else { p[1]='m'; p[2]='h'; p[3]='k'; p[4]=0; }
if (!loadmaphack(levname)) initprintf("Loaded map hack file %s\n",levname);
}
}
else if ( loadboard( level_file_names[ (ud.volume_number*11)+ud.level_number],&ps[0].posx, &ps[0].posy, &ps[0].posz, &ps[0].ang,&ps[0].cursectnum ) == -1)
{
initprintf("Map %s not found!\n",level_file_names[(ud.volume_number*11)+ud.level_number]);
//gameexit(tempbuf);
return 1;
} else {
char *p;
strcpy(levname, level_file_names[ (ud.volume_number*11)+ud.level_number]);
p = Bstrrchr(levname,'.');
if (!p) strcat(levname,".mhk");
else { p[1]='m'; p[2]='h'; p[3]='k'; p[4]=0; }
if (!loadmaphack(levname)) initprintf("Loaded map hack file %s\n",levname);
}
#else
l = strlen(level_file_names[ (ud.volume_number*11)+ud.level_number]);
copybufbyte( level_file_names[ (ud.volume_number*11)+ud.level_number],&levname[0],l);
levname[l] = 255;
levname[l+1] = 0;
if ( loadboard( levname,&ps[0].posx, &ps[0].posy, &ps[0].posz, &ps[0].ang,&ps[0].cursectnum ) == -1)
{
initprintf("Map %s not found!\n",level_file_names[(ud.volume_number*11)+ud.level_number]);
//gameexit(tempbuf);
return 1;
} else {
char *p;
p = Bstrrchr(levname,'.');
if (!p) strcat(levname,".mhk");
else { p[1]='m'; p[2]='h'; p[3]='k'; p[4]=0; }
if (!loadmaphack(levname)) initprintf("Loaded map hack file %s\n",levname);
}
#endif
clearbufbyte(gotpic,sizeof(gotpic),0L);
prelevel(g);
allignwarpelevators();
resetpspritevars(g);
cachedebug = 0;
automapping = 0;
if(ud.recstat != 2) MUSIC_StopSong();
cacheit();
if(ud.recstat != 2)
{
music_select = (ud.volume_number*11) + ud.level_number;
playmusic(&music_fn[0][music_select][0]);
}
if( (g&MODE_GAME) || (g&MODE_EOL) )
ps[myconnectindex].gm = MODE_GAME;
else if(g&MODE_RESTART)
{
if(ud.recstat == 2)
ps[myconnectindex].gm = MODE_DEMO;
else ps[myconnectindex].gm = MODE_GAME;
}
if( (ud.recstat == 1) && (g&MODE_RESTART) != MODE_RESTART )
opendemowrite();
#ifdef VOLUMEONE
if(ud.level_number == 0 && ud.recstat != 2) FTA(40,&ps[myconnectindex]);
#endif
for(i=connecthead;i>=0;i=connectpoint2[i])
switch(sector[sprite[ps[i].i].sectnum].floorpicnum)
{
case HURTRAIL:
case FLOORSLIME:
case FLOORPLASMA:
resetweapons(i);
resetinventory(i);
ps[i].gotweapon[PISTOL_WEAPON] = 0;
ps[i].ammo_amount[PISTOL_WEAPON] = 0;
ps[i].curr_weapon = KNEE_WEAPON;
ps[i].kickback_pic = 0;
break;
}
//PREMAP.C - replace near the my's at the end of the file
resetmys();
ps[myconnectindex].palette = palette;
palto(0,0,0,0);
setpal(&ps[myconnectindex]);
flushperms();
everyothertime = 0;
global_random = 0;
ud.last_level = ud.level_number+1;
clearfifo();
for(i=numinterpolations-1;i>=0;i--) bakipos[i] = *curipos[i];
restorepalette = 1;
flushpackets();
waitforeverybody();
palto(0,0,0,0);
vscrn();
clearview(0L);
drawbackground();
displayrooms(myconnectindex,65536);
clearbufbyte(playerquitflag,MAXPLAYERS,0x01010101);
ps[myconnectindex].over_shoulder_on = 0;
clearfrags();
resettimevars(); // Here we go
}
#endif
END_DUKE_NS

1191
source/games/duke/src/premap_r.cpp Normal file
View file

File diff suppressed because it is too large Load diff

50
source/games/duke/src/zz_premap.cpp
View file

@ -626,31 +626,6 @@ void G_CacheMapData(void)
if ((j&7) == 0)
G_HandleAsync();
#if 0
if (bpp > 8 && totalclock - tc > TICRATE/4)
{
/*Bsprintf(tempbuf,"%d resources remaining\n",g_precacheCount-pc+1);*/
int percentage = min(100, tabledivide32_noinline(100 * pc, g_precacheCount));
while (percentage > lpc)
{
G_HandleAsync();
Bsprintf(tempbuf, "Loaded %d%% (%d/%d textures)\n", lpc, pc, g_precacheCount);
G_DoLoadScreen(tempbuf, lpc);
if (totalclock - tc >= 1)
{
tc = (int32_t) totalclock;
lpc++;
}
// Printf("percentage %d lpc %d\n", percentage, lpc);
}
tc = (int32_t) totalclock;
}
#endif
}
Bmemset(gotpic, 0, sizeof(gotpic));
@ -727,7 +702,7 @@ void P_RandomSpawnPoint(int playerNum)
if ((g_netServer || ud.multimode > 1) && !(g_gametypeFlags[ud.coop] & GAMETYPE_FIXEDRESPAWN))
{
i = krand2() % g_playerSpawnCnt;
i = krand2() % numplayersprites;
if (g_gametypeFlags[ud.coop] & GAMETYPE_TDMSPAWN)
{
@ -736,7 +711,7 @@ void P_RandomSpawnPoint(int playerNum)
{
if (j != playerNum && g_player[j].ps->team == pPlayer->team && sprite[g_player[j].ps->i].extra > 0)
{
for (bssize_t k=0; k<g_playerSpawnCnt; k++)
for (bssize_t k=0; k<numplayersprites; k++)
{
uint32_t dist = FindDistance2D(g_player[j].ps->pos.x - g_playerSpawnPoints[k].pos.x,
g_player[j].ps->pos.y - g_playerSpawnPoints[k].pos.y);
@ -830,6 +805,7 @@ void P_ResetPlayer(int playerNum)
pPlayer->movement_lock = 0;
}
#if 0
void P_ResetStatus(int playerNum)
{
DukePlayer_t *const pPlayer = g_player[playerNum].ps;
@ -1011,7 +987,7 @@ void P_ResetStatus(int playerNum)
}
}
}
#endif
void P_ResetWeapons(int playerNum)
{
DukePlayer_t *const pPlayer = g_player[playerNum].ps;
@ -1972,7 +1948,7 @@ static void resetpspritevars(char gameMode)
}
}
P_ResetStatus(0);
resetplayerstats(0);
for (TRAVERSE_CONNECT(i))
if (i) Bmemcpy(g_player[i].ps,g_player[0].ps,sizeof(DukePlayer_t));
@ -1995,7 +1971,7 @@ static void resetpspritevars(char gameMode)
}
}
g_playerSpawnCnt = 0;
numplayersprites = 0;
// circ = 2048/ud.multimode;
g_whichPalForPlayer = 9;
@ -2006,16 +1982,16 @@ static void resetpspritevars(char gameMode)
const int32_t nexti = nextspritestat[i];
spritetype *const s = &sprite[i];
if (g_playerSpawnCnt == MAXPLAYERS)
if (numplayersprites == MAXPLAYERS)
G_GameExit("\nToo many player sprites (max 16.)");
g_playerSpawnPoints[g_playerSpawnCnt].pos.x = s->x;
g_playerSpawnPoints[g_playerSpawnCnt].pos.y = s->y;
g_playerSpawnPoints[g_playerSpawnCnt].pos.z = s->z;
g_playerSpawnPoints[g_playerSpawnCnt].ang = s->ang;
g_playerSpawnPoints[g_playerSpawnCnt].sect = s->sectnum;
g_playerSpawnPoints[numplayersprites].pos.x = s->x;
g_playerSpawnPoints[numplayersprites].pos.y = s->y;
g_playerSpawnPoints[numplayersprites].pos.z = s->z;
g_playerSpawnPoints[numplayersprites].ang = s->ang;
g_playerSpawnPoints[numplayersprites].sect = s->sectnum;
g_playerSpawnCnt++;
numplayersprites++;
if (j < MAXPLAYERS)
{

2
source/games/duke/src/zz_savegame.cpp
View file

@ -783,7 +783,7 @@ static const dataspec_t svgm_udnetw[] =
{
{ DS_STRING, (void *)svgm_udnetw_string, 0, 1 },
{ 0, &ud.multimode, sizeof(ud.multimode), 1 },
{ 0, &g_playerSpawnCnt, sizeof(g_playerSpawnCnt), 1 },
{ 0, &numplayersprites, sizeof(numplayersprites), 1 },
{ 0, &g_playerSpawnPoints, sizeof(g_playerSpawnPoints), 1 },
{ DS_NOCHK, &ud.volume_number, sizeof(ud.volume_number), 1 },

6
source/glbackend/glbackend.cpp
View file

@ -464,4 +464,10 @@ void videoShowFrame(int32_t w)
twod->Clear();
}
void markTileForPrecache(int tilenum, int palnum)
{
}
void precacheMarkedTiles()
{
}