void Mega8Config::loadConfig(const wxString &profile)
{
bool isNew;
if (_config == NULL) {
_config = new wxConfig(wxT("Mega8"), wxT("Ready4Next"));
if (!readBool(wxT("FirstInit"))) {
resetConfig();
writeBool(wxT("FirstInit"), true);
saveConfig(profile);
}
}
_currentProfile = profile;
isNew = loadKeyboard(profile);
_LastFolder = readString(wxT("LastFolder"));
_FullScreen = readBool(wxT("FullScreen"));
_SpeedAuto = readBool(wxT("SpeedAuto"));
_DisplayHUD = readBool(wxT("DisplayHUD"));
_Filtered = readBool(wxT("Filtered"));
_Sound = readBool(wxT("Sound"));
_UseSleep = readBool(wxT("UseSleep"));
_SyncClock = readBool(wxT("SyncClock"));
_ColorTheme = (Chip8ColorTheme)readLong(wxT("ColorTheme"));
_InverseColor = readBool(wxT("InverseColor"));
for (int i = 0; i <= sizeof(Chip8Types); i++) {
_FrequencyRatio[i] = (long)min((long)max((long)readLong(wxT("FrequencyRatio/") + getMachineTypeStr((Chip8Types) i)), (long)4), (long)9);
}
// Save this profile if new
if (isNew) {
saveConfig(profile);
}
}
//---------------------------------------------------------------------------
int32_t PacketFile::afterOpen(void)
{
if(!numPackets && getLength() >= 12)
{
int32_t firstPacketOffset;
int32_t firstCheck = readLong();
if(firstCheck == PACKET_FILE_VERSION && !usesCheckSum)
{
}
else
{
//---------------------------------------
// This is probably a checksum. Check it
int32_t checkSum = checkSumFile();
if(checkSum != firstCheck)
return PACKET_OUT_OF_RANGE;
}
firstPacketOffset = readLong();
numPackets = (firstPacketOffset / sizeof(int32_t)) - 2;
}
currentPacket = -1;
if(fileMode == READ || fileMode == RDWRITE)
{
if(numPackets && !seekTable)
{
seekTable = (int32_t*)systemHeap->Malloc(numPackets * sizeof(int32_t));
gosASSERT(seekTable != nullptr);
seek(sizeof(int32_t) * 2); //File Version & File Length
read(puint8_t(seekTable), (numPackets * sizeof(int32_t)));
}
}
return(NO_ERROR);
}
/* $(itimerspec) */
void readITimerSpec( TAInputStream * stream, struct itimerspec * value ) {
verifyType_TAInputStream( stream, "itimerspec" );
value->it_value .tv_sec = readLong( stream );
value->it_value .tv_nsec = readLong( stream );
value->it_interval.tv_sec = readLong( stream );
value->it_interval.tv_nsec = readLong( stream );
}
void readTimeValPair(TAInputStream* stream, struct timeval* times)
{
verifyType_TAInputStream(stream,"timeval_list");
times[0].tv_sec=readLong(stream);
times[0].tv_usec=readLong(stream);
times[1].tv_sec=readLong(stream);
times[1].tv_usec=readLong(stream);
}
void FileAllocator::read_node(FileOffset offset, list_node *node)
{
if (! (fseek(f, offset, SEEK_SET) == 0 &&
readLong(f, &node->bytes) &&
readLong(f, &node->prev) &&
readLong(f, &node->next)))
throw GenericException(__FILE__, __LINE__,
"FileAllocator node read at 0x%08lX failed",
(unsigned long)offset);
}
struct utimbuf readUTimBuf(TAInputStream* stream)
{
struct utimbuf res;
verifyType_TAInputStream(stream,"utimbuf");
res.actime=readLong(stream);
res.modtime=readLong(stream);
return res;
}
UserEnums::URType
RouteStorageGetRouteReplyPacket::getUrmask() const {
int pos = endStatic_POS;
pos += readShort( strlenExtraUserinfo_POS ) + 1;
pos += readLong( routePackLength_POS );
pos += readLong( driverPrefSize_POS );
UserEnums::URType urmask;
urmask.load( this, pos );
return urmask;
}
HRESULT PsfParser::parse() {
STATSTG streamStat;
ULONG bytesRead;
HRESULT hresult;
hresult=stream->Stat(&streamStat,STATFLAG_NONAME);
retIfFail;
if(streamStat.cbSize.QuadPart<MIN_PCF_SIZE) {
return E_INVALIDARG;
}
LARGE_INTEGER seekPos;
seekPos.QuadPart=0;
hresult=stream->Seek(seekPos,STREAM_SEEK_SET,nullptr);
retIfFail;
CHAR fileSig[3];
hresult=stream->Read(fileSig,3,&bytesRead);
retIfNonOk;
if(strcmp(fileSig,"PSF")!=0) return E_INVALIDARG;
hresult=stream->Read(&version,1,&bytesRead);
retIfNonOk;
uint32_t reservatedLength,compressedLength,compressedCrc;
hresult=readLong(reservatedLength);
retIfNonOk;
hresult=readLong(compressedLength);
retIfNonOk;
hresult=readLong(compressedCrc);
retIfNonOk;
seekPos.QuadPart=reservatedLength+compressedLength;
hresult=stream->Seek(seekPos,STREAM_SEEK_CUR,nullptr);
retIfFail;
CHAR tagSig[5];
hresult=stream->Read(tagSig,5,&bytesRead);
retIfFail;
if(hresult==S_FALSE) return S_FALSE;
if(strcmp(tagSig,"[TAG]")!=0) return E_INVALIDARG;
seekPos.QuadPart=0;
hresult=stream->Seek(seekPos,STREAM_SEEK_CUR,&tagStart);
retIfFail;
return parseTags();
}
//---------------------------------------------------------------------------
long PacketFile::seekPacket (long packet)
{
long offset, next;
if (packet < 0)
{
return(PACKET_OUT_OF_RANGE);
}
offset = readPacketOffset(packet, &packetType);
currentPacket = packet++;
if (packet == numPackets)
next = getLength();
else
next = readPacketOffset(packet);
packetSize = next-offset;
packetBase = offset; // seek to beginning of packet
seek(packetBase);
switch (getStorageType())
{
case STORAGE_TYPE_LZD:
// the first DWORD of a compressed packet is the unpacked length
packetUnpackedSize = readLong();
break;
case STORAGE_TYPE_ZLIB:
// the first DWORD of a compressed packet is the unpacked length
packetUnpackedSize = readLong();
break;
case STORAGE_TYPE_RAW:
packetUnpackedSize = packetSize;
break;
case STORAGE_TYPE_NUL:
packetUnpackedSize = 0;
break;
default:
return(BAD_PACKET_VERSION);
}
if (offset > 0)
return(NO_ERR);
return (PACKET_OUT_OF_RANGE);
}
/* $(timeval) */
int readTimeVal( TAInputStream * stream, struct timeval * value )
{
if(startsWith_TAInputStream(stream, "null:"))
{
shift_TAInputStream(stream, 5);
return 0;
}
verifyType_TAInputStream( stream, "timeval" );
value->tv_sec = readLong( stream );
value->tv_usec = readLong( stream );
return 1;
}
bool ZLZipHeader::readFrom(ZLInputStream &stream) {
size_t startOffset = stream.offset();
Signature = readLong(stream);
Version = readShort(stream);
Flags = readShort(stream);
CompressionMethod = readShort(stream);
ModificationTime = readShort(stream);
ModificationDate = readShort(stream);
CRC32 = readLong(stream);
CompressedSize = readLong(stream);
UncompressedSize = readLong(stream);
NameLength = readShort(stream);
ExtraLength = readShort(stream);
return (Signature == 0x04034B50) && (stream.offset() == startOffset + 30) && (NameLength != 0);
}
unsigned long chunkArchive::readAny(unsigned char *type, unsigned long *size)
{
unsigned char id = readByte();
if (type)
*type = id;
switch ((atoms) (id)) {
case CHUNK_BYTE:
if (size)
*size = 1;
return readByte();
break;
case CHUNK_SHORT:
if (size)
*size = 2;
return readShort();
break;
case CHUNK_LONG:
if (size)
*size = 4;
return readLong();
break;
case CHUNK_STRING:
return (unsigned long) readString(size);
break;
case CHUNK_BINARY:
return (unsigned long) readBinary(size);
break;
default:
if (size)
*size = 0;
return 0;
}
}
//---------------------------------------------------------------------------
void PacketFile::atClose(void)
{
if(isOpen() && fileMode != READ) // update filesize
{
int32_t endPtr = getLength();
//seek(sizeof(int32_t)); //Move Past Version Marker
//writeLong(endPtr); //Write File length
int32_t tableEntry;
currentPacket = numPackets;
if(!seekTable)
{
while(--currentPacket >= 0)
{
seek(TABLE_ENTRY(currentPacket));
tableEntry = readLong();
if(GetPacketType(tableEntry) == STORAGE_TYPE_NUL)
{
seek(TABLE_ENTRY(currentPacket));
writeLong(SetPacketType(endPtr, STORAGE_TYPE_NUL));
}
else
{
endPtr = GetPacketOffset(tableEntry);
}
}
}
else
{
while(--currentPacket >= 0)
{
tableEntry = seekTable[currentPacket];
if(GetPacketType(tableEntry) == STORAGE_TYPE_NUL)
{
seekTable[currentPacket] = SetPacketType(endPtr, STORAGE_TYPE_NUL);
}
else
{
endPtr = GetPacketOffset(tableEntry);
}
}
}
//-----------------------------------------------------
// If seekTable was being used, write it back to file
if(seekTable)
{
seek(sizeof(int32_t) * 2); //File Version & File Length
write(puint8_t(seekTable), (numPackets * sizeof(int32_t)));
}
//------------------------------------------------------
// Is we were using a checkSum, calc it and write it to
// the beginning of the file.
if(usesCheckSum)
{
int32_t checkSum = checkSumFile();
seek(0);
writeLong(checkSum);
}
}
clear();
}
int main()
{
int dia, mes, anio;
long int fecha;
writeLnString("ingrese la fecha en formato AAAAMMDD");
readLong(fecha);
anio = fecha/10000;
fecha -= anio * 10000;
mes = fecha/100;
fecha -= mes * 100;
dia = fecha;
writeString("La Fecha es ");
writeInteger(dia);
writeString("/");
writeInteger(mes);
writeString("/");
writeInteger(anio);
return 0;
}
void ByteStream::readFormat(const char *fmt, ...) {
va_list ap;
va_start(ap, fmt);
while (*fmt) {
const char typeID = *fmt++;
switch (typeID) {
case 'b':
*va_arg(ap, int *) = readByte();
break;
case 's':
*va_arg(ap, int *) = readShort();
break;
case 'i':
*va_arg(ap, int *) = readInt();
break;
case 'l':
*va_arg(ap, long *) = readLong();
break;
default:
core_assert(false);
}
}
va_end(ap);
}
bool
UpdateTrafficCostRequestPacket::getCost(uint32 &itemID,
uint32 &cost,
uint32 i) const
{
if (i<getNbrCosts()) {
itemID = readLong(m_firstcostpos+8*i);
cost = readLong(m_firstcostpos+8*i + 4);
return (true);
}
return (false);
}
void
cgicc::CgiEnvironment::restore(const std::string& filename)
{
std::ifstream file( filename.c_str(), std::ios::binary | std::ios::in );
if( ! file )
throw std::runtime_error("I/O error");
file.flags(file.flags() & std::ios::skipws);
fContentLength = readLong(file);
fServerPort = readLong(file);
fUsingHTTPS = (bool) readLong(file);
fServerSoftware = readString(file);
fServerName = readString(file);
fGatewayInterface = readString(file);
fServerProtocol = readString(file);
fRequestMethod = readString(file);
fPathInfo = readString(file);
fPathTranslated = readString(file);
fScriptName = readString(file);
fQueryString = readString(file);
fRemoteHost = readString(file);
fRemoteAddr = readString(file);
fAuthType = readString(file);
fRemoteUser = readString(file);
fRemoteIdent = readString(file);
fContentType = readString(file);
fAccept = readString(file);
fUserAgent = readString(file);
fRedirectRequest = readString(file);
fRedirectURL = readString(file);
fRedirectStatus = readString(file);
fReferrer = readString(file);
fCookie = readString(file);
if(stringsAreEqual(fRequestMethod, "post"))
fPostData = readString(file);
file.close();
fCookies.clear();
fCookies.reserve(10);
parseCookies();
}
bool ZLZipHeader::readFrom(ZLInputStream &stream) {
size_t startOffset = stream.offset();
Signature = readLong(stream);
switch (Signature) {
default:
return false;
case SignatureLocalFile:
Version = readShort(stream);
Flags = readShort(stream);
CompressionMethod = readShort(stream);
ModificationTime = readShort(stream);
ModificationDate = readShort(stream);
CRC32 = readLong(stream);
CompressedSize = readLong(stream);
UncompressedSize = readLong(stream);
if (CompressionMethod == 0 && CompressedSize != UncompressedSize) {
ZLLogger::Instance().println("zip", "Different compressed & uncompressed size for stored entry; the uncompressed one will be used.");
CompressedSize = UncompressedSize;
}
NameLength = readShort(stream);
ExtraLength = readShort(stream);
return stream.offset() == startOffset + 30 && NameLength != 0;
case SignatureData:
CRC32 = readLong(stream);
CompressedSize = readLong(stream);
UncompressedSize = readLong(stream);
NameLength = 0;
ExtraLength = 0;
return stream.offset() == startOffset + 16;
}
}
void
RouteStorageGetRouteReplyPacket::getDriverPrefs(
DriverPref& driverPref ) const
{
int pos = endStatic_POS;
pos += readShort( strlenExtraUserinfo_POS ) + 1;
pos += readLong( routePackLength_POS );
driverPref.load( this, pos );
}
void
GfxFeatureMapRequestPacket::getMapSettings( MapSettings* mapSettings ) const
{
MC2_ASSERT( mapSettings != NULL );
if ( readLong( mapSettingsLen_POS ) > 0 ) {
int pos = endStatic_POS;
mapSettings->loadFromPacket( this, pos );
}
}
unsigned long chunkArchive::beginChunk()
{
VALIDF;
unsigned long len = readLong();
SET_BIT(status_bits, bCHUNK);
current_chunk_start = F->pos();
current_chunk_end = current_chunk_start + len;
return len;
}
uint32
ItemNamesRequestPacket::getItem(uint32 i) const
{
if (i<getNbrItems()) {
return (readLong(ITEM_NAMES_REQUEST_FIRST_ITEM_POS + i*4));
} else {
return (MAX_UINT32);
}
}
//---------------------------------------------------------------------------
long PacketFile::afterOpen (void)
{
if (!numPackets && getLength() >= 12)
{
long firstPacketOffset;
long firstCheck = readLong();
if (firstCheck == PACKET_FILE_VERSION && !usesCheckSum)
{
}
else
{
//---------------------------------------
// This is probably a checksum. Check it
long checkSum = checkSumFile();
if (checkSum != firstCheck)
return PACKET_OUT_OF_RANGE;
}
firstPacketOffset = readLong();
numPackets = (firstPacketOffset/sizeof(long))-2;
}
currentPacket = -1;
if (fileMode == READ || fileMode == RDWRITE)
{
if (numPackets && !seekTable)
{
//seekTable = (long *)systemHeap->Malloc(numPackets * sizeof(long));
seekTable = new long[numPackets]; //magic 02102011
gosASSERT(seekTable != NULL);
seek(sizeof(long)*2); //File Version & File Length
read(MemoryPtr(seekTable),(numPackets*sizeof(long)));
}
}
return(NO_ERR);
}
/**
* Menu principal du jeu
*/
void mainMenu(){
printf(
"_________ _______ _______ __________________ _______ _______ " "\n"
"\\__ __/( ___ )( ____ \\__ __/ \\__ __/( ____ \\( ____ \\ " "\n"
" ) ( | ( ) || ( \\/ ) ( ) ( | ( \\/| ( \\/" "\n"
" | | | (___) || | | | | | | | | (_____ " "\n"
" | | | ___ || | | | | | | | (_____ )" "\n"
" | | | ( ) || | | | | | | | ) |" "\n"
" | | | ) ( || (____/\\ | | ___) (___| (____/\\/\\____) |" "\n"
" )_( |/ \\|(_______/ )_( \\_______/(_______/\\_______)" "\n"
" " "\n"
" _______ _______ _______ _ _______ " "\n"
"( ___ )( ____ )( ____ \\( ( /|( ___ )" "\n"
"| ( ) || ( )|| ( \\/| \\ ( || ( ) |" "\n"
"| (___) || (____)|| (__ | \\ | || (___) |" "\n"
"| ___ || __)| __) | (\\ \\) || ___ |" "\n"
"| ( ) || (\\ ( | ( | | \\ || ( ) |" "\n"
"| ) ( || ) \\ \\__| (____/\\| ) \\ || ) ( |" "\n"
"|/ \\||/ \\__/(_______/|/ )_)|/ \\|" "\n"
);
int choix;
color(red, "\nBienvenue sur le jeu Tactics arena SPI deluxe edition \n"); // Change la couleur des caractères suivants en rouge
color(cyan, "Pour une meilleure immersion, veuillez mettre la console en fullscreen, svp\n");
do{
printf("\nMenu principal :\n");
printf(" 1 - Nouvelle partie\n");
printf(" 2 - Charger partie\n");
printf(" 3 - Aide jeu \n");
printf(" 4 - Quitter\n");
printf("Votre choix : ");
choix = readLong(); // Choix = 1 si chiffre est rentré, 0 sinon
if(choix == 0) {
printf("Erreur : Veuillez rentrer un chiffre et non un caractère \n");
}
switch(choix){
case 1: gameInit(); break;
case 2: load(); break;
case 3: mainHelp(); break;
case 4: clearScreen(); break;
default: printf("Erreur: votre choix doit etre compris entre 1 et 4\n");
}
}while(choix != 4);
printf("A bientôt ! Hope you enjoy this game ! \n");
exit(1);
}
/* $(dotsarguments) - read only */
int readDotsArguments( TAInputStream * stream, long ** listPtr ) {
int size, i;
verifyType_TAInputStream( stream, "dotsarguments" );
size = readInt( stream );
assertion( size >= 0, "readDotsArguments : size (%d) < 0", size );
size++; // !
* listPtr = (long *)ta_alloc_memory( size * sizeof( long ) );
assertion( * listPtr != NULL, "Can't alloc %d bytes for list", size * sizeof( long ) );
for ( i = 1; i < size; i++ ) { (* listPtr)[ i ] = readLong( stream ); } // (* listPtr)[ 0 ] - for ptr to function
return size;
}
uint32
GfxFeatureMapReplyPacket::getMapIDToResend(uint32 i) const
{
if (i < getNbrRequestsToResend()) {
// get the map id for i:th map
return readLong( MAP_ID_START_POS + (i * 8) +
readShort( LENGTH_COPYRIGHT_POS ) );
} else {
return MAX_UINT32;
}
}
bool
GfxFeatureMapReplyPacket::getIncludeCountryPolygonForMapToResend(uint32 i) const
{
if (i < getNbrRequestsToResend()) {
// get countrymap bool for i:th map
return (readLong( MAP_ID_START_POS + (i * 8) + 4 +
readShort( LENGTH_COPYRIGHT_POS )) != 0);
} else {
return false;
}
}
char *chunkArchive::readBinary(unsigned long *size)
{
unsigned long BlockSize = readLong();
if (size)
*size = BlockSize;
char *chunk = (char *) malloc(BlockSize);
if (!chunk)
EXCEP("out of memory");
readBlock((void *) chunk, BlockSize);
return chunk;
}
uint32
GfxFeatureMapRequestPacket::getNodeIDs( const GenericMap* theMap,
list<uint32>& nodeIDs ) const
{
uint32 nbrNodeIDs = getNbrNodeIDs();
int pos = readLong( mapSettingsLen_POS ) + endStatic_POS;
for ( uint32 i = 0; i < nbrNodeIDs; ++i ) {
nodeIDs.push_back( incReadLong( pos ) );
}
// Expand node ids.
return theMap->expandNodeIDs( nodeIDs );
}
static int readHeader(FILE* file, char *tag, int32_t *size)
{
if (fread(tag, 1, 4, file) != 4) {
fprintf(stderr, "Failed to read tag\n");
return -1;
}
if (readLong(file, size)) {
fprintf(stderr, "Failed to read length\n");
return -1;
}
return 0;
}
