THE OPERATIVE · NO ONE LIVES FOREVER · PORT

1. téma: Linux

Hogyan lesz a forrásból nolf1 + libnolfobject.so, és mi fut a Linux-réteg alatt
TOPIC 1 · LINUX

A Linux-build ugyanazt a motorforrást használja, mint a Mac. Csak a legalsó réteg más: Cocoa helyett SDL3, Metal helyett OpenGL 4.6, CoreAudio helyett SDL-hang, Apple-betű helyett FreeType. A fejlesztés Ubuntu aarch64-en folyt (Snapdragon X, Adreno X1-45, Mesa), clang 21-gyel és SDL3-mal. x86-64-en is ugyanígy fordul.

Mac → Linux megfeleltetés

FeladatmacOS fájlLinux fájlLinuxos technológia
Ablak, bemenetplatform/ltwindow.mmlinux/ltwindow_sdl.cppSDL3
GPU renderelőrender/ltmetal.mmlinux/ltgl.cpp (+ ltglwin.h)OpenGL 4.6 core, GLSL 450
Hangkimenet, MP3sound/ltaudio.mmlinux/ltaudio_sdl.cppSDL3 audio + dr_mp3
Élsimított betűplatform/ltsysfont.mmlinux/ltsysfont_ft.cppFreeType + DejaVu
GM zenei bankApple gs_instruments.dlslinux/ltsf2.cppSoundFont 2 (.sf2)
Saját exe útvonala<mach-o/dyld.h>linux/include/mach-o/dyld.hreadlink("/proc/self/exe")
Szerver modullibnolfobject.dyliblibnolfobject.sodlopen, -Wl,-Bsymbolic
Adatkönyvtár~/Library/Application Support/NOLF1~/.local/share/NOLF1
MIÉRT van minden Linux-fájl #ifndef __APPLE__-ban? Az Xcode projekt „szinkronizált mappaként” kezeli az engine/-t: minden ott lévő forrást lefordít, az engine/linux/-t is. A guard miatt ezek a fájlok Macen üresek, és nem kell a projektfájlhoz nyúlni. Fordítva nincs ilyen gond: a Linux-build csak *.cpp-t fordít, a .mm fájlokat észre sem veszi.

Az ablak: ltwindow_sdl.cpp

engine/linux/ltwindow_sdl.cpp:147
int ww = w, wh = h;  // w×h = a játék felbontása (LT_SCREEN)if (SDL_DisplayID d = SDL_GetPrimaryDisplay()){    SDL_Rect r;    if (SDL_GetDisplayUsableBounds(d, &r) && r.w > 0 && r.h > 0)    ↳ a használható képernyőterület (panel nélkül)    {        float k = SDL_min(1.0f, SDL_min(r.w * 0.92f / w, (r.h - 32) * 0.92f / h));        ↳ legfeljebb 92%-a, sosem nagyobb        ww = (int)(w * k + 0.5f); wh = (int)(h * k + 0.5f);    }}SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);↳ OpenGL 4.6...SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 6);SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);↳ ...core profil, régi API nélkülSDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 0);       // every 3D pass has its own target↳ az ablaknak nem kell mélységpufferg_pWin = SDL_CreateWindow(pTitle ? pTitle : "NOLF", ww, wh,                          SDL_WINDOW_RESIZABLE | SDL_WINDOW_HIGH_PIXEL_DENSITY | SDL_WINDOW_OPENGL);                          ↳ átméretezhető, HiDPIif (!g_pWin) { fprintf(stderr, "[LTWINDOW] SDL_CreateWindow: %s\n", SDL_GetError()); return false; }g_Ctx = SDL_GL_CreateContext(g_pWin);if (!g_Ctx) { fprintf(stderr, "[LTWINDOW] OpenGL 4.6 context: %s\n", SDL_GetError());↳ nincs GL 4.6 -> érthető hibaüzenet              SDL_DestroyWindow(g_pWin); g_pWin = 0; return false; }SDL_GL_MakeCurrent(g_pWin, g_Ctx);if (getenv("LT_NOVSYNC")) SDL_GL_SetSwapInterval(0);↳ LT_NOVSYNC: vsync ki (méréshez)else if (!SDL_GL_SetSwapInterval(-1))↳ adaptív vsync: egy lekésett képkocka nem vár egy teljes periódust{ fprintf(stderr, "[LTWINDOW] no adaptive vsync (%s) -- plain vsync\n", SDL_GetError()); SDL_GL_SetSwapInterval(1); }SDL_StartTextInput(g_pWin);  // szövegbevitel (mentés neve, konzol)

A GPU: ltgl.cpp (OpenGL 4.6)

A ltgl.cpp (1740 sor) ugyanazt a ltmetal.h API-t valósítja meg, mint a Macen a ltmetal.mm. A motor többi része (ltworldmetal, ltcomp) nem tudja, melyik GPU API fut alatta. A belső neve ezért Linuxon is „Metal” (pl. LT_METAL=1).

engine/linux/ltgl.cpp:784
// ⚠️ METAL'S CONVENTIONS (see the top of the file), for every pass.glClipControl(GL_UPPER_LEFT, GL_ZERO_TO_ONE);↳ a Metal konvenciója: 0. sor = FELÜL, mélység 0..1glProvokingVertex(GL_FIRST_VERTEX_CONVENTION);     // [[flat]] takes the first vertex in MSL↳ lapos árnyalásnál az 1. csúcs színeglPixelStorei(GL_UNPACK_ALIGNMENT, 1);↳ szorosan pakolt sorok feltöltéskor...glPixelStorei(GL_PACK_ALIGNMENT, 1);  // ...és visszaolvasáskor
MIÉRT a Metal szokásai OpenGL-ben? Az OpenGL alapból alulról felfelé számol, és a mélysége −1..1. A glClipControl-lal a GL ugyanúgy számol, mint a Metal: felülről lefelé, 0..1 mélységgel. Így a nézetablak, az ollózás, a textúrasorok és a visszaolvasás mind ugyanaz, mint a ltmetal.mm-ben, a shaderek „soronként ugyanazt számolják”. Csak a végső kitétel az ablak alulról felfelé számoló alap framebufferébe fordít, egyetlen helyen.

Renderelőválasztás

engine/skeleton/skeleton_host.cpp:3304
static bool LTHost_WantMetal(bool bWindow){    if (getenv("LT_SOFTWARE")) return false;    ↳ LT_SOFTWARE=1 -> szoftveres raszterizáló    if (const char* p = getenv("LT_METAL")) return p[0] && p[0] != '0';    ↳ kifejezett kérés    return bWindow;    ↳ ablakkal alapból GPU; ablak nélkül (teszt) szoftver = bitpontos referencia}

A játék Beállítások → Kijelző menüjében „OpenGL - Linux” és „Software - Linux” jelenik meg. A választás az autoexec.cfg-be kerül (RenderDll), és a play_linux.sh a következő indításkor ez alapján állítja be a LT_SOFTWARE=1-et, mert futás közben a renderelő nem cserélhető.

A kompozitor: ltcomp

A NOLF a HUD-ot és a menüket képernyőpixelekben, 640×480-ra tervezte. A port a 3D-t a monitor natív felbontásán rajzolja, a 2D-t a játék felbontásán, és kitételkor egyesíti a kettőt. Az átlátszóság miatt egy trükk kell: a 2D réteg kétszer rajzolódik, egyszer fekete (B), egyszer 128-as szürke (G) háttérre. A GPU ebből pontosan visszaszámolja:

kimenet = jelenet · M + A,   M = (G − B) · 255/128,   A = B

Nyitókép 4:3
A nyitókép 1440×900-on: 4:3, középen, fekete sávokkal.

Szoftveres raszterizáló, több szálon

A render/lt3d.cpp bitpontos szoftveres raszterizálója egy nagy háromszög sorait 4-es csomagokban szétosztja a szálak között. Csak az legalább 16 sor magas és legalább 4096 pixeles befoglalójú háromszögeket. A háromszög a hívás visszatérése előtt elkészül, így a rajzolási sorrend, a mélység és a keverés nem változik, a kép pixelre ugyanaz. A szálak száma alapból magok − 2 (LT_SWTHREADS), mert a hang- és a kompozitorszál különben kiszorítaná őket („170–200 ms akadás az X1P-n”).

Hang: ltaudio_sdl.cpp

engine/linux/ltaudio_sdl.cpp:30 – az SDL hangszál etetése
void SDLCALL Feed(void*, SDL_AudioStream* s, int nAdditional, int)↳ az SDL saját hangszálán fut{    const int nFrameBytes = CLTMixer::kChannels * (int)sizeof(short);    ↳ sztereó, 16 bit    while (nAdditional > 0)  // amennyit az eszköz kér    {        int nFrames = nAdditional / nFrameBytes;        if (nFrames <= 0) nFrames = 1;        if (nFrames > 4096) nFrames = 4096;        ↳ legfeljebb 4096 képkocka egyszerre        short* p = g_Buf.data();        if (g_pMixer) g_pMixer->Render(p, (unsigned int)nFrames);        ↳ a motor SAJÁT keverője számol (közös a Mackel)        else          memset(p, 0, (size_t)nFrames * nFrameBytes);        ↳ nincs keverő: csend        if (g_pMixDump) fwrite(p, (size_t)nFrameBytes, (size_t)nFrames, g_pMixDump);   // LT_MIXWAV (raw s16 stereo)        ↳ hibakereséshez fájlba is        SDL_PutAudioStreamData(s, p, nFrames * nFrameBytes);        ↳ átadja az SDL-nek        nAdditional -= nFrames * nFrameBytes;    }}
engine/linux/ltaudio_sdl.cpp:59 – az eszköz megnyitása
SDL_AudioSpec spec;spec.format = SDL_AUDIO_S16;  // előjeles 16 bites mintákspec.channels = CLTMixer::kChannels;  // 2spec.freq = CLTMixer::kRate;  // 44100 Hzg_pStream = SDL_OpenAudioDeviceStream(SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK, &spec, &Feed, 0);↳ alapértelmezett kimenet (PipeWire/Pulse/ALSA)
engine/linux/ltaudio_sdl.cpp:85 – MP3 dekódolás
bool LTAudio_DecodeMP3(const void* pData, unsigned int nSize,↳ a .WAV-ba csomagolt MP3 bájtjai                       std::vector<short>& outSamples,                       unsigned int& outRate, unsigned int& outChannels){    if (!pData || nSize < 4) return false;    drmp3_config cfg;    drmp3_uint64 nFrames = 0;    drmp3_int16* p = drmp3_open_memory_and_read_pcm_frames_s16(pData, nSize, &cfg, &nFrames, 0);    ↳ dr_mp3: memóriából, egyben    if (!p) return false;    if (nFrames == 0 || cfg.channels == 0) { drmp3_free(p, 0); return false; }    outSamples.assign(p, p + (size_t)nFrames * cfg.channels);    ↳ PCM minták a keverőnek    drmp3_free(p, 0);    outRate = cfg.sampleRate;    outChannels = cfg.channels;    return true;}

A engine/linux/third_party/dr_mp3.h (v0.7.5, David Reid, public domain / MIT-0) egyetlen fejlécfájl. Nem kell hozzá külön csomag és nem kell linkelni.

Élsimított betűk: ltsysfont_ft.cpp

A magyar menük és a feliratok olvashatósága miatt a port a kis bitmap betűket egy rendszerbetűből újrarajzolja (részletek az 5. fejezetben). Linuxon a FreeType rajzolja a betűképeket:

engine/linux/ltsysfont_ft.cpp:42 – melyik betűtípus
const char* kPaths[] ={    getenv("NOLF_FONT"),  // saját .ttf/.otf megadható    // Condensed first: the bitmap fonts are narrow, and the menus    ↳ a KESKENY változat az első: a menük    // were laid out for their widths ("Vissza" beside the help box).    ↳ a keskeny bitmap betűkre lettek tervezve    "/usr/share/fonts/truetype/dejavu/DejaVuSansCondensed-Bold.ttf",    ↳ Debian/Ubuntu    "/usr/share/fonts/TTF/DejaVuSansCondensed-Bold.ttf",  // Arch    "/usr/share/fonts/dejavu/DejaVuSansCondensed-Bold.ttf",    ↳ régebbi Fedora    "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",    ↳ tartalék: normál szélességű    ...  // majd Noto Sans Bold, Liberation Sans Bold};
engine/linux/ltsysfont_ft.cpp:77 – méret és alapvonal
bool SetSize(int nPixelHeight){    if (g_nSize == nPixelHeight) return true;  // már be van állítva    const int nEm = (int)floorf((float)nPixelHeight / 1.22f + 0.5f);    ↳ sormagasság ≈ 1,22 × em, mint a Mac-es mérés    if (FT_Set_Pixel_Sizes(g_Face, 0, (FT_UInt)(nEm > 1 ? nEm : 1))) return false;    const int asc  = (int)(g_Face->size->metrics.ascender  >> 6);    ↳ 26.6 fixpontos -> pixel    const int desc = (int)(g_Face->size->metrics.descender >> 6);   // negative    g_nBaseline = (nPixelHeight - (asc - desc)) / 2 + asc;    ↳ a betűdobozt függőlegesen középre teszi    g_nSize = nPixelHeight;    return true;}
engine/linux/ltsysfont_ft.cpp:95 – egy betűkép
bool LTSysFont_RasterGlyph(unsigned int cp, int nPixelHeight,↳ cp = Unicode kódpont (pl. 0x0151 = ő)                           std::vector<unsigned char>& cov, int& nWidth){    if (nPixelHeight < 6 || !OpenFace() || !SetSize(nPixelHeight)) return false;    if (cp != ' ' && FT_Get_Char_Index(g_Face, cp) == 0) return false;    ↳ nincs ilyen betű a fontban    if (FT_Load_Char(g_Face, cp, FT_LOAD_RENDER | FT_LOAD_TARGET_LIGHT)) return false;    ↳ élsimított, enyhe hinting    const FT_GlyphSlot g = g_Face->glyph;    int w = (int)((g->advance.x + 63) >> 6);    ↳ a betű teljes szélessége (felfelé kerekítve)    if (w <= 0) return false;    cov.assign((size_t)w * nPixelHeight, 0);    ↳ fedettségi térkép: 0 = üres, 255 = tele    const FT_Bitmap& bm = g->bitmap;    for (int yy = 0; yy < (int)bm.rows; ++yy)    ↳ a FreeType bitmapját az alapvonalhoz igazítva másolja    {        const int dy = g_nBaseline - g->bitmap_top + yy;        if (dy < 0 || dy >= nPixelHeight) continue;        const unsigned char* src = bm.buffer + yy * bm.pitch;        for (int xx = 0; xx < (int)bm.width; ++xx)        {            const int dx = g->bitmap_left + xx;            if (dx < 0 || dx >= w) continue;            unsigned char& d = cov[(size_t)dy * w + dx];            if (src[xx] > d) d = src[xx];        }    }    nWidth = w;    return true;  // a ltfont.cpp ebből alfa-csatornás betűt épít}

A szerver modul betöltése

A nolf1 indulás után betölti a mellette lévő libnolfobject.so-t. Az útvonal sorrendje: NOLF_SERVER → a futtatható fájl könyvtára (a /proc/self/exe alapján, a mach-o/dyld.h shimen keresztül) → a NOLF_BIN könyvtára. /tmp-tartalék szándékosan nincs.

engine/server/ltserverhost.cpp:5767
bool LTServerHost_Start(CLTFileMgr* /*pFileMgr*/, const char* pPath){    if (g_pShell) return true;    const std::string sPath = pPath ? pPath : DefaultPath();    ↳ .../build-linux/libnolfobject.so    g_pLib = dlopen(sPath.c_str(), RTLD_NOW | RTLD_LOCAL);    ↳ NOW: minden hiányzó szimbólum AZONNAL kiderül    if (!g_pLib)    {        const char* pWhy = dlerror();        ↳ csak EGYSZER hívható: utána már NULL        fprintf(stderr, "[SERVER] cannot load %s\n           %s\n",                sPath.c_str(), pWhy ? pWhy : "?");        LTRecord_Event("server", "dlopen failed");        return false;    }    GetFnsFn pGetFns = (GetFnsFn)dlsym(g_pLib, "GetServerShellFunctions");    ↳ a SETUP_SERVERSHELL makró exportjai    GetVerFn pGetVer = (GetVerFn)dlsym(g_pLib, "GetServerShellVersion");    if (!pGetFns)    {        fprintf(stderr, "[SERVER] %s has no GetServerShellFunctions\n", sPath.c_str());        dlclose(g_pLib); g_pLib = 0;        return false;    }    const int nVer = pGetVer ? pGetVer() : -1;    ↳ verzióellenőrzés: "rossz modul", nem "összeomlott"

A játék objektumosztály-tábláját (ObjectDLLSetup) a ltserverobjects.cpp kéri le ugyanígy, dlsym-mel. A szerver alapból be van kapcsolva; LT_NOSERVER=1 kikapcsolja (pl. csak a menü vagy a pályanézegető kell).

A build_linux.sh részletesen

A engine/build_linux.sh (296 sor) végzi a tényleges fordítást. A Mac-es build_skeleton.sh másolata, ezért egyes megjegyzései még Objective-C++-ról és Metalról szólnak. Make, CMake és Ninja nincs: egy sima bash szkript, amely párhuzamosan hívja a clang++-t.

Kapcsolók

engine/build_linux.sh:70 – a kapcsolócsoportok
SYS="-I$R/engine/linux/include -I$R/engine/compat -I$R/engine/compat/include-shims -I$R/LT2/sdk/inc \↳ include-keresés: shim -> compat -> SDK -I$R/LT2/lithshared/incs -I$R/LT2/lithshared/butemgr -I$R/LT2/lithshared/stdlith \ ↳ lithshared fejlécek ...  # + az engine/* alkönyvtárai -I$R/engine/platform -I$R/engine/sound -I$R/engine/model -I$R/engine/kernel/console -I$R/engine/kernel/math -I$R/engine/world"Q="-iquote$R/NOLF/Shared -iquote$R/NOLF/ObjectDLL -iquote$R/NOLF/ClientShellDLL"↳ -iquote: csak az #include "..." látjaDEF="-DNO_PRAGMA_LIBS -D_NOLFBUILD -D_REZFILE -D_FINAL -DNDEBUG \↳ az eredeti .dsp "Final" konfigurációjából -D_LITHTECH_ -D_LITHTECH2 -DSTRICT" ↳ STRICT: WNDPROC típus a CallWindowProc-hozFLAGS="-std=c++17 -fdeclspec -fPIC -Wno-everything -g -O2 $(pkg-config --cflags sdl3 freetype2)"↳ pkg-config adja az SDL3/FreeType -I-jétif [ "${NOLF_ASAN:-0}" = "1" ]; then↳ NOLF_ASAN=1: AddressSanitizer memóriahibákhoz    FLAGS="$FLAGS -fsanitize=address -fno-omit-frame-pointer"fiCXX="${CXX:-clang++}"  # a fordító: clang++ (felülírható CXX=...)
KapcsolóMiért kell
-iquote (nem -I) a játékkönyvtárakraA NOLF/Shared/unistd.h egy nulla bájtos fájl. -I-vel elfedné a rendszer <unistd.h>-ját, és csendben eltüntetné az összes POSIX-deklarációt.
-fdeclspecA DEFINE_CLASSES() makró __declspec-et használ (MSVC kulcsszó); a clang ezzel fogadja el.
-DSTRICTEldönti, hogy a WNDPROC vagy a FARPROC típus érvényes, különben a CallWindowProc nem illeszkedik.
WIN32, _WINDOWS NINCSKülönben a játékkód a valódi Windows-ágakba futna.
-std=c++17A port motorkódja C++17-et használ; a 2000-es játékkód ezzel is fordul.
-fPICPozíciófüggetlen kód: a .so-hoz kötelező.
-Wno-everythingA 2000-es kód több ezer figyelmeztetést adna, amelyek elfednék a valódi hibákat.
-g -O2Optimalizált, de hibakereső szimbólumokkal (használható hívási verem összeomláskor).
-O3 -mcpu=native (3 fájl)Az lt3d.cpp, ltmodeldraw.cpp és ltworldwalk.cpp adja egy szoftveres képkocka kb. 90%-át, ezért vektorizáljon. ⚠️ A bináris így a fordító gép CPU-jára hangolt. x86-on a clang szokásos írásmódja -march=native.

Inkrementális fordítás

engine/build_linux.sh:113 – compile()
compile() {    local src="$1" objdir="$2"; shift 2    local obj="$objdir/$(basename "${src%.*}").o"    ↳ foo.cpp -> objdir/foo.o    mkdir -p "$objdir"    if [ -f "$obj" ] && [ "$obj" -nt "$src" ]; then return 0; fi    ↳ ha a .o újabb a forrásnál: kihagyja    throttle  # legfeljebb JOBS (= nproc) párhuzamos fordítás    local hot=""    case "$(basename "$src")" in lt3d.cpp|ltmodeldraw.cpp|ltworldwalk.cpp) hot="-O3 -mcpu=native" ;; esac    ↳ a "forró" fájlok    ( if ! $CXX $FLAGS $hot $DEF $SYS $Q "$@" -c "$src" -o "$obj" 2>"$obj.log"; then          echo "COMPILE FAILED: $src"          head -40 "$obj.log"  # a hiba első 40 sora          rm -f "$obj"                 # never leave a stale object behind          ↳ soha ne maradjon régi .o          echo "$src" >> "$ERRFLAG"          ↳ fájlba írja: egy háttér-alhéj változója nem látszana kívül      fi      rm -f "$obj.log" ) &  # & = háttérben fut}
Fejlécmódosítás után tiszta build kell! A compile() csak a .cpp és a .o dátumát hasonlítja össze, a függőségeket nem nézi. Ha egy .h-t módosítasz, futtasd a ./forditas.sh tiszta-t.

A lépések sorrendje

  1. Motor-segédkönyvtárak: engine/libs/*/*.cpp → obj/support. Külön könyvtárba kerülnek, mert az ObjectDLL-nek is kellenek (ButeMgr, RegMgr …), de a motor nem.
  2. Generált parser: engine/generated/*.cpp → obj/obj. A szerveroldalhoz tartozik, a kliens linkelése nem láthatja.
  3. A motor: engine/linux, kernel/*, render, world, model, sound, shared, server, platform → obj/libs; plusz skeleton_host.cpp -D_CLIENTBUILD; majd a windows_compat.c C-ként.
  4. ObjectDLL + Shared (szerverízű): a fájllistát a NOLF/ObjectDLL/Object.dsp SOURCE= soraiból veszi → obj/obj, obj/shared.
  5. ClientShellDLL + Shared (kliensízű, -D_CLIENTBUILD): a ClientShellDLL.dsp-ből → obj/csh, obj/shared_csh.
  6. Hibaellenőrzés: ha a .build_failed fájl létezik, kiírja a hibás fájlokat és kilép.
  7. Kliens linkelése → build-linux/nolf1.
  8. Szerver linkelése → build-linux/libnolfobject.so.
engine/build_linux.sh:253 – a két linkelés
$CXX $FLAGS -rdynamic -o "$OUT" \↳ -rdynamic: a motor szimbólumai exportálva a .so felé    "$O"/libs/*.o "$O"/support/*.o "$O"/compat/*.o \    ↳ motor + segédkönyvtárak + Win32 compat    "$O"/csh/*.o "$O"/shared_csh/*.o $LINK_EXTRA || fail=1    ↳ + kliens játékkód; LINK_EXTRA = SDL3 FreeType -ldl -lpthread$CXX $FLAGS -shared -Wl,-Bsymbolic -o "$SERVER_OUT" \↳ -shared: .so; -Bsymbolic: lásd lent    "$O"/obj/*.o "$O"/shared/*.o "$O"/support/*.o \    ↳ ObjectDLL + szerverízű Shared + segédkönyvtárak, MOTOR NÉLKÜL    || fail=1
MIÉRT -rdynamic és -Wl,-Bsymbolic?
  • A .so a motor függvényeit (pl. a fájlkezelőt) hívja, de nem tartalmazza őket. A -rdynamic a futtatható fájl szimbólumait láthatóvá teszi a betöltött könyvtárak számára. Macen ennek a -undefined dynamic_lookup felel meg.
  • Viszont így a futtatható fájl a kliensízű Shared/ függvényeit is exportálja, ugyanazokkal a nevekkel, mint a .so szerverízűi. ELF-en az alapértelmezés az, hogy az exe szimbóluma „nyer” (interposition): a szerver a kliens változatát hívná, és összeomlana. A -Bsymbolic előírja, hogy a .so a saját belső hivatkozásait a saját példányaihoz kösse. Macen a Mach-O kétszintű névtere ezt magától megoldja.

A kis- és nagybetűs include-ok: linux_case_links.py

A macOS fájlrendszere alapból nem különbözteti meg a kis- és nagybetűt, a Linuxé igen. A 2000-es Windows-kódban ezért vegyesen szerepel #include "LTGuiMgr.h" és "ltguimgr.h", miközben a fájl neve LTGUIMgr.h.

  1. A szkript kiolvassa a build_linux.sh-ból az összes -I és -iquote könyvtárat.
  2. Végigmegy minden .c .cpp .h .hpp .inl .y .l fájlon, és megkeresi az #include-okat. A visszaperjeles include-okat kihagyja, azokat az include-shims kezeli.
  3. Ha az include pontos írásmóddal nem található, de kis- és nagybetű-függetlenül igen, akkor a kért írásmóddal szimlinket tesz az igazi fájl mellé.
  4. Második körben a hibás szimlinkeket javítja, ha a célpont csak betűméretben tér el.

Kb. 53 szimlinket hoz létre. Ezek a git status-ban ??-ként látszanak, és nem szabad őket bekommitolni. Bármikor újra létrehozhatók, és a szkript többszöri futtatása sem árt (idempotens).

Futtatás: play_linux.sh

play_linux.sh
R="$(cd "$(dirname "$0")" && pwd)"↳ a repó gyökere, bárhonnan indítodCFG="$HOME/.local/share/NOLF1/autoexec.cfg"↳ a játékos saját beállításaicfgval() { [ -f "$CFG" ] && sed -n "s/^\"$1\" \"\([^\"]*\)\".*/\1/Ip" "$CFG" | tail -1; }↳ "kulcs" "érték" kiolvasásaexport NOLF_GAME_DIR="${NOLF_GAME_DIR:-$HOME/workspace/No One Lives Forever}"↳ a játékadat helyeif [ "${NOLF_LANG:-hu}" = "en" ]; then↳ NOLF_LANG=en -> eredeti angol    unset NOLF_LANG_FILEelse    export NOLF_LANG_FILE="${NOLF_LANG_FILE:-$R/launcher/hu.txt}"    ↳ alapból MAGYARfiif [ -n "${1:-}" ]; then↳ felbontás: paraméter > LT_SCREEN > a játékban mentett > 1024x768    export LT_SCREEN="$1"elif [ -z "${LT_SCREEN:-}" ]; then    W="$(cfgval screenwidth)"; H="$(cfgval screenheight)"    if [ -n "$W" ] && [ -n "$H" ] && [ "$W" -ge 640 ] 2>/dev/null && [ "$H" -ge 480 ] 2>/dev/null; then        export LT_SCREEN="${W}x${H}"    else        export LT_SCREEN="1024x768"    fifiif [ -z "${LT_SOFTWARE:-}" ] && [ "$(cfgval RenderDll)" = "Software" ]; then↳ a menüben választott renderelő    export LT_SOFTWARE=1fiexport LT_WINDOW=1 LT_REALTIME=1 LT_STUB_QUIET=1↳ ablak, valós idejű óra, csonkok némánLOG="$HOME/.local/share/NOLF1/utolso_futas.log"mkdir -p "$(dirname "$LOG")"[ -f "$LOG" ] && mv -f "$LOG" "$LOG.1"↳ az előző napló megmarad .1-kéntecho "NOLF1 $(date '+%F %T')  LT_SCREEN=$LT_SCREEN  renderer=..." > "$LOG"cd "$R/build-linux" || exit 1  # a mentések (Save/) ide kerülnekset -o pipefail  # a tee mögött is a játék kilépési kódja számít./nolf1 2>&1 | tee -a "$LOG"  # képernyőre és naplóba
Összeomlás esetén a napló végén [LTFATAL] <jel> és egy hívási verem áll (a backtrace() adja). A címekből így lesz függvénynév és sorszám: addr2line -f -C -e build-linux/nolf1 <offset> (vagy -e build-linux/libnolfobject.so).

Hasznos környezeti változók (Linux)

VáltozóHatás
NOLF_GAME_DIRA játékadat könyvtára(i), :-tal elválasztva.
NOLF_LANG=en / NOLF_LANG_FILEAngol, illetve tetszőleges fordítási fájl.
LT_SCREEN=WxHA játék felbontása.
LT_SOFTWARE=1Szoftveres renderelő OpenGL helyett.
LT_NOVSYNC, LT_MSAA, LT_ANISOVsync ki, élsimítás mintaszáma, anizotróp szűrés.
LT_SWTHREADS=nA szoftveres raszterizáló szálai.
LT_GMBANK=fájlGM hangszerbank (.sf2/.dls) a zenéhez.
NOLF_FONT=fájl.ttfMás betűtípus az élsimított betűkhöz.
NOLF_SMOOTHFONTS=0, NOLF_SUBSCALE=0Az eredeti bitmap menü-, illetve feliratbetű.
NOLF_SUBTITLES=0Felirat ki (magyar módban alapból be van kapcsolva).
LT_TRACE_FILE=1Minden megnyitott fájlt kiír a forrásfájával együtt.
LT_GLSHOT=dir, LT_GLSHOT_EVERY=nKépernyőképek PPM-ben.
LT_AUTOCLOSE=s, LT_TEST_KEYS, LT_TEST_MOUSEAutomatikus tesztfuttatás.
LT_MIXWAV=fájlA hangkimenet nyers s16 sztereó mentése.