char* FileBasedAGSDebugger::GetNextMessage()
{
Stream *in = Common::File::OpenFileRead("dbgsend.tmp");
if (in == NULL)
{
// check again, because the editor might have deleted the file in the meantime
return NULL;
}
int fileSize = in->GetLength();
char *msg = (char*)malloc(fileSize + 1);
in->Read(msg, fileSize);
delete in;
unlink("dbgsend.tmp");
msg[fileSize] = 0;
return msg;
}
///////////////////////////////////////////////////////////////////////////////
// //
// File I/O //
// //
///////////////////////////////////////////////////////////////////////////////
aalError Sample::Load(const char * _name)
{
Stream * stream = CreateStream(_name);
if (!stream) return AAL_ERROR_FILEIO;
stream->GetFormat(format);
stream->GetLength(length);
DeleteStream(stream);
aalVoid * ptr = realloc(name, strlen(_name) + 1);
if (!ptr) return AAL_ERROR_MEMORY;
name = (char *)ptr;
strcpy(name, _name);
return AAL_OK;
}
// Test whether all three reads return the same thing.
void consistencyTesting(Stream &s) {
int location = rand() % s.GetLength();
int size = 128;
// Run all three tests: Sequential, Backwards, and Random.
int* seq = testReadSequential(s, location, size);
int* back = testReadBackwards(s, location, size);
int* random = testReadRandom(s, location, size);
// Are they all the same?
if (seq == back && back == random)
printf("Data is consistent between all three read formats.\n");
// Otherwise, error check.
else {
if (seq != back)
printf("Error: Data is not consistent between sequential and backwards reading.\n");
if (seq != random)
printf("Error: Data is not consistent between sequential and random reading.\n");
if (random != back)
printf("Error: Data is not consistent between backwards and random reading.\n");
}
}
void start_playback()
{
Stream *in = Common::File::OpenFileRead(replayfile);
if (in != NULL) {
char buffer [100];
in->Read(buffer, 12);
buffer[12] = 0;
if (strcmp (buffer, "AGSRecording") != 0) {
Display("ERROR: Invalid recorded data file");
play.playback = 0;
}
else {
String version_string = String::FromStream(in, 12);
AGS::Engine::Version requested_engine_version(version_string);
if (requested_engine_version.Major != '2')
quit("!Replay file is from an old version of AGS");
if (requested_engine_version < AGS::Engine::Version(2, 55, 553))
quit("!Replay file was recorded with an older incompatible version");
if (requested_engine_version != EngineVersion) {
// Disable text as speech while displaying the warning message
// This happens if the user's graphics card does BGR order 16-bit colour
int oldalways = game.options[OPT_ALWAYSSPCH];
game.options[OPT_ALWAYSSPCH] = 0;
play.playback = 0;
Display("Warning! replay is from a different version of AGS (%s) - it may not work properly.", buffer);
play.playback = 1;
srand (play.randseed);
play.gamestep = 0;
game.options[OPT_ALWAYSSPCH] = oldalways;
}
int replayver = in->ReadInt32();
if ((replayver < 1) || (replayver > 3))
quit("!Unsupported Replay file version");
if (replayver >= 2) {
fgetstring_limit (buffer, in, 99);
int uid = in->ReadInt32 ();
if ((strcmp (buffer, game.gamename) != 0) || (uid != game.uniqueid)) {
char msg[150];
sprintf (msg, "!This replay is meant for the game '%s' and will not work correctly with this game.", buffer);
delete in;
quit (msg);
}
// skip the total time
in->ReadInt32 ();
// replay description, maybe we'll use this later
fgetstring_limit (buffer, in, 99);
}
play.randseed = in->ReadInt32();
int flen = in->GetLength() - in->GetPosition ();
if (replayver >= 3) {
flen = in->ReadInt32() * sizeof(short);
}
recordbuffer = (short*)malloc (flen);
in->Read(recordbuffer, flen);
srand (play.randseed);
recbuffersize = flen / sizeof(short);
recsize = 0;
disable_mgetgraphpos = 1;
replay_time = 0;
replay_last_second = loopcounter;
if (replayver >= 3) {
int issave = in->ReadInt32();
if (issave) {
if (RestoreGameState(in, kSvgVersion_321) != kSvgErr_NoError)
quit("!Error running replay... could be incorrect game version");
replay_last_second = loopcounter;
}
}
delete in;
}
}
else // file not found
play.playback = 0;
}
void Write_Validation_Tests(Stream & S)
{
char s_buf[4000];
char r_buf[4000];
for (int i = 0; i < 4000; i++)
{
s_buf[i] = 'a';
}
s_buf[3999] = '\0';
//cout << s_buf << endl;
if (S.CanWrite())
{
cout << "Can write" << endl;
}
else
{
cout << "Can't write Unit test passed" << endl;
return;
}
S.Write(s_buf, 4000);
S.Read(r_buf, 4000);
if (memcmp(r_buf, s_buf, 4000) == 0)
{
cout << "T1). PASS: Write all in one write works" << endl;
}
else
{
cout << "T1). FAILED: Write all in one write does not match" << endl;
}
char k_buf[1024];
char o_buf[1801];
for (int i = 0; i < 4000; i++)
{
s_buf[i] = 'b';
}
s_buf[3999] = '\0';
S.SetPosition(S.GetLength());
int k = 4000;
for (int i = 0; i <= 3; i++)
{
int l;
if ((k - 1024) >= 0)
{
l = 1024;
k = k - 1024;
}
else
{
l = k;
}
for (int j = 0; j < l; j++)
{
k_buf[j] = s_buf[i * 1024 + j];
}
S.Write(k_buf, l);
S.SetPosition(S.GetLength());
}
S.SetPosition(4000);
k = 4000;
for (int i = 0; i <= 3; i++)
{
if (k - 1024 >= 0)
{
S.Read(k_buf, 1024);
k = k - 1024;
memcpy(&r_buf[i * 1024], k_buf, 1024);
}
else
{
S.Read(k_buf, k);
memcpy(&r_buf[i * 1024], k_buf, k);
}
S.SetPosition(4000 + (i*1024));
}
r_buf[3999] = '\0';
if (memcmp(r_buf, s_buf, 4000) == 0)
{
cout << "T2). PASS: Write by block works" << endl;
}
else
{
cout << "T2). FAILED: Write all in one write does not match" << endl;
}
for (int i = 0; i < 4000; i++)
{
s_buf[i] = 'c';
}
s_buf[3999] = '\0';
S.SetPosition(S.GetLength());
k = 4000;
for (int i = 0; i <= 2; i++)
{
int l;
if ((k - 1801) >= 0)
{
l = 1801;
k = k - 1801;
}
else
{
l = k;
}
for (int j = 0; j < l; j++)
{
o_buf[j] = s_buf[i * 1801 + j];
}
S.Write(o_buf, l);
S.SetPosition(S.GetLength());
}
S.SetPosition(8000);
k = 4000;
for (int i = 0; i <= 2; i++)
{
if (k - 1801 >= 0)
{
S.Read(o_buf, 1801);
k = k - 1801;
memcpy(&r_buf[i * 1801], o_buf, 1801);
}
else
{
S.Read(o_buf, k);
memcpy(&r_buf[i * 1801], o_buf, k);
}
S.SetPosition(8000 + (i * 1801));
}
r_buf[3999] = '\0';
if (memcmp(r_buf, s_buf, 4000) == 0)
{
cout << "T3). PASS: Write by uncommon buffer size works" << endl;
}
else
{
cout << "T3). FAILED: Write all in one write does not match" << endl;
}
system("pause");
return;
}