static void CAL_SetupAudioFile()
{
int handle;
long length;
char fname[13];
int i;
strcpy(fname, aheadname);
strcat(fname, extension);
handle = OpenRead(fname);
if (handle == -1)
CA_CannotOpen(fname);
length = ReadLength(handle);
MM_GetPtr((memptr)&audiostarts, length);
for (i = 0; i < (length/4); i++)
audiostarts[i] = ReadInt32(handle);
CloseRead(handle);
/* open the data file */
strcpy(fname, afilename);
strcat(fname, extension);
audiohandle = OpenRead(fname);
if (audiohandle == -1)
CA_CannotOpen(fname);
}
void CAL_SetupGrFile()
{
char fname[13];
bstone::FileStream handle;
Uint8* compseg;
//
// load ???dict.ext (huffman dictionary for graphics files)
//
strcpy(fname, gdictname);
strcat(fname, extension);
handle.open(fname);
if (!handle.is_open())
CA_CannotOpen(fname);
handle.read(&grhuffman, sizeof(grhuffman));
//
// load the data offsets from ???head.ext
//
int grstarts_size = (NUMCHUNKS + 1) * FILEPOSSIZE;
grstarts = new Sint32[(grstarts_size + 3) / 4];
strcpy(fname, gheadname);
strcat(fname, extension);
handle.open(fname);
if (!handle.is_open())
CA_CannotOpen(fname);
handle.read(grstarts, grstarts_size);
//
// Open the graphics file, leaving it open until the game is finished
//
OpenGrFile();
//
// load the pic and sprite headers into the arrays in the data segment
//
pictable = new pictabletype[NUMPICS];
CAL_GetGrChunkLength(STRUCTPIC); // position file pointer
compseg = new Uint8[chunkcomplen];
grhandle.read(compseg, chunkcomplen);
CAL_HuffExpand(
compseg,
(Uint8*)pictable,
NUMPICS * sizeof(pictabletype),
grhuffman);
delete [] compseg;
}
void CAL_SetupAudioFile (void)
{
bstone::FileStream handle;
Sint32 length;
char fname[13];
//
// load maphead.ext (offsets and tileinfo for map file)
//
#ifndef AUDIOHEADERLINKED
strcpy(fname,aheadname);
strcat(fname,extension);
handle.open(fname);
if (!handle.is_open())
CA_CannotOpen(fname);
length = static_cast<Sint32>(handle.get_size());
audiostarts = new Sint32[length / 4];
handle.read(audiostarts, length);
handle.close();
#else
audiohuffman = (huffnode *)&audiodict;
CAL_OptimizeNodes (audiohuffman);
audiostarts = (Sint32 *)FP_SEG(&audiohead);
#endif
//
// open the data file
//
OpenAudioFile();
}
void PM_Startup()
{
char fname[13] = "vswap.";
strcat(fname,extension);
FILE *file = fopen(fname,"rb");
if(!file)
CA_CannotOpen(fname);
ChunksInFile = 0;
fread(&ChunksInFile, sizeof(word), 1, file);
PMSpriteStart = 0;
fread(&PMSpriteStart, sizeof(word), 1, file);
PMSoundStart = 0;
fread(&PMSoundStart, sizeof(word), 1, file);
uint32_t* pageOffsets = (uint32_t *) malloc((ChunksInFile + 1) * sizeof(int32_t));
CHECKMALLOCRESULT(pageOffsets);
fread(pageOffsets, sizeof(uint32_t), ChunksInFile, file);
word *pageLengths = (word *) malloc(ChunksInFile * sizeof(word));
CHECKMALLOCRESULT(pageLengths);
fread(pageLengths, sizeof(word), ChunksInFile, file);
fseek(file, 0, SEEK_END);
long fileSize = ftell(file);
long pageDataSize = fileSize - pageOffsets[0];
if(pageDataSize > (size_t) -1)
Quit("The page file \"%s\" is too large!", fname);
pageOffsets[ChunksInFile] = fileSize;
uint32_t dataStart = pageOffsets[0];
int i;
// Check that all pageOffsets are valid
for(i = 0; i < ChunksInFile; i++)
{
if(!pageOffsets[i]) continue; // sparse page
if(pageOffsets[i] < dataStart || pageOffsets[i] >= (size_t) fileSize)
Quit("Illegal page offset for page %i: %u (filesize: %u)",
i, pageOffsets[i], fileSize);
}
// Calculate total amount of padding needed for sprites and sound info page
int alignPadding = 0;
for(i = PMSpriteStart; i < PMSoundStart; i++)
{
if(!pageOffsets[i]) continue; // sparse page
uint32_t offs = pageOffsets[i] - dataStart + alignPadding;
if(offs & 1)
alignPadding++;
}
if((pageOffsets[ChunksInFile - 1] - dataStart + alignPadding) & 1)
alignPadding++;
PMPageDataSize = (size_t) pageDataSize + alignPadding;
PMPageData = (uint32_t *) malloc(PMPageDataSize);
CHECKMALLOCRESULT(PMPageData);
PMPages = (uint8_t **) malloc((ChunksInFile + 1) * sizeof(uint8_t *));
CHECKMALLOCRESULT(PMPages);
// Load pages and initialize PMPages pointers
uint8_t *ptr = (uint8_t *) PMPageData;
for(i = 0; i < ChunksInFile; i++)
{
if(i >= PMSpriteStart && i < PMSoundStart || i == ChunksInFile - 1)
{
size_t offs = ptr - (uint8_t *) PMPageData;
// pad with zeros to make it 2-byte aligned
if(offs & 1)
{
*ptr++ = 0;
if(i == ChunksInFile - 1) PMSoundInfoPagePadded = true;
}
}
PMPages[i] = ptr;
if(!pageOffsets[i])
continue; // sparse page
// Use specified page length, when next page is sparse page.
// Otherwise, calculate size from the offset difference between this and the next page.
uint32_t size;
if(!pageOffsets[i + 1]) size = pageLengths[i];
else size = pageOffsets[i + 1] - pageOffsets[i];
fseek(file, pageOffsets[i], SEEK_SET);
fread(ptr, 1, size, file);
ptr += size;
}
// last page points after page buffer
PMPages[ChunksInFile] = ptr;
free(pageLengths);
free(pageOffsets);
fclose(file);
}
static void CAL_SetupMapFile()
{
int i;
int handle;
long pos;
char fname[13];
strcpy(fname, mheadname);
if (w0 == true || w1 == true || s0 == true || s1 == true){
strcat(fname, extension);
}else{
strcat(fname, extension2);
}
handle = OpenRead(fname);
if (handle == -1)
CA_CannotOpen(fname);
RLEWtag = ReadInt16(handle);
/* open the data file */
strcpy(fname, gmapsname);
if (w0 == true || w1 == true || s0 == true || s1 == true){
strcat(fname, extension);
}else{
strcat(fname, extension2);
}
maphandle = OpenRead(fname);
if (maphandle == -1)
CA_CannotOpen(fname);
/* load all map header */
for (i = 0; i < NUMMAPS; i++)
{
pos = ReadInt32(handle);
if (pos == 0) {
mapheaderseg[i] = NULL;
continue;
}
MM_GetPtr((memptr)&mapheaderseg[i], sizeof(maptype));
MM_SetLock((memptr)&mapheaderseg[i], true);
ReadSeek(maphandle, pos, SEEK_SET);
mapheaderseg[i]->planestart[0] = ReadInt32(maphandle);
mapheaderseg[i]->planestart[1] = ReadInt32(maphandle);
mapheaderseg[i]->planestart[2] = ReadInt32(maphandle);
mapheaderseg[i]->planelength[0] = ReadInt16(maphandle);
mapheaderseg[i]->planelength[1] = ReadInt16(maphandle);
mapheaderseg[i]->planelength[2] = ReadInt16(maphandle);
mapheaderseg[i]->width = ReadInt16(maphandle);
mapheaderseg[i]->height = ReadInt16(maphandle);
ReadBytes(maphandle, (byte *)mapheaderseg[i]->name, 16);
}
CloseRead(handle);
/* allocate space for 2 64*64 planes */
for (i = 0;i < MAPPLANES; i++) {
MM_GetPtr((memptr)&mapsegs[i], 64*64*2);
MM_SetLock((memptr)&mapsegs[i], true);
}
}
static void CAL_SetupGrFile()
{
char fname[13];
int handle;
byte *grtemp;
int i;
/* load vgadict.ext (huffman dictionary for graphics files) */
strcpy(fname, gdictname);
strcat(fname, extension);
handle = OpenRead(fname);
if (handle == -1)
CA_CannotOpen(fname);
for (i = 0; i < 256; i++) {
grhuffman[i].bit0 = ReadInt16(handle);
grhuffman[i].bit1 = ReadInt16(handle);
}
CloseRead(handle);
/* load the data offsets from vgahead.ext */
if (w0 == true){
MM_GetPtr((memptr)&grstarts, (NUMCHUNKSWL1+1)*4);
MM_GetPtr((memptr)&grtemp, (NUMCHUNKSWL1+1)*3);
}else if (w1 == true){
MM_GetPtr((memptr)&grstarts, (NUMCHUNKSWL6+1)*4);
MM_GetPtr((memptr)&grtemp, (NUMCHUNKSWL6+1)*3);
}else if (s0 == true){
MM_GetPtr((memptr)&grstarts, (NUMCHUNKSSDM+1)*4);
MM_GetPtr((memptr)&grtemp, (NUMCHUNKSSDM+1)*3);
}else{
MM_GetPtr((memptr)&grstarts, (NUMCHUNKSSOD+1)*4);
MM_GetPtr((memptr)&grtemp, (NUMCHUNKSSOD+1)*3);
}
strcpy(fname, gheadname);
strcat(fname, extension);
handle = OpenRead(fname);
if (handle == -1)
CA_CannotOpen(fname);
if (w0 == true){
ReadBytes(handle, grtemp, (NUMCHUNKSWL1+1)*3);
for (i = 0; i < NUMCHUNKSWL1+1; i++)
grstarts[i] = (grtemp[i*3+0]<<0)|(grtemp[i*3+1]<<8)|(grtemp[i*3+2]<<16);
}else if (w1 == true){
ReadBytes(handle, grtemp, (NUMCHUNKSWL6+1)*3);
for (i = 0; i < NUMCHUNKSWL6+1; i++)
grstarts[i] = (grtemp[i*3+0]<<0)|(grtemp[i*3+1]<<8)|(grtemp[i*3+2]<<16);
}else if (s0 == true){
ReadBytes(handle, grtemp, (NUMCHUNKSSDM+1)*3);
for (i = 0; i < NUMCHUNKSSDM+1; i++)
grstarts[i] = (grtemp[i*3+0]<<0)|(grtemp[i*3+1]<<8)|(grtemp[i*3+2]<<16);
}else{
ReadBytes(handle, grtemp, (NUMCHUNKSSOD+1)*3);
for (i = 0; i < NUMCHUNKSSOD+1; i++)
grstarts[i] = (grtemp[i*3+0]<<0)|(grtemp[i*3+1]<<8)|(grtemp[i*3+2]<<16);
}
MM_FreePtr((memptr)&grtemp);
CloseRead(handle);
/* Open the graphics file, leaving it open until the game is finished */
strcpy(fname, gfilename);
strcat(fname, extension);
grhandle = OpenRead(fname);
if (grhandle == -1)
CA_CannotOpen(fname);
/* load the pic headers into pictable */
CA_CacheGrChunk(STRUCTPIC);
if (w0 == true){
grtemp = grsegsWL1[STRUCTPIC];
for (i = 0; i < NUMPICSWL1; i++) {
pictableWL1[i].width = grtemp[i*4+0] | (grtemp[i*4+1] << 8);
pictableWL1[i].height = grtemp[i*4+2] | (grtemp[i*4+3] << 8);
}
}else if (w1 == true){
grtemp = grsegsWL6[STRUCTPIC];
for (i = 0; i < NUMPICSWL6; i++) {
pictableWL6[i].width = grtemp[i*4+0] | (grtemp[i*4+1] << 8);
pictableWL6[i].height = grtemp[i*4+2] | (grtemp[i*4+3] << 8);
}
}else if (s0 == true){
grtemp = grsegsSDM[STRUCTPIC];
for (i = 0; i < NUMPICSSDM; i++) {
pictableSDM[i].width = grtemp[i*4+0] | (grtemp[i*4+1] << 8);
pictableSDM[i].height = grtemp[i*4+2] | (grtemp[i*4+3] << 8);
}
}else{
grtemp = grsegsSOD[STRUCTPIC];
for (i = 0; i < NUMPICSSOD; i++) {
pictableSOD[i].width = grtemp[i*4+0] | (grtemp[i*4+1] << 8);
pictableSOD[i].height = grtemp[i*4+2] | (grtemp[i*4+3] << 8);
}
}
CA_UnCacheGrChunk(STRUCTPIC);
}
void CAL_SetupMapFile()
{
Sint16 i;
bstone::FileStream handle;
Sint32 pos;
char fname[13];
mapfiletype header;
maptype* map_header;
//
// load maphead.ext (offsets and tileinfo for map file)
//
strcpy(fname, mheadname);
strcat(fname, extension);
handle.open(fname);
if (!handle.is_open())
CA_CannotOpen(fname);
handle.read(&header.RLEWtag, sizeof(header.RLEWtag));
handle.read(&header.headeroffsets, sizeof(header.headeroffsets));
rlew_tag = header.RLEWtag;
//
// open the data file
//
OpenMapFile();
//
// load all map header
//
for (i = 0; i < NUMMAPS; ++i) {
pos = header.headeroffsets[i];
if (pos < 0)
continue;
mapheaderseg[i] = new maptype();
map_header = mapheaderseg[i];
maphandle.set_position(pos);
maphandle.read(
&map_header->planestart,
sizeof(map_header->planestart));
maphandle.read(
&map_header->planelength,
sizeof(map_header->planelength));
maphandle.read(
&map_header->width,
sizeof(map_header->width));
maphandle.read(
&map_header->height,
sizeof(map_header->height));
maphandle.read(
&map_header->name,
sizeof(map_header->name));
}
//
// allocate space for 3 64*64 planes
//
for (i = 0; i < MAPPLANES; ++i)
mapsegs[i] = new Uint16[64 * 64];
#if FORCE_FILE_CLOSE
CloseMapFile();
#endif
}
