/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* This program 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
*/
/*
* This code is based on Labyrinth of Time code with assistance of
*
* Copyright (c) 1993 Terra Nova Development
* Copyright (c) 2004 The Wyrmkeep Entertainment Co.
*
*/
#include "lab/stddefines.h"
namespace Lab {
bool IsHiRes = false;
/*****************************************************************************/
/* Scales the x co-ordinates to that of the new display. In the room parser */
/* file, co-ordinates are set up on a 360x336 display. */
/*****************************************************************************/
uint16 scaleX(uint16 x) {
if (IsHiRes)
return (uint16)((x * 16) / 9);
else
return (uint16)((x * 8) / 9);
}
/*****************************************************************************/
/* Scales the y co-ordinates to that of the new display. In the room parser */
/* file, co-ordinates are set up on a 368x336 display. */
/*****************************************************************************/
uint16 scaleY(uint16 y) {
if (IsHiRes)
return (y + (y / 14));
else
return ((y * 10) / 24);
}
/*****************************************************************************/
/* Scales the VGA cords to SVGA if necessary; otherwise, returns VGA cords. */
/*****************************************************************************/
uint16 VGAScaleX(uint16 x) {
if (IsHiRes)
return (x * 2);
else
return x;
}
/*****************************************************************************/
/* Scales the VGA cords to SVGA if necessary; otherwise, returns VGA cords. */
/*****************************************************************************/
uint16 VGAScaleY(uint16 y) {
if (IsHiRes)
return ((y * 12) / 5);
else
return y;
}
/*****************************************************************************/
/* Scales the VGA cords to SVGA if necessary; otherwise, returns VGA cords. */
/*****************************************************************************/
int16 VGAScaleXs(int16 x) {
if (IsHiRes)
return (x * 2);
else
return x;
}
/*****************************************************************************/
/* Scales the VGA cords to SVGA if necessary; otherwise, returns VGA cords. */
/*****************************************************************************/
int16 VGAScaleYs(int16 y) {
if (IsHiRes)
return ((y * 12) / 5);
else
return y;
}
uint16 SVGACord(uint16 cord) {
if (IsHiRes)
return cord;
else
return 0;
}
/*****************************************************************************/
/* Converts SVGA cords to VGA if necessary, otherwise returns VGA cords. */
/*****************************************************************************/
uint16 VGAUnScaleX(uint16 x) {
if (IsHiRes)
return (x / 2);
else
return x;
}
/*****************************************************************************/
/* Converts SVGA cords to VGA if necessary, otherwise returns VGA cords. */
/*****************************************************************************/
uint16 VGAUnScaleY(uint16 y) {
if (IsHiRes)
return ((y * 5) / 12);
else
return y;
}
/*****************************************************************************/
/* Checks to see if all the characters in the second string are at the start */
/* of the first. */
/*****************************************************************************/
static bool strstart(const char **Source, const char *Start) {
uint16 len1, len2, counter;
len1 = strlen(*Source);
len2 = strlen(Start);
if (len1 < len2)
return false;
for (counter = 0; counter < len2; counter++)
if ((*Source)[counter] != Start[counter])
return false;
(*Source) += len2;
return true;
}
static char NewFileName[255];
/*****************************************************************************/
/* Modifes the filename so that paths and stuff are correct. Should mostly */
/* deal with assigns and the '/' instead of '\' on IBM systems. */
/* */
/* NOTE: Make a *copy* of the string, and modify that. It would be a real */
/* *bad* idea to modify the original. Since Labyrinth only focuses its */
/* attention to one file at a time, it would be fine to have one variable */
/* not on the stack which is used to store the new filename. */
/*****************************************************************************/
static void mystrupr(char *s) {
char c;
while ((c = *s) != 0)
*s++ = toupper(c);
}
char *translateFileName(const char *filename) {
char tempfilename[255];
char *dot;
strcpy(tempfilename, filename);
mystrupr(tempfilename);
*NewFileName = 0;
filename = tempfilename;
if (strstart(&filename, "P:")) {
if (IsHiRes)
strcat(NewFileName, "GAME/SPICT/");
else
strcat(NewFileName, "GAME/PICT/");
} else if (strstart(&filename, "LAB:"))
strcat(NewFileName, "GAME/");
else if (strstart(&filename, "MUSIC:"))
strcat(NewFileName, "GAME/MUSIC/");
strcat(NewFileName, filename);
dot = strrchr(NewFileName, '.');
if (dot != NewFileName && dot != NULL && dot[4] != '/') { // Linux may start with '.'
dot[4] = 0; // Back to the days of 8.3, even if your OS was never DOSish!!
}
return NewFileName;
}
#if defined(USE_SWAP)
uint16 swapUShort(uint16 value) {
char *b = (char *)&value;
char t = b[0];
b[0] = b[1];
b[1] = t;
return value;
}
uint16 *wapUShortPtsr(uint16 *ptr, int count) {
while (count-- > 0) {
char *b = (char *)ptr++;
char t = b[0];
b[0] = b[1];
b[1] = t;
}
return ptr;
}
int16 swapShort(int16 value) {
char *b = (char *)&value;
char t = b[0];
b[0] = b[1];
b[1] = t;
return value;
}
int16 *swapShortPtr(int16 *ptr, int count) {
while (count-- > 0) {
char *b = (char *)ptr++;
char t = b[0];
b[0] = b[1];
b[1] = t;
}
return ptr;
}
unsigned int swapUInt(unsigned int value) {
char *b = (char *)&value;
char t = b[0];
b[0] = b[3];
b[3] = t;
t = b[1];
b[1] = b[2];
b[2] = t;
return value;
}
unsigned int *swapUIntPtr(unsigned int *ptr, int count) {
while (count-- > 0) {
char *b = (char *)ptr++;
char t = b[0];
b[0] = b[3];
b[3] = t;
t = b[1];
b[1] = b[2];
b[2] = t;
}
return ptr;
}
int swapInt(int value) {
char *b = (char *)&value;
char t = b[0];
b[0] = b[3];
b[3] = t;
t = b[1];
b[1] = b[2];
b[2] = t;
return value;
}
int *swapIntPtr(int *ptr, int count) {
while (count-- > 0) {
char *b = (char *)ptr++;
char t = b[0];
b[0] = b[3];
b[3] = t;
t = b[1];
b[1] = b[2];
b[2] = t;
}
return ptr;
}
uint32 swapULong(uint32 value) {
char *b = (char *)&value;
char t = b[0];
b[0] = b[3];
b[3] = t;
t = b[1];
b[1] = b[2];
b[2] = t;
return value;
}
uint32 *swapULongPtr(uint32 *ptr, int count) {
while (count-- > 0) {
char *b = (char *)ptr++;
char t = b[0];
b[0] = b[3];
b[3] = t;
t = b[1];
b[1] = b[2];
b[2] = t;
}
return ptr;
}
int32 swapLong(int32 value) {
char *b = (char *)&value;
char t = b[0];
b[0] = b[3];
b[3] = t;
t = b[1];
b[1] = b[2];
b[2] = t;
return value;
}
int32 *swapLongPtr(int32 *ptr, int count) {
while (count-- > 0) {
char *b = (char *)ptr++;
char t = b[0];
b[0] = b[3];
b[3] = t;
t = b[1];
b[1] = b[2];
b[2] = t;
}
return ptr;
}
#endif
} // End of namespace Lab