void G_DoLoadLevel (void)
{
int i;
for (i=0 ; i<MAXPLAYERS ; i++)
{
if (playeringame[i] && players[i].playerstate == PST_DEAD)
players[i].playerstate = PST_REBORN;
players[i].frags = 0;
}
/* */
/* set the sky map for the episode */
/* */
if (gamemap < 9)
skytexture = R_TextureNumForName ("SKY1");
else if (gamemap < 18)
skytexture = R_TextureNumForName ("SKY2");
else
skytexture = R_TextureNumForName ("SKY3");
skytexturep = &textures[skytexture];
P_SetupLevel (gamemap, gameskill);
displayplayer = consoleplayer; /* view the guy you are playing */
gameaction = ga_nothing;
/* S_StartSong(1, 0); */ /* Added CEF */
Z_CheckHeap (mainzone); /* DEBUG */
}
/**
* Calculate the amount of unused memory in all volumes combined.
*/
size_t Z_FreeMemory(void)
{
memvolume_t *volume;
memblock_t *block;
size_t free = 0;
lockZone();
Z_CheckHeap();
for (volume = volumeRoot; volume; volume = volume->next)
{
for (block = volume->zone->blockList.next;
block != &volume->zone->blockList;
block = block->next)
{
if (!block->user)
{
free += block->size;
}
}
}
unlockZone();
return free;
}
void G_DoLoadLevel(void)
{
int i;
levelstarttic = gametic; // for time calculation
gamestate = GS_LEVEL;
for (i = 0; i < MAXPLAYERS; i++)
{
if (playeringame[i] && players[i].playerstate == PST_DEAD)
players[i].playerstate = PST_REBORN;
memset(players[i].frags, 0, sizeof(players[i].frags));
}
P_SetupLevel(gameepisode, gamemap, 0, gameskill);
displayplayer = consoleplayer; // view the guy you are playing
gameaction = ga_nothing;
Z_CheckHeap();
//
// clear cmd building stuff
//
memset(gamekeydown, 0, sizeof(gamekeydown));
joyxmove = joyymove = joystrafemove = 0;
mousex = mousey = 0;
sendpause = sendsave = paused = false;
memset(mousearray, 0, sizeof(mousearray));
memset(joyarray, 0, sizeof(joyarray));
if (testcontrols)
{
P_SetMessage(&players[consoleplayer], "PRESS ESCAPE TO QUIT.", false);
}
}
/*
========================
Z_Malloc
========================
*/
void *Z_Malloc (int size)
{
void *buf;
Z_CheckHeap (); // DEBUG
buf = Z_TagMalloc (size, 1);
if (!buf)
Sys_Error ("Z_Malloc: failed on allocation of %i bytes",size);
Q_memset (buf, 0, size);
return buf;
}
/*
* ========================
* Z_Malloc
* ========================
*/
void *
Z_Malloc(int size)
{
void *buf;
Z_CheckHeap(); /* DEBUG */
buf = Z_TagMalloc(size, 1);
if (!buf)
Sys_Error("%s: failed on allocation of %i bytes", __func__, size);
memset(buf, 0, size);
return buf;
}
/**
* Create a new memory volume. The new volume is added to the list of
* memory volumes.
*/
static memvolume_t *createVolume(size_t volumeSize)
{
memblock_t *block;
memvolume_t *vol = M_Calloc(sizeof(memvolume_t));
lockZone();
// Append to the end of the volume list.
if (volumeLast)
volumeLast->next = vol;
volumeLast = vol;
vol->next = 0;
if (!volumeRoot)
volumeRoot = vol;
// Allocate memory for the zone volume.
vol->size = volumeSize;
vol->zone = M_Malloc(vol->size);
vol->allocatedBytes = 0;
// Clear the start of the zone.
memset(vol->zone, 0, sizeof(memzone_t) + sizeof(memblock_t));
vol->zone->size = vol->size;
// Set the entire zone to one free block.
vol->zone->blockList.next
= vol->zone->blockList.prev
= block
= (memblock_t *) ((byte *) vol->zone + sizeof(memzone_t));
vol->zone->blockList.user = (void *) vol->zone;
vol->zone->blockList.volume = vol;
vol->zone->blockList.tag = PU_APPSTATIC;
vol->zone->rover = vol->zone->staticRover = block;
block->prev = block->next = &vol->zone->blockList;
block->user = NULL; // free block
block->seqFirst = block->seqLast = NULL;
block->size = vol->zone->size - sizeof(memzone_t);
unlockZone();
App_Log(DE2_LOG_MESSAGE,
"Created a new %.1f MB memory volume.", vol->size / 1024.0 / 1024.0);
Z_CheckHeap();
return vol;
}
/*
========================
Z_Malloc
========================
*/
void *Z_Malloc (int size, int zone_id)
{
void *buf;
if (zone_id != Z_MAINZONE && zone_id != Z_SECZONE)
Sys_Error ("%s: Bad Zone ID %i", __thisfunc__, zone_id);
#if Z_CHECKHEAP
Z_CheckHeap (zone_id); // DEBUG
#endif
buf = Z_TagMalloc (zone_id, size, 1);
if (!buf)
Sys_Error ("%s: failed on allocation of %i bytes", __thisfunc__, size);
memset (buf, 0, size);
return buf;
}
//
// E_CleanUpEDF
//
// Shared shutdown phase code for E_ProcessEDF and E_ProcessNewEDF
//
static void E_CleanUpEDF(cfg_t *cfg)
{
E_EDFLogPuts("\n==================== Shutdown Phase =====================\n");
// Free the cfg_t object.
E_EDFLogPuts("\t* Freeing main cfg object\n");
cfg_free(cfg);
// check heap integrity for safety
E_EDFLogPuts("\t* Checking zone heap integrity\n");
Z_CheckHeap();
// close the verbose log file
E_EDFCloseVerboseLog();
// Output warnings display
E_EDFPrintWarningCount();
}
void (Z_ChangeTag)(void *ptr, int tag, const char *file, int line)
{
memblock_t *block = (memblock_t *)((char *) ptr - HEADER_SIZE);
#ifdef INSTRUMENTED
#ifdef CHECKHEAP
Z_CheckHeap();
#endif
#endif
#ifdef ZONEIDCHECK
if (block->id != ZONEID)
I_Error ("Z_ChangeTag: freed a pointer without ZONEID"
"\nSource: %s:%d"
#ifdef INSTRUMENTED
"\nSource of malloc: %s:%d"
, file, line, block->file, block->line
#else
, file, line
#endif
);
if (tag >= PU_PURGELEVEL && !block->user)
I_Error ("Z_ChangeTag: an owner is required for purgable blocks\n"
"Source: %s:%d"
#ifdef INSTRUMENTED
"\nSource of malloc: %s:%d"
, file, line, block->file, block->line
#else
, file, line
#endif
);
#endif // ZONEIDCHECK
if (block->vm)
{
if ((*(memblock_t **) block->prev = block->next))
block->next->prev = block->prev;
if ((block->next = blockbytag[tag]))
block->next->prev = (memblock_t *) &block->next;
block->prev = (memblock_t *) &blockbytag[tag];
blockbytag[tag] = block;
}
else
{
#ifdef INSTRUMENTED
if (block->tag < PU_PURGELEVEL && tag >= PU_PURGELEVEL)
{
active_memory -= block->size - block->extra;
purgable_memory += block->size - block->extra;
}
else
if (block->tag >= PU_PURGELEVEL && tag < PU_PURGELEVEL)
{
active_memory += block->size - block->extra;
purgable_memory -= block->size - block->extra;
}
#endif
}
block->tag = tag;
}
void (Z_Free)(void *p, const char *file, int line)
{
#ifdef INSTRUMENTED
#ifdef CHECKHEAP
Z_CheckHeap();
#endif
file_history[free_history][history_index[free_history]] = file;
line_history[free_history][history_index[free_history]++] = line;
history_index[free_history] &= ZONE_HISTORY-1;
#endif
if (p)
{
memblock_t *other, *block = (memblock_t *)((char *) p - HEADER_SIZE);
#ifdef ZONEIDCHECK
if (block->id != ZONEID)
I_Error("Z_Free: freed a pointer without ZONEID\n"
"Source: %s:%d"
#ifdef INSTRUMENTED
"\nSource of malloc: %s:%d"
, file, line, block->file, block->line
#else
, file, line
#endif
);
block->id = 0; // Nullify id so another free fails
#endif
#ifdef INSTRUMENTED
// scramble memory -- weed out any bugs
memset(p, gametic & 0xff, block->size - block->extra);
#endif
if (block->user) // Nullify user if one exists
*block->user = NULL;
if (block->vm)
{
if ((*(memblock_t **) block->prev = block->next))
block->next->prev = block->prev;
#ifdef INSTRUMENTED
virtual_memory -= block->size;
#endif
(free)(block);
}
else
{
#ifdef INSTRUMENTED
free_memory += block->size;
inactive_memory -= block->extra;
if (block->tag >= PU_PURGELEVEL)
purgable_memory -= block->size - block->extra;
else
active_memory -= block->size - block->extra;
#endif
block->tag = PU_FREE; // Mark block freed
if (block != zone)
{
other = block->prev; // Possibly merge with previous block
if (other->tag == PU_FREE)
{
if (rover == block) // Move back rover if it points at block
rover = other;
(other->next = block->next)->prev = other;
other->size += block->size + HEADER_SIZE;
block = other;
#ifdef INSTRUMENTED
inactive_memory -= HEADER_SIZE;
free_memory += HEADER_SIZE;
#endif
}
}
other = block->next; // Possibly merge with next block
if (other->tag == PU_FREE && other != zone)
{
if (rover == other) // Move back rover if it points at next block
rover = block;
(block->next = other->next)->prev = block;
block->size += other->size + HEADER_SIZE;
#ifdef INSTRUMENTED
inactive_memory -= HEADER_SIZE;
free_memory += HEADER_SIZE;
#endif
}
}
#ifdef INSTRUMENTED
Z_PrintStats(); // print memory allocation stats
#endif
}
}
void *(Z_Malloc)(size_t size, int tag, void **user, const char *file, int line)
{
register memblock_t *block;
memblock_t *start;
#ifdef INSTRUMENTED
size_t size_orig = size;
#ifdef CHECKHEAP
Z_CheckHeap();
#endif
file_history[malloc_history][history_index[malloc_history]] = file;
line_history[malloc_history][history_index[malloc_history]++] = line;
history_index[malloc_history] &= ZONE_HISTORY-1;
#endif
#ifdef ZONEIDCHECK
if (tag >= PU_PURGELEVEL && !user)
I_Error ("Z_Malloc: an owner is required for purgable blocks\n"
"Source: %s:%d", file, line);
#endif
if (!size)
return user ? *user = NULL : NULL; // malloc(0) returns NULL
size = (size+CHUNK_SIZE-1) & ~(CHUNK_SIZE-1); // round to chunk size
block = rover;
if (block->prev->tag == PU_FREE)
block = block->prev;
start = block;
do
{
if (block->tag >= PU_PURGELEVEL) // Free purgable blocks
{ // replacement is roughly FIFO
start = block->prev;
Z_Free((char *) block + HEADER_SIZE);
block = start = start->next; // Important: resets start
}
if (block->tag == PU_FREE && block->size >= size) // First-fit
{
size_t extra = block->size - size;
if (extra >= MIN_BLOCK_SPLIT + HEADER_SIZE)
{
memblock_t *newb = (memblock_t *)((char *) block +
HEADER_SIZE + size);
(newb->next = block->next)->prev = newb;
(newb->prev = block)->next = newb; // Split up block
block->size = size;
newb->size = extra - HEADER_SIZE;
newb->tag = PU_FREE;
newb->vm = 0;
#ifdef INSTRUMENTED
inactive_memory += HEADER_SIZE;
free_memory -= HEADER_SIZE;
#endif
}
rover = block->next; // set roving pointer for next search
#ifdef INSTRUMENTED
inactive_memory += block->extra = block->size - size_orig;
if (tag >= PU_PURGELEVEL)
purgable_memory += size_orig;
else
active_memory += size_orig;
free_memory -= block->size;
#endif
allocated:
#ifdef INSTRUMENTED
block->file = file;
block->line = line;
#endif
#ifdef ZONEIDCHECK
block->id = ZONEID; // signature required in block header
#endif
block->tag = tag; // tag
block->user = user; // user
block = (memblock_t *)((char *) block + HEADER_SIZE);
if (user) // if there is a user
*user = block; // set user to point to new block
#ifdef INSTRUMENTED
Z_PrintStats(); // print memory allocation stats
// scramble memory -- weed out any bugs
memset(block, gametic & 0xff, size);
#endif
return block;
}
}
while ((block = block->next) != start); // detect cycles as failure
// We've run out of physical memory, or so we think.
// Although less efficient, we'll just use ordinary malloc.
// This will squeeze the remaining juice out of this machine
// and start cutting into virtual memory if it has it.
while (!(block = (malloc)(size + HEADER_SIZE)))
{
if (!blockbytag[PU_CACHE])
I_Error ("Z_Malloc: Failure trying to allocate %lu bytes"
"\nSource: %s:%d",(unsigned long) size, file, line);
Z_FreeTags(PU_CACHE,PU_CACHE);
}
if ((block->next = blockbytag[tag]))
block->next->prev = (memblock_t *) &block->next;
blockbytag[tag] = block;
block->prev = (memblock_t *) &blockbytag[tag];
block->vm = 1;
#ifdef INSTRUMENTED
virtual_memory +=
#endif
block->size = size + HEADER_SIZE; // CPhipps - this was lost in the #ifdef above
goto allocated;
}
void* (Z_Malloc)(size_t size, int tag, void** user, const char* file, int line)
{
register memblock_t* block;
memblock_t* start;
#ifdef INSTRUMENTED
size_t size_orig = size;
#ifdef CHECKHEAP
Z_CheckHeap();
#endif
file_history[malloc_history][history_index[malloc_history]] = file;
line_history[malloc_history][history_index[malloc_history]++] = line;
history_index[malloc_history] &= ZONE_HISTORY - 1;
#endif
#ifdef ZONEIDCHECK
if (tag >= PU_PURGELEVEL && !user)
I_Error("Z_Malloc: an owner is required for purgable blocks\n"
"Source: %s:%d", file, line);
#endif
if (!size)
return user ? *user = NULL : NULL; // malloc(0) returns NULL
size = (size + CHUNK_SIZE - 1) & ~(CHUNK_SIZE - 1); // round to chunk size
block = rover;
if (block->prev->tag == PU_FREE)
block = block->prev;
start = block;
// haleyjd 06/17/08: import from EE:
// the first if() inside the loop below contains cph's memory
// purging efficiency fix
do
{
// Free purgable blocks; replacement is roughly FIFO
if (block->tag >= PU_PURGELEVEL)
{
start = block->prev;
Z_Free((char*) block + HEADER_SIZE);
/* cph - If start->next == block, we did not merge with the previous
* If !=, we did, so we continue from start.
* Important: we've reset start!
*/
if (start->next == block)
start = start->next;
else
block = start;
}
if (block->tag == PU_FREE && block->size >= size) // First-fit
{
size_t extra = block->size - size;
if (extra >= MIN_BLOCK_SPLIT + HEADER_SIZE)
{
memblock_t* newb =
(memblock_t*)((char*) block + HEADER_SIZE + size);
(newb->next = block->next)->prev = newb;
(newb->prev = block)->next = newb; // Split up block
block->size = size;
newb->size = extra - HEADER_SIZE;
newb->tag = PU_FREE;
newb->vm = 0;
#ifdef INSTRUMENTED
inactive_memory += HEADER_SIZE;
free_memory -= HEADER_SIZE;
#endif
}
rover = block->next; // set roving pointer for next search
#ifdef INSTRUMENTED
inactive_memory += block->extra = block->size - size_orig;
if (tag >= PU_PURGELEVEL)
purgable_memory += size_orig;
else
active_memory += size_orig;
free_memory -= block->size;
#endif
allocated:
#ifdef INSTRUMENTED
block->file = file;
block->line = line;
#endif
#ifdef ZONEIDCHECK
block->id = ZONEID; // signature required in block header
#endif
block->tag = tag; // tag
block->user = user; // user
block = (memblock_t*)((char*) block + HEADER_SIZE);
if (user) // if there is a user
*user = block; // set user to point to new block
#ifdef INSTRUMENTED
Z_PrintStats(); // print memory allocation stats
// scramble memory -- weed out any bugs
memset(block, gametic & 0xff, size);
#endif
return block;
}
}
while ((block = block->next) != start); // detect cycles as failure
// We've run out of physical memory, or so we think.
// Although less efficient, we'll just use ordinary malloc.
// This will squeeze the remaining juice out of this machine
// and start cutting into virtual memory if it has it.
while (!(block = (malloc)(size + HEADER_SIZE)))
{
if (!blockbytag[PU_CACHE])
I_Error("Z_Malloc: Failure trying to allocate %lu bytes"
"\nSource: %s:%d", (unsigned long) size, file, line);
Z_FreeTags(PU_CACHE, PU_CACHE);
}
if ((block->next = blockbytag[tag]))
block->next->prev = (memblock_t*) &block->next;
blockbytag[tag] = block;
block->prev = (memblock_t*) &blockbytag[tag];
block->vm = 1;
// haleyjd: cph's virtual memory error fix
#ifdef INSTRUMENTED
virtual_memory += size + HEADER_SIZE;
// haleyjd 06/17/08: Import from EE:
// Big problem: extra wasn't being initialized for vm
// blocks. This caused the memset used to randomize freed memory when
// INSTRUMENTED is defined to stomp all over the C heap.
block->extra = 0;
#endif
/* cph - the next line was lost in the #ifdef above, and also added an
* extra HEADER_SIZE to block->size, which was incorrect */
block->size = size;
goto allocated;
}
void (Z_ChangeTag)(void *ptr, int tag
#ifdef INSTRUMENTED
, const char *file, int line
#endif
)
{
memblock_t *block = (memblock_t *)((char *) ptr - HEADER_SIZE);
// proff - added sanity check, this can happen when an empty lump is locked
if (!ptr)
return;
// proff - do nothing if tag doesn't differ
if (tag == block->tag)
return;
#ifdef INSTRUMENTED
#ifdef CHECKHEAP
Z_CheckHeap();
#endif
#endif
#ifdef ZONEIDCHECK
if (block->id != ZONEID)
I_Error ("Z_ChangeTag: freed a pointer without ZONEID"
#ifdef INSTRUMENTED
"\nSource: %s:%d"
"\nSource of malloc: %s:%d"
, file, line, block->file, block->line
#endif
);
if (tag >= PU_PURGELEVEL && !block->user)
I_Error ("Z_ChangeTag: an owner is required for purgable blocks\n"
#ifdef INSTRUMENTED
"Source: %s:%d"
"\nSource of malloc: %s:%d"
, file, line, block->file, block->line
#endif
);
#endif // ZONEIDCHECK
if (block == block->next)
blockbytag[block->tag] = NULL;
else
if (blockbytag[block->tag] == block)
blockbytag[block->tag] = block->next;
block->prev->next = block->next;
block->next->prev = block->prev;
if (!blockbytag[tag])
{
blockbytag[tag] = block;
block->next = block->prev = block;
}
else
{
blockbytag[tag]->prev->next = block;
block->prev = blockbytag[tag]->prev;
block->next = blockbytag[tag];
blockbytag[tag]->prev = block;
}
#ifdef INSTRUMENTED
if (block->tag < PU_PURGELEVEL && tag >= PU_PURGELEVEL)
{
active_memory -= block->size;
purgable_memory += block->size;
}
else
if (block->tag >= PU_PURGELEVEL && tag < PU_PURGELEVEL)
{
active_memory += block->size;
purgable_memory -= block->size;
}
#endif
block->tag = tag;
}
void *(Z_Malloc)(size_t size, int tag, void **user
#ifdef INSTRUMENTED
, const char *file, int line
#endif
)
{
memblock_t *block = NULL;
#ifdef INSTRUMENTED
#ifdef CHECKHEAP
Z_CheckHeap();
#endif
file_history[malloc_history][history_index[malloc_history]] = file;
line_history[malloc_history][history_index[malloc_history]++] = line;
history_index[malloc_history] &= ZONE_HISTORY-1;
#endif
#ifdef ZONEIDCHECK
if (tag >= PU_PURGELEVEL && !user)
I_Error ("Z_Malloc: An owner is required for purgable blocks"
#ifdef INSTRUMENTED
"Source: %s:%d", file, line
#endif
);
#endif
if (!size)
return user ? *user = NULL : NULL; // malloc(0) returns NULL
size = (size+CHUNK_SIZE-1) & ~(CHUNK_SIZE-1); // round to chunk size
if (memory_size > 0 && ((free_memory + memory_size) < (int)(size + HEADER_SIZE)))
{
memblock_t *end_block;
block = blockbytag[PU_CACHE];
if (block)
{
end_block = block->prev;
while (1)
{
memblock_t *next = block->next;
#ifdef INSTRUMENTED
(Z_Free)((char *) block + HEADER_SIZE, file, line);
#else
(Z_Free)((char *) block + HEADER_SIZE);
#endif
if (((free_memory + memory_size) >= (int)(size + HEADER_SIZE)) || (block == end_block))
break;
block = next; // Advance to next block
}
}
block = NULL;
}
#ifdef HAVE_LIBDMALLOC
while (!(block = dmalloc_malloc(file,line,size + HEADER_SIZE,DMALLOC_FUNC_MALLOC,0,0))) {
#else
while (!(block = (malloc)(size + HEADER_SIZE))) {
#endif
if (!blockbytag[PU_CACHE])
I_Error ("Z_Malloc: Failure trying to allocate %lu bytes"
#ifdef INSTRUMENTED
"\nSource: %s:%d"
#endif
,(unsigned long) size
#ifdef INSTRUMENTED
, file, line
#endif
);
Z_FreeTags(PU_CACHE,PU_CACHE);
}
if (!blockbytag[tag])
{
blockbytag[tag] = block;
block->next = block->prev = block;
}
else
{
blockbytag[tag]->prev->next = block;
block->prev = blockbytag[tag]->prev;
block->next = blockbytag[tag];
blockbytag[tag]->prev = block;
}
block->size = size;
#ifdef INSTRUMENTED
if (tag >= PU_PURGELEVEL)
purgable_memory += block->size;
else
active_memory += block->size;
#endif
free_memory -= block->size;
#ifdef INSTRUMENTED
block->file = file;
block->line = line;
#endif
#ifdef ZONEIDCHECK
block->id = ZONEID; // signature required in block header
#endif
block->tag = tag; // tag
block->user = user; // user
block = (memblock_t *)((char *) block + HEADER_SIZE);
if (user) // if there is a user
*user = block; // set user to point to new block
#ifdef INSTRUMENTED
Z_DrawStats(); // print memory allocation stats
// scramble memory -- weed out any bugs
memset(block, gametic & 0xff, size);
#endif
return block;
}
void (Z_Free)(void *p
#ifdef INSTRUMENTED
, const char *file, int line
#endif
)
{
memblock_t *block = (memblock_t *)((char *) p - HEADER_SIZE);
#ifdef INSTRUMENTED
#ifdef CHECKHEAP
Z_CheckHeap();
#endif
file_history[free_history][history_index[free_history]] = file;
line_history[free_history][history_index[free_history]++] = line;
history_index[free_history] &= ZONE_HISTORY-1;
#endif
if (!p)
return;
#ifdef ZONEIDCHECK
if (block->id != ZONEID)
I_Error("Z_Free: freed a pointer without ZONEID"
#ifdef INSTRUMENTED
"\nSource: %s:%d"
"\nSource of malloc: %s:%d"
, file, line, block->file, block->line
#endif
);
block->id = 0; // Nullify id so another free fails
#endif
if (block->user) // Nullify user if one exists
*block->user = NULL;
if (block == block->next)
blockbytag[block->tag] = NULL;
else
if (blockbytag[block->tag] == block)
blockbytag[block->tag] = block->next;
block->prev->next = block->next;
block->next->prev = block->prev;
free_memory += block->size;
#ifdef INSTRUMENTED
if (block->tag >= PU_PURGELEVEL)
purgable_memory -= block->size;
else
active_memory -= block->size;
/* scramble memory -- weed out any bugs */
memset(block, gametic & 0xff, block->size + HEADER_SIZE);
#endif
#ifdef HAVE_LIBDMALLOC
dmalloc_free(file,line,block,DMALLOC_FUNC_MALLOC);
#else
(free)(block);
#endif
#ifdef INSTRUMENTED
Z_DrawStats(); // print memory allocation stats
#endif
}
void P_SetupLevel(int map, skill_t skill)
{
int i;
static char lumpname[16];
int lumpnum;
mobj_t *mobj;
extern int cy;
M_ClearRandom();
P_LoadingPlaque();
D_printf("P_SetupLevel(%i,%i)\n", map, skill);
totalkills = totalitems = totalsecret = 0;
for(i = 0; i < MAXPLAYERS; i++)
players[i].killcount = players[i].secretcount = players[i].itemcount = 0;
Z_CheckHeap(mainzone);
Z_CheckHeap(refzone);
Z_FreeTags(mainzone);
P_InitThinkers();
//
// look for a regular (development) map first
//
lumpname[0] = 'M';
lumpname[1] = 'A';
lumpname[2] = 'P';
lumpname[3] = '0' + map / 10;
lumpname[4] = '0' + map % 10;
lumpname[5] = 0;
lumpnum = W_GetNumForName(lumpname);
// note: most of this ordering is important
P_LoadBlockMap(lumpnum+ML_BLOCKMAP);
P_LoadVertexes(lumpnum+ML_VERTEXES);
P_LoadSectors(lumpnum+ML_SECTORS);
P_LoadSideDefs(lumpnum+ML_SIDEDEFS);
P_LoadLineDefs(lumpnum+ML_LINEDEFS);
P_LoadSubsectors(lumpnum+ML_SSECTORS);
P_LoadNodes(lumpnum+ML_NODES);
P_LoadSegs(lumpnum+ML_SEGS);
rejectmatrix = W_CacheLumpNum(lumpnum + ML_REJECT, PU_LEVEL);
P_GroupLines();
deathmatch_p = deathmatchstarts;
P_LoadThings(lumpnum + ML_THINGS);
//
// if deathmatch, randomly spawn the active players
//
if(netgame == gt_deathmatch)
{
for(i = 0; i < MAXPLAYERS; i++)
{
if(playeringame[i])
{
// must give a player spot before deathmatchspawn
mobj = P_SpawnMobj(deathmatchstarts[0].x << 16 ,deathmatchstarts[0].y << 16, 0, MT_PLAYER);
players[i].mo = mobj;
G_DeathMatchSpawnPlayer(i);
P_RemoveMobj(mobj);
}
}
}
// set up world state
P_SpawnSpecials();
ST_InitEveryLevel();
cy = 4;
iquehead = iquetail = 0;
gamepaused = false;
}
void P_SetupLevel (int map, skill_t skill)
{
int i;
static char lumpname[16];
int lumpnum;
mobj_t *mobj;
extern int cy;
M_ClearRandom ();
P_LoadingPlaque ();
D_printf ("P_SetupLevel(%i,%i)\n",map,skill);
totalkills = totalitems = totalsecret = 0;
for (i=0 ; i<MAXPLAYERS ; i++)
{
players[i].killcount = players[i].secretcount
= players[i].itemcount = 0;
}
Z_CheckHeap (mainzone);
#ifndef MARS
Z_CheckHeap (refzone);
#endif
Z_FreeTags (mainzone);
/*PrintHex (1,1,Z_FreeMemory (mainzone)); */
P_InitThinkers ();
/* */
/* look for a regular (development) map first */
/* */
lumpname[0] = 'M';
lumpname[1] = 'A';
lumpname[2] = 'P';
lumpname[3] = '0' + map/10;
lumpname[4] = '0' + map%10;
lumpname[5] = 0;
lumpnum = W_GetNumForName (lumpname);
/* note: most of this ordering is important */
P_LoadBlockMap (lumpnum+ML_BLOCKMAP);
P_LoadVertexes (lumpnum+ML_VERTEXES);
P_LoadSectors (lumpnum+ML_SECTORS);
P_LoadSideDefs (lumpnum+ML_SIDEDEFS);
P_LoadLineDefs (lumpnum+ML_LINEDEFS);
P_LoadSubsectors (lumpnum+ML_SSECTORS);
P_LoadNodes (lumpnum+ML_NODES);
P_LoadSegs (lumpnum+ML_SEGS);
#ifdef MARS
rejectmatrix = (byte *)(wadfileptr+BIGLONG(lumpinfo[lumpnum+ML_REJECT].filepos));
#else
rejectmatrix = W_CacheLumpNum (lumpnum+ML_REJECT,PU_LEVEL);
#endif
P_GroupLines ();
deathmatch_p = deathmatchstarts;
P_LoadThings (lumpnum+ML_THINGS);
/* */
/* if deathmatch, randomly spawn the active players */
/* */
if (netgame == gt_deathmatch)
{
for (i=0 ; i<MAXPLAYERS ; i++)
if (playeringame[i])
{ /* must give a player spot before deathmatchspawn */
mobj = P_SpawnMobj (deathmatchstarts[0].x<<16
,deathmatchstarts[0].y<<16,0, MT_PLAYER);
players[i].mo = mobj;
G_DeathMatchSpawnPlayer (i);
P_RemoveMobj (mobj);
}
}
/* set up world state */
P_SpawnSpecials ();
ST_InitEveryLevel ();
/*printf ("free memory: 0x%x\n", Z_FreeMemory(mainzone)); */
cy = 4;
#ifdef JAGUAR
{
extern byte *debugscreen;
D_memset (debugscreen,0,32*224);
}
#endif
iquehead = iquetail = 0;
gamepaused = false;
}