Using game engines (Unity, Unreal) in arcade slots
Arcade slots require cinematography, stable FPS and strict mathematical honesty. Unity and Unreal close the visual, production tools and multi-platform, and the server is responsible for RNG/payouts. Below is the framework of the solution with specifics for mobile/web/PC.
1) Basic architecture
```
[Unity/Unreal Client]
Principles: client - visual and input; the outcome of the spin and meta-payout - on the server; all awards/balance - in config with server validation. RTP invariance is required.
2) Engine choice: when Unity, when Unreal
Unity: quick access to mobile and WebGL, wide SDK stack, Addressables, C-stack, UGUI/UI Toolkit, VFX Graph. Preferred for 2D/stylized 3D, lightweight client, fast iteration, large number of Title
s with a common code-base.
Unreal: high-end 3D, cinematography out of the box, Sequencer, Niagara, powerful C++ brand, bluprints for designers. Preferred for premium 3D scenes, complex chamber production, PC/console; on mobile - with an experienced team and thoughtful optimization.
Selection criteria: target devices, required entertainment, team competencies, deadlines, build/patch bones, web client requirements.
3) Content pipeline and data
Unity
Addressables for streaming content; versioned catalogs.
ScriptableObjects for pay tables, missions, collections; resolving via Remote Config.
Timeline for bonus/big wine scene introductions.
VFX Graph for batching profiled win effects.
Unreal
Pak files/Chunking for patches; PrimaryAsset Labels и ChunkId.
DataTable/DataAsset for configs; Gameplay Tags for states.
Sequencer for cut scenes; Niagara for FX with LOD.
StreamableManager for asynchronous loading.
General: strict version scheme, separation of "code vs data," "hot" parameters - only from the server.
4) UI/UX and readability
Unity: UGUI (reliable) or UI Toolkit (modern layouts).
Unreal: UMG + Slate for custom widgets.
Rendering: one contour score (ease-out), clear contrasts, masks for illuminating clusters/lines.
Skip/accelerate scenes without losing key signals.
Availability: FX down mode, color color profiles, subtitles, flash warning.
5) Animations/Cameras/VFX
Scheme "vaccination → impact → settle," duration of big wines ≤ 2. 5 p.
Camera: static work plan + short (≤1. 2 c) events; roll/zoom limitation.
FX: Niagara/VFX Graph with emitter cap, GPU particles, transparency sorting, minimum overdrive.
Sink audio: ± 20ms to the peaks of animations, ducking the background track when winning.
6) Optimization for mobile/web/PC
FPS goals: 60 (ideal), fail safe 30. Frame time 16. 7/33. 3 ms.
Stage budgets (benchmarks):
7) The logic of arcade mechanics
Mini-games (pick/timing/aim) - local logic and validation on the server (if the reward is significant).
Gamification (levels/missions/passes) - progress is stored on the server; the client reads only the view.
The volatility of the freespin profile (a lot × a little vs a little × a lot) is controlled by the server, the client shows the choice.
8) RNG, payments, compliance
The outcome of the spin/bonus is strictly server RNG/mathematics, the client does not store sides, does not simulate EV.
Server returns result + provable trace; client - visual.
Restriction "false choice": when pre-draw, the client is obliged to inform that the opening order does not affect EV.
Audit logs, limits, responsible reminders (session, deposits in RMG, or soft limits in social).
RTP does not change due to scene animations/timing.
9) Assembly, patching and multiplatform
Unity
AndroID:IL2CPP + ARM64; Split APK/ABB; Addressables Remote Catalog for hot updates.
iOS: IL2CPP + Metal; Bitcode (if required), App Thinning; On-Demand Resources for heavy assets.
PC/WebGL: individual quality profiles; CDN for bundles.
Unreal
Pak files with Chunking, DLC chunks for events/seasons; IoStore.
Mobile: turn off heavy features (full dynamic GI/expensive shadows), use a mobile renderer.
Patching: delta patches of the chunk level, the data version is separate from the code.
10) Analytics, A/B, remote configuration
Events: time to 1st award, frequency of bonus inputs, percentage of scene skip, FPS/memory, depth of progress, share of completed missions, "dry" sessions.
A/B: cutscene duration, FX density, beacon award values, mission complexity, UI layouts.
Remote Config/ficheflags: instant edits without release.
Privacy: aggregated metrics, GDPR/CCPA; disabled personal identifiers.
11) Client security
TLS pinning, certificate verification, replay protection.
Hash signature of configs; anti-tamper (obfuscation/integrity checks).
Server validation of all awards/progress; "blind" customer for economically significant operations.
Bot detection: timing variability, session anomalies, heuristics for repeating patterns.
12) Team Pipeline
Git + LFS/Perforce (UE) for heavy assets; trunk-based with short fichevets.
CI/CD: assembly/dimension/profile check; auto-generation of Addressables/ChunkId.
Gate metrics before release: FPS 60 ± 5 without drawdowns on reference devices, memory stability, boot time <5-8 s (first input), big wine scene ≤ 2. 5 c.
13) Numerical landmarks (for start)
Draw calls mobile: ≤120; desktop ≤300.
Textures: 2k maximum for key backgrounds, the rest ≤1k; always meeps.
Audio: winning themes ≤3 c; systems (ambient/SFX/UI/fanfare), ducking -6... - 9 dB.
Loading: cold start ≤8 c, repeated ≤3 c; lazy FX loadings/bonuses.
Bonus Scene: Intro 0. 8–1. 5 c, final prize frame ≤1 c, instant return.
14) Implementation checklist
1. Set goals: platforms, FPS, customer size, budgets.
2. Define the architecture and boundaries of server responsibility (RNG/economics/progress).
3. Select the engine according to the criteria of entertainment/time/competencies.
Conclusion: Unity and Unreal accelerate the production of arcade slots, providing a high visual and convenient pipeline. It is critical to keep the server-authority in mathematics, build controlled entertainment (camera/FX/audio) and keep performance in budgets. With this approach, the slot remains honest in RTP, fast on devices and spectacular in presentation - exactly what awaits the section "Arcade slots: more than just spins."
1) Basic architecture
```
[Unity/Unreal Client]
| ├─ UI/UX (UGUI/UI Toolkit | UMG) |
|---|---|
| ├─ Timeline | Sequencer |
| ├─ VFX (VFX Graph | Niagara) |
| ├─ Scene/Minigame Logic (C | C++) |
| └─ Networking (WebSocket/HTTP, Protobuf/JSON) | |
| │ | |
| TLS + pinning | |
| │ | |
| [Gaming backend] | |
| ├─ Server RNG/Slot Math (Certified) | |
| ├─ Economy/Balance/Config (Remote Config) | |
| ├─ Storage of progress/passes/collections | |
| ├─ Anti-Fraud/Limits/Responsible Play | |
| └─ Analytics/AB/Experiments/Phicheflags | |
| ``` |
Principles: client - visual and input; the outcome of the spin and meta-payout - on the server; all awards/balance - in config with server validation. RTP invariance is required.
2) Engine choice: when Unity, when Unreal
Unity: quick access to mobile and WebGL, wide SDK stack, Addressables, C-stack, UGUI/UI Toolkit, VFX Graph. Preferred for 2D/stylized 3D, lightweight client, fast iteration, large number of Title
s with a common code-base.
Unreal: high-end 3D, cinematography out of the box, Sequencer, Niagara, powerful C++ brand, bluprints for designers. Preferred for premium 3D scenes, complex chamber production, PC/console; on mobile - with an experienced team and thoughtful optimization.
Selection criteria: target devices, required entertainment, team competencies, deadlines, build/patch bones, web client requirements.
3) Content pipeline and data
Unity
Addressables for streaming content; versioned catalogs.
ScriptableObjects for pay tables, missions, collections; resolving via Remote Config.
Timeline for bonus/big wine scene introductions.
VFX Graph for batching profiled win effects.
Unreal
Pak files/Chunking for patches; PrimaryAsset Labels и ChunkId.
DataTable/DataAsset for configs; Gameplay Tags for states.
Sequencer for cut scenes; Niagara for FX with LOD.
StreamableManager for asynchronous loading.
General: strict version scheme, separation of "code vs data," "hot" parameters - only from the server.
4) UI/UX and readability
Unity: UGUI (reliable) or UI Toolkit (modern layouts).
Unreal: UMG + Slate for custom widgets.
Rendering: one contour score (ease-out), clear contrasts, masks for illuminating clusters/lines.
Skip/accelerate scenes without losing key signals.
Availability: FX down mode, color color profiles, subtitles, flash warning.
5) Animations/Cameras/VFX
Scheme "vaccination → impact → settle," duration of big wines ≤ 2. 5 p.
Camera: static work plan + short (≤1. 2 c) events; roll/zoom limitation.
FX: Niagara/VFX Graph with emitter cap, GPU particles, transparency sorting, minimum overdrive.
Sink audio: ± 20ms to the peaks of animations, ducking the background track when winning.
6) Optimization for mobile/web/PC
FPS goals: 60 (ideal), fail safe 30. Frame time 16. 7/33. 3 ms.
Stage budgets (benchmarks):
- Mobile mid-range: 80-120k tris/frame, ≤120 draw calls, dynamic shadows minimum.
- Desktop: 180-300k tris, ≤200 -300 draw calls.
- Textures: atlases, compression (ASTC/ETC2 on mobile, BCn on desktop), mip levels, 4k limit only for large backgrounds.
- Lighting: baked/mixed, Light Probe/Reflection Probe; on UE - disable expensive GI on mobile; on Unity - URP (for mobile) with simple shaders.
- Lodas/Mullions: 2-3 levels; aggressive background culling.
- Shaders: variability control, prewarm; на Unity — SRP Batcher; on UE - instance material instead of duplicates.
- WebGL: Unity WebGL - light scenes; turn off heavy post-effects, use a static background, optimize bundle size. Pixel Streaming UE - promo/high bitrate channels only (latency).
- Memory: target mobile ≤ 256-400 MB per stage; Pools for VFX/Audio unloading assets when changing modes.
7) The logic of arcade mechanics
Mini-games (pick/timing/aim) - local logic and validation on the server (if the reward is significant).
Gamification (levels/missions/passes) - progress is stored on the server; the client reads only the view.
The volatility of the freespin profile (a lot × a little vs a little × a lot) is controlled by the server, the client shows the choice.
8) RNG, payments, compliance
The outcome of the spin/bonus is strictly server RNG/mathematics, the client does not store sides, does not simulate EV.
Server returns result + provable trace; client - visual.
Restriction "false choice": when pre-draw, the client is obliged to inform that the opening order does not affect EV.
Audit logs, limits, responsible reminders (session, deposits in RMG, or soft limits in social).
RTP does not change due to scene animations/timing.
9) Assembly, patching and multiplatform
Unity
AndroID:IL2CPP + ARM64; Split APK/ABB; Addressables Remote Catalog for hot updates.
iOS: IL2CPP + Metal; Bitcode (if required), App Thinning; On-Demand Resources for heavy assets.
PC/WebGL: individual quality profiles; CDN for bundles.
Unreal
Pak files with Chunking, DLC chunks for events/seasons; IoStore.
Mobile: turn off heavy features (full dynamic GI/expensive shadows), use a mobile renderer.
Patching: delta patches of the chunk level, the data version is separate from the code.
10) Analytics, A/B, remote configuration
Events: time to 1st award, frequency of bonus inputs, percentage of scene skip, FPS/memory, depth of progress, share of completed missions, "dry" sessions.
A/B: cutscene duration, FX density, beacon award values, mission complexity, UI layouts.
Remote Config/ficheflags: instant edits without release.
Privacy: aggregated metrics, GDPR/CCPA; disabled personal identifiers.
11) Client security
TLS pinning, certificate verification, replay protection.
Hash signature of configs; anti-tamper (obfuscation/integrity checks).
Server validation of all awards/progress; "blind" customer for economically significant operations.
Bot detection: timing variability, session anomalies, heuristics for repeating patterns.
12) Team Pipeline
Git + LFS/Perforce (UE) for heavy assets; trunk-based with short fichevets.
CI/CD: assembly/dimension/profile check; auto-generation of Addressables/ChunkId.
Gate metrics before release: FPS 60 ± 5 without drawdowns on reference devices, memory stability, boot time <5-8 s (first input), big wine scene ≤ 2. 5 c.
13) Numerical landmarks (for start)
Draw calls mobile: ≤120; desktop ≤300.
Textures: 2k maximum for key backgrounds, the rest ≤1k; always meeps.
Audio: winning themes ≤3 c; systems (ambient/SFX/UI/fanfare), ducking -6... - 9 dB.
Loading: cold start ≤8 c, repeated ≤3 c; lazy FX loadings/bonuses.
Bonus Scene: Intro 0. 8–1. 5 c, final prize frame ≤1 c, instant return.
14) Implementation checklist
1. Set goals: platforms, FPS, customer size, budgets.
2. Define the architecture and boundaries of server responsibility (RNG/economics/progress).
3. Select the engine according to the criteria of entertainment/time/competencies.
| 4. Configure Content Pipeline (Addressables | Pak/Chunks), Remote Config. |
|---|---|
| 5. Implement UI/UX with win readability and availability. | |
| 6. Assemble VFX/cameras according to the timing/impact/settle scheme, limit the duration. | |
| 7. Enter telemetry, A/B, and performance alerts. | |
| 8. Undergo optimization for target devices (LOD, compression, butching). | |
| 9. Close security (pinning, anti-tamper, server validation). | |
| 10. Conduct device tests, fixed budgets, release gate. | |
| 11. Set up patching/seasonal content without updating the app. | |
| 12. Plan for regular rebalancing of the economy and visual density from the data. |
Conclusion: Unity and Unreal accelerate the production of arcade slots, providing a high visual and convenient pipeline. It is critical to keep the server-authority in mathematics, build controlled entertainment (camera/FX/audio) and keep performance in budgets. With this approach, the slot remains honest in RTP, fast on devices and spectacular in presentation - exactly what awaits the section "Arcade slots: more than just spins."
