From 64be72194e5fe89229a6bbb6395f9f456dcf998c Mon Sep 17 00:00:00 2001 From: Christian Semmler Date: Sat, 31 Jan 2026 15:28:16 -0800 Subject: [PATCH] Add save game editor (#12) * WIP * stuff * WIP: Interactive 3D score cube for save editor * Conditionally render ScoreCube to properly clean up WebGL canvas Only mount the ScoreCube component when on the save-editor page. This ensures onDestroy is called when navigating away, properly disposing of the WebGL renderer and removing the canvas from DOM. * Refactor: Consolidate formats and genericize WDB rendering - Move parsing/serialization code to src/core/formats/: - BinaryReader.js, BinaryWriter.js (shared utilities) - SaveGameParser.js, SaveGameSerializer.js - PlayersParser.js, PlayersSerializer.js - Create formats/index.js as barrel export - Extract generic WdbModelRenderer from ScoreCubeRenderer: - WdbModelRenderer handles D3DRM geometry and paletted textures - ScoreCubeRenderer extends it with score-specific logic - Prepares for rendering other WDB models in the future - Keep savegame/constants.js for domain-specific constants - savegame/index.js remains as high-level API facade * Save editor UI improvements - Make save slot cards fixed width (85px) to prevent resizing with name length - Make save slot cards more compact (smaller icons, padding, font) - Remove Act selection from Character section - Remove box-shadow from selected character to fix collapsed section bleed * Improve score cube lighting to match in-game appearance - Use flat, even lighting (high ambient + soft front light) - Remove harsh directional shadows from edges - Adjust camera position slightly for better framing * Add spacing below score cube canvas * Add spinning loader while loading score cube * Update three.js to 0.182.0 and fix npm audit issues - Update three.js from 0.170.0 to 0.182.0 - Fix npm audit vulnerabilities (devalue, lodash, svelte) - Remaining vulns are in dev dependencies (vite, workbox-cli) * Fix score cube overflow on mobile Add max-width constraints to prevent the score cube from expanding its container on narrow viewports while preserving its natural 200x200 size on desktop. * Add save slot carousel and improve empty states - Add reusable Carousel component with arrow navigation, drag-to-scroll, and click-to-scroll-into-view functionality - Replace static save slot list with horizontal carousel - Add empty state with image when no save files exist - Add prompt state when saves exist but none is selected - Reset selected slot when entering Save Editor page * Add February 2026 changelog entry for Save Editor * Add missing January 2026 changelog entries for Safari and mobile fixes * Remove unused mission images * Refactor opfs.js to reduce code duplication - Consolidate getFileHandle to use getOpfsRoot internally - Add writeTextFile helper that uses writeBinaryFile - Extract showToast helper for toast notifications - Simplify saveConfig to use writeTextFile instead of duplicate worker - Simplify fileExists and readBinaryFile to use getFileHandle * Remove unused ScoreColorButton component * Remove unused UI components --- package-lock.json | 44 +- package.json | 3 + public/laura-selected.webp | Bin 0 -> 918 bytes public/laura.webp | Bin 0 -> 1018 bytes public/mama-selected.webp | Bin 0 -> 964 bytes public/mama.webp | Bin 0 -> 1016 bytes public/nick-selected.webp | Bin 0 -> 876 bytes public/nick.webp | Bin 0 -> 986 bytes public/papa-selected.webp | Bin 0 -> 948 bytes public/papa.webp | Bin 0 -> 980 bytes public/pepper-selected.webp | Bin 0 -> 844 bytes public/pepper.webp | Bin 0 -> 946 bytes public/save.webp | Bin 0 -> 20846 bytes src/App.svelte | 4 + src/app.css | 27 +- src/core/formats/BinaryReader.js | 164 ++++++ src/core/formats/BinaryWriter.js | 172 ++++++ src/core/formats/PlayersParser.js | 54 ++ src/core/formats/PlayersSerializer.js | 62 ++ src/core/formats/SaveGameParser.js | 396 +++++++++++++ src/core/formats/SaveGameSerializer.js | 329 +++++++++++ src/core/formats/WdbParser.js | 439 +++++++++++++++ src/core/formats/index.js | 18 + src/core/opfs.js | 230 ++++++-- src/core/rendering/ScoreCubeRenderer.js | 84 +++ src/core/rendering/WdbModelRenderer.js | 303 ++++++++++ src/core/savegame/constants.js | 191 +++++++ src/core/savegame/index.js | 280 ++++++++++ src/lib/Carousel.svelte | 184 ++++++ src/lib/CollapsibleSection.svelte | 15 - src/lib/ConfigToast.svelte | 4 +- src/lib/ReadMePage.svelte | 7 +- src/lib/SaveEditorPage.svelte | 528 ++++++++++++++++++ src/lib/TabNavigation.svelte | 18 - src/lib/ToggleSwitch.svelte | 49 -- src/lib/config/ExtrasTab.svelte | 11 +- .../save-editor/MissionScoresEditor.svelte | 31 + src/lib/save-editor/ScoreCube.svelte | 226 ++++++++ src/stores.js | 12 +- 39 files changed, 3723 insertions(+), 162 deletions(-) create mode 100644 public/laura-selected.webp create mode 100644 public/laura.webp create mode 100644 public/mama-selected.webp create mode 100644 public/mama.webp create mode 100644 public/nick-selected.webp create mode 100644 public/nick.webp create mode 100644 public/papa-selected.webp create mode 100644 public/papa.webp create mode 100644 public/pepper-selected.webp create mode 100644 public/pepper.webp create mode 100644 public/save.webp create mode 100644 src/core/formats/BinaryReader.js create mode 100644 src/core/formats/BinaryWriter.js create mode 100644 src/core/formats/PlayersParser.js create mode 100644 src/core/formats/PlayersSerializer.js create mode 100644 src/core/formats/SaveGameParser.js create mode 100644 src/core/formats/SaveGameSerializer.js create mode 100644 src/core/formats/WdbParser.js create mode 100644 src/core/formats/index.js create mode 100644 src/core/rendering/ScoreCubeRenderer.js create mode 100644 src/core/rendering/WdbModelRenderer.js create mode 100644 src/core/savegame/constants.js create mode 100644 src/core/savegame/index.js create mode 100644 src/lib/Carousel.svelte delete mode 100644 src/lib/CollapsibleSection.svelte create mode 100644 src/lib/SaveEditorPage.svelte delete mode 100644 src/lib/TabNavigation.svelte delete mode 100644 src/lib/ToggleSwitch.svelte create mode 100644 src/lib/save-editor/MissionScoresEditor.svelte create mode 100644 src/lib/save-editor/ScoreCube.svelte diff --git a/package-lock.json b/package-lock.json index 7934ee1..b0d8f9c 100644 --- a/package-lock.json +++ b/package-lock.json @@ -7,6 +7,9 @@ "": { "name": "isle.pizza", "version": "1.0.0", + "dependencies": { + "three": "^0.182.0" + }, "devDependencies": { "@sveltejs/vite-plugin-svelte": "^4.0.0", "svelte": "^5.0.0", @@ -3583,10 +3586,11 @@ } }, "node_modules/devalue": { - "version": "5.6.1", - "resolved": "https://registry.npmjs.org/devalue/-/devalue-5.6.1.tgz", - "integrity": "sha512-jDwizj+IlEZBunHcOuuFVBnIMPAEHvTsJj0BcIp94xYguLRVBcXO853px/MyIJvbVzWdsGvrRweIUWJw8hBP7A==", - "dev": true + "version": "5.6.2", + "resolved": "https://registry.npmjs.org/devalue/-/devalue-5.6.2.tgz", + "integrity": "sha512-nPRkjWzzDQlsejL1WVifk5rvcFi/y1onBRxjaFMjZeR9mFpqu2gmAZ9xUB9/IEanEP/vBtGeGganC/GO1fmufg==", + "dev": true, + "license": "MIT" }, "node_modules/dot-prop": { "version": "9.0.0", @@ -3876,10 +3880,11 @@ "dev": true }, "node_modules/esrap": { - "version": "2.2.1", - "resolved": "https://registry.npmjs.org/esrap/-/esrap-2.2.1.tgz", - "integrity": "sha512-GiYWG34AN/4CUyaWAgunGt0Rxvr1PTMlGC0vvEov/uOQYWne2bpN03Um+k8jT+q3op33mKouP2zeJ6OlM+qeUg==", + "version": "2.2.2", + "resolved": "https://registry.npmjs.org/esrap/-/esrap-2.2.2.tgz", + "integrity": "sha512-zA6497ha+qKvoWIK+WM9NAh5ni17sKZKhbS5B3PoYbBvaYHZWoS33zmFybmyqpn07RLUxSmn+RCls2/XF+d0oQ==", "dev": true, + "license": "MIT", "dependencies": { "@jridgewell/sourcemap-codec": "^1.4.15" } @@ -5192,10 +5197,11 @@ } }, "node_modules/lodash": { - "version": "4.17.21", - "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz", - "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==", - "dev": true + "version": "4.17.23", + "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.23.tgz", + "integrity": "sha512-LgVTMpQtIopCi79SJeDiP0TfWi5CNEc/L/aRdTh3yIvmZXTnheWpKjSZhnvMl8iXbC1tFg9gdHHDMLoV7CnG+w==", + "dev": true, + "license": "MIT" }, "node_modules/lodash.debounce": { "version": "4.0.8", @@ -6715,10 +6721,11 @@ } }, "node_modules/svelte": { - "version": "5.46.1", - "resolved": "https://registry.npmjs.org/svelte/-/svelte-5.46.1.tgz", - "integrity": "sha512-ynjfCHD3nP2el70kN5Pmg37sSi0EjOm9FgHYQdC4giWG/hzO3AatzXXJJgP305uIhGQxSufJLuYWtkY8uK/8RA==", + "version": "5.49.1", + "resolved": "https://registry.npmjs.org/svelte/-/svelte-5.49.1.tgz", + "integrity": "sha512-jj95WnbKbXsXXngYj28a4zx8jeZx50CN/J4r0CEeax2pbfdsETv/J1K8V9Hbu3DCXnpHz5qAikICuxEooi7eNQ==", "dev": true, + "license": "MIT", "dependencies": { "@jridgewell/remapping": "^2.3.4", "@jridgewell/sourcemap-codec": "^1.5.0", @@ -6728,9 +6735,9 @@ "aria-query": "^5.3.1", "axobject-query": "^4.1.0", "clsx": "^2.1.1", - "devalue": "^5.5.0", + "devalue": "^5.6.2", "esm-env": "^1.2.1", - "esrap": "^2.2.1", + "esrap": "^2.2.2", "is-reference": "^3.0.3", "locate-character": "^3.0.0", "magic-string": "^0.30.11", @@ -6879,6 +6886,11 @@ "node": ">=10" } }, + "node_modules/three": { + "version": "0.182.0", + "resolved": "https://registry.npmjs.org/three/-/three-0.182.0.tgz", + "integrity": "sha512-GbHabT+Irv+ihI1/f5kIIsZ+Ef9Sl5A1Y7imvS5RQjWgtTPfPnZ43JmlYI7NtCRDK9zir20lQpfg8/9Yd02OvQ==" + }, "node_modules/through": { "version": "2.3.8", "resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz", diff --git a/package.json b/package.json index dda8867..5e4ea1a 100644 --- a/package.json +++ b/package.json @@ -10,6 +10,9 @@ "preview": "vite preview", "prepare:assets": "node scripts/prepare.js" }, + "dependencies": { + "three": "^0.182.0" + }, "devDependencies": { "@sveltejs/vite-plugin-svelte": "^4.0.0", "svelte": "^5.0.0", diff --git a/public/laura-selected.webp b/public/laura-selected.webp new file mode 100644 index 0000000000000000000000000000000000000000..70b5f8635defc741e5839ffdbc899aec7ea6b5fe GIT binary patch literal 918 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 literal 0 HcmV?d00001 diff --git a/public/mama.webp b/public/mama.webp new file mode 100644 index 0000000000000000000000000000000000000000..55c51bfba5ee7af364b1c2d6dc3e2f06e29b0989 GIT binary patch literal 1016 zcmVJDZ_W|$Q)Nb0}F@AOagM9!$Vm%qXiai8BRed-ASUwql zUB7C*sB0AR+6{FVIq|?!SN}WVTYG=Se$E{vFlA<3qOgfk6!BHJoZdkPRQW7|Nb2c~ zv%}=7;Wlpz8!l_baJ=E90~;#{fhRZHsHc|z0RH)ww)YdqP^eLddYvc^ZVnv^x8xE_ zFoI7?R$GyNr);EOa62~9PuxaSI!?Is@u$#5p1}Is_(?Z>LtTYQ?%oD|6d6~+{Dl52 zfMM;1Djh;<|2$QM)OVPH*$POB5wteCKaS_js#uJKJiekXK3>n#KWe!^fmK`Dw+d@R z%R8fT3s<}=Q|LAR#FgegyK76;YUBPyv0HTgh)5sOpprLI#scaHpM#uzf#;gJ0a3!u z!o%<`Ni+STZxssUrRLu>|Hb+%H(c-!m$QfoOJr_nlOsEUR~wYh!2Mlk}Nzauvsp!=ucM}1gl5#B%_*1P!n#= z^Tx4cSk`ZpJCq2K=WZ~tED#N21{ZiMqG1t^ z-i>2V#`B>~nMw5hgTLT0b&ma+O`|wwA8OP4CG#Wq>%Z-fzA(o#`-8L0XHD+5QyL)_ zVh`uMtET6_)PgO6k&80_UI>bDJ}`5l4Zcq~iucX1GFTED!y`ddF(;KY6b@W82jzCH zsp`Vr$r#S8_tM5L?Jy_CkYR2@ubq0_ih1F>wuC>xUh@k#V&%cu#|t>IoU;YjeuVsR z^}n%*K0JdyJYv@8|MLSpRH}`k>awlVXAl03{v5DW`mx zwZHN<_nZ~+C7#j>D`otIM>f50UW_Jl+|wkdQ&fl!oxTxnfs>cWs(oftO&_F)&MxS; z>(0dJ#Wgi?yNBV+rj-)_%?irgdeW5x5@NiXp1+y-Q9P1@AGUU2>?R_l&gM(eX)J$G z9$>>8m9ZO}H}guNyBuUTw+8T3>}4$;`vzf@mc}wDnyp_7M?f&@G~Zvb1`Oq#0Hn4` mz{zv{ZRa5FH4lU$Rft7&v<03zYy+-cnU1C;$M6Xzh*w literal 0 HcmV?d00001 diff --git a/public/nick-selected.webp b/public/nick-selected.webp new file mode 100644 index 0000000000000000000000000000000000000000..d6e626c307de86107b1d8180fc56b39855ea7040 GIT binary patch literal 876 zcmV-y1C#txNk&Fw0{{S5MM6+kP&go10{{RJ5CEM4DklIg06uLlkVYgTp`k7~3ow8U ziEIF!IYCqYK>fP)J7UJeY~MV0_zzUO&>o4uupXK|%AQacarmO?uXr+n;0GI?0_Jbd zqwasW1kivE`ZieXbk3W{Z@UXxm0+IAI$^`vi8p#tJ^VI7Apkh_QkE z44OEeVj2aQgYIPr?$I!Ud3XwMMr z@-3Qb1GC5pD+F=l8$MgLMNvco5N(C{P;pmvtJT-OLSgxDBc?Q+i@EFhqgc=Kczf`K zv_4YLOBk<(oPyVz{s18!A|Lz4wBJuAwwLZedjGE}t3xZIU-9dA-woFjp(NPczg4&p zBbq9e0Pq^Z%Mr8ry=VX>`PQw$SG%&d>^6$pEBVaQ##f~#TN!o7V$}I%>h)y~&&FgK z6sd`}^);jhmf+Zd$5p4KJ##dIG%&f-8l#87b(hllO`Eoa-)bnAjZyG&vfMlP5R;D}e3S30Ux znu86a3T?Z2doxlz}k&w=U=QoJzgC95nZ!fjL&s;lGGf8_@GFiw}BfGclH>-CWRqU$KpZ#Kz7M3yw-QmY|4KxQ#IcI?*mWF@M)D&I{KRuvjnd#A#{1M``{ zX&~-kufWe(TN2z@Ww}wOai=T>j+I0!u5M_&{ZQ2_V&fW+46=y|B z($nqYEdhU~tl7tc`xmqIxhkYkPZMGnaRBmC)6}1qlLQx;%2B8_dcB!ObhFRw-|Kf$ zt44^q1E^L*U)_i}^*jgJfdhnubt}{h@8sk`vNre)7Lj(}e3;rbCZfK)?VF2Li8_-$ zB`Hfz0pYk0b92%2F1RFomK0l&9SFU0I-R=zfffv_iZYb`T)qoH3f8NC0oFXwbw%d~BYBnXjelhfg(o{(Qi}!fLtA$LZ056s&5WVjhJe$y zB)lNGyGKtWJ~3oR%c5Uq@KYts>6}Sq1Eu+a#Wq)?f5T$^0RsUGozT`irH9n2o2f{3 z6xcSY`}{80Gd+kd3POi=mM6F*GI-3F-LSV^B~K2E`<3C!u*-e@JV1A_xr<|>^090^ zA0Zhq%%C5h=FlH|w$#ukBvv)@z2BSA(qT&EFgKq`-SJrbjsZR4lU@eyb!o)*DvCQZ z(ehY?_c+pIeu)Cb{vJ2pFuOofH|%7DnW~gJk6tL0**a#hl~^GG{AU(O`Le`Lgtt|a z>!Hs$oz_>wLa}9oHoXk~AHcCdd4rjDIR@x+L(|m>L*TB?T>-RN#`X==+c3`B)G(PFjdwEE#U_~5QN-s#);S^AfN`meZL&sS#u z-#F}MdjsvMv4Ilm+P08qckd^OqQ!}v?Z!l*Ud4tf(h0(E)@!6PhK{?jDf%(>#u-=M z5VpjCcgM{Gui0auu>vX*y_XENS*TYM0B#w@S-)CrqIOw_GyviJv1D7<8>uiID zytwR<8V46C%0>kgv|g;v75g8LOi^-u=D+qs|Bd_KR^s!2ocA;{mT?M3<=^_}^uizA IF~wj20AD`xzyJUM literal 0 HcmV?d00001 diff --git a/public/papa-selected.webp b/public/papa-selected.webp new file mode 100644 index 0000000000000000000000000000000000000000..cc6b2213e83ab4bb63ba554049fdd71f55cab51c GIT binary patch literal 948 zcmV;l155l;Nk&Gj0{{S5MM6+kP&go<0{{SU5CEM4DklIg06uLjkwv5;p_;0!06+%B zwg66X z1GAb}WszNPzR16nzO)Nnb7KY!Xv-&v`g(GQo>0HOU9(ff+2$4cEeS%0Sp%AlMWuW$rG!wZq zF$gR_DBzjXYu~pn?-PEKg6k^+PCeacWHQ$Y3;SlT8x2J}U1v*0d9$nE|&vv3W^Lj^~{6jMD^~s9Ma9N-jm$a}5mF@(0=nuOJVfPJu4DnIP zRF_T*5UG|$mDBniaM$NSn2!bDckG|>-2=EkFYD{}k&jLB@1uvAo)hzB7RhTZfUV0K zq(98IAMdcvFU{)T=RUkcVZH#^Nm*w-HisDP?cUt1SNjIJBlKqJP)ufaM@ZjcOc$4R zKry}VMWc*IUx(+i;=$HG&|!i%v6w!ZSGJGmDCW1109lENsdNaiSr`-YC=^m)B zBCE|+2JuIaIb{&Z2QM*^!A2E=9pl=rJSSe&9yshAjk38IY54#5M_WJJ?R0k4DjuIw zI87*UR}>1EQ4lFT)({frUkFi1a)RijN-Z}1RCm14>Vazi W|0!}?kGe^x+}gj_&$m1aNB{u*cGB|z literal 0 HcmV?d00001 diff --git a/public/papa.webp b/public/papa.webp new file mode 100644 index 0000000000000000000000000000000000000000..83935244cb85a6d520aef00a290e76be825c4c14 GIT binary patch literal 980 zcmV;_11tPeNk&G@0{{S5MM6+kP&gpK0{{RJ5&)e6DklIg06uLjkwzpUp`kI>Y5;%@ ziEIF!GQD#T%6XAepS9}|FvGgAFiI3zRn(0m5jN~^hA)# zE_G{*BX zcnE#3Vqg9C}aGj^)+Wy=FlZ7;$&VL-d04%?jIrfB?I9+q4 zM5EI!|EDwPP~9TsIZ@@vVc;QaS8M>lBpjD0oYTlt-RT4lUZs!7{P1nXURyJ^tW z?G6rrVC>ukamnZY5674Am(+rW$h?STeEe)=l+k>)$mnb-uxh2Gca%&ql3M6GNM_Fm zE2dJgAx)>i0VJ@Tepxx%jy7r407)VzA(cuiyAmY_eQd@$WlhwN93sNw zCDC00R5R(I*&qL~_+=5QwV>&y1j@#$U$Kco%83TWzX}c}(|NF~0FW9cROmlz+>FOd>B%4W_zSGn zV-^1eN}quy`#@}K_ua&FHnc(iK89U4%CScbgn7p?%W~Rc9wfWFAvGDDQ~pxy;yXR7 z;hah+2#08rR+2EZzx27huaGN2Vv)qG7t{YF1?++aMc!5265bS>F8?hoe>kxmy>C;T zI!zRk<<;v53szn;FEBHe5EW)Ua(*wwF`VZMIEzC4mg<;Df^J56VmhxCm>RWiAOHYN CH{0g` literal 0 HcmV?d00001 diff --git a/public/pepper-selected.webp b/public/pepper-selected.webp new file mode 100644 index 0000000000000000000000000000000000000000..1cacc1402e2a0f219218462bc9c6e6f90a5e19b9 GIT binary patch literal 844 zcmV-S1GD^6Nk&FQ0{{S5MM6+kP&gns0{{T94*;D3DklIg06uLhk42;+p%)fpKnBFN z08X5ssNWF2@8(5aYPu8dz;Y|hy?W0092<#_i|rV)S+=^Y~m6^yxpRnGqa8yW>gVPEw&8dliGJW1TzhotmtrMlA<& z*=kE4jA(boq7pn5pa3mM96)vcBmgTX(2*as?uyI_NmgMtCUw7kA#KiYobY-7a`u-L z>wi$49|TwbsIK-h{gX6awJ1{!HOQ={)M@KiMit;KiIw3$ium>nZuOE&mBb&VWB_tn z!4wZns(acD7IJ018sYIb=q|I{X=2i}hdHAP`Uqm$ETf|O;Ha;$(suM}61SsoM!ZWxE{49|m9RZV$UxX$_8OvNlkGp5ATVmeaP9+coW zaR)(=a-KZDVJ-=gxl~q$4}Dvt#3gtAY#7{=*iRkTRi6@qa90=duf+!%?lw>)qW2${BQ)DM`u&zlHtc?(5i}V#u z{_9>B968gsgM&Yyg?x*(>vQPfP9~4yrA||DOdMf#7emKWCC;R+i`NkAq8nqjs4%WE W$WSr6nvtmsg?QXDu>)HH@&EwzvzC4U literal 0 HcmV?d00001 diff --git a/public/pepper.webp b/public/pepper.webp new file mode 100644 index 0000000000000000000000000000000000000000..fdf9fa102d05805d9e3bde725a93067a1ee47623 GIT binary patch literal 946 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 JOc#0J001AUnSlTR literal 0 HcmV?d00001 diff --git a/src/App.svelte b/src/App.svelte index 7f3bd8f..81dfbdd 100644 --- a/src/App.svelte +++ b/src/App.svelte @@ -8,6 +8,7 @@ import ReadMePage from './lib/ReadMePage.svelte'; import ConfigurePage from './lib/ConfigurePage.svelte'; import FreeStuffPage from './lib/FreeStuffPage.svelte'; + import SaveEditorPage from './lib/SaveEditorPage.svelte'; import UpdatePopup from './lib/UpdatePopup.svelte'; import GoodbyePopup from './lib/GoodbyePopup.svelte'; import ConfigToast from './lib/ConfigToast.svelte'; @@ -76,6 +77,9 @@
+
+ +

LEGO® and LEGO Island™ are trademarks of The LEGO Group.

diff --git a/src/app.css b/src/app.css index 7b69ab7..c79bf0d 100644 --- a/src/app.css +++ b/src/app.css @@ -412,7 +412,8 @@ body { text-decoration: underline; } -#configure-page .page-inner-content.config-layout { +#configure-page .page-inner-content.config-layout, +#save-editor .page-inner-content.config-layout { display: flex; background-color: var(--color-bg-input); border: 1px solid #303030; @@ -563,6 +564,27 @@ body { content: '−'; } +.config-card-header.nav-link { + text-decoration: none; + display: flex; + box-sizing: border-box; +} + +.config-card-header.nav-link:hover, +.config-card-header.nav-link:focus, +.config-card-header.nav-link:active { + text-decoration: none; +} + +.config-card-header.nav-link::after { + content: '→'; + transition: color 0.2s ease; +} + +.config-card-header.nav-link:hover::after { + color: var(--color-text-light); +} + .config-card-content { display: grid; grid-template-rows: 0fr; @@ -1388,7 +1410,8 @@ select:focus { display: none; } - #configure-page .page-inner-content.config-layout { + #configure-page .page-inner-content.config-layout, + #save-editor .page-inner-content.config-layout { background-color: transparent; border: none; padding: 0; diff --git a/src/core/formats/BinaryReader.js b/src/core/formats/BinaryReader.js new file mode 100644 index 0000000..76dbb47 --- /dev/null +++ b/src/core/formats/BinaryReader.js @@ -0,0 +1,164 @@ +/** + * Little-endian binary reader for parsing save game files + */ +export class BinaryReader { + /** + * @param {ArrayBuffer} buffer - The binary data to read + */ + constructor(buffer) { + this.buffer = buffer; + this.view = new DataView(buffer); + this.offset = 0; + } + + /** + * Read signed 8-bit integer + * @returns {number} + */ + readS8() { + const value = this.view.getInt8(this.offset); + this.offset += 1; + return value; + } + + /** + * Read unsigned 8-bit integer + * @returns {number} + */ + readU8() { + const value = this.view.getUint8(this.offset); + this.offset += 1; + return value; + } + + /** + * Read signed 16-bit integer (little-endian) + * @returns {number} + */ + readS16() { + const value = this.view.getInt16(this.offset, true); + this.offset += 2; + return value; + } + + /** + * Read unsigned 16-bit integer (little-endian) + * @returns {number} + */ + readU16() { + const value = this.view.getUint16(this.offset, true); + this.offset += 2; + return value; + } + + /** + * Read signed 32-bit integer (little-endian) + * @returns {number} + */ + readS32() { + const value = this.view.getInt32(this.offset, true); + this.offset += 4; + return value; + } + + /** + * Read unsigned 32-bit integer (little-endian) + * @returns {number} + */ + readU32() { + const value = this.view.getUint32(this.offset, true); + this.offset += 4; + return value; + } + + /** + * Read 32-bit float (little-endian) + * @returns {number} + */ + readF32() { + const value = this.view.getFloat32(this.offset, true); + this.offset += 4; + return value; + } + + /** + * Read ASCII string of specified length + * @param {number} length - Number of bytes to read + * @returns {string} + */ + readString(length) { + const bytes = new Uint8Array(this.buffer, this.offset, length); + this.offset += length; + return String.fromCharCode(...bytes); + } + + /** + * Read length-prefixed string (U8 length prefix) + * @returns {string} + */ + readLengthPrefixedString() { + const length = this.readU8(); + return this.readString(length); + } + + /** + * Read length-prefixed string (S16 length prefix) + * @returns {string} + */ + readLengthPrefixedStringS16() { + const length = this.readS16(); + if (length <= 0) return ''; + return this.readString(length); + } + + /** + * Seek to absolute position + * @param {number} offset + */ + seek(offset) { + this.offset = offset; + } + + /** + * Skip bytes relative to current position + * @param {number} bytes + */ + skip(bytes) { + this.offset += bytes; + } + + /** + * Get current position + * @returns {number} + */ + tell() { + return this.offset; + } + + /** + * Get remaining bytes + * @returns {number} + */ + remaining() { + return this.buffer.byteLength - this.offset; + } + + /** + * Check if at end of buffer + * @returns {boolean} + */ + eof() { + return this.offset >= this.buffer.byteLength; + } + + /** + * Slice out a portion of the buffer + * @param {number} length + * @returns {ArrayBuffer} + */ + slice(length) { + const sliced = this.buffer.slice(this.offset, this.offset + length); + this.offset += length; + return sliced; + } +} diff --git a/src/core/formats/BinaryWriter.js b/src/core/formats/BinaryWriter.js new file mode 100644 index 0000000..35434a7 --- /dev/null +++ b/src/core/formats/BinaryWriter.js @@ -0,0 +1,172 @@ +/** + * Little-endian binary writer for serializing save game files + */ +export class BinaryWriter { + /** + * @param {number} initialSize - Initial buffer size (will grow as needed) + */ + constructor(initialSize = 1024) { + this.buffer = new ArrayBuffer(initialSize); + this.view = new DataView(this.buffer); + this.offset = 0; + } + + /** + * Ensure buffer has capacity for additional bytes + * @param {number} additionalBytes + */ + ensureCapacity(additionalBytes) { + const required = this.offset + additionalBytes; + if (required > this.buffer.byteLength) { + const newSize = Math.max(required, this.buffer.byteLength * 2); + const newBuffer = new ArrayBuffer(newSize); + new Uint8Array(newBuffer).set(new Uint8Array(this.buffer)); + this.buffer = newBuffer; + this.view = new DataView(this.buffer); + } + } + + /** + * Write signed 8-bit integer + * @param {number} value + */ + writeS8(value) { + this.ensureCapacity(1); + this.view.setInt8(this.offset, value); + this.offset += 1; + } + + /** + * Write unsigned 8-bit integer + * @param {number} value + */ + writeU8(value) { + this.ensureCapacity(1); + this.view.setUint8(this.offset, value); + this.offset += 1; + } + + /** + * Write signed 16-bit integer (little-endian) + * @param {number} value + */ + writeS16(value) { + this.ensureCapacity(2); + this.view.setInt16(this.offset, value, true); + this.offset += 2; + } + + /** + * Write unsigned 16-bit integer (little-endian) + * @param {number} value + */ + writeU16(value) { + this.ensureCapacity(2); + this.view.setUint16(this.offset, value, true); + this.offset += 2; + } + + /** + * Write signed 32-bit integer (little-endian) + * @param {number} value + */ + writeS32(value) { + this.ensureCapacity(4); + this.view.setInt32(this.offset, value, true); + this.offset += 4; + } + + /** + * Write unsigned 32-bit integer (little-endian) + * @param {number} value + */ + writeU32(value) { + this.ensureCapacity(4); + this.view.setUint32(this.offset, value, true); + this.offset += 4; + } + + /** + * Write 32-bit float (little-endian) + * @param {number} value + */ + writeF32(value) { + this.ensureCapacity(4); + this.view.setFloat32(this.offset, value, true); + this.offset += 4; + } + + /** + * Write ASCII string (no length prefix) + * @param {string} str + */ + writeString(str) { + this.ensureCapacity(str.length); + for (let i = 0; i < str.length; i++) { + this.view.setUint8(this.offset + i, str.charCodeAt(i)); + } + this.offset += str.length; + } + + /** + * Write length-prefixed string (U8 length prefix) + * @param {string} str + */ + writeLengthPrefixedString(str) { + this.writeU8(str.length); + this.writeString(str); + } + + /** + * Write length-prefixed string (S16 length prefix) + * @param {string} str + */ + writeLengthPrefixedStringS16(str) { + this.writeS16(str.length); + this.writeString(str); + } + + /** + * Write raw bytes + * @param {Uint8Array|ArrayBuffer} data + */ + writeBytes(data) { + const bytes = data instanceof ArrayBuffer ? new Uint8Array(data) : data; + this.ensureCapacity(bytes.length); + new Uint8Array(this.buffer, this.offset, bytes.length).set(bytes); + this.offset += bytes.length; + } + + /** + * Seek to absolute position + * @param {number} offset + */ + seek(offset) { + this.ensureCapacity(offset - this.offset); + this.offset = offset; + } + + /** + * Get current position + * @returns {number} + */ + tell() { + return this.offset; + } + + /** + * Get the final buffer (trimmed to actual size) + * @returns {ArrayBuffer} + */ + toArrayBuffer() { + return this.buffer.slice(0, this.offset); + } + + /** + * Get the final buffer as Uint8Array + * @returns {Uint8Array} + */ + toUint8Array() { + return new Uint8Array(this.buffer, 0, this.offset); + } +} diff --git a/src/core/formats/PlayersParser.js b/src/core/formats/PlayersParser.js new file mode 100644 index 0000000..cc8b117 --- /dev/null +++ b/src/core/formats/PlayersParser.js @@ -0,0 +1,54 @@ +/** + * Parser for Players.gsi file - player profile names + */ +import { BinaryReader } from './BinaryReader.js'; +import { LetterIndex } from '../savegame/constants.js'; + +/** + * @typedef {Object} PlayerEntry + * @property {number[]} letters - Array of 7 letter indices + * @property {string} name - Decoded player name + */ + +/** + * Parser for Players.gsi file + */ +export class PlayersParser { + /** + * @param {ArrayBuffer} buffer - Raw file contents + */ + constructor(buffer) { + this.reader = new BinaryReader(buffer); + } + + /** + * Parse the Players.gsi file + * @returns {{ count: number, players: PlayerEntry[] }} + */ + parse() { + const count = this.reader.readS16(); + const players = []; + + for (let i = 0; i < count; i++) { + const letters = []; + for (let j = 0; j < 7; j++) { + letters.push(this.reader.readS16()); + } + + const name = LetterIndex.decode(letters); + players.push({ letters, name }); + } + + return { count, players }; + } +} + +/** + * Parse Players.gsi buffer and return player names + * @param {ArrayBuffer} buffer - Raw file contents + * @returns {{ count: number, players: PlayerEntry[] }} + */ +export function parsePlayers(buffer) { + const parser = new PlayersParser(buffer); + return parser.parse(); +} diff --git a/src/core/formats/PlayersSerializer.js b/src/core/formats/PlayersSerializer.js new file mode 100644 index 0000000..815d264 --- /dev/null +++ b/src/core/formats/PlayersSerializer.js @@ -0,0 +1,62 @@ +/** + * Serializer for Players.gsi file - updating player names + */ +import { BinaryWriter } from './BinaryWriter.js'; +import { LetterIndex } from '../savegame/constants.js'; + +/** + * Serializer for Players.gsi file + */ +export class PlayersSerializer { + /** + * @param {{ count: number, players: Array<{ letters: number[], name: string }> }} playersData + */ + constructor(playersData) { + this.data = playersData; + } + + /** + * Update a player's name at the given index + * @param {number} index - Player index + * @param {string} newName - New name (max 7 characters, A-Z only) + */ + updateName(index, newName) { + if (index < 0 || index >= this.data.players.length) { + throw new Error('Invalid player index'); + } + + // Encode the new name to letter indices + const letters = LetterIndex.encode(newName); + this.data.players[index].letters = letters; + this.data.players[index].name = LetterIndex.decode(letters); + } + + /** + * Serialize the players data to binary format + * @returns {ArrayBuffer} + */ + serialize() { + const writer = new BinaryWriter(256); + + // Write count + writer.writeS16(this.data.count); + + // Write each player entry (7 x S16 letters each = 14 bytes) + for (const player of this.data.players) { + for (const letter of player.letters) { + writer.writeS16(letter); + } + } + + return writer.toArrayBuffer(); + } +} + +/** + * Create a serializer for players data + * @param {{ count: number, players: Array<{ letters: number[], name: string }> }} playersData + * @returns {PlayersSerializer} + */ +export function createPlayersSerializer(playersData) { + return new PlayersSerializer(playersData); +} diff --git a/src/core/formats/SaveGameParser.js b/src/core/formats/SaveGameParser.js new file mode 100644 index 0000000..1934aa5 --- /dev/null +++ b/src/core/formats/SaveGameParser.js @@ -0,0 +1,396 @@ +/** + * Parser for G0-G9.GS save game files + */ +import { BinaryReader } from './BinaryReader.js'; +import { SAVEGAME_VERSION, GameStateTypes, GameStateSizes, Actor } from '../savegame/constants.js'; + +/** + * @typedef {Object} SaveGameHeader + * @property {number} version - File version (must be 0x1000c) + * @property {number} playerId - Player profile ID + * @property {number} currentAct - Current act (0-2) + * @property {number} actorId - Current character (1-5) + */ + +/** + * @typedef {Object} MissionScores + * @property {Object|null} pizza - Pizza delivery mission scores + * @property {Object|null} carRace - Car race mission scores + * @property {Object|null} jetskiRace - Jetski race mission scores + * @property {Object|null} towTrack - Tow track mission scores + * @property {Object|null} ambulance - Ambulance mission scores + */ + +/** + * @typedef {Object} GameStateLocation + * @property {string} name - State name + * @property {number} nameOffset - Offset of name length field + * @property {number} dataOffset - Offset of state data + * @property {number} dataSize - Size of state data + */ + +/** + * Parser for G0-G9.GS save game files + */ +export class SaveGameParser { + /** + * @param {ArrayBuffer} buffer - Raw file contents + */ + constructor(buffer) { + this.buffer = buffer; + this.reader = new BinaryReader(buffer); + this.parsed = { + header: null, + missions: null, + stateLocations: [], + stateCountOffset: null, + stateCount: 0, + statesEndOffset: null // Where to insert new states (before previous_area) + }; + } + + /** + * Parse the save file header (9 bytes) + * @returns {SaveGameHeader} + */ + parseHeader() { + this.reader.seek(0); + + const version = this.reader.readS32(); + if (version !== SAVEGAME_VERSION) { + throw new Error(`Invalid save file version: 0x${version.toString(16)} (expected 0x${SAVEGAME_VERSION.toString(16)})`); + } + + const playerId = this.reader.readS16(); + const currentAct = this.reader.readU16(); + const actorId = this.reader.readU8(); + + this.parsed.header = { version, playerId, currentAct, actorId }; + return this.parsed.header; + } + + /** + * Skip over the variables section + * Must be called after parseHeader() + */ + skipVariables() { + while (true) { + const nameLength = this.reader.readU8(); + const name = this.reader.readString(nameLength); + + if (name === 'END_OF_VARIABLES') { + break; + } + + const valueLength = this.reader.readU8(); + this.reader.skip(valueLength); + } + } + + /** + * Skip character manager data (66 characters * 16 bytes = 1056 bytes) + */ + skipCharacters() { + this.reader.skip(66 * 16); + } + + /** + * Skip plant manager data (81 plants * 12 bytes = 972 bytes) + */ + skipPlants() { + this.reader.skip(81 * 12); + } + + /** + * Skip building manager data (16 buildings * 10 bytes = 160 bytes + 1 byte variant) + */ + skipBuildings() { + this.reader.skip(16 * 10 + 1); + } + + /** + * Parse game states to extract mission scores + * Records state locations for later patching + * @returns {MissionScores} + */ + parseGameStates() { + this.parsed.stateCountOffset = this.reader.tell(); + const stateCount = this.reader.readS16(); + this.parsed.stateCount = stateCount; + const missions = { + pizza: null, + carRace: null, + jetskiRace: null, + towTrack: null, + ambulance: null + }; + + for (let i = 0; i < stateCount; i++) { + const nameOffset = this.reader.tell(); + const nameLength = this.reader.readS16(); + const name = this.reader.readString(nameLength); + const dataOffset = this.reader.tell(); + + // Record location for all states + let dataSize = 0; + + switch (name) { + case GameStateTypes.PIZZA_MISSION: + missions.pizza = this.parsePizzaMissionState(); + dataSize = 40; + break; + + case GameStateTypes.CAR_RACE: + missions.carRace = this.parseRaceState(); + dataSize = 25; + break; + + case GameStateTypes.JETSKI_RACE: + missions.jetskiRace = this.parseRaceState(); + dataSize = 25; + break; + + case GameStateTypes.TOW_TRACK: + missions.towTrack = this.parseScoreMissionState(); + dataSize = 20; + break; + + case GameStateTypes.AMBULANCE: + missions.ambulance = this.parseScoreMissionState(); + dataSize = 20; + break; + + default: + // Skip other state types + dataSize = this.skipGameStateData(name); + break; + } + + this.parsed.stateLocations.push({ + name, + nameOffset, + dataOffset, + dataSize + }); + } + + // Record where states end (before previous_area field) + this.parsed.statesEndOffset = this.reader.tell(); + + this.parsed.missions = missions; + return missions; + } + + /** + * Parse pizza mission state (40 bytes - 5 actors * 8 bytes each) + * Each entry: unk(2) + counter(2) + score(2) + hiScore(2) + * @returns {Object} + */ + parsePizzaMissionState() { + const result = { + scores: {}, + highScores: {} + }; + + for (let actor = Actor.PEPPER; actor <= Actor.LAURA; actor++) { + this.reader.skip(2); // unk0x06 + this.reader.skip(2); // counter + result.scores[actor] = this.reader.readS16(); + result.highScores[actor] = this.reader.readS16(); + } + + return result; + } + + /** + * Parse score mission state (tow track, ambulance - 20 bytes) + * 5 scores followed by 5 high scores, all S16 + * @returns {Object} + */ + parseScoreMissionState() { + const result = { + scores: {}, + highScores: {} + }; + + // Read 5 scores + for (let actor = Actor.PEPPER; actor <= Actor.LAURA; actor++) { + result.scores[actor] = this.reader.readS16(); + } + + // Read 5 high scores + for (let actor = Actor.PEPPER; actor <= Actor.LAURA; actor++) { + result.highScores[actor] = this.reader.readS16(); + } + + return result; + } + + /** + * Parse race state (jetski, car - 25 bytes) + * 5 entries of 5 bytes each: id(1) + lastScore(2) + highScore(2) + * @returns {Object} + */ + parseRaceState() { + const result = { + scores: {}, + highScores: {} + }; + + for (let i = 0; i < 5; i++) { + const actorId = this.reader.readU8(); + const score = this.reader.readS16(); + const highScore = this.reader.readS16(); + + result.scores[actorId] = score; + result.highScores[actorId] = highScore; + } + + return result; + } + + /** + * Skip game state data based on state name + * @param {string} name - State name + * @returns {number} - Number of bytes skipped + */ + skipGameStateData(name) { + // Check fixed-size states first + const fixedSize = GameStateSizes[name]; + if (fixedSize) { + this.reader.skip(fixedSize); + return fixedSize; + } + + // Variable-length states + if (name === 'AnimState') { + return this.skipAnimState(); + } + + if (name === 'Act1State') { + return this.skipAct1State(); + } + + // Unknown state - this shouldn't happen with valid save files + console.warn(`Unknown game state type: ${name}`); + return 0; + } + + /** + * Skip AnimState (variable length) + * @returns {number} - Number of bytes skipped + */ + skipAnimState() { + const startOffset = this.reader.tell(); + + this.reader.skip(4); // extra_character_id + const animCount = this.reader.readU32(); + this.reader.skip(animCount * 2); // anim_indices (U16 each) + const locationFlagsCount = this.reader.readU32(); + this.reader.skip(locationFlagsCount); // location_flags (U8 each) + + return this.reader.tell() - startOffset; + } + + /** + * Skip Act1State (variable length with conditional textures) + * @returns {number} - Number of bytes skipped + */ + skipAct1State() { + const startOffset = this.reader.tell(); + + // Read 7 named planes + const planeNameLengths = []; + for (let i = 0; i < 7; i++) { + const nameLength = this.reader.readS16(); + planeNameLengths.push(nameLength); + if (nameLength > 0) { + this.reader.skip(nameLength); // name + } + this.reader.skip(36); // position(12) + direction(12) + up(12) + } + + // Conditional textures based on which planes have names + const helicopterHasName = planeNameLengths[3] > 0; + const jetskiHasName = planeNameLengths[4] > 0; + const dunebuggyHasName = planeNameLengths[5] > 0; + const racecarHasName = planeNameLengths[6] > 0; + + if (helicopterHasName) { + for (let i = 0; i < 3; i++) { + this.skipAct1Texture(); + } + } + + if (jetskiHasName) { + for (let i = 0; i < 2; i++) { + this.skipAct1Texture(); + } + } + + if (dunebuggyHasName) { + this.skipAct1Texture(); + } + + if (racecarHasName) { + for (let i = 0; i < 3; i++) { + this.skipAct1Texture(); + } + } + + // Final fields + this.reader.skip(2); // cpt_click_dialogue_next_index (S16) + this.reader.skip(1); // played_exit_explanation (U8) + + return this.reader.tell() - startOffset; + } + + /** + * Skip a single Act1 texture + */ + skipAct1Texture() { + const nameLength = this.reader.readS16(); + if (nameLength > 0) { + this.reader.skip(nameLength); // name + } + const width = this.reader.readU32(); + const height = this.reader.readU32(); + const paletteCount = this.reader.readU32(); + this.reader.skip(paletteCount * 3); // palette (RGB triplets) + this.reader.skip(width * height); // bitmap data + } + + /** + * Get location of a specific game state + * @param {string} stateName - State name to find + * @returns {GameStateLocation|null} + */ + getStateLocation(stateName) { + return this.parsed.stateLocations.find(loc => loc.name === stateName) || null; + } + + /** + * Full parse for the save editor (header + missions) + * @returns {{ header: SaveGameHeader, missions: MissionScores, stateLocations: GameStateLocation[] }} + */ + parse() { + this.parseHeader(); + this.skipVariables(); + this.skipCharacters(); + this.skipPlants(); + this.skipBuildings(); + this.parseGameStates(); + + return this.parsed; + } +} + +/** + * Parse a save game buffer + * @param {ArrayBuffer} buffer - Raw file contents + * @returns {{ header: SaveGameHeader, missions: MissionScores, stateLocations: GameStateLocation[] }} + */ +export function parseSaveGame(buffer) { + const parser = new SaveGameParser(buffer); + return parser.parse(); +} diff --git a/src/core/formats/SaveGameSerializer.js b/src/core/formats/SaveGameSerializer.js new file mode 100644 index 0000000..44639b1 --- /dev/null +++ b/src/core/formats/SaveGameSerializer.js @@ -0,0 +1,329 @@ +/** + * Serializer for modifying save game files + * Uses a "patch in place" approach - copies the original buffer and modifies specific bytes + */ +import { SaveGameParser } from './SaveGameParser.js'; +import { GameStateTypes, GameStateSizes, Actor } from '../savegame/constants.js'; + +/** + * Offsets for header fields + */ +const HEADER_OFFSETS = { + VERSION: 0, // S32, 4 bytes + PLAYER_ID: 4, // S16, 2 bytes + CURRENT_ACT: 6, // U16, 2 bytes + ACTOR_ID: 8 // U8, 1 byte +}; + +/** + * Map mission type to state name + */ +const MISSION_STATE_MAP = { + pizza: GameStateTypes.PIZZA_MISSION, + carRace: GameStateTypes.CAR_RACE, + jetskiRace: GameStateTypes.JETSKI_RACE, + towTrack: GameStateTypes.TOW_TRACK, + ambulance: GameStateTypes.AMBULANCE +}; + +/** + * Serializer for modifying save game files + */ +export class SaveGameSerializer { + /** + * @param {ArrayBuffer} originalBuffer - Original file data + */ + constructor(originalBuffer) { + this.original = originalBuffer; + // Parse to find state locations + this.parser = new SaveGameParser(originalBuffer); + this.parsed = this.parser.parse(); + } + + /** + * Create a copy of the original buffer for modification + * @returns {ArrayBuffer} + */ + createCopy() { + return this.original.slice(0); + } + + /** + * Update header fields (act and actor) + * @param {Object} updates - Fields to update + * @param {number} [updates.currentAct] - New act (0-2) + * @param {number} [updates.actorId] - New actor ID (1-5) + * @returns {ArrayBuffer} - Modified buffer + */ + updateHeader(updates) { + const copy = this.createCopy(); + const view = new DataView(copy); + + if ('currentAct' in updates && updates.currentAct !== undefined) { + view.setUint16(HEADER_OFFSETS.CURRENT_ACT, updates.currentAct, true); + } + + if ('actorId' in updates && updates.actorId !== undefined) { + view.setUint8(HEADER_OFFSETS.ACTOR_ID, updates.actorId); + } + + return copy; + } + + /** + * Create default state data for a mission type + * @param {string} stateName - State name (e.g., 'CarRaceState') + * @returns {Uint8Array} - State data with default values (all zeros) + */ + createDefaultStateData(stateName) { + const size = GameStateSizes[stateName]; + if (!size) { + throw new Error(`Unknown state size for: ${stateName}`); + } + + const data = new Uint8Array(size); + + // For race states, we need to set the actor IDs + if (stateName === GameStateTypes.CAR_RACE || stateName === GameStateTypes.JETSKI_RACE) { + // 5 entries of 5 bytes: id(1) + score(2) + hiScore(2) + for (let i = 0; i < 5; i++) { + data[i * 5] = Actor.PEPPER + i; // Set actor ID + } + } + + return data; + } + + /** + * Add a missing state to the save file + * @param {ArrayBuffer} buffer - Current buffer + * @param {string} stateName - State name to add + * @returns {ArrayBuffer} - New buffer with state added + */ + addMissingState(buffer, stateName) { + const stateData = this.createDefaultStateData(stateName); + const nameBytes = new TextEncoder().encode(stateName); + + // Calculate new state size: name length (2) + name + data + const stateSize = 2 + nameBytes.length + stateData.length; + + // Insert position is where states end (before previous_area field) + const insertOffset = this.parsed.statesEndOffset; + + // Create new buffer with space for the new state + const newBuffer = new ArrayBuffer(buffer.byteLength + stateSize); + const newView = new DataView(newBuffer); + const newArray = new Uint8Array(newBuffer); + const oldArray = new Uint8Array(buffer); + + // Copy everything up to insert point + newArray.set(oldArray.slice(0, insertOffset)); + + // Write new state at insert point + let offset = insertOffset; + + // Write name length (S16) + newView.setInt16(offset, nameBytes.length, true); + offset += 2; + + // Write name + newArray.set(nameBytes, offset); + offset += nameBytes.length; + + // Write state data + newArray.set(stateData, offset); + offset += stateData.length; + + // Copy the rest of the original buffer (previous_area field) + newArray.set(oldArray.slice(insertOffset), offset); + + // Increment state count + const stateCountOffset = this.parsed.stateCountOffset; + const oldCount = new DataView(buffer).getInt16(stateCountOffset, true); + newView.setInt16(stateCountOffset, oldCount + 1, true); + + // Update parsed data to include the new state + const dataOffset = insertOffset + 2 + nameBytes.length; + this.parsed.stateLocations.push({ + name: stateName, + nameOffset: insertOffset, + dataOffset: dataOffset, + dataSize: stateData.length + }); + this.parsed.stateCount++; + this.parsed.statesEndOffset = insertOffset + stateSize; + + // Update original reference for subsequent operations + this.original = newBuffer; + + return newBuffer; + } + + /** + * Ensure a mission state exists in the buffer, adding it if missing + * @param {ArrayBuffer} buffer - Current buffer + * @param {string} missionType - Mission type + * @returns {ArrayBuffer} - Buffer with state present + */ + ensureMissionState(buffer, missionType) { + const stateName = MISSION_STATE_MAP[missionType]; + if (!stateName) { + throw new Error(`Unknown mission type: ${missionType}`); + } + + const stateLocation = this.parsed.stateLocations.find(loc => loc.name === stateName); + if (stateLocation) { + return buffer; // State already exists + } + + return this.addMissingState(buffer, stateName); + } + + /** + * Update mission scores in the save file + * @param {string} missionType - Mission type (pizza, carRace, jetskiRace, towTrack, ambulance) + * @param {number} actorId - Actor ID (1-5) + * @param {'score'|'highScore'} scoreType - Which score to update + * @param {number} value - New score color value (0-3) + * @param {ArrayBuffer} [buffer] - Optional buffer to use (for chaining operations) + * @returns {ArrayBuffer} - Modified buffer + */ + updateMissionScore(missionType, actorId, scoreType, value, buffer = null) { + const stateName = MISSION_STATE_MAP[missionType]; + if (!stateName) { + console.error(`Unknown mission type: ${missionType}`); + return null; + } + + // Use provided buffer or create a copy + let workingBuffer = buffer || this.createCopy(); + + // Ensure the state exists + workingBuffer = this.ensureMissionState(workingBuffer, missionType); + + const stateLocation = this.parsed.stateLocations.find(loc => loc.name === stateName); + if (!stateLocation) { + console.error(`Failed to find or create state: ${stateName}`); + return null; + } + + const view = new DataView(workingBuffer); + + // Calculate offset based on mission type + let offset; + + if (missionType === 'pizza') { + // Pizza: 5 actors * 8 bytes (unk(2) + counter(2) + score(2) + hiScore(2)) + const actorIndex = actorId - Actor.PEPPER; // 0-4 + const entryOffset = stateLocation.dataOffset + (actorIndex * 8); + if (scoreType === 'score') { + offset = entryOffset + 4; // Skip unk + counter + } else { + offset = entryOffset + 6; // Skip unk + counter + score + } + } else if (missionType === 'carRace' || missionType === 'jetskiRace') { + // Race: 5 actors * 5 bytes (id(1) + lastScore(2) + highScore(2)) + const actorIndex = actorId - Actor.PEPPER; + const entryOffset = stateLocation.dataOffset + (actorIndex * 5); + if (scoreType === 'score') { + offset = entryOffset + 1; // Skip id + } else { + offset = entryOffset + 3; // Skip id + lastScore + } + } else if (missionType === 'towTrack' || missionType === 'ambulance') { + // Score mission: 5 scores then 5 high scores (all S16) + const actorIndex = actorId - Actor.PEPPER; + if (scoreType === 'score') { + offset = stateLocation.dataOffset + (actorIndex * 2); + } else { + offset = stateLocation.dataOffset + 10 + (actorIndex * 2); // Skip 5 scores + } + } + + if (offset !== undefined) { + view.setInt16(offset, value, true); + } + + return workingBuffer; + } + + /** + * Apply multiple updates at once + * @param {Object} updates - Updates to apply + * @param {Object} [updates.header] - Header updates + * @param {Array} [updates.missions] - Mission score updates + * @returns {ArrayBuffer} - Modified buffer + */ + applyUpdates(updates) { + let buffer = this.original; + + // Apply header updates first + if (updates.header) { + const view = new DataView(buffer = buffer.slice(0)); + + if ('currentAct' in updates.header) { + view.setUint16(HEADER_OFFSETS.CURRENT_ACT, updates.header.currentAct, true); + } + if ('actorId' in updates.header) { + view.setUint8(HEADER_OFFSETS.ACTOR_ID, updates.header.actorId); + } + } + + // Apply mission updates + if (updates.missions && updates.missions.length > 0) { + for (const mission of updates.missions) { + buffer = this.updateMissionScore( + mission.missionType, + mission.actorId, + mission.scoreType, + mission.value, + buffer + ); + } + } + + return buffer; + } + + /** + * Get the byte offset for a mission score + * @param {string} missionType + * @param {number} actorId + * @param {'score'|'highScore'} scoreType + * @returns {number|null} + */ + getMissionScoreOffset(missionType, actorId, scoreType) { + const stateName = MISSION_STATE_MAP[missionType]; + if (!stateName) return null; + + const stateLocation = this.parsed.stateLocations.find(loc => loc.name === stateName); + if (!stateLocation) return null; + + const actorIndex = actorId - Actor.PEPPER; + + if (missionType === 'pizza') { + const entryOffset = stateLocation.dataOffset + (actorIndex * 8); + return scoreType === 'score' ? entryOffset + 4 : entryOffset + 6; + } else if (missionType === 'carRace' || missionType === 'jetskiRace') { + const entryOffset = stateLocation.dataOffset + (actorIndex * 5); + return scoreType === 'score' ? entryOffset + 1 : entryOffset + 3; + } else if (missionType === 'towTrack' || missionType === 'ambulance') { + if (scoreType === 'score') { + return stateLocation.dataOffset + (actorIndex * 2); + } else { + return stateLocation.dataOffset + 10 + (actorIndex * 2); + } + } + + return null; + } +} + +/** + * Create a serializer for a save game buffer + * @param {ArrayBuffer} buffer + * @returns {SaveGameSerializer} + */ +export function createSerializer(buffer) { + return new SaveGameSerializer(buffer); +} diff --git a/src/core/formats/WdbParser.js b/src/core/formats/WdbParser.js new file mode 100644 index 0000000..b5645b6 --- /dev/null +++ b/src/core/formats/WdbParser.js @@ -0,0 +1,439 @@ +import { BinaryReader } from './BinaryReader.js'; + +/** + * Parser for LEGO Island WORLD.WDB files + * Based on wdb.ksy specification and source code analysis + */ +export class WdbParser { + constructor(buffer) { + this.reader = new BinaryReader(buffer); + this.buffer = buffer; + } + + /** + * Parse the WDB file structure + * @returns {{ worlds: Array, globalTexturesSize: number, globalPartsSize: number }} + */ + parse() { + const numWorlds = this.reader.readS32(); + const worlds = []; + + for (let i = 0; i < numWorlds; i++) { + worlds.push(this.parseWorldEntry()); + } + + const globalTexturesSize = this.reader.readU32(); + // Skip global textures for now - BIGCUBE.GIF is in model_data + this.reader.skip(globalTexturesSize); + + const globalPartsSize = this.reader.readU32(); + // Skip global parts + this.reader.skip(globalPartsSize); + + return { worlds, globalTexturesSize, globalPartsSize }; + } + + parseWorldEntry() { + const nameLen = this.reader.readS32(); + const name = this.reader.readString(nameLen).replace(/\0/g, ''); + + // Parse parts (skip for now) + const numParts = this.reader.readS32(); + for (let i = 0; i < numParts; i++) { + this.skipPartReference(); + } + + // Parse models + const numModels = this.reader.readS32(); + const models = []; + for (let i = 0; i < numModels; i++) { + models.push(this.parseModelEntry()); + } + + return { name, numParts, models }; + } + + skipPartReference() { + const nameLen = this.reader.readU32(); + this.reader.skip(nameLen); // name + this.reader.skip(4); // data_length + this.reader.skip(4); // data_offset + } + + parseModelEntry() { + const nameLen = this.reader.readU32(); + const name = this.reader.readString(nameLen).replace(/\0/g, ''); + const dataLength = this.reader.readU32(); + const dataOffset = this.reader.readU32(); + const presenterLen = this.reader.readU32(); + const presenter = this.reader.readString(presenterLen).replace(/\0/g, ''); + const location = this.readVertex3(); + const direction = this.readVertex3(); + const up = this.readVertex3(); + const visible = this.reader.readU8(); + + return { name, dataLength, dataOffset, presenter, location, direction, up, visible }; + } + + readVertex3() { + return { + x: this.reader.readF32(), + y: this.reader.readF32(), + z: this.reader.readF32() + }; + } + + /** + * Read string and strip null terminators + */ + readCleanString(length) { + return this.reader.readString(length).replace(/\0/g, ''); + } + + /** + * Parse model_data blob at specified offset + * @param {number} offset - Absolute file offset + * @returns {{ version: number, anim: object, roi: object, textures: Array }} + */ + parseModelData(offset) { + this.reader.seek(offset); + + const version = this.reader.readU32(); + if (version !== 19) { + throw new Error(`Unexpected model version: ${version}, expected 19`); + } + + const textureInfoOffset = this.reader.readU32(); + const numRois = this.reader.readU32(); + + // Parse animation data + const anim = this.parseModelAnim(); + + // Parse ROI hierarchy + const roi = this.parseRoi(); + + // Parse textures at textureInfoOffset + this.reader.seek(offset + textureInfoOffset); + const textures = this.parseTextureInfo(); + + return { version, anim, roi, textures }; + } + + parseModelAnim() { + const numActors = this.reader.readU32(); + const actors = []; + + for (let i = 0; i < numActors; i++) { + const nameLen = this.reader.readU32(); + if (nameLen > 0) { + const name = this.readCleanString(nameLen); + const actorType = this.reader.readU32(); + actors.push({ name, actorType }); + } + } + + const duration = this.reader.readS32(); + const rootNode = this.parseAnimTreeNode(); + + return { actors, duration, rootNode }; + } + + parseAnimTreeNode() { + const data = this.parseAnimNodeData(); + const numChildren = this.reader.readU32(); + const children = []; + + for (let i = 0; i < numChildren; i++) { + children.push(this.parseAnimTreeNode()); + } + + return { data, children }; + } + + parseAnimNodeData() { + const nameLen = this.reader.readU32(); + const name = nameLen > 0 ? this.readCleanString(nameLen) : ''; + + // Translation keys + const numTranslationKeys = this.reader.readU16(); + const translationKeys = []; + for (let i = 0; i < numTranslationKeys; i++) { + translationKeys.push(this.parseTranslationKey()); + } + + // Rotation keys + const numRotationKeys = this.reader.readU16(); + const rotationKeys = []; + for (let i = 0; i < numRotationKeys; i++) { + rotationKeys.push(this.parseRotationKey()); + } + + // Scale keys + const numScaleKeys = this.reader.readU16(); + const scaleKeys = []; + for (let i = 0; i < numScaleKeys; i++) { + scaleKeys.push(this.parseScaleKey()); + } + + // Morph keys + const numMorphKeys = this.reader.readU16(); + const morphKeys = []; + for (let i = 0; i < numMorphKeys; i++) { + morphKeys.push(this.parseMorphKey()); + } + + return { name, translationKeys, rotationKeys, scaleKeys, morphKeys }; + } + + parseAnimKey() { + const timeAndFlags = this.reader.readS32(); + const time = timeAndFlags & 0xFFFFFF; + const flags = (timeAndFlags >> 24) & 0xFF; + return { time, flags }; + } + + parseTranslationKey() { + const key = this.parseAnimKey(); + const x = this.reader.readF32(); + const y = this.reader.readF32(); + const z = this.reader.readF32(); + return { ...key, x, y, z }; + } + + parseRotationKey() { + const key = this.parseAnimKey(); + const angle = this.reader.readF32(); // w component + const x = this.reader.readF32(); + const y = this.reader.readF32(); + const z = this.reader.readF32(); + return { ...key, angle, x, y, z }; + } + + parseScaleKey() { + const key = this.parseAnimKey(); + const x = this.reader.readF32(); + const y = this.reader.readF32(); + const z = this.reader.readF32(); + return { ...key, x, y, z }; + } + + parseMorphKey() { + const key = this.parseAnimKey(); + const visible = this.reader.readU8(); + return { ...key, visible }; + } + + parseRoi() { + const nameLen = this.reader.readU32(); + const name = this.reader.readString(nameLen).replace(/\0/g, ''); + + // Bounding sphere + const boundingSphere = { + center: this.readVertex3(), + radius: this.reader.readF32() + }; + + // Bounding box + const boundingBox = { + min: this.readVertex3(), + max: this.readVertex3() + }; + + // Texture name (for color/material reference) + const textureNameLen = this.reader.readU32(); + const textureName = textureNameLen > 0 ? this.readCleanString(textureNameLen) : null; + + // Shared LOD list flag + const sharedLodList = this.reader.readU8(); + + let lods = []; + if (sharedLodList === 0) { + const numLods = this.reader.readU32(); + if (numLods > 0) { + const nextRoiOffset = this.reader.readU32(); + for (let i = 0; i < numLods; i++) { + lods.push(this.parseLod()); + } + } + } + + // Children + const numChildren = this.reader.readU32(); + const children = []; + for (let i = 0; i < numChildren; i++) { + children.push(this.parseRoi()); + } + + return { name, boundingSphere, boundingBox, textureName, lods, children }; + } + + parseLod() { + const flags = this.reader.readU32(); + const numMeshes = this.reader.readU32(); + + if (numMeshes === 0) { + return { flags, numMeshes, vertices: [], normals: [], textureVertices: [], meshes: [] }; + } + + // Packed vertex/normal counts + const vertexNormalCounts = this.reader.readU32(); + const vertexCount = vertexNormalCounts & 0xFFFF; + const normalCount = (vertexNormalCounts >> 17) & 0x7FFF; + + const numTextureVertices = this.reader.readS32(); + + // Read vertices + const vertices = []; + for (let i = 0; i < vertexCount; i++) { + vertices.push(this.readVertex3()); + } + + // Read normals + const normals = []; + for (let i = 0; i < normalCount; i++) { + normals.push(this.readVertex3()); + } + + // Read texture vertices (UVs) + const textureVertices = []; + for (let i = 0; i < numTextureVertices; i++) { + textureVertices.push({ + u: this.reader.readF32(), + v: this.reader.readF32() + }); + } + + // Read meshes + const meshes = []; + for (let i = 0; i < numMeshes; i++) { + meshes.push(this.parseMesh()); + } + + return { flags, numMeshes, vertexCount, normalCount, vertices, normals, textureVertices, meshes }; + } + + parseMesh() { + const numPolygons = this.reader.readU16(); + const numVertices = this.reader.readU16(); + + // Polygon indices (vertex/normal pairs) + const polygonIndices = []; + for (let i = 0; i < numPolygons; i++) { + polygonIndices.push({ + a: this.reader.readU32(), + b: this.reader.readU32(), + c: this.reader.readU32() + }); + } + + // Texture indices + const numTextureIndices = this.reader.readU32(); + const textureIndices = []; + if (numTextureIndices > 0) { + for (let i = 0; i < numPolygons; i++) { + textureIndices.push({ + a: this.reader.readU32(), + b: this.reader.readU32(), + c: this.reader.readU32() + }); + } + } + + // Mesh properties + const properties = this.parseMeshProperties(); + + return { numPolygons, numVertices, polygonIndices, textureIndices, properties }; + } + + parseMeshProperties() { + const color = { + r: this.reader.readU8(), + g: this.reader.readU8(), + b: this.reader.readU8() + }; + const alpha = this.reader.readF32(); + const shading = this.reader.readU8(); + const unknown0x0d = this.reader.readU8(); + const unknown0x20 = this.reader.readU8(); + const useAlias = this.reader.readU8(); + + const textureNameLen = this.reader.readU32(); + const textureName = textureNameLen > 0 ? this.readCleanString(textureNameLen) : null; + + const materialNameLen = this.reader.readU32(); + const materialName = materialNameLen > 0 ? this.readCleanString(materialNameLen) : null; + + return { color, alpha, shading, useAlias, textureName, materialName }; + } + + parseTextureInfo() { + const numTextures = this.reader.readU32(); + const skipTextures = this.reader.readU32(); + const textures = []; + + for (let i = 0; i < numTextures; i++) { + const nameLen = this.reader.readU32(); + let name = this.readCleanString(nameLen).toLowerCase(); + + // Handle '^' prefix (hi-res/lo-res pair) + let hasHighRes = false; + if (name.startsWith('^')) { + name = name.substring(1); + hasHighRes = true; + // Read hi-res texture + const hiRes = this.parseLegoImage(); + // Skip lo-res texture + this.skipLegoImage(); + textures.push({ name, ...hiRes }); + } else { + textures.push({ name, ...this.parseLegoImage() }); + } + } + + return textures; + } + + parseLegoImage() { + const width = this.reader.readU32(); + const height = this.reader.readU32(); + const paletteSize = this.reader.readU32(); + + const palette = []; + for (let i = 0; i < paletteSize; i++) { + palette.push({ + r: this.reader.readU8(), + g: this.reader.readU8(), + b: this.reader.readU8() + }); + } + + const pixels = new Uint8Array(this.reader.slice(width * height)); + + return { width, height, paletteSize, palette, pixels }; + } + + skipLegoImage() { + const width = this.reader.readU32(); + const height = this.reader.readU32(); + const paletteSize = this.reader.readU32(); + this.reader.skip(paletteSize * 3); // palette + this.reader.skip(width * height); // pixels + } +} + +/** + * Helper to find an ROI by name in a hierarchy + * @param {object} roi - Root ROI + * @param {string} name - Name to find (case-insensitive) + * @returns {object|null} + */ +export function findRoi(roi, name) { + if (roi.name.toLowerCase() === name.toLowerCase()) { + return roi; + } + for (const child of roi.children || []) { + const found = findRoi(child, name); + if (found) return found; + } + return null; +} diff --git a/src/core/formats/index.js b/src/core/formats/index.js new file mode 100644 index 0000000..96ea9e3 --- /dev/null +++ b/src/core/formats/index.js @@ -0,0 +1,18 @@ +/** + * File Format Parsers and Serializers + */ + +// Binary utilities +export { BinaryReader } from './BinaryReader.js'; +export { BinaryWriter } from './BinaryWriter.js'; + +// WDB format +export { WdbParser, findRoi } from './WdbParser.js'; + +// Save game format +export { SaveGameParser, parseSaveGame } from './SaveGameParser.js'; +export { SaveGameSerializer, createSerializer } from './SaveGameSerializer.js'; + +// Players format +export { PlayersParser, parsePlayers } from './PlayersParser.js'; +export { PlayersSerializer, createPlayersSerializer } from './PlayersSerializer.js'; diff --git a/src/core/opfs.js b/src/core/opfs.js index 0938133..b3d3979 100644 --- a/src/core/opfs.js +++ b/src/core/opfs.js @@ -1,21 +1,188 @@ // OPFS Config Manager - handles saving/loading configuration via Origin Private File System -import { configToastVisible } from '../stores.js'; +import { configToastVisible, configToastMessage } from '../stores.js'; const CONFIG_FILE = 'isle.ini'; let toastTimeout = null; -export async function getFileHandle() { +// ============================================================================ +// Core OPFS Operations +// ============================================================================ + +/** + * Get OPFS root directory + * @returns {Promise} + */ +export async function getOpfsRoot() { try { - const root = await navigator.storage.getDirectory(); - return await root.getFileHandle(CONFIG_FILE, { create: true }); + return await navigator.storage.getDirectory(); } catch (e) { console.error("OPFS not available or permission denied.", e); return null; } } +/** + * Get a file handle from OPFS + * @param {string} filename - Name of the file + * @param {boolean} create - Whether to create the file if it doesn't exist + * @returns {Promise} + */ +export async function getFileHandle(filename = CONFIG_FILE, create = true) { + try { + const root = await getOpfsRoot(); + if (!root) return null; + return await root.getFileHandle(filename, { create }); + } catch (e) { + if (e.name === 'NotFoundError') return null; + console.error("Failed to get file handle:", e); + return null; + } +} + +/** + * Check if a file exists in OPFS + * @param {string} filename - Name of the file + * @returns {Promise} + */ +export async function fileExists(filename) { + const handle = await getFileHandle(filename, false); + return handle !== null; +} + +/** + * Read a binary file from OPFS + * @param {string} filename - Name of the file + * @returns {Promise} - File contents or null if not found + */ +export async function readBinaryFile(filename) { + try { + const handle = await getFileHandle(filename, false); + if (!handle) return null; + + const file = await handle.getFile(); + return await file.arrayBuffer(); + } catch (e) { + console.error('Failed to read binary file:', e); + return null; + } +} + +/** + * Write a binary file to OPFS using Web Worker pattern (Safari-compatible) + * @param {string} filename - Name of the file + * @param {ArrayBuffer|Uint8Array} data - Binary data to write + * @param {boolean} silent - If true, don't show toast notification + * @param {string} toastMsg - Custom toast message (default: 'Settings saved') + * @returns {Promise} - True if successful + */ +export async function writeBinaryFile(filename, data, silent = false, toastMsg = 'Settings saved') { + const workerCode = ` + self.onmessage = async (e) => { + try { + const root = await navigator.storage.getDirectory(); + const handle = await root.getFileHandle(e.data.filename, { create: true }); + const accessHandle = await handle.createSyncAccessHandle(); + const bytes = new Uint8Array(e.data.buffer); + + accessHandle.truncate(0); + accessHandle.write(bytes, { at: 0 }); + accessHandle.flush(); + accessHandle.close(); + + self.postMessage({ status: 'success', message: 'File saved: ' + e.data.filename }); + } catch (err) { + self.postMessage({ status: 'error', message: 'Failed to save file: ' + err.message }); + } + }; + `; + + const blob = new Blob([workerCode], { type: 'application/javascript' }); + const workerUrl = URL.createObjectURL(blob); + const worker = new Worker(workerUrl); + + return new Promise((resolve) => { + worker.postMessage({ filename, buffer: data }); + + worker.onmessage = (e) => { + console.log(e.data.message); + URL.revokeObjectURL(workerUrl); + worker.terminate(); + + if (e.data.status === 'success') { + if (!silent) { + showToast(toastMsg); + } + resolve(true); + } else { + resolve(false); + } + }; + + worker.onerror = (e) => { + console.error('An error occurred in the file-saving worker:', e.message); + URL.revokeObjectURL(workerUrl); + worker.terminate(); + resolve(false); + }; + }); +} + +/** + * Write a text file to OPFS + * @param {string} filename - Name of the file + * @param {string} content - Text content to write + * @param {boolean} silent - If true, don't show toast notification + * @param {string} toastMsg - Custom toast message + * @returns {Promise} - True if successful + */ +export async function writeTextFile(filename, content, silent = false, toastMsg = 'Settings saved') { + const encoder = new TextEncoder(); + const data = encoder.encode(content); + return writeBinaryFile(filename, data.buffer, silent, toastMsg); +} + +/** + * List all files in OPFS matching a pattern + * @param {RegExp} pattern - Regular expression to match filenames + * @returns {Promise} - Array of matching filenames + */ +export async function listFiles(pattern) { + try { + const root = await getOpfsRoot(); + if (!root) return []; + + const files = []; + for await (const entry of root.values()) { + if (entry.kind === 'file' && pattern.test(entry.name)) { + files.push(entry.name); + } + } + return files; + } catch (e) { + console.error('Failed to list files:', e); + return []; + } +} + +/** + * Show a toast notification + * @param {string} message - Message to display + */ +function showToast(message) { + if (toastTimeout) { + clearTimeout(toastTimeout); + } + configToastMessage.set(message); + configToastVisible.set(true); + toastTimeout = setTimeout(() => configToastVisible.set(false), 2000); +} + +// ============================================================================ +// Config File Operations +// ============================================================================ + export async function loadConfig(form) { - const handle = await getFileHandle(); + const handle = await getFileHandle(CONFIG_FILE, true); if (!handle) return null; try { @@ -142,56 +309,5 @@ export async function saveConfig(form, getSiFiles, silent = false) { iniContent += `directives=${directives.join(",\\\n")}\n`; } - // Use inline Web Worker for Safari compatibility - const workerCode = ` - self.onmessage = async (e) => { - if (e.data.action === 'save') { - try { - const root = await navigator.storage.getDirectory(); - const handle = await root.getFileHandle(e.data.filePath, { create: true }); - const accessHandle = await handle.createSyncAccessHandle(); - const encoder = new TextEncoder(); - const encodedData = encoder.encode(e.data.content); - - accessHandle.truncate(0); - accessHandle.write(encodedData, { at: 0 }); - accessHandle.flush(); - accessHandle.close(); - - self.postMessage({ status: 'success', message: 'Config saved to ' + e.data.filePath }); - } catch (err) { - self.postMessage({ status: 'error', message: 'Failed to save config: ' + err.message }); - } - } - }; - `; - - const blob = new Blob([workerCode], { type: 'application/javascript' }); - const workerUrl = URL.createObjectURL(blob); - const worker = new Worker(workerUrl); - - worker.postMessage({ - action: 'save', - content: iniContent, - filePath: CONFIG_FILE - }); - - worker.onmessage = (e) => { - console.log(e.data.message); - URL.revokeObjectURL(workerUrl); - worker.terminate(); - if (e.data.status === 'success' && !silent) { - if (toastTimeout) { - clearTimeout(toastTimeout); - } - configToastVisible.set(true); - toastTimeout = setTimeout(() => configToastVisible.set(false), 2000); - } - }; - - worker.onerror = (e) => { - console.error('An error occurred in the config-saving worker:', e.message); - URL.revokeObjectURL(workerUrl); - worker.terminate(); - }; + return writeTextFile(CONFIG_FILE, iniContent, silent); } diff --git a/src/core/rendering/ScoreCubeRenderer.js b/src/core/rendering/ScoreCubeRenderer.js new file mode 100644 index 0000000..93406d2 --- /dev/null +++ b/src/core/rendering/ScoreCubeRenderer.js @@ -0,0 +1,84 @@ +import { WdbModelRenderer } from './WdbModelRenderer.js'; + +/** + * Specialized renderer for the LEGO Island score cube + * Extends WdbModelRenderer with score-specific functionality + */ +export class ScoreCubeRenderer extends WdbModelRenderer { + // Score grid layout constants (from score.cpp) + static AREA_Y_OFFSETS = [0x2b, 0x57, 0x80, 0xab, 0xd6]; // per actor row + static AREA_HEIGHTS = [0x2a, 0x27, 0x29, 0x29, 0x2a]; + static AREA_X_OFFSETS = [0x2f, 0x56, 0x81, 0xaa, 0xd4]; // per activity column + static AREA_WIDTHS = [0x25, 0x29, 0x27, 0x28, 0x28]; + static COLOR_INDICES = [0x11, 0x0f, 0x08, 0x05]; // grey, yellow, blue, red + + /** + * Update score colors on texture + * Score layout on cube (left to right, top to bottom): + * - Activities (columns): carRace, jetskiRace, pizza, towTrack, ambulance (0-4) + * - Actors (rows): pepper, mama, papa, nick, laura (0-4) + * @param {Array>} scores - 2D array [actor][activity] with values 0-3 + */ + updateScores(scores) { + if (!this.textureCanvas || !this.baseImageData || !this.palette) return; + + const ctx = this.textureCanvas.getContext('2d'); + ctx.putImageData(this.baseImageData, 0, 0); + + for (let actor = 0; actor < 5; actor++) { + for (let activity = 0; activity < 5; activity++) { + const score = scores?.[actor]?.[activity] ?? 0; + const clampedScore = Math.max(0, Math.min(3, score)); + const colorIdx = ScoreCubeRenderer.COLOR_INDICES[clampedScore]; + const color = this.palette[colorIdx]; + + if (color) { + ctx.fillStyle = `rgb(${color.r}, ${color.g}, ${color.b})`; + ctx.fillRect( + ScoreCubeRenderer.AREA_X_OFFSETS[activity], + ScoreCubeRenderer.AREA_Y_OFFSETS[actor], + ScoreCubeRenderer.AREA_WIDTHS[activity], + ScoreCubeRenderer.AREA_HEIGHTS[actor] + ); + } + } + } + + if (this.texture) { + this.texture.needsUpdate = true; + } + } + + /** + * Raycast to find clicked score cell + * @param {MouseEvent} event - Click event + * @returns {{ actor: number, activity: number } | null} + */ + raycast(event) { + const hit = this.raycastUV(event); + if (!hit) return null; + return this.uvToScoreCell(hit.x, hit.y); + } + + /** + * Convert texture pixel coordinates to score cell + * @param {number} x - X coordinate (0-256) + * @param {number} y - Y coordinate (0-256) + * @returns {{ actor: number, activity: number } | null} + */ + uvToScoreCell(x, y) { + for (let activity = 0; activity < 5; activity++) { + for (let actor = 0; actor < 5; actor++) { + if ( + x >= ScoreCubeRenderer.AREA_X_OFFSETS[activity] && + x < ScoreCubeRenderer.AREA_X_OFFSETS[activity] + ScoreCubeRenderer.AREA_WIDTHS[activity] && + y >= ScoreCubeRenderer.AREA_Y_OFFSETS[actor] && + y < ScoreCubeRenderer.AREA_Y_OFFSETS[actor] + ScoreCubeRenderer.AREA_HEIGHTS[actor] + ) { + return { actor, activity }; + } + } + } + return null; + } +} diff --git a/src/core/rendering/WdbModelRenderer.js b/src/core/rendering/WdbModelRenderer.js new file mode 100644 index 0000000..675e3f6 --- /dev/null +++ b/src/core/rendering/WdbModelRenderer.js @@ -0,0 +1,303 @@ +import * as THREE from 'three'; + +/** + * Generic Three.js renderer for LEGO Island WDB models + * Handles D3DRM packed vertex format and paletted textures + */ +export class WdbModelRenderer { + constructor(canvas) { + this.canvas = canvas; + this.animating = false; + this.modelGroup = null; + this.texturedMesh = null; + this.texture = null; + this.textureCanvas = null; + this.baseImageData = null; + this.palette = null; + + this.scene = new THREE.Scene(); + + this.camera = new THREE.PerspectiveCamera(45, 1, 0.1, 100); + this.camera.position.set(0, 0.2, 7); + + this.renderer = new THREE.WebGLRenderer({ + canvas, + antialias: true, + alpha: true + }); + this.renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2)); + this.renderer.setClearColor(0x000000, 0); + + this.setupLighting(); + } + + /** + * Setup scene lighting - override to customize + */ + setupLighting() { + // Flat, even lighting similar to in-game + const ambient = new THREE.AmbientLight(0xffffff, 1.5); + this.scene.add(ambient); + + // Soft front light + const frontLight = new THREE.DirectionalLight(0xffffff, 0.3); + frontLight.position.set(0, 0, 5); + this.scene.add(frontLight); + } + + /** + * Load model geometry and texture from parsed WDB data + * @param {object} roiData - Parsed ROI data with lods + * @param {object} textureData - Parsed texture with palette and pixels + */ + loadModel(roiData, textureData) { + this.palette = textureData.palette; + this.modelGroup = new THREE.Group(); + + const { texturedGeometry, nonTexturedGeometries } = this.createGeometries(roiData); + + this.textureCanvas = this.createTextureCanvas(textureData); + this.texture = new THREE.CanvasTexture(this.textureCanvas); + this.texture.minFilter = THREE.LinearFilter; + this.texture.magFilter = THREE.LinearFilter; + + if (texturedGeometry) { + const texturedMaterial = new THREE.MeshStandardMaterial({ + map: this.texture, + side: THREE.DoubleSide, + roughness: 0.8, + metalness: 0.1 + }); + this.texturedMesh = new THREE.Mesh(texturedGeometry, texturedMaterial); + this.modelGroup.add(this.texturedMesh); + } + + for (const { geometry, color } of nonTexturedGeometries) { + const material = new THREE.MeshStandardMaterial({ + color: new THREE.Color(color.r / 255, color.g / 255, color.b / 255), + side: THREE.DoubleSide, + roughness: 0.8, + metalness: 0.1 + }); + const mesh = new THREE.Mesh(geometry, material); + this.modelGroup.add(mesh); + } + + this.scene.add(this.modelGroup); + this.renderer.render(this.scene, this.camera); + } + + /** + * Create Three.js BufferGeometries from ROI LOD data + * + * D3DRM packed polygon index format (32-bit): + * - Bits 0-15: vertex index (16 bits) into positions array, OR destination index when reusing + * - Bits 16-30: normal index into normals array + * - Bit 31: "create new vertex" flag - when set, create a new mesh vertex; + * when clear, bits 0-15 is the INDEX into the created mesh vertices array + * + * @param {object} roiData - ROI with lods array + * @returns {{ texturedGeometry: THREE.BufferGeometry|null, nonTexturedGeometries: Array }} + */ + createGeometries(roiData) { + if (!roiData.lods || roiData.lods.length === 0) { + console.warn('ROI has no LODs'); + return { texturedGeometry: null, nonTexturedGeometries: [] }; + } + + const lod = roiData.lods[0]; + let texturedGeometry = null; + const nonTexturedGeometries = []; + + for (const mesh of lod.meshes) { + const hasTexture = mesh.textureIndices && mesh.textureIndices.length > 0; + + // Flatten polygon indices + const vertexIndicesPacked = []; + for (const poly of mesh.polygonIndices) { + vertexIndicesPacked.push(poly.a, poly.b, poly.c); + } + + // Flatten texture indices if present + const textureIndicesFlat = []; + if (hasTexture) { + for (const texPoly of mesh.textureIndices) { + textureIndicesFlat.push(texPoly.a, texPoly.b, texPoly.c); + } + } + + // Build mesh vertices following brickolini-island logic + const meshVertices = []; + const meshNormals = []; + const meshUvs = []; + const indices = []; + + for (let i = 0; i < vertexIndicesPacked.length; i++) { + const packed = vertexIndicesPacked[i]; + + if ((packed & 0x80000000) !== 0) { + // Create flag is set - create new mesh vertex + indices.push(meshVertices.length); + + const gv = packed & 0xFFFF; // Vertex index (16 bits) + const v = lod.vertices[gv] || { x: 0, y: 0, z: 0 }; + // Negate X for coordinate system conversion + meshVertices.push([-v.x, v.y, v.z]); + + const gn = (packed >>> 16) & 0x7fff; // Normal index (15 bits) + const n = lod.normals[gn] || { x: 0, y: 1, z: 0 }; + meshNormals.push([-n.x, n.y, n.z]); + + if (hasTexture && lod.textureVertices.length > 0) { + const tex = textureIndicesFlat[i]; + const uv = lod.textureVertices[tex] || { u: 0, v: 0 }; + meshUvs.push([uv.u, 1 - uv.v]); + } + } else { + // Create flag NOT set - reuse existing mesh vertex by index + indices.push(packed & 0xFFFF); + } + } + + // Reverse face winding (swap indices 0 and 2 of each triangle) + for (let i = 0; i < indices.length; i += 3) { + const temp = indices[i]; + indices[i] = indices[i + 2]; + indices[i + 2] = temp; + } + + // Create geometry + const geometry = new THREE.BufferGeometry(); + const vertices = meshVertices.flat(); + const normals = meshNormals.flat(); + + geometry.setAttribute('position', new THREE.Float32BufferAttribute(vertices, 3)); + geometry.setAttribute('normal', new THREE.Float32BufferAttribute(normals, 3)); + geometry.setIndex(indices); + + if (hasTexture) { + const uvs = meshUvs.flat(); + geometry.setAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2)); + texturedGeometry = geometry; + } else { + const color = mesh.properties?.color || { r: 128, g: 128, b: 128 }; + nonTexturedGeometries.push({ geometry, color }); + } + } + + return { texturedGeometry, nonTexturedGeometries }; + } + + /** + * Create canvas texture from paletted LEGO texture data + * @param {object} textureData - { width, height, palette, pixels } + * @returns {HTMLCanvasElement} + */ + createTextureCanvas(textureData) { + const canvas = document.createElement('canvas'); + canvas.width = textureData.width; + canvas.height = textureData.height; + const ctx = canvas.getContext('2d'); + + const imageData = ctx.createImageData(textureData.width, textureData.height); + for (let i = 0; i < textureData.pixels.length; i++) { + const colorIdx = textureData.pixels[i]; + const color = textureData.palette[colorIdx] || { r: 0, g: 0, b: 0 }; + imageData.data[i * 4 + 0] = color.r; + imageData.data[i * 4 + 1] = color.g; + imageData.data[i * 4 + 2] = color.b; + imageData.data[i * 4 + 3] = 255; + } + ctx.putImageData(imageData, 0, 0); + + this.baseImageData = ctx.getImageData(0, 0, textureData.width, textureData.height); + return canvas; + } + + /** + * Raycast and return UV coordinates of hit on textured mesh + * @param {MouseEvent} event - Mouse event + * @returns {{ uv: THREE.Vector2, x: number, y: number } | null} + */ + raycastUV(event) { + if (!this.texturedMesh) return null; + + const rect = this.canvas.getBoundingClientRect(); + const mouse = new THREE.Vector2( + ((event.clientX - rect.left) / rect.width) * 2 - 1, + -((event.clientY - rect.top) / rect.height) * 2 + 1 + ); + + const raycaster = new THREE.Raycaster(); + raycaster.setFromCamera(mouse, this.camera); + const intersects = raycaster.intersectObject(this.texturedMesh); + + if (intersects.length > 0 && intersects[0].uv) { + const uv = intersects[0].uv; + const x = uv.x * this.textureCanvas.width; + const y = (1 - uv.y) * this.textureCanvas.height; + return { uv, x, y }; + } + return null; + } + + /** + * Start animation loop + */ + start() { + this.animating = true; + this.animate(); + } + + /** + * Stop animation loop + */ + stop() { + this.animating = false; + } + + /** + * Animation loop - override to customize animation + */ + animate = () => { + if (!this.animating) return; + requestAnimationFrame(this.animate); + + if (this.modelGroup) { + this.modelGroup.rotation.y += 0.008; + } + + this.renderer.render(this.scene, this.camera); + } + + /** + * Resize renderer to match canvas size + * @param {number} width + * @param {number} height + */ + resize(width, height) { + this.camera.aspect = width / height; + this.camera.updateProjectionMatrix(); + this.renderer.setSize(width, height, false); + } + + /** + * Clean up resources + */ + dispose() { + this.animating = false; + + if (this.modelGroup) { + this.modelGroup.traverse((child) => { + if (child instanceof THREE.Mesh) { + child.geometry?.dispose(); + child.material?.dispose(); + } + }); + this.scene.remove(this.modelGroup); + } + + this.texture?.dispose(); + this.renderer?.dispose(); + } +} diff --git a/src/core/savegame/constants.js b/src/core/savegame/constants.js new file mode 100644 index 0000000..ad93c43 --- /dev/null +++ b/src/core/savegame/constants.js @@ -0,0 +1,191 @@ +/** + * Constants and enums from KSY save file specifications + */ + +// Save game file version (must match for valid saves) +export const SAVEGAME_VERSION = 0x1000c; // 65548 + +// Actor enum - playable characters +export const Actor = Object.freeze({ + NONE: 0, + PEPPER: 1, + MAMA: 2, + PAPA: 3, + NICK: 4, + LAURA: 5 +}); + +// Actor display names +export const ActorNames = Object.freeze({ + 0: 'None', + 1: 'Pepper', + 2: 'Mama', + 3: 'Papa', + 4: 'Nick', + 5: 'Laura' +}); + +// Act enum +export const Act = Object.freeze({ + ACT1: 0, + ACT2: 1, + ACT3: 2 +}); + +// Score color enum - used for mission scores +export const ScoreColor = Object.freeze({ + GREY: 0, + YELLOW: 1, + BLUE: 2, + RED: 3 +}); + +// Score color to CSS color mapping +export const ScoreColorCSS = Object.freeze({ + 0: '#808080', // grey + 1: '#FFD700', // yellow (gold) + 2: '#4169E1', // blue (royal blue) + 3: '#DC143C' // red (crimson) +}); + +// Score color display names +export const ScoreColorNames = Object.freeze({ + 0: 'Grey', + 1: 'Yellow', + 2: 'Blue', + 3: 'Red' +}); + +// Mission types that have scores +export const MissionTypes = Object.freeze({ + PIZZA: 'pizza', + CAR_RACE: 'carRace', + JETSKI_RACE: 'jetskiRace', + TOW_TRACK: 'towTrack', + AMBULANCE: 'ambulance' +}); + +// Mission display names +export const MissionNames = Object.freeze({ + pizza: 'Pizza Delivery', + carRace: 'Car Race', + jetskiRace: 'Jetski Race', + towTrack: 'Tow Track', + ambulance: 'Ambulance' +}); + +// Game state type names for polymorphic parsing +export const GameStateTypes = Object.freeze({ + PIZZERIA: 'PizzeriaState', + PIZZA_MISSION: 'PizzaMissionState', + TOW_TRACK: 'TowTrackMissionState', + AMBULANCE: 'AmbulanceMissionState', + HOSPITAL: 'HospitalState', + GAS_STATION: 'GasStationState', + POLICE: 'PoliceState', + JETSKI_RACE: 'JetskiRaceState', + CAR_RACE: 'CarRaceState', + JETSKI_BUILD: 'LegoJetskiBuildState', + COPTER_BUILD: 'LegoCopterBuildState', + DUNE_CAR_BUILD: 'LegoDuneCarBuildState', + RACE_CAR_BUILD: 'LegoRaceCarBuildState', + ANIM: 'AnimState', + ACT1: 'Act1State' +}); + +// Fixed sizes for known game state types (for skipping) +export const GameStateSizes = Object.freeze({ + 'PizzeriaState': 10, + 'PizzaMissionState': 40, + 'TowTrackMissionState': 20, + 'AmbulanceMissionState': 20, + 'HospitalState': 12, + 'GasStationState': 10, + 'PoliceState': 4, + 'JetskiRaceState': 25, + 'CarRaceState': 25, + 'LegoJetskiBuildState': 4, + 'LegoCopterBuildState': 4, + 'LegoDuneCarBuildState': 4, + 'LegoRaceCarBuildState': 4 + // AnimState and Act1State are variable length +}); + +// Letter index utilities for username encoding/decoding +export const LetterIndex = { + /** + * Convert letter index to character + * @param {number} index - Letter index from save file + * @returns {string} - Character or empty string + */ + toChar(index) { + // Standard alphabet A-Z + if (index >= 0 && index <= 25) { + return String.fromCharCode(65 + index); // A = 65 in ASCII + } + // International characters (simplified) + if (index === 29) return 'A'; // Originally international chars + if (index === 30) return 'O'; + if (index === 31) return 'S'; + if (index === 32) return 'U'; + // Empty/unused position + if (index === -1 || index === 0xFFFF) return ''; + return '?'; + }, + + /** + * Convert character to letter index + * @param {string} char - Single character + * @returns {number} - Letter index or -1 for invalid/empty + */ + fromChar(char) { + if (!char) return -1; + const upper = char.toUpperCase(); + const code = upper.charCodeAt(0); + // A-Z + if (code >= 65 && code <= 90) { + return code - 65; + } + return -1; + }, + + /** + * Decode array of letter indices to string + * @param {number[]} letters - Array of 7 letter indices + * @returns {string} - Decoded player name + */ + decode(letters) { + return letters.map(l => this.toChar(l)).join('').trim(); + }, + + /** + * Encode string to array of 7 letter indices + * @param {string} name - Player name (max 7 chars) + * @returns {number[]} - Array of 7 letter indices + */ + encode(name) { + const letters = []; + const upper = name.toUpperCase().slice(0, 7); + for (let i = 0; i < 7; i++) { + if (i < upper.length) { + letters.push(this.fromChar(upper[i])); + } else { + letters.push(-1); // Empty position + } + } + return letters; + } +}; + +// Save file names +export const PLAYERS_FILE = 'Players.gsi'; +export const HISTORY_FILE = 'History.gsi'; + +/** + * Get save slot filename + * @param {number} slot - Slot number 0-9 + * @returns {string} - Filename like "G0.GS" + */ +export function getSaveFileName(slot) { + return `G${slot}.GS`; +} diff --git a/src/core/savegame/index.js b/src/core/savegame/index.js new file mode 100644 index 0000000..2bab6d1 --- /dev/null +++ b/src/core/savegame/index.js @@ -0,0 +1,280 @@ +/** + * Save Game Editor - Public API + * + * High-level functions for managing LEGO Island save files + */ + +// Re-export format utilities (from formats/) +export { BinaryReader, BinaryWriter } from '../formats/index.js'; +export { SaveGameParser, parseSaveGame } from '../formats/index.js'; +export { SaveGameSerializer, createSerializer } from '../formats/index.js'; +export { PlayersParser, parsePlayers } from '../formats/index.js'; +export { PlayersSerializer, createPlayersSerializer } from '../formats/index.js'; +export * from './constants.js'; + +// Import dependencies +import { readBinaryFile, writeBinaryFile, fileExists, listFiles } from '../opfs.js'; +import { parseSaveGame, parsePlayers, createSerializer, createPlayersSerializer } from '../formats/index.js'; +import { getSaveFileName, PLAYERS_FILE, Actor, ActorNames } from './constants.js'; + +/** + * @typedef {Object} SaveSlot + * @property {number} slotNumber - Slot number (0-9) + * @property {boolean} exists - Whether the save file exists + * @property {string} fileName - Save file name + * @property {Object|null} header - Parsed header data + * @property {Object|null} missions - Mission scores + * @property {string|null} playerName - Player name from Players.gsi + * @property {ArrayBuffer|null} buffer - Raw file buffer (for editing) + */ + +/** + * Cache for player names (avoids re-parsing Players.gsi) + */ +let playersCache = null; + +/** + * Load and cache player names from Players.gsi + * @returns {Promise<{ count: number, players: Array<{ letters: number[], name: string }> }|null>} + */ +async function loadPlayers() { + if (playersCache) return playersCache; + + const buffer = await readBinaryFile(PLAYERS_FILE); + if (!buffer) return null; + + playersCache = parsePlayers(buffer); + return playersCache; +} + +/** + * Clear the players cache (call when Players.gsi changes) + */ +export function clearPlayersCache() { + playersCache = null; +} + +/** + * Get player name by index + * @param {number} index - Player index in Players.gsi + * @returns {Promise} + */ +async function getPlayerName(index) { + const players = await loadPlayers(); + if (!players || index < 0 || index >= players.players.length) { + return null; + } + return players.players[index].name; +} + +/** + * List all save slots (0-9) with basic info + * @returns {Promise} + */ +export async function listSaveSlots() { + const slots = []; + + // First load players to resolve names + await loadPlayers(); + + for (let i = 0; i < 10; i++) { + const fileName = getSaveFileName(i); + const exists = await fileExists(fileName); + + const slot = { + slotNumber: i, + exists, + fileName, + header: null, + missions: null, + playerName: null, + buffer: null + }; + + if (exists) { + try { + const buffer = await readBinaryFile(fileName); + if (buffer) { + const parsed = parseSaveGame(buffer); + slot.header = parsed.header; + slot.missions = parsed.missions; + slot.buffer = buffer; + + // Try to get player name + // The playerId in the save file corresponds to an index in Players.gsi + // Actually, we need to match by looking at order - player names are stored + // in order of most recently played, so we just use the index + if (playersCache && playersCache.players.length > 0) { + // Find player by matching the slot with Players.gsi order + // For now, just use the first player if available + // In reality, we'd need to match by player_id + const playerIndex = i < playersCache.players.length ? i : 0; + if (playersCache.players[playerIndex]) { + slot.playerName = playersCache.players[playerIndex].name; + } + } + } + } catch (e) { + console.error(`Failed to parse save slot ${i}:`, e); + } + } + + slots.push(slot); + } + + return slots; +} + +/** + * Load a specific save slot with full details + * @param {number} slotNumber - Slot number (0-9) + * @returns {Promise} + */ +export async function loadSaveSlot(slotNumber) { + if (slotNumber < 0 || slotNumber > 9) { + throw new Error('Invalid slot number'); + } + + const fileName = getSaveFileName(slotNumber); + const buffer = await readBinaryFile(fileName); + + if (!buffer) { + return null; + } + + const parsed = parseSaveGame(buffer); + const players = await loadPlayers(); + + let playerName = null; + if (players && players.players.length > 0) { + // Use slot index as a simple mapping + const playerIndex = slotNumber < players.players.length ? slotNumber : 0; + if (players.players[playerIndex]) { + playerName = players.players[playerIndex].name; + } + } + + return { + slotNumber, + exists: true, + fileName, + header: parsed.header, + missions: parsed.missions, + playerName, + buffer + }; +} + +/** + * Save changes to a save slot + * @param {number} slotNumber - Slot number (0-9) + * @param {ArrayBuffer} buffer - Modified buffer to save + * @param {boolean} [silent=false] - If true, don't show toast + * @returns {Promise} + */ +export async function saveSaveSlot(slotNumber, buffer, silent = false) { + if (slotNumber < 0 || slotNumber > 9) { + throw new Error('Invalid slot number'); + } + + const fileName = getSaveFileName(slotNumber); + return await writeBinaryFile(fileName, buffer, silent, 'Save updated'); +} + +/** + * Update a save slot with specific changes + * @param {number} slotNumber - Slot number (0-9) + * @param {Object} updates - Updates to apply + * @param {Object} [updates.header] - Header updates (currentAct, actorId) + * @param {Object} [updates.missionScore] - Single mission score update + * @returns {Promise} - Updated slot data + */ +export async function updateSaveSlot(slotNumber, updates) { + const slot = await loadSaveSlot(slotNumber); + if (!slot || !slot.buffer) { + console.error('Failed to load save slot'); + return null; + } + + const serializer = createSerializer(slot.buffer); + let newBuffer = slot.buffer; + let modified = false; + + // Apply header updates + if (updates.header) { + newBuffer = serializer.updateHeader(updates.header); + modified = true; + } + + // Apply mission score update + if (updates.missionScore) { + const { missionType, actorId, scoreType, value } = updates.missionScore; + // Create new serializer with current buffer state + const scoreSerializer = createSerializer(newBuffer); + // updateMissionScore will add missing states automatically + const result = scoreSerializer.updateMissionScore(missionType, actorId, scoreType, value); + if (result) { + newBuffer = result; + modified = true; + } + } + + // Only save if something was actually modified + if (!modified) { + return slot; + } + + // Save the modified buffer + const success = await saveSaveSlot(slotNumber, newBuffer); + if (!success) { + console.error('Failed to save slot'); + return null; + } + + // Re-load and return updated slot + return await loadSaveSlot(slotNumber); +} + +/** + * Get all existing save slots (convenience function) + * @returns {Promise} + */ +export async function getExistingSaveSlots() { + const allSlots = await listSaveSlots(); + return allSlots.filter(slot => slot.exists); +} + +/** + * Update a player's name in Players.gsi + * @param {number} playerIndex - Index in Players.gsi (0-8) + * @param {string} newName - New name (max 7 chars, A-Z only) + * @returns {Promise} - True if successful + */ +export async function updatePlayerName(playerIndex, newName) { + // Load current players data + const players = await loadPlayers(); + if (!players) { + console.error('Failed to load Players.gsi'); + return false; + } + + if (playerIndex < 0 || playerIndex >= players.players.length) { + console.error('Invalid player index'); + return false; + } + + // Create serializer and update name + const serializer = createPlayersSerializer(players); + serializer.updateName(playerIndex, newName); + + // Serialize and save + const buffer = serializer.serialize(); + const success = await writeBinaryFile(PLAYERS_FILE, buffer, false, 'Save updated'); + + if (success) { + // Clear cache so next load gets fresh data + clearPlayersCache(); + } + + return success; +} diff --git a/src/lib/Carousel.svelte b/src/lib/Carousel.svelte new file mode 100644 index 0000000..c0804fb --- /dev/null +++ b/src/lib/Carousel.svelte @@ -0,0 +1,184 @@ + + +
+ + +
+ +
+ +
+ + diff --git a/src/lib/CollapsibleSection.svelte b/src/lib/CollapsibleSection.svelte deleted file mode 100644 index b9e3cf4..0000000 --- a/src/lib/CollapsibleSection.svelte +++ /dev/null @@ -1,15 +0,0 @@ - - -
- -
- -
-
diff --git a/src/lib/ConfigToast.svelte b/src/lib/ConfigToast.svelte index 82ff65d..29d267b 100644 --- a/src/lib/ConfigToast.svelte +++ b/src/lib/ConfigToast.svelte @@ -1,7 +1,7 @@
- Settings saved + {$configToastMessage}
diff --git a/src/lib/ReadMePage.svelte b/src/lib/ReadMePage.svelte index d6afbae..a0adead 100644 --- a/src/lib/ReadMePage.svelte +++ b/src/lib/ReadMePage.svelte @@ -33,10 +33,15 @@ ]; const changelogItems = [ + { id: 'cl0', title: 'February 2026', items: [ + { type: 'New', text: 'Save Editor lets you view and modify save files — change your player name, character, and high scores directly from the browser' } + ]}, { id: 'cl1', title: 'January 2026', items: [ { type: 'New', text: 'Debug menu for developers and power users. Tap the LEGO Island logo 5 times to unlock OGEL mode and access debug features like teleporting to locations, switching acts, and playing animations' }, { type: 'Improved', text: 'Configure page redesigned with tabbed navigation, collapsible sections, quick presets (Classic/Modern Mode), and modern toggle switches' }, - { type: 'Improved', text: 'Read Me page reorganized into tabs (About, System, FAQ, Changelog, Manual) with the original instruction manual now viewable in-browser' } + { type: 'Improved', text: 'Read Me page reorganized into tabs (About, System, FAQ, Changelog, Manual) with the original instruction manual now viewable in-browser' }, + { type: 'Fixed', text: 'Safari audio not playing on first toggle' }, + { type: 'Fixed', text: 'Tooltips not working correctly on mobile devices' } ]}, { id: 'cl2', title: 'December 2025', items: [ { type: 'New', text: '"Active in Background" option keeps the game running when the tab loses focus' }, diff --git a/src/lib/SaveEditorPage.svelte b/src/lib/SaveEditorPage.svelte new file mode 100644 index 0000000..c5faa00 --- /dev/null +++ b/src/lib/SaveEditorPage.svelte @@ -0,0 +1,528 @@ + + +
+ +
+
+ LEGO Island Save Editor +
+
+ {#if loading || error || existingSlots.length > 0} + + {#if loading} + Loading save files... + {:else if error} + {error} + {:else} + {#each existingSlots as slot} + + {/each} + {/if} + + {/if} + + {#if !loading && !error && existingSlots.length === 0} +
+ + No save files found +

+ Start playing LEGO Island and your save will appear here automatically. +

+
+ {:else if !loading && !error && existingSlots.length > 0 && !currentSlot} +
+ + Select a save file above +

+ Choose a save slot to view and edit your player name, character, and high scores. +

+
+ {/if} + + {#if currentSlot && currentSlot.exists} +
+
+ {#each saveTabs as tab} + + {/each} +
+ + +
+
+ +
+
+
+ {#each nameSlots as char, i} + handleSlotBeforeInput(i, e)} + onkeydown={(e) => handleSlotKeydown(i, e)} + onfocus={handleSlotFocus} + bind:this={slotRefs[i]} + /> + {/each} +
+
+
+
+ +
+ +
+
+
+ {#each actorOptions as actor} + + {/each} +
+
+
+
+
+ + +
+ +
+
+ {/if} +
+
+
+ + diff --git a/src/lib/TabNavigation.svelte b/src/lib/TabNavigation.svelte deleted file mode 100644 index e58dfb7..0000000 --- a/src/lib/TabNavigation.svelte +++ /dev/null @@ -1,18 +0,0 @@ - - -
- {#each tabs as tab} - - {/each} -
diff --git a/src/lib/ToggleSwitch.svelte b/src/lib/ToggleSwitch.svelte deleted file mode 100644 index a3865d4..0000000 --- a/src/lib/ToggleSwitch.svelte +++ /dev/null @@ -1,49 +0,0 @@ - - -{#if tooltip} -
- - ?{tooltip} -
-{:else} - -{/if} diff --git a/src/lib/config/ExtrasTab.svelte b/src/lib/config/ExtrasTab.svelte index c586e22..de3d469 100644 --- a/src/lib/config/ExtrasTab.svelte +++ b/src/lib/config/ExtrasTab.svelte @@ -1,6 +1,6 @@
@@ -76,4 +82,7 @@
+
+ Save Editor +
diff --git a/src/lib/save-editor/MissionScoresEditor.svelte b/src/lib/save-editor/MissionScoresEditor.svelte new file mode 100644 index 0000000..f51bbec --- /dev/null +++ b/src/lib/save-editor/MissionScoresEditor.svelte @@ -0,0 +1,31 @@ + + +
+ {#if $currentPage === 'save-editor'} + + {/if} +
+ + diff --git a/src/lib/save-editor/ScoreCube.svelte b/src/lib/save-editor/ScoreCube.svelte new file mode 100644 index 0000000..93db3a5 --- /dev/null +++ b/src/lib/save-editor/ScoreCube.svelte @@ -0,0 +1,226 @@ + + +
+
+ ? + Click on the cube to cycle high scores. Changes are automatically saved. + +
+ + + {#if loading} +
+ +
+ {:else if error} +
Error: {error}
+ {/if} +
+ + diff --git a/src/stores.js b/src/stores.js index 97dd8f4..cf9e708 100644 --- a/src/stores.js +++ b/src/stores.js @@ -7,7 +7,8 @@ function getInitialPage() { const pageMap = { '#read-me': 'read-me', '#configure': 'configure', - '#free-stuff': 'free-stuff' + '#free-stuff': 'free-stuff', + '#save-editor': 'save-editor' }; return pageMap[hash] || 'main'; } @@ -35,6 +36,7 @@ export const installState = writable({ // Config toast export const configToastVisible = writable(false); +export const configToastMessage = writable('Settings saved'); // Debug UI visible (set when game reaches intro animation) export const debugUIVisible = writable(false); @@ -44,3 +46,11 @@ export const gameRunning = writable(false); // Service worker registration export const swRegistration = writable(null); + +// Save editor state +export const saveEditorState = writable({ + slots: [], // Array of SaveSlot objects + selectedSlot: null, // Currently selected slot number + loading: true, + error: null +});