Files / folder structure added

This commit is contained in:
2026-05-30 18:13:54 +12:00
commit f248b6f99f
38 changed files with 1212 additions and 0 deletions
+55
View File
@@ -0,0 +1,55 @@
# Build outputs
build/
bin/
obj/
out/
dist/
*.dll
*.exe
*.pdb
*.lib
*.exp
*.ilk
# Visual Studio
.vs/
*.sln.docstates
*.user
*.vcxproj.user
# CMake
CMakeFiles/
CMakeCache.txt
cmake_install.cmake
# XMake
.xmake/
# Python
__pycache__/
*.pyc
.venv/
venv/
# Logs
*.log
logs/
# Fallout 4 files
Fallout4.exe
Fallout4Launcher.exe
*.ba2
*.bsa
*.esm
# Mod manager files
modlist.txt
loadorder.txt
plugins.txt
# Creation Kit temporary files
*.tes
*.bak
# Releases
releases/
+72
View File
@@ -0,0 +1,72 @@
# Contributing
Fallout 4 Together is currently in the research and prototype stage.
At this stage, contributions should focus on documentation, research, setup notes, tooling experiments, and small isolated prototypes.
## Current Contribution Areas
Useful contributions include:
- F4SE setup notes
- CommonLibF4 setup notes
- Creation Kit test cell documentation
- Fallout 4 actor sync research
- Network packet design
- Server architecture experiments
- Safe testing workflows
- Crash reports from controlled test builds
## Scope
Please keep contributions focused on the first prototype goal:
> Two Fallout 4 clients in a controlled test environment, with each player visible as a synced remote actor.
Avoid adding large systems before the core prototype works.
Out of scope for early development:
- Full campaign co-op
- Quest sync
- Settlement sync
- Public matchmaking
- Anti-cheat
- Large modlist support
- MMO-style gameplay
## Legal Requirements
Do not contribute:
- Fallout 4 executable files
- Bethesda game assets
- Bethesda archives
- DLC files
- F4SE binaries
- Proprietary game code
- Decompiled Bethesda scripts
- Other mods' files without permission
Only contribute files that you have the right to share.
## Recommended Workflow
1. Open an issue describing the problem or idea.
2. Keep changes small and focused.
3. Document what was tested.
4. Use a clean Fallout 4 test profile when testing.
5. Avoid testing with large modlists.
## Commit Style
Suggested commit prefixes:
```text
docs: update setup notes
research: add actor sync notes
plugin: add basic plugin skeleton
server: add connection prototype
ck: document test cell plan
protocol: define transform packet
```
+18
View File
@@ -0,0 +1,18 @@
# Disclaimer
Fallout 4 Together is an unofficial fan research project.
This project is not affiliated with, endorsed by, or supported by Bethesda Game Studios, Bethesda Softworks, Microsoft, or the F4SE team.
This repository does not contain:
- Fallout 4 executable files
- Fallout 4 game assets
- Bethesda archives
- DLC files
- F4SE binaries
- Proprietary game code
Users must own a legal copy of Fallout 4 and install any required tools themselves.
This project is experimental and may cause crashes, broken saves, or unstable gameplay. Use a dedicated test profile and test save.
+4
View File
@@ -0,0 +1,4 @@
To be decided.
This project currently has no formal open-source license.
Do not reuse, redistribute, or publish this code/assets until a license is selected.
+107
View File
@@ -0,0 +1,107 @@
# Fallout 4 Together
Fallout 4 Together is an experimental research project exploring the possibility of adding basic multiplayer-style networking to Fallout 4.
The goal is not to create a full co-op campaign mod immediately. The first goal is much smaller:
> Two Fallout 4 clients in a controlled test environment, with each player visible as a synced remote actor.
This project is currently in the research and prototype stage.
## Project Goals
### First Prototype
- Load a native Fallout 4 plugin through F4SE
- Connect to a local test server
- Send local player position data
- Receive remote player transform data
- Represent another connected player using a placeholder actor
- Restrict all testing to a custom test cell
### Long-Term Ideas
- Basic LAN multiplayer test mode
- Remote player movement sync
- Basic animation state sync
- Basic chat or debug messages
- Host-controlled test cell
- Simple co-op combat arena
## Non-Goals
This project is not currently trying to support:
- Full Fallout 4 campaign co-op
- Quest synchronization
- Settlement synchronization
- Full NPC/world state synchronization
- VATS synchronization
- Public server/MMO gameplay
- Compatibility with large modlists
Those systems are extremely complex and are outside the scope of the first prototype.
## Repository Layout
```text
docs/ Project documentation and research notes
plugin/ Native F4SE/CommonLibF4 plugin work
creation-kit/ Creation Kit plugin files, Papyrus scripts, and test cell notes
server/ External multiplayer test server
protocol/ Network packet design and sync documentation
tools/ Helper scripts and utilities
test-data/ Example packets and test data
screenshots/ Development screenshots
```
## Requirements
This project is expected to require:
- Fallout 4 on PC
- Fallout 4 Script Extender, F4SE
- Fallout 4 Creation Kit
- Visual Studio 2022 or newer
- CMake or another supported C++ build system
- A CommonLibF4-based plugin template
- Git
- A clean Fallout 4 test profile
## Recommended Development Setup
Use a separate Fallout 4 installation or a dedicated modding profile for testing.
Recommended setup:
```text
Fallout 4
F4SE
Creation Kit
Mod Organizer 2 or Vortex
Visual Studio
Git
```
Use a clean test save and avoid testing with a full personal modlist.
## Legal Notice
This repository does not include Fallout 4 game files, Bethesda assets, F4SE binaries, or any proprietary game code.
Users are responsible for owning Fallout 4 and installing required external tools themselves.
## Status
Current status:
```text
Research phase
Repository structure setup
Protocol planning
No playable multiplayer build yet
```
## License
To be decided.
+65
View File
@@ -0,0 +1,65 @@
# Roadmap
## Phase 0: Research and Setup
- [ ] Create repository structure
- [ ] Document project scope
- [ ] Document legal boundaries
- [ ] Set up Fallout 4 test profile
- [ ] Install F4SE
- [ ] Install Creation Kit
- [ ] Choose CommonLibF4 template
- [ ] Create test cell plan
## Phase 1: F4SE Plugin Bootstrap
- [ ] Create basic F4SE plugin project
- [ ] Confirm plugin loads in Fallout 4
- [ ] Create plugin log output
- [ ] Detect game version
- [ ] Read local player reference
- [ ] Read local player position
- [ ] Write position to log
## Phase 2: External Server Prototype
- [ ] Create basic local server
- [ ] Define packet format
- [ ] Support client connect/disconnect
- [ ] Assign player IDs
- [ ] Receive transform packets
- [ ] Broadcast transform packets to other clients
## Phase 3: Fallout 4 Network Connection
- [ ] Connect F4SE plugin to local server
- [ ] Send test packets from Fallout 4
- [ ] Send real player transform packets
- [ ] Receive remote transform packets
- [ ] Store remote player state safely
## Phase 4: Remote Player Representation
- [ ] Create test cell in Creation Kit
- [ ] Create placeholder remote player actor
- [ ] Spawn or place remote actor
- [ ] Move remote actor using received transform data
- [ ] Smooth remote actor movement
- [ ] Clean up actor on disconnect
## Phase 5: Basic Gameplay Sync
- [ ] Sync crouch state
- [ ] Sync sprint/walk state
- [ ] Sync weapon drawn state
- [ ] Sync basic fire event
- [ ] Sync simple health state
- [ ] Add debug UI or console commands
## Phase 6: Controlled Multiplayer Test
- [ ] Two clients in same test cell
- [ ] Both players visible
- [ ] Movement sync working
- [ ] Basic animation sync working
- [ ] Basic LAN test documented
+29
View File
@@ -0,0 +1,29 @@
# Creation Kit Files
This folder is for Creation Kit-side work for Fallout 4 Together.
The Creation Kit plugin should provide controlled test content for multiplayer experiments.
## Planned Contents
- Test cell
- Placeholder remote player actor
- Debug markers
- Optional Papyrus helper scripts
- Optional startup quest for testing
## Plugin Format
Early development can use an ESP.
Possible file name:
```text
Fallout4Together_Test.esp
```
## Important
Do not commit Bethesda master files or game assets.
Only commit original plugin files and original scripts created for this project.
+11
View File
@@ -0,0 +1,11 @@
# ESP Files
This folder is for original Fallout 4 Together Creation Kit plugin files.
Possible early plugin file:
```text
Fallout4Together_Test.esp
```
Do not place Bethesda master files or other mods' plugin files here.
+9
View File
@@ -0,0 +1,9 @@
# Compiled Papyrus Scripts
This folder is for compiled Papyrus `.pex` scripts if they are part of a test release.
Keep source scripts in:
```text
creation-kit/scripts/source/
```
+12
View File
@@ -0,0 +1,12 @@
# Papyrus Source Scripts
This folder is for original Papyrus source scripts created for Fallout 4 Together.
Possible uses:
- Debug startup quest
- Test cell helper scripts
- Actor spawn helpers
- On-screen debug messages
Networking should not be handled directly in Papyrus.
+30
View File
@@ -0,0 +1,30 @@
# Test Cells
The first multiplayer test should happen in a small controlled cell.
## First Test Cell Requirements
- Flat open area
- Good lighting
- No hostile NPCs
- No quests
- No doors to other cells
- A few visual markers for movement testing
- Spawn marker for local player
- Placeholder marker for remote players
## Suggested Cell Name
```text
F4TTestCell01
```
## Purpose
This cell exists to test:
- Remote actor spawning
- Position synchronization
- Rotation synchronization
- Movement smoothing
- Disconnect cleanup
+48
View File
@@ -0,0 +1,48 @@
# Architecture
## Main Components
### F4SE Plugin
The native plugin is responsible for:
- Loading into Fallout 4
- Reading local player state
- Sending local player data to the server
- Receiving remote player data
- Applying remote player updates safely
### External Server
The server is responsible for:
- Accepting client connections
- Assigning player IDs
- Receiving player state
- Broadcasting player state
- Tracking disconnects
### Creation Kit Plugin
The Creation Kit side is responsible for:
- Test cells
- Placeholder actors
- Optional Papyrus helper scripts
- Debug objects
- Controlled test environments
## Threading Model
Networking should run separately from game update logic.
Recommended approach:
```text
Networking thread receives packets
Networking thread stores remote player state
Game update reads remote player state
Game update applies actor movement
```
The networking thread should avoid directly modifying Fallout 4 game objects unless the operation is known to be safe.
+46
View File
@@ -0,0 +1,46 @@
# Creation Kit Notes
The Creation Kit side of Fallout 4 Together should provide controlled test content for multiplayer development.
## First Creation Kit Goals
- Create a small test cell
- Add player start markers
- Add remote player placeholder markers
- Add simple lighting
- Avoid quests, doors, hostile NPCs, and complex world state
## Suggested Test Cell
```text
F4TTestCell01
```
## Suggested Test Plugin
```text
Fallout4Together_Test.esp
```
## Test Cell Requirements
The first test cell should include:
- Flat ground
- Clear lighting
- No enemies
- No quest dependencies
- No doors to other cells
- A few visual markers to judge movement
- Enough space for movement syncing tests
## Papyrus Scripts
Papyrus may eventually be useful for helper systems, but networking should not be handled in Papyrus.
Possible Papyrus uses:
- Debug startup quest
- Spawning helper actors
- Showing messages
- Triggering test events
+42
View File
@@ -0,0 +1,42 @@
# F4SE Notes
F4SE is expected to be the main entry point for the native plugin side of Fallout 4 Together.
## Plugin Goals
The first plugin goals are:
- Confirm the plugin loads
- Create a log file
- Detect the game version
- Read the local player reference
- Read the local player position
- Send basic data to a local server
## Expected Plugin Output
Eventually, the compiled plugin should output something like:
```text
Data/F4SE/Plugins/Fallout4Together.dll
```
## Important Notes
Do not commit F4SE binaries to this repository.
Do not commit Fallout 4 executable files or game assets.
Use a CommonLibF4 template to reduce setup friction.
## Plugin Safety
Avoid modifying Fallout 4 game objects directly from a networking thread.
Recommended flow:
```text
Networking thread receives packets
Networking thread stores packet data
Main/game update applies safe changes
```
+38
View File
@@ -0,0 +1,38 @@
# Limitations
Fallout 4 was designed as a single-player game. Fallout 4 Together is therefore expected to have serious technical limitations, especially during early development.
## Early Prototype Limitations
The first prototype will likely require:
- All players to remain in the same test cell
- A clean Fallout 4 test profile
- A dedicated test save
- No large gameplay mods
- No quest synchronization
- No settlement synchronization
- No VATS synchronization
- No dialogue synchronization
## Systems Not Supported Early
### Quests
Quest state is complex and deeply tied to the single-player game world. Quest synchronization is not part of the first prototype.
### Settlements
Settlements involve workshop data, placed objects, NPC ownership, resources, attacks, and persistent state. Settlement sync is not part of the first prototype.
### VATS
VATS depends on single-player time behavior and targeting logic. VATS should be disabled or ignored during early tests.
### Saves
Multiplayer state may desync or damage saves if handled incorrectly. Use a dedicated test save only.
### Mod Compatibility
The first prototype should be tested with a clean setup. Compatibility with large modlists is not an early goal.
+39
View File
@@ -0,0 +1,39 @@
# Project Overview
Fallout 4 Together is a prototype multiplayer framework experiment for Fallout 4.
The first target is not full co-op. The first target is a controlled test where two clients can connect to a local server and see each other as synced actors in a custom test cell.
## Core Idea
Fallout 4 remains the client application. A native F4SE plugin reads local player state and communicates with an external server.
The server tracks connected players and broadcasts relevant state to other clients.
A Creation Kit plugin provides test cells, placeholder actors, scripts, and controlled test content.
## Basic Flow
```text
Fallout 4 Client A
|
| local player transform
v
External Server
|
| remote player transform
v
Fallout 4 Client B
```
## Early Limitations
The first prototype should assume:
- All players are in the same cell
- No quest synchronization
- No settlement synchronization
- No VATS
- No dialogue sync
- No full inventory sync
- No support for large modlists
+23
View File
@@ -0,0 +1,23 @@
# Protocol Overview
The Fallout 4 Together protocol defines the messages sent between Fallout 4 clients and the external server.
Early versions should stay simple and easy to debug.
## Early Design
The first version can use human-readable packets during testing.
Long-term versions may move to a binary protocol if performance becomes a problem.
## First Required Messages
- `welcome`
- `transform`
- `disconnect`
- `ping`
- `pong`
## Main Rule
The protocol should be testable outside Fallout 4 before it is used inside the F4SE plugin.
+20
View File
@@ -0,0 +1,20 @@
# Bethesda Engine Notes
This file is for general research notes about Fallout 4 and the Creation Engine.
## Topics to Research
- Actor references
- Player reference behavior
- Cell loading
- Worldspace loading
- AI packages
- Animation state
- Actor values
- Save game persistence
- Papyrus limitations
- F4SE plugin safety
## Notes
Add technical findings here as research develops.
+23
View File
@@ -0,0 +1,23 @@
# Existing Projects Research
This file is for notes on existing Bethesda multiplayer projects and experiments.
## Research Targets
- Skyrim Together
- NV:MP
- VaultMP
- F4MP attempts
- Other Fallout 4 multiplayer experiments
## Research Questions
- How did they handle remote player actors?
- How did they handle cell changes?
- How did they handle quest state?
- What systems were impossible or unstable?
- What parts are useful references for Fallout 4 Together?
## Notes
Add findings here as research develops.
+31
View File
@@ -0,0 +1,31 @@
# Multiplayer Sync Notes
This file is for notes on synchronizing multiplayer state.
## Initial Sync Targets
- Position
- Rotation
- Cell ID
- Worldspace ID
- Basic animation state
- Disconnect cleanup
## Later Sync Targets
- Weapon state
- Health
- Basic combat events
- Cell transitions
- Limited world interactions
## Known Hard Problems
- Quest state
- Settlement state
- Dialogue state
- Save files
- Physics objects
- NPC ownership
- Time dilation
- VATS
+48
View File
@@ -0,0 +1,48 @@
# Development Setup
## Required Tools
- Fallout 4 on PC
- Fallout 4 Script Extender, F4SE
- Fallout 4 Creation Kit
- Visual Studio 2022 or newer
- Git
- CMake or another build system required by the selected plugin template
- Mod Organizer 2 or Vortex
## Recommended Fallout 4 Setup
Use a clean test profile.
Recommended:
```text
Fallout 4
F4SE
Fallout 4 Together test plugin
No other gameplay mods
Dedicated test save
```
Avoid testing with a full modlist while developing the core systems.
## Version Tracking
Record the exact versions used:
```text
Fallout 4 version:
F4SE version:
Creation Kit version:
CommonLibF4 template:
Windows version:
Compiler version:
```
## Folder Notes
Do not copy Fallout 4 game files into this repository.
Do not copy F4SE binaries into this repository.
Use the `plugin/external/README.md` file to document where external dependencies should be installed.
+38
View File
@@ -0,0 +1,38 @@
# Native Plugin
This folder is for the native Fallout 4 Together plugin.
The plugin is expected to be built using F4SE and CommonLibF4.
## Responsibilities
The plugin should eventually:
- Load through F4SE
- Create log output
- Detect the local player
- Read player transform data
- Connect to the external server
- Send local player state
- Receive remote player state
- Apply remote actor updates
## External Dependencies
Do not commit F4SE or CommonLibF4 binaries directly into this repository.
Document dependency setup in:
```text
plugin/external/README.md
```
## Build Output
Compiled plugin files should not be committed unless part of an official release.
Expected output eventually:
```text
Data/F4SE/Plugins/Fallout4Together.dll
```
+29
View File
@@ -0,0 +1,29 @@
# External Plugin Dependencies
This folder documents external dependencies.
Do not commit downloaded dependency binaries here unless their license allows it and the project intentionally vendors them.
Expected dependencies:
- Fallout 4 Script Extender, F4SE
- CommonLibF4 or CommonLibF4 NG
- CMake or XMake, depending on the selected template
- Visual Studio C++ toolchain
## F4SE
Install F4SE into the Fallout 4 game folder according to the official instructions.
## CommonLibF4
Use a CommonLibF4 template as the starting point for the native plugin project.
Record the selected template here:
```text
Selected template:
Template URL:
Commit/tag used:
Date added:
```
+11
View File
@@ -0,0 +1,11 @@
# Include
This folder is for shared native plugin header files.
Possible future headers:
- protocol types
- player state types
- network client declarations
- logging declarations
- configuration types
+13
View File
@@ -0,0 +1,13 @@
# Source
This folder is for Fallout 4 Together native plugin source files.
Initial planned source areas:
- Plugin entry point
- Logging
- F4SE/CommonLibF4 integration
- Player state reading
- Networking client
- Remote player state storage
- Safe game update application
+33
View File
@@ -0,0 +1,33 @@
# Protocol
This folder documents the planned network protocol for Fallout 4 Together.
The first protocol should be simple and focused on player transform sync.
## First Packet Types
- Welcome packet
- Transform packet
- Disconnect packet
## Future Packet Types
- Animation state packet
- Fire weapon packet
- Health packet
- Chat packet
- Cell change packet
## Design Goals
The protocol should be:
- Simple
- Easy to debug
- Versioned
- Safe to extend
- Clear enough to test outside Fallout 4
## Early Testing
The protocol should be testable using fake clients before being connected to Fallout 4.
+43
View File
@@ -0,0 +1,43 @@
# Message Types
This file tracks planned message type names for the Fallout 4 Together protocol.
## Core Messages
```text
welcome
transform
disconnect
ping
pong
```
## Planned Gameplay Messages
```text
animation_state
weapon_fire
weapon_reload
health_update
chat_message
cell_change
actor_spawn
actor_remove
```
## Debug Messages
```text
debug_log
debug_marker
debug_error
```
## Naming Rules
Message types should be:
- Lowercase
- Snake case
- Short but clear
- Stable once used in test builds
+64
View File
@@ -0,0 +1,64 @@
# Packet Types
This document describes planned packet types for the multiplayer prototype.
## Welcome Packet
Sent from server to client after connection.
Fields:
```text
type
playerId
serverTime
```
## Transform Packet
Sent from client to server and broadcast to other clients.
Fields:
```text
type
playerId
cellId
worldspaceId
x
y
z
pitch
yaw
roll
timestamp
```
## Animation State Packet
Planned later.
Fields:
```text
type
playerId
movementState
weaponDrawn
isCrouching
isSprinting
isAiming
isFiring
```
## Disconnect Packet
Sent when a player leaves.
Fields:
```text
type
playerId
reason
```
+51
View File
@@ -0,0 +1,51 @@
# Player Sync
Player synchronization is the first major technical goal for Fallout 4 Together.
## First Goal
The first goal is to represent remote players as placeholder actors in a controlled test cell.
The first version only needs to sync:
- Position
- Rotation
- Cell ID
- Basic connection state
## Not Required at First
The first version does not need:
- Full animation graph sync
- Combat sync
- Inventory sync
- Quest sync
- Dialogue sync
- Accurate physics sync
## Transform Sync
Each client should send its local player transform to the server.
The server should broadcast that transform to other clients.
Remote clients should move placeholder actors based on the received transform.
## Smoothing
Remote players should not snap instantly to every received transform.
Instead, remote actors should interpolate toward the latest received position.
Basic idea:
```text
current actor position + latest network position = smoothed visual position
```
## Same-Cell Restriction
Early prototypes should require all players to remain in the same test cell.
Cell transitions should not be supported until basic player sync is stable.
+42
View File
@@ -0,0 +1,42 @@
# World Sync
World synchronization is a long-term problem and is not part of the first prototype.
Fallout 4 assumes a single player owns the world state. Multiplayer requires deciding which client or server controls each piece of world state.
## World State Examples
World state can include:
- Doors
- Containers
- Pickups
- NPC deaths
- Physics objects
- Quest stages
- Workshop objects
- Terminal states
- Dialogue state
## Early Approach
The first prototype should avoid world sync as much as possible.
Recommended early restrictions:
- Use a custom test cell
- Avoid lootable containers
- Avoid quests
- Avoid doors
- Avoid terminals
- Avoid persistent world changes
## Later Ideas
Possible future approaches:
- Host-controlled world state
- Server-authoritative world state
- Cell-specific state tracking
- Limited interaction whitelist
- Resettable test environments
+13
View File
@@ -0,0 +1,13 @@
# Screenshots
This folder is for development screenshots.
Useful screenshots may include:
- Test cell layout
- Debug UI
- Remote player sync tests
- Server console output
- Plugin log output
Avoid uploading screenshots that show private account information or unrelated personal files.
+24
View File
@@ -0,0 +1,24 @@
# Server
This folder is for the external multiplayer test server.
The server is responsible for managing connected clients and broadcasting player state.
## First Server Goals
- Start local server
- Accept client connections
- Assign player IDs
- Receive transform packets
- Broadcast transform packets
- Handle disconnects
## Not Planned Yet
- Authentication
- Public matchmaking
- Anti-cheat
- Persistence
- Quest state
- Settlement state
- Large-scale world simulation
+14
View File
@@ -0,0 +1,14 @@
# Server Config
This folder is for server configuration templates.
Possible future config values:
```text
host=127.0.0.1
port=7777
max_players=2
tick_rate=20
```
Do not commit private IPs, tokens, or secrets.
+12
View File
@@ -0,0 +1,12 @@
# Server Source
This folder is for external server source code.
The first server only needs to:
- Start locally
- Accept clients
- Assign player IDs
- Receive transform packets
- Broadcast packets
- Handle disconnects
+18
View File
@@ -0,0 +1,18 @@
# Test Data
This folder is for safe test data used during development.
Allowed test data:
- Example packet files
- Fake player data
- Debug logs with no personal information
- Small manually written test cases
Do not include:
- Fallout 4 save files
- Game assets
- Bethesda archives
- Personal account data
- Private server information
+12
View File
@@ -0,0 +1,12 @@
# Sample Packets
This folder is for example packet data used during protocol testing.
Possible files later:
```text
welcome.json
transform.json
disconnect.json
animation_state.json
```
+14
View File
@@ -0,0 +1,14 @@
# Tools
This folder is for helper tools and development scripts.
Possible future tools:
- Build scripts
- Packaging scripts
- Log parsers
- Packet replay tools
- Test client scripts
- Development environment helpers
Do not place Fallout 4 game files or proprietary tools in this folder.
+11
View File
@@ -0,0 +1,11 @@
# Scripts
This folder is for small helper scripts.
Possible future scripts:
- Create folder structure
- Package test release
- Clean build outputs
- Validate protocol examples
- Parse plugin logs