bool C4Network2ResChunk::Set(C4Network2Res *pRes, uint32_t inChunk)
{
const C4Network2ResCore &Core = pRes->getCore();
iResID = pRes->getResID();
iChunk = inChunk;
// calculate offset and size
int32_t iOffset = iChunk * Core.getChunkSize(),
iSize = std::min<int32_t>(Core.getFileSize() - iOffset, C4NetResChunkSize);
if (iSize < 0) { LogF("Network: could not get chunk from offset %d from resource file %s: File size is only %d!", iOffset, pRes->getFile(), Core.getFileSize()); return false; }
// open file
int32_t f = pRes->OpenFileRead();
if (f == -1) { LogF("Network: could not open resource file %s!", pRes->getFile()); return false; }
// seek
if (iOffset)
if (lseek(f, iOffset, SEEK_SET) != iOffset)
{ close(f); LogF("Network: could not read resource file %s!", pRes->getFile()); return false; }
// read chunk of data
char *pBuf = new char[iSize];
if (read(f, pBuf, iSize) != iSize)
{ delete [] pBuf; close(f); LogF("Network: could not read resource file %s!", pRes->getFile()); return false; }
// set
Data.Take(pBuf, iSize);
// close
close(f);
// ok
return true;
}
bool C4DownloadDlg::DownloadFile(const char *szDLType, C4GUI::Screen *pScreen, const char *szURL, const char *szSaveAsFilename, const char *szNotFoundMessage)
{
// log it
LogF(LoadResStr("IDS_PRC_DOWNLOADINGFILE"), szURL);
// show download dialog
C4DownloadDlg *pDlg = new C4DownloadDlg(szDLType);
if (!pDlg->ShowModal(pScreen, szURL, szSaveAsFilename))
{
// show an appropriate error
const char *szError = pDlg->GetError();
if (!szError || !*szError) szError = LoadResStr("IDS_PRC_UNKOWNERROR");
StdStrBuf sError;
sError.Format(LoadResStr("IDS_PRC_DOWNLOADERROR"), GetFilename(szURL), szError);
// it's a 404: display extended message
if (SSearch(szError, "404") && szNotFoundMessage)
{ sError.Append("|"); sError.Append(szNotFoundMessage); }
// display message
pScreen->ShowMessageModal(sError.getData(), FormatString(LoadResStr("IDS_CTL_DL_TITLE"), szDLType).getData(), C4GUI::MessageDialog::btnOK, C4GUI::Ico_Error, NULL);
delete pDlg;
return false;
}
LogF(LoadResStr("IDS_PRC_DOWNLOADCOMPLETE"), szURL);
delete pDlg;
return true;
}
bool C4GraphicsResource::LoadFile(C4Surface& sfc, const char *szName, C4GroupSet &rGfxSet, int32_t &ridCurrSfc, int iFlags)
{
// find
char FileName[_MAX_FNAME]; int32_t ID = 0;
C4Group *pGrp = FindSuitableFile(szName, rGfxSet, FileName, &ID);
if (!pGrp)
{
LogF(LoadResStr("IDS_PRC_NOGFXFILE"), szName, LoadResStr("IDS_PRC_FILENOTFOUND"));
return false;
}
// check group
if (ID == ridCurrSfc)
// already up-to-date
return true;
// load
if (!sfc.Load(*pGrp, FileName, false, false, iFlags))
{
LogF(LoadResStr("IDS_PRC_NOGFXFILE"), FileName, LoadResStr("IDS_ERR_NOFILE"));
return false;
}
ridCurrSfc = ID;
Game.SetInitProgress(ProgressStart);
ProgressStart += ProgressIncrement;
return true;
}
bool C4GraphicsResource::LoadFile(C4FacetID &fct, const char *szName, C4GroupSet &rGfxSet, int32_t iWdt, int32_t iHgt, bool fNoWarnIfNotFound, int iFlags)
{
char FileName[_MAX_FNAME]; int32_t ID = 0;
C4Group *pGrp = FindSuitableFile(szName, rGfxSet, FileName, &ID);
if (!pGrp)
{
// FIXME: Use LogFatal here
if (!fNoWarnIfNotFound)
{
LogF(LoadResStr("IDS_PRC_NOGFXFILE"), szName, LoadResStr("IDS_PRC_FILENOTFOUND"));
}
return false;
}
// check group
if (fct.idSourceGroup == ID)
// already up-to-date
return true;
// load
if (!fct.Load(*pGrp, FileName, iWdt, iHgt, false, iFlags))
{
LogF(LoadResStr("IDS_PRC_NOGFXFILE"), FileName, LoadResStr("IDS_ERR_NOFILE"));
return false;
}
fct.idSourceGroup = ID;
Game.SetInitProgress(ProgressStart);
ProgressStart += ProgressIncrement;
return true;
}
void C4MusicSystem::LoadDir(const char *szPath)
{
char Path[_MAX_FNAME + 1], File[_MAX_FNAME + 1];
C4Group *pDirGroup = NULL;
// split path
SCopy(szPath, Path, _MAX_FNAME);
char *pFileName = GetFilename(Path);
SCopy(pFileName, File);
*(pFileName - 1) = 0;
// no file name?
if (!File[0])
// -> add the whole directory
SCopy("*", File);
// no wildcard match?
else if (!SSearch(File, "*?"))
{
// then it's either a file or a directory - do the test with C4Group
pDirGroup = new C4Group();
if (!pDirGroup->Open(szPath))
{
// so it must be a file
if (!pDirGroup->Open(Path))
{
// -> file/dir doesn't exist
LogF("Music File not found: %s", szPath);
delete pDirGroup;
return;
}
// mother group is open... proceed with normal handling
}
else
{
// ok, set wildcard (load the whole directory)
SCopy(szPath, Path);
SCopy("*", File);
}
}
// open directory group, if not already done so
if (!pDirGroup)
{
pDirGroup = new C4Group();
if (!pDirGroup->Open(Path))
{
LogF("Music File not found: %s", szPath);
delete pDirGroup;
return;
}
}
// search file(s)
char szFile[_MAX_FNAME + 1];
pDirGroup->ResetSearch();
while (pDirGroup->FindNextEntry(File, szFile))
{
char strFullPath[_MAX_FNAME + 1];
sprintf(strFullPath, "%s%c%s", Path, DirectorySeparator, szFile);
Load(strFullPath);
}
// free it
delete pDirGroup;
}
StdBuf C4Playback::ReWriteBinary() {
const int OUTPUT_GROW = 16 * 1024;
StdBuf Output;
int iPos = 0;
bool fFinished = false;
uint32_t iFrame = 0;
for (chunks_t::const_iterator i = chunks.begin();
!fFinished && i != chunks.end(); i++) {
// Check frame difference
if (i->Frame - iFrame < 0 || i->Frame - iFrame > 0xff)
LogF(
"ERROR: Invalid frame difference between chunks (0-255 allowed)! "
"Data will be invalid!");
// Pack data
StdBuf Chunk;
try {
switch (i->Type) {
case RCT_Ctrl:
Chunk = DecompileToBuf<StdCompilerBinWrite>(*i->pCtrl);
break;
case RCT_CtrlPkt:
Chunk = DecompileToBuf<StdCompilerBinWrite>(*i->pPkt);
break;
case RCT_End:
fFinished = true;
break;
default: // debugrec
if (i->pDbg) Chunk = DecompileToBuf<StdCompilerBinWrite>(*i->pDbg);
break;
}
} catch (StdCompiler::Exception *pEx) {
LogF("Record: Binary unpack error: %s", pEx->Msg.getData());
delete pEx;
return StdBuf();
}
// Grow output
while (Output.getSize() - iPos <
sizeof(C4RecordChunkHead) + Chunk.getSize())
Output.Grow(OUTPUT_GROW);
// Write header
C4RecordChunkHead *pHead = getMBufPtr<C4RecordChunkHead>(Output, iPos);
pHead->Type = i->Type;
pHead->iFrm = i->Frame - iFrame;
iPos += sizeof(C4RecordChunkHead);
iFrame = i->Frame;
// Write chunk
Output.Write(Chunk, iPos);
iPos += Chunk.getSize();
}
Output.SetSize(iPos);
return Output;
}
void ShowGfxErrorDialog()
{
// Application.Close will eventually post a quit message. We need to discard
// that, so DialogBox() doesn't immediately exit.
auto msg = MSG();
while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE) != 0)
{
if (msg.message == WM_QUIT) break;
TranslateMessage(&msg);
DispatchMessage(&msg);
}
int ret = DialogBox(Application.GetInstance(), MAKEINTRESOURCE(IDD_GFXERROR), NULL, GfxErrProcedure);
if (ret == 0 || ret == -1)
{
LPVOID lpMsgBuf;
DWORD err = GetLastError();
FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL,
err,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR) &lpMsgBuf,
0, NULL );
LogF("Error in GfxErrorDlg: %d - %s", err, StdStrBuf((wchar_t*)lpMsgBuf).getData());
LocalFree(lpMsgBuf);
}
// If we discarded a quit message, re-post it now
if (msg.message == WM_QUIT)
PostQuitMessage(msg.wParam);
}
bool C4FileMonitor::Execute(int iTimeout, pollfd * pfd) // some other thread
{
if ((pfd->revents & pfd->events) != POLLIN || pfd->fd != fd)
LogF("C4FileMonitor::Execute unexpectedly called %d %d %hd %hd", fd, pfd->fd, pfd->events, pfd->revents);
char buf[sizeof(inotify_event) + _MAX_FNAME + 1];
inotify_event* event = new (buf) inotify_event;
if (read(fd, buf, sizeof(buf)) > 0)
{
const char * file = watch_descriptors[event->wd];
uint32_t mask = event->mask;
C4InteractiveThread &Thread = Application.InteractiveThread;
if (mask & IN_CREATE)
Thread.PushEvent(Ev_FileChange, (void*)file);
if (mask & IN_MODIFY)
Thread.PushEvent(Ev_FileChange, (void*)file);
if (mask & IN_MOVED_TO)
Thread.PushEvent(Ev_FileChange, (void*)file);
if (mask & IN_MOVE_SELF)
Thread.PushEvent(Ev_FileChange, (void*)file);
// FIXME: (*(inotify_event*)buf).name);
}
else
{
Log("inotify buffer too small");
}
return true;
}
bool C4Network2Res::SetByFile(const char *strFilePath, bool fTemp, C4Network2ResType eType, int32_t iResID, const char *szResName, bool fSilent)
{
CStdLock FileLock(&FileCSec);
// default resource name: relative path
if (!szResName) szResName = Config.AtRelativePath(strFilePath);
SCopy(strFilePath, szFile, sizeof(szFile)-1);
// group?
C4Group Grp;
if (Reloc.Open(Grp, strFilePath))
return SetByGroup(&Grp, fTemp, eType, iResID, szResName, fSilent);
// so it needs to be a file
StdStrBuf szFullFile;
if (!Reloc.LocateItem(szFile, szFullFile))
{ if (!fSilent) LogF("SetByFile: file %s not found!", strFilePath); return false; }
// calc checksum
uint32_t iCRC32;
if (!GetFileCRC(szFullFile.getData(), &iCRC32)) return false;
#ifdef C4NET2RES_DEBUG_LOG
// log
LogSilentF("Network: Resource: complete %d:%s is file %s (%s)", iResID, szResName, szFile, fTemp ? "temp" : "static");
#endif
// set core
Core.Set(eType, iResID, Config.AtRelativePath(szFullFile.getData()), iCRC32);
// set own data
fDirty = true;
fTempFile = fTemp;
fStandaloneFailed = false;
fRemoved = false;
iLastReqTime = time(NULL);
fLoading = false;
// ok
return true;
}
bool C4Network2Res::OptimizeStandalone(bool fSilent)
{
CStdLock FileLock(&FileCSec);
// for now: player files only
if (Core.getType() == NRT_Player)
{
// log - this may take a few seconds
if (!fSilent) LogF(LoadResStr("IDS_PRC_NETPREPARING"), GetFilename(szFile));
// copy to temp file, if needed
if (!fTempFile && SEqual(szFile, szStandalone))
{
char szNewStandalone[_MAX_PATH + 1];
if (!pParent->FindTempResFileName(szStandalone, szNewStandalone))
{ if (!fSilent) Log("OptimizeStandalone: could not find free name for temporary file!"); return false; }
if (!C4Group_CopyItem(szStandalone, szNewStandalone))
{ if (!fSilent) Log("OptimizeStandalone: could not copy to temporary file!"); return false; } /* TODO: Test failure */
SCopy(szNewStandalone, szStandalone, sizeof(szStandalone) - 1);
}
// open as group
C4Group Grp;
if (!Grp.Open(szStandalone))
{ if (!fSilent) Log("OptimizeStandalone: could not open player file!"); return false; }
// remove bigicon, if the file size is too large
size_t iBigIconSize=0;
if (Grp.FindEntry(C4CFN_BigIcon, NULL, &iBigIconSize))
if (iBigIconSize > C4NetResMaxBigicon*1024)
Grp.Delete(C4CFN_BigIcon);
Grp.Close();
}
return true;
}
bool C4Network2IO::Connect(const C4NetIO::addr_t &addr, C4Network2IOProtocol eProt, const C4ClientCore &nCCore, const char *szPassword) // by main thread
{
// get network class
C4NetIO *pNetIO = getNetIO(eProt);
if (!pNetIO) return false;
// already connected/connecting?
if (GetConnectionByConnAddr(addr, pNetIO)) return true;
// assign new connection ID, peer address isn't known yet
uint32_t iConnID = iNextConnID++;
C4NetIO::addr_t paddr;
ZeroMem(&paddr, sizeof paddr);
// create connection object and add to list
C4Network2IOConnection *pConn = new C4Network2IOConnection();
pConn->Set(pNetIO, eProt, paddr, addr, CS_Connect, szPassword, iConnID);
pConn->SetCCore(nCCore);
AddConnection(pConn);
// connect
if (!pConn->Connect())
{
// show error
LogF("Network: could not connect to %s:%d using %s: %s", inet_ntoa(addr.sin_addr), htons(addr.sin_port),
getNetIOName(pNetIO), pNetIO->GetError() ? pNetIO->GetError() : "");
pNetIO->ResetError();
// remove class
RemoveConnection(pConn);
return false;
}
// ok, wait for connection
return true;
}
void C4Application::ApplyResolutionConstraints()
{
// Not changing the resolution always works anyway
if (Config.Graphics.ResX == -1 && Config.Graphics.ResY == -1)
return;
// Enumerate display modes
int32_t idx = -1, iXRes, iYRes, iBitDepth, iRefreshRate;
int32_t best_match = -1;
uint32_t best_delta = ~0;
while (GetIndexedDisplayMode(++idx, &iXRes, &iYRes, &iBitDepth, &iRefreshRate, Config.Graphics.Monitor))
{
if (iBitDepth != Config.Graphics.BitDepth) continue;
uint32_t delta = std::abs(Config.Graphics.ResX*Config.Graphics.ResY - iXRes*iYRes);
if (!delta && iBitDepth == Config.Graphics.BitDepth && iRefreshRate == Config.Graphics.RefreshRate)
return; // Exactly the expected mode
if (delta < best_delta)
{
// Better match than before
best_match = idx;
best_delta = delta;
}
}
if (best_match != -1)
{
// Apply next-best mode
GetIndexedDisplayMode(best_match, &iXRes, &iYRes, &iBitDepth, &iRefreshRate, Config.Graphics.Monitor);
if (iXRes != Config.Graphics.ResX || iYRes != Config.Graphics.ResY)
// Don't warn if only bit depth changes
// Also, lang table not loaded yet
LogF("Warning: The selected resolution %dx%d is not available and has been changed to %dx%d.", Config.Graphics.ResX, Config.Graphics.ResY, iXRes, iYRes);
Config.Graphics.ResX = iXRes; Config.Graphics.ResY = iYRes;
Config.Graphics.BitDepth = iBitDepth;
Config.Graphics.RefreshRate = iRefreshRate;
}
}
void C4FoWAmbient::CreateFromLandscape(const C4Landscape& landscape, double resolution, double radius, double full_coverage)
{
assert(resolution >= 1.);
assert(radius >= 1.);
assert(full_coverage > 0 && full_coverage <= 1.);
// Clear old map
Clear();
Resolution = resolution;
Radius = radius;
FullCoverage = full_coverage;
// Number of zoomed pixels
LandscapeX = Landscape.GetWidth();
LandscapeY = Landscape.GetHeight();
SizeX = std::min<unsigned int>(static_cast<unsigned int>(ceil(LandscapeX / resolution)), pDraw->MaxTexSize);
SizeY = std::min<unsigned int>(static_cast<unsigned int>(ceil(LandscapeY / resolution)), pDraw->MaxTexSize);
#ifndef USE_CONSOLE
glGenTextures(1, &Tex);
glBindTexture(GL_TEXTURE_2D, Tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, SizeX, SizeY, 0, GL_RED, GL_FLOAT, nullptr);
const C4TimeMilliseconds begin = C4TimeMilliseconds::Now();
UpdateFromLandscape(landscape, C4Rect(0, 0, Landscape.GetWidth(), Landscape.GetHeight()));
uint32_t dt = C4TimeMilliseconds::Now() - begin;
LogF("Created %ux%u ambient map in %g secs", SizeX, SizeY, dt / 1000.);
#endif
}
void C4LSectors::Remove(C4Object *pObj)
{
assert(Sectors); assert(pObj);
// Remove from owning sector
C4LSector *pSct = SectorAt(pObj->old_x, pObj->old_y);
if (!pSct->Objects.Remove(pObj))
{
#ifdef _DEBUG
LogF("WARNING: Object %d of type %s deleted but not found in pos sector list!", pObj->Number, pObj->id.ToString());
#endif
// if it was not found in owning sector, it must be somewhere else. yeah...
bool fFound = false;
for (pSct = pObj->Area.First(); pSct; pSct = pObj->Area.Next(pSct))
if (pSct->Objects.Remove(pObj)) { fFound=true; break; }
// yukh, somewhere else entirely...
if (!fFound)
{
fFound = !!SectorOut.Objects.Remove(pObj);
if (!fFound)
{
pSct = Sectors;
for (int cnt=0; cnt<Size; cnt++, pSct++)
if (pSct->Objects.Remove(pObj)) { fFound=true; break; }
}
assert(fFound);
}
}
// Remove from all sectors in shape area
for (pSct = pObj->Area.First(); pSct; pSct = pObj->Area.Next(pSct))
pSct->ObjectShapes.Remove(pObj);
if (Config.General.DebugRec)
pObj->Area.DebugRec(pObj, 'R');
}
C4GamePadControl::C4GamePadControl()
{
if (SDL_InitSubSystem(SDL_INIT_GAMECONTROLLER | SDL_INIT_HAPTIC | SDL_INIT_EVENTS) != 0)
LogF("SDL_InitSubSystem(SDL_INIT_GAMECONTROLLER): %s", SDL_GetError());
SDL_GameControllerEventState(SDL_ENABLE);
if (!GetGamePadCount()) Log("No Gamepad found");
}
bool glCheck() {
if (int err = glGetError()) {
LogF("GL error %d: %s", err, gluErrorString(err));
return false;
}
return true;
}
void C4FileMonitor::AddDirectory(const char * file)
{
// Add IN_CLOSE_WRITE?
int wd = inotify_add_watch(fd, file, IN_CREATE | IN_MODIFY | IN_MOVED_TO | IN_MOVE_SELF | IN_ONLYDIR);
if (wd == -1)
LogF("inotify_add_watch %s", strerror(errno));
watch_descriptors[wd] = file;
}
void udi_debug_printf( const char *format, ... )
{
va_list args;
va_start(args, format);
LogF("udi_debug_printf: ");
LogFV(format, args);
va_end(args);
}
C4GamePadOpener::C4GamePadOpener(int iGamepad)
{
int n = iGamepad;
for (int i = 0; i < SDL_NumJoysticks(); i++)
if (SDL_IsGameController(i) && n-- == 0)
{
controller = SDL_GameControllerOpen(i);
if (!controller) LogF("SDL: %s", SDL_GetError());
SDL_Joystick *joystick = SDL_GameControllerGetJoystick(controller);
haptic = SDL_HapticOpenFromJoystick(joystick);
if (haptic && SDL_HapticRumbleSupported(haptic))
SDL_HapticRumbleInit(haptic);
else
LogF("Gamepad #%d %s does not support rumbling.", SDL_JoystickInstanceID(joystick), SDL_JoystickName(joystick));
break;
}
if (!controller) LogF("Gamepad %d not available", iGamepad);
}
bool C4GraphicsSystem::SaveScreenshot(bool fSaveAll, float fSaveAllZoom)
{
// Find a unique screenshot filename by iterating over all possible names
// Keep static counter so multiple screenshots in succession do not use same filename even if the background thread hasn't started writing the file yet
char szFilename[_MAX_PATH+1];
static int32_t iScreenshotIndex=1;
const char *strFilePath = NULL;
do
sprintf(szFilename,"Screenshot%03i.png",iScreenshotIndex++);
while (FileExists(strFilePath = Config.AtScreenshotPath(szFilename)));
bool fSuccess=DoSaveScreenshot(fSaveAll, strFilePath, fSaveAllZoom);
// log if successful/where it has been stored
if (!fSuccess)
LogF(LoadResStr("IDS_PRC_SCREENSHOTERROR"), Config.AtUserDataRelativePath(Config.AtScreenshotPath(szFilename)));
else
LogF(LoadResStr("IDS_PRC_SCREENSHOT"), Config.AtUserDataRelativePath(Config.AtScreenshotPath(szFilename)));
// return success
return !!fSuccess;
}
bool C4GameSave::SaveCreateGroup(const char *szFilename, C4Group &hUseGroup)
{
// erase any previous item (2do: work in C4Groups?)
EraseItem(szFilename);
// copy from previous group?
if (GetCopyScenario())
if (!ItemIdentical(Game.ScenarioFilename, szFilename))
if (!C4Group_CopyItem(Game.ScenarioFilename, szFilename))
{ LogF(LoadResStr("IDS_CNS_SAVEASERROR"), szFilename); return false; }
// open it
if (!hUseGroup.Open(szFilename, !GetCopyScenario()))
{
EraseItem(szFilename);
LogF(LoadResStr("IDS_CNS_SAVEASERROR"), szFilename);
return false;
}
// done, success
return true;
}
void C4ObjectList::CompileFunc(StdCompiler *pComp, bool fSkipPlayerObjects, C4ValueNumbers * numbers)
{
// "Object" section count
int32_t iObjCnt = ObjectCount();
pComp->Value(mkNamingCountAdapt(iObjCnt, "Object"));
if (pComp->isDecompiler())
{
// skipping player objects would screw object counting in non-naming compilers
assert(!fSkipPlayerObjects || pComp->hasNaming());
// Decompile all objects in reverse order
for (C4ObjectLink *pPos = Last; pPos; pPos = pPos->Prev)
if (pPos->Obj->Status)
if (!fSkipPlayerObjects || !pPos->Obj->IsUserPlayerObject())
pComp->Value(mkNamingAdapt(mkParAdapt(*pPos->Obj, numbers), "Object"));
}
else
{
// FIXME: Check that no PlayerObjects are loaded when fSkipPlayerObjects is true
// i.e. that loading and saving was done with the same flag.
// Remove previous data
Clear();
// Load objects, add them to the list.
for (int i = 0; i < iObjCnt; i++)
{
C4Object *pObj = NULL;
try
{
pComp->Value(mkNamingAdapt(mkParAdapt(mkPtrAdaptNoNull(pObj), numbers), "Object"));
Add(pObj, stReverse);
}
catch (StdCompiler::Exception *pExc)
{
// Failsafe object loading: If an error occurs during object loading, just skip that object and load the next one
if (!pExc->Pos.getLength())
LogF("ERROR: Object loading: %s", pExc->Msg.getData());
else
LogF("ERROR: Object loading(%s): %s", pExc->Pos.getData(), pExc->Msg.getData());
delete pExc;
}
}
}
}
bool C4MusicSystem::InitForScenario(C4Group & hGroup)
{
// check if the scenario contains music
bool fLocalMusic = false;
StdStrBuf MusicDir;
if (GrpContainsMusic(hGroup))
{
// clear global songs
ClearSongs();
fLocalMusic = true;
// add songs
MusicDir.Take(Game.ScenarioFile.GetFullName());
LoadDir(MusicDir.getData());
// log
LogF(LoadResStr("IDS_PRC_LOCALMUSIC"), MusicDir.getData());
}
// check for music folders in group set
C4Group *pMusicFolder = NULL;
while ((pMusicFolder = Game.GroupSet.FindGroup(C4GSCnt_Music, pMusicFolder)))
{
if (!fLocalMusic)
{
// clear global songs
ClearSongs();
fLocalMusic = true;
}
// add songs
MusicDir.Take(pMusicFolder->GetFullName());
MusicDir.AppendChar(DirectorySeparator);
MusicDir.Append(C4CFN_Music);
LoadDir(MusicDir.getData());
// log
LogF(LoadResStr("IDS_PRC_LOCALMUSIC"), MusicDir.getData());
}
// no music?
if (!SongCount) return false;
// set play list
SetPlayList(0);
// ok
return true;
}
bool C4KeyboardInput::LoadCustomConfig()
{
// load from INI file (2do: load from registry)
C4Group GrpExtra;
if (!GrpExtra.Open(C4CFN_Extra)) return false;
StdBuf sFileContents;
if (!GrpExtra.LoadEntry(C4CFN_KeyConfig, &sFileContents)) return false;
StdStrBuf sFileContentsString((const char *) sFileContents.getData());
if (!CompileFromBuf_LogWarn<StdCompilerINIRead>(*this, sFileContentsString, "Custom keys from" C4CFN_Extra DirSep C4CFN_KeyConfig))
return false;
LogF(LoadResStr("IDS_PRC_LOADEDKEYCONF"), C4CFN_Extra DirSep C4CFN_KeyConfig);
return true;
}
bool C4Extra::LoadDef(C4Group &hGroup, const char *szName)
{
// check if file exists
if (!hGroup.FindEntry(szName)) return false;
// log that extra group is loaded
LogF(LoadResStr("IDS_PRC_LOADEXTRA"), hGroup.GetName(), szName);
// open and add group to set
C4Group *pGrp = new C4Group;
if (!pGrp->OpenAsChild(&hGroup, szName)) { Log(LoadResStr("IDS_ERR_FAILURE")); delete pGrp; return false; }
Game.GroupSet.RegisterGroup(*pGrp, true, C4GSPrio_Extra, C4GSCnt_Extra);
// done, success
return true;
}
void C4GamePadControl::CheckGamePad(const SDL_Event& e)
{
switch (e.type)
{
case SDL_JOYDEVICEADDED:
// Report that an unsupported joystick device has been detected, to help with controller issues.
if (!SDL_IsGameController(e.jdevice.which))
LogF("Gamepad %s isn't supported.", SDL_JoystickNameForIndex(e.jdevice.which));
break;
case SDL_CONTROLLERDEVICEADDED:
{
auto device = std::make_shared<C4GamePadOpener>(e.cdevice.which);
Gamepads[device->GetID()] = device;
LogF("Gamepad #%d connected: %s", device->GetID(), SDL_JoystickNameForIndex(e.cdevice.which));
break;
}
case SDL_CONTROLLERDEVICEREMOVED:
LogF("Gamepad #%d disconnected.", e.cdevice.which);
Gamepads.erase(e.cdevice.which);
break;
}
}
ClientManager::ClientManager()
{
int titanium_port = atoi(server.config->GetVariable("Titanium", "port").c_str());
EQ::Net::EQStreamManagerOptions titanium_opts(titanium_port, false, false);
titanium_stream = new EQ::Net::EQStreamManager(titanium_opts);
titanium_ops = new RegularOpcodeManager;
if (!titanium_ops->LoadOpcodes(server.config->GetVariable("Titanium", "opcodes").c_str()))
{
Log(Logs::General, Logs::Error, "ClientManager fatal error: couldn't load opcodes for Titanium file %s.",
server.config->GetVariable("Titanium", "opcodes").c_str());
run_server = false;
}
titanium_stream->OnNewConnection([this](std::shared_ptr<EQ::Net::EQStream> stream) {
LogF(Logs::General, Logs::Login_Server, "New Titanium client connection from {0}:{1}", stream->RemoteEndpoint(), stream->GetRemotePort());
stream->SetOpcodeManager(&titanium_ops);
Client *c = new Client(stream, cv_titanium);
clients.push_back(c);
});
int sod_port = atoi(server.config->GetVariable("SoD", "port").c_str());
EQ::Net::EQStreamManagerOptions sod_opts(sod_port, false, false);
sod_stream = new EQ::Net::EQStreamManager(sod_opts);
sod_ops = new RegularOpcodeManager;
if (!sod_ops->LoadOpcodes(server.config->GetVariable("SoD", "opcodes").c_str()))
{
Log(Logs::General, Logs::Error, "ClientManager fatal error: couldn't load opcodes for SoD file %s.",
server.config->GetVariable("SoD", "opcodes").c_str());
run_server = false;
}
sod_stream->OnNewConnection([this](std::shared_ptr<EQ::Net::EQStream> stream) {
LogF(Logs::General, Logs::Login_Server, "New SoD client connection from {0}:{1}", stream->RemoteEndpoint(), stream->GetRemotePort());
stream->SetOpcodeManager(&sod_ops);
Client *c = new Client(stream, cv_sod);
clients.push_back(c);
});
}
C4Player* C4PlayerList::Join(const char *szFilename, bool fScenarioInit, int iAtClient, const char *szAtClientName, C4PlayerInfo *pInfo, C4ValueNumbers * numbers)
{
assert(pInfo);
assert(fScenarioInit || numbers);
// safeties
if (szFilename && !*szFilename) szFilename = NULL;
// Log
LogF(LoadResStr(fScenarioInit ? "IDS_PRC_JOINPLR" : "IDS_PRC_RECREATE"),pInfo->GetName());
// Too many players
if (1) // replay needs to check, too!
if (GetCount()+1>Game.Parameters.MaxPlayers)
{
LogF(LoadResStr("IDS_PRC_TOOMANYPLRS"),Game.Parameters.MaxPlayers);
return NULL;
}
// Check duplicate file usage
if (szFilename) if (FileInUse(szFilename))
{ Log(LoadResStr("IDS_PRC_PLRFILEINUSE")); return NULL; }
// Create
C4Player *pPlr = new C4Player;
// Append to player list
C4Player *pLast=First;
while (pLast && pLast->Next) pLast=pLast->Next;
if (pLast) pLast->Next=pPlr; else First = pPlr;
// Init
if (!pPlr->Init(GetFreeNumber(),iAtClient,szAtClientName,szFilename,fScenarioInit,pInfo, numbers))
{ Remove(pPlr, false, false); Log(LoadResStr("IDS_PRC_JOINFAIL")); return NULL; }
// Done
return pPlr;
}
bool C4GameSave::Save(const char *szFilename)
{
// close any previous
Close();
// create group
C4Group *pLSaveGroup = new C4Group();
if (!SaveCreateGroup(szFilename, *pLSaveGroup))
{
LogF(LoadResStr("IDS_ERR_SAVE_TARGETGRP"), szFilename ? szFilename : "nullptr!");
delete pLSaveGroup;
return false;
}
// save to it
return Save(*pLSaveGroup, true);
}
void C4AulScriptEngine::ReLink(C4DefList *rDefs)
{
// unlink scripts
UnLink();
// unlink defs
if (rDefs) rDefs->ResetIncludeDependencies();
// re-link
Link(rDefs);
// display state
LogF("C4AulScriptEngine linked - %d line%s, %d warning%s, %d error%s",
lineCnt, (lineCnt != 1 ? "s" : ""), warnCnt, (warnCnt != 1 ? "s" : ""), errCnt, (errCnt != 1 ? "s" : ""));
}
