bool Serializer::writeRoomData() {
// Write the enable status for the spots of all nodes of all rooms
if (!SDL_WriteBE16(_rw, Control::instance().numRooms()))
return false;
for (Room *room : Control::instance().rooms()) {
if (!SDL_WriteBE16(_rw, room->numNodes()))
return false;
if (room->hasNodes()) {
room->beginIteratingNodes();
do {
Node *node = room->iterator();
if (!SDL_WriteBE16(_rw, node->numSpots()))
return false;
if (node->hasSpots()) {
node->beginIteratingSpots();
do {
if (!SDL_WriteU8(_rw, node->currentSpot()->isEnabled()))
return false;
} while (node->iterateSpots());
}
} while (room->iterateNodes());
}
}
Room *room = Control::instance().currentRoom();
// Write node number
uint16_t nodeIdx = 0;
if (room->hasNodes()) {
room->beginIteratingNodes();
do {
if (room->iterator() == room->currentNode())
break;
nodeIdx++;
} while (room->iterateNodes());
}
if (!SDL_WriteBE16(_rw, nodeIdx))
return false;
// Write camera angles
int hAngle = CameraManager::instance().angleHorizontal();
const std::string hAngleStr = std::to_string(hAngle);
if (!SDL_WriteU8(_rw, hAngleStr.length()))
return false;
if (!SDL_RWwrite(_rw, hAngleStr.c_str(), hAngleStr.length(), 1))
return false;
int vAngle = CameraManager::instance().angleVertical();
const std::string vAngleStr = std::to_string(vAngle);
if (!SDL_WriteU8(_rw, vAngleStr.length()))
return false;
if (!SDL_RWwrite(_rw, vAngleStr.c_str(), vAngleStr.length(), 1))
return false;
float fov = CameraManager::instance().fieldOfView();
const std::string fovStr = std::to_string(fov);
if (!SDL_WriteU8(_rw, fovStr.length()))
return false;
if (!SDL_RWwrite(_rw, fovStr.c_str(), fovStr.length(), 1))
return false;
// Write audio states
if (!SDL_WriteBE16(_rw, room->arrayOfAudios().size()))
return false;
for (Audio *audio : room->arrayOfAudios()) {
if (!SDL_WriteU8(_rw, audio->state()))
return false;
}
// Write timers
int64_t timersPtr = SDL_RWtell(_rw);
if (timersPtr < 0)
return false;
if (!SDL_WriteBE16(_rw, 0)) // 2 placeholder bytes for the actual number of timers
return false;
uint16_t numTimers = 0;
for (const auto &timer : TimerManager::instance().timers()) {
if (timer.type != DGTimerNormal || !timer.isEnabled ||
(!timer.isLoopable && timer.hasTriggered))
continue;
double elapsed = TimerManager::instance().timeElapsed(timer);
if (timer.trigger - elapsed > 0) {
const std::string triggerStr = std::to_string(timer.trigger);
if (!SDL_WriteU8(_rw, timer.isLoopable))
return false;
if (!SDL_WriteU8(_rw, triggerStr.length()))
return false;
if (!SDL_RWwrite(_rw, triggerStr.c_str(), triggerStr.length(), 1))
return false;
const std::string elapsedStr = std::to_string(elapsed);
if (!SDL_WriteU8(_rw, elapsedStr.length()))
return false;
if (!SDL_RWwrite(_rw, elapsedStr.c_str(), elapsedStr.length(), 1))
return false;
lua_rawgeti(_L, LUA_REGISTRYINDEX, timer.luaHandler); // Push timer function to top of stack
int64_t funcSizePtr = SDL_RWtell(_rw);
if (funcSizePtr < 0)
return false;
if (!SDL_WriteBE16(_rw, 0)) // 2 placeholder bytes for the actual function size
return false;
int64_t beforeFuncPtr = SDL_RWtell(_rw);
if (beforeFuncPtr < 0)
return false;
int errCode = lua_dump(_L, writeFunction, _rw);
if (errCode != 0)
return false;
int64_t afterFuncPtr = SDL_RWtell(_rw);
if (afterFuncPtr < 0)
return false;
uint16_t numBytesWritten = afterFuncPtr - beforeFuncPtr;
if (SDL_RWseek(_rw, funcSizePtr, RW_SEEK_SET) < 0)
return false;
if (!SDL_WriteBE16(_rw, numBytesWritten))
return false;
if (SDL_RWseek(_rw, 0, RW_SEEK_END) < 0) // Restore file pointer to end
return false;
numTimers++;
}
}
if (SDL_RWseek(_rw, timersPtr, RW_SEEK_SET) < 0)
return false;
if (!SDL_WriteBE16(_rw, numTimers))
return false;
if (SDL_RWseek(_rw, 0, RW_SEEK_END) < 0) // Restore file pointer to end
return false;
// Write control mode
if (!SDL_WriteU8(_rw, Config::instance().controlMode))
return false;
return true;
}
bool Serializer::writeField(const std::string &key, const std::string &val) {
return SDL_WriteBE16(_rw, key.length() + val.length() + 1) && // +1 because of =
SDL_RWwrite(_rw, key.c_str(), key.length(), 1) &&
SDL_WriteU8(_rw, '=') &&
SDL_RWwrite(_rw, val.c_str(), val.length(), 1);
}
/**
* @brief Tests writing and reading from file using endian aware functions.
*
* \sa
* http://wiki.libsdl.org/moin.cgi/SDL_RWFromFile
* http://wiki.libsdl.org/moin.cgi/SDL_RWClose
* http://wiki.libsdl.org/moin.cgi/SDL_ReadBE16
* http://wiki.libsdl.org/moin.cgi/SDL_WriteBE16
*/
int
rwops_testFileWriteReadEndian(void)
{
SDL_RWops *rw;
Sint64 result;
int mode;
size_t objectsWritten;
Uint16 BE16value;
Uint32 BE32value;
Uint64 BE64value;
Uint16 LE16value;
Uint32 LE32value;
Uint64 LE64value;
Uint16 BE16test;
Uint32 BE32test;
Uint64 BE64test;
Uint16 LE16test;
Uint32 LE32test;
Uint64 LE64test;
int cresult;
for (mode = 0; mode < 3; mode++) {
/* Create test data */
switch (mode) {
case 0:
SDLTest_Log("All 0 values");
BE16value = 0;
BE32value = 0;
BE64value = 0;
LE16value = 0;
LE32value = 0;
LE64value = 0;
break;
case 1:
SDLTest_Log("All 1 values");
BE16value = 1;
BE32value = 1;
BE64value = 1;
LE16value = 1;
LE32value = 1;
LE64value = 1;
break;
case 2:
SDLTest_Log("Random values");
BE16value = SDLTest_RandomUint16();
BE32value = SDLTest_RandomUint32();
BE64value = SDLTest_RandomUint64();
LE16value = SDLTest_RandomUint16();
LE32value = SDLTest_RandomUint32();
LE64value = SDLTest_RandomUint64();
break;
}
/* Write test. */
rw = SDL_RWFromFile(RWopsWriteTestFilename, "w+");
SDLTest_AssertPass("Call to SDL_RWFromFile(..,\"w+\")");
SDLTest_AssertCheck(rw != NULL, "Verify opening file with SDL_RWFromFile in write mode does not return NULL");
/* Bail out if NULL */
if (rw == NULL) return TEST_ABORTED;
/* Write test data */
objectsWritten = SDL_WriteBE16(rw, BE16value);
SDLTest_AssertPass("Call to SDL_WriteBE16");
SDLTest_AssertCheck(objectsWritten == 1, "Validate number of objects written, expected: 1, got: %i", objectsWritten);
objectsWritten = SDL_WriteBE32(rw, BE32value);
SDLTest_AssertPass("Call to SDL_WriteBE32");
SDLTest_AssertCheck(objectsWritten == 1, "Validate number of objects written, expected: 1, got: %i", objectsWritten);
objectsWritten = SDL_WriteBE64(rw, BE64value);
SDLTest_AssertPass("Call to SDL_WriteBE64");
SDLTest_AssertCheck(objectsWritten == 1, "Validate number of objects written, expected: 1, got: %i", objectsWritten);
objectsWritten = SDL_WriteLE16(rw, LE16value);
SDLTest_AssertPass("Call to SDL_WriteLE16");
SDLTest_AssertCheck(objectsWritten == 1, "Validate number of objects written, expected: 1, got: %i", objectsWritten);
objectsWritten = SDL_WriteLE32(rw, LE32value);
SDLTest_AssertPass("Call to SDL_WriteLE32");
SDLTest_AssertCheck(objectsWritten == 1, "Validate number of objects written, expected: 1, got: %i", objectsWritten);
objectsWritten = SDL_WriteLE64(rw, LE64value);
SDLTest_AssertPass("Call to SDL_WriteLE64");
SDLTest_AssertCheck(objectsWritten == 1, "Validate number of objects written, expected: 1, got: %i", objectsWritten);
/* Test seek to start */
result = SDL_RWseek( rw, 0, RW_SEEK_SET );
SDLTest_AssertPass("Call to SDL_RWseek succeeded");
SDLTest_AssertCheck(result == 0, "Verify result from position 0 with SDL_RWseek, expected 0, got %i", result);
/* Read test data */
BE16test = SDL_ReadBE16(rw);
SDLTest_AssertPass("Call to SDL_ReadBE16");
SDLTest_AssertCheck(BE16test == BE16value, "Validate return value from SDL_ReadBE16, expected: %hu, got: %hu", BE16value, BE16test);
BE32test = SDL_ReadBE32(rw);
SDLTest_AssertPass("Call to SDL_ReadBE32");
SDLTest_AssertCheck(BE32test == BE32value, "Validate return value from SDL_ReadBE32, expected: %u, got: %u", BE32value, BE32test);
BE64test = SDL_ReadBE64(rw);
SDLTest_AssertPass("Call to SDL_ReadBE64");
SDLTest_AssertCheck(BE64test == BE64value, "Validate return value from SDL_ReadBE64, expected: %llu, got: %llu", BE64value, BE64test);
LE16test = SDL_ReadLE16(rw);
SDLTest_AssertPass("Call to SDL_ReadLE16");
SDLTest_AssertCheck(LE16test == LE16value, "Validate return value from SDL_ReadLE16, expected: %hu, got: %hu", LE16value, LE16test);
LE32test = SDL_ReadLE32(rw);
SDLTest_AssertPass("Call to SDL_ReadLE32");
SDLTest_AssertCheck(LE32test == LE32value, "Validate return value from SDL_ReadLE32, expected: %u, got: %u", LE32value, LE32test);
LE64test = SDL_ReadLE64(rw);
SDLTest_AssertPass("Call to SDL_ReadLE64");
SDLTest_AssertCheck(LE64test == LE64value, "Validate return value from SDL_ReadLE64, expected: %llu, got: %llu", LE64value, LE64test);
/* Close handle */
cresult = SDL_RWclose(rw);
SDLTest_AssertPass("Call to SDL_RWclose() succeeded");
SDLTest_AssertCheck(cresult == 0, "Verify result value is 0; got: %d", cresult);
}
return TEST_COMPLETED;
}
