Add project files.

MSCO.cs

@@ -0,0 +1,73 @@
+using MSCLoader;
+using UnityEngine;
+
+namespace MSCO
+{
+    public class MSCO : Mod
+    {
+        public const string ModVersion = "1.0";
+
+        public override string ID => "MSCO"; // Your (unique) mod ID
+        public override string Name => "MSCO"; // Your mod name
+        public override string Author => "MBM"; // Name of the Author (your name)
+        public override string Version => ModVersion; // Version
+        public override string Description => "Online mod by mbm.wtf"; // Short description of your mod
+        public override Game SupportedGames => Game.MySummerCar;
+
+        bool commandAdded;
+
+        public override void ModSetup()
+        {
+            SetupFunction(Setup.OnMenuLoad, Mod_OnMenuLoad);
+            SetupFunction(Setup.OnLoad, Mod_OnLoad);
+            SetupFunction(Setup.PostLoad, Mod_PostLoad);
+            SetupFunction(Setup.OnSave, Mod_OnSave);
+            SetupFunction(Setup.OnGUI, Mod_OnGUI);
+            SetupFunction(Setup.Update, Mod_Update);
+            SetupFunction(Setup.FixedUpdate, Mod_FixedUpdate);
+            SetupFunction(Setup.ModSettings, Mod_Settings);
+        }
+
+        private void Mod_Settings()
+        {
+            // All settings should be created here.
+            // DO NOT put anything that isn't settings or keybinds in here!
+        }
+
+        private void Mod_OnMenuLoad()
+        {
+            ModConsole.Print("Welcome to MSCO by mbm.wtf");
+            // Netzwerk + Lobby leben in einem eigenen Objekt, das Szenenwechsel überlebt
+            MultiplayerManager.Ensure();
+            if (!commandAdded)
+            {
+                ConsoleCommand.Add(new MpCommand());
+                commandAdded = true;
+            }
+        }
+        private void Mod_OnLoad()
+        {
+            // Called once, when mod is loading after game is fully loaded
+        }
+        private void Mod_PostLoad()
+        {
+            // Called once, after all mods finished OnLoad
+        }
+        private void Mod_OnSave()
+        {
+            // Called once, when save and quit
+        }
+        private void Mod_OnGUI()
+        {
+            // Lobby/Status zeichnet der MultiplayerManager
+        }
+        private void Mod_Update()
+        {
+            // Netzwerk läuft im MultiplayerManager
+        }
+        private void Mod_FixedUpdate()
+        {
+            // FixedUpdate is called once per fixed frame
+        }
+    }
+}

MSCO.csproj

@@ -0,0 +1,106 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Release</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{CE3FFBAB-946E-9569-CCAA-9CFA2D5C11F3}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>MSCO</RootNamespace>
+    <AssemblyName>MSCO</AssemblyName>
+    <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <TargetFrameworkProfile>Unity Full v3.5</TargetFrameworkProfile>
+    <LangVersion>13</LangVersion>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>none</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+    <Reference Include="UnityEngine">
+      <HintPath>F:\SteamLibrary\steamapps\common\My Summer Car\mysummercar_Data\Managed\UnityEngine.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="MSCLoader">
+      <HintPath>F:\SteamLibrary\steamapps\common\My Summer Car\mysummercar_Data\Managed\MSCLoader.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="Assembly-CSharp">
+      <HintPath>F:\SteamLibrary\steamapps\common\My Summer Car\mysummercar_Data\Managed\Assembly-CSharp.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="cInput">
+      <HintPath>F:\SteamLibrary\steamapps\common\My Summer Car\mysummercar_Data\Managed\cInput.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="PlayMaker">
+      <HintPath>F:\SteamLibrary\steamapps\common\My Summer Car\mysummercar_Data\Managed\PlayMaker.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="0Harmony">
+      <HintPath>F:\SteamLibrary\steamapps\common\My Summer Car\mysummercar_Data\Managed\0Harmony.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="MpCommand.cs" />
+    <Compile Include="MenuHelper.cs" />
+    <Compile Include="MSCO.cs" />
+    <Compile Include="MultiplayerManager.cs" />
+    <Compile Include="NetSession.cs" />
+    <Compile Include="SaveSync.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="RemotePlayer.cs" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <PropertyGroup>
+    <MSCMODSFOLDER>C:\Users\nico\Documents\MySummerCar\Mods</MSCMODSFOLDER>
+    <MWCMODSFOLDER>NONE</MWCMODSFOLDER>
+    <ABFOLDER>NONE</ABFOLDER>
+    <PostBuildEvent>
+      echo .
+      echo "== Running post build actions for configuration $(ConfigurationName)! ==="
+
+      IF "$(ConfigurationName)" == "Release" (
+      IF NOT "$(MSCMODSFOLDER)" == "NONE" (
+      copy "$(TargetPath)" "$(MSCMODSFOLDER)" /y
+      echo  "Copied dll into MSC mods folder!"        
+      )
+      IF NOT "$(MWCMODSFOLDER)" == "NONE" (
+      copy "$(TargetPath)" "$(MWCMODSFOLDER)" /y
+      echo  "Copied dll into MWC mods folder!"        
+      )
+      )
+
+if "$(ConfigurationName)" == "Debug" (
+copy "$(TargetPath)" "C:\Users\nico\Documents\MySummerCar\Mods" /y
+copy "$(TargetDir)$(TargetName).pdb" "C:\Users\nico\Documents\MySummerCar\Mods" /y
+cd "C:\Users\nico\Documents\MySummerCar\Mods"
+call "C:\Users\nico\Documents\MySummerCar\Mods\debug.bat"
+) ELSE (
+copy "$(TargetPath)" "C:\Users\nico\Documents\MySummerCar\Mods\Mods" /y
+)
+</PostBuildEvent>
+  </PropertyGroup>
+</Project>

MSCO.slnx

@@ -0,0 +1,3 @@
+<Solution>
+  <Project Path="MSCO.csproj" />
+</Solution>

MenuHelper.cs

@@ -0,0 +1,77 @@
+using System.Reflection;
+using HutongGames.PlayMaker;
+using HutongGames.PlayMaker.Actions;
+using MSCLoader;
+using UnityEngine;
+
+namespace MSCO
+{
+    /// <summary>Hilfsfunktionen rund um Hauptmenü und das Laden der Spielszene.</summary>
+    public static class MenuHelper
+    {
+        public const string MenuScene = "MainMenu";
+        public const string GameScene = "GAME";
+
+        public static bool InMenu { get { return Application.loadedLevelName == MenuScene; } }
+        public static bool InGame { get { return Application.loadedLevelName == GameScene; } }
+
+        static readonly MethodInfo switchState =
+            typeof(Fsm).GetMethod("SwitchState", BindingFlags.NonPublic | BindingFlags.Instance);
+
+        /// <summary>
+        /// Sucht im Hauptmenü die PlayMaker-FSM des CONTINUE-Buttons und den Zustand,
+        /// der per LoadLevel die Szene "GAME" lädt.
+        /// </summary>
+        public static bool FindContinueLoadState(out PlayMakerFSM fsm, out FsmState state)
+        {
+            fsm = null;
+            state = null;
+            foreach (Object o in Object.FindObjectsOfType(typeof(PlayMakerFSM)))
+            {
+                var candidate = (PlayMakerFSM)o;
+                if (!HierarchyContains(candidate.transform, "continue")) continue;
+
+                foreach (FsmState s in candidate.FsmStates)
+                {
+                    if (!s.ActionsLoaded) s.LoadActions();
+                    if (s.Actions == null) continue;
+                    foreach (FsmStateAction action in s.Actions)
+                    {
+                        var load = action as LoadLevel;
+                        if (load != null && load.levelName != null && load.levelName.Value == GameScene)
+                        {
+                            fsm = candidate;
+                            state = s;
+                            return true;
+                        }
+                    }
+                }
+            }
+            return false;
+        }
+
+        /// <summary>Startet das Spiel wie ein Klick auf CONTINUE.</summary>
+        public static void StartGame()
+        {
+            PlayMakerFSM fsm;
+            FsmState state;
+            if (switchState != null && FindContinueLoadState(out fsm, out state))
+            {
+                ModConsole.Print("[MSCO] Loading via CONTINUE (" + fsm.name + " / " + state.Name + ")");
+                switchState.Invoke(fsm.Fsm, new object[] { state });
+            }
+            else
+            {
+                ModConsole.Warning("[MSCO] CONTINUE button not found, loading GAME directly");
+                Application.LoadLevel(GameScene);
+            }
+        }
+
+        static bool HierarchyContains(Transform t, string text)
+        {
+            for (; t != null; t = t.parent)
+                if (t.name.ToLower().Contains(text)) return true;
+            return false;
+        }
+    }
+}

MpCommand.cs

@@ -0,0 +1,38 @@
+using MSCLoader;
+
+namespace MSCO
+{
+    /// <summary>Konsolenbefehl: mp host [port] | mp join <ip> [port] | mp stop</summary>
+    public class MpCommand : ConsoleCommand
+    {
+        public override string Name => "mp";
+        public override string Help => "mp host [port] | mp join <ip> [port] | mp stop";
+
+        public override void Run(string[] args)
+        {
+            var mp = MultiplayerManager.Instance;
+            if (mp == null) { ModConsole.Print("[MSCO] Not ready yet"); return; }
+            if (args.Length == 0) { ModConsole.Print(Help); return; }
+
+            int port = MultiplayerManager.DefaultPort;
+            switch (args[0].ToLower())
+            {
+                case "host":
+                    if (args.Length > 1) int.TryParse(args[1], out port);
+                    mp.Host(port);
+                    break;
+                case "join":
+                    if (args.Length < 2) { ModConsole.Print("mp join <ip> [port]"); return; }
+                    if (args.Length > 2) int.TryParse(args[2], out port);
+                    mp.Join(args[1], port);
+                    break;
+                case "stop":
+                    mp.Disconnect();
+                    break;
+                default:
+                    ModConsole.Print(Help);
+                    break;
+            }
+        }
+    }
+}

MultiplayerManager.cs

@@ -0,0 +1,369 @@
+using System.Collections.Generic;
+using System.IO;
+using HutongGames.PlayMaker;
+using MSCLoader;
+using UnityEngine;
+
+namespace MSCO
+{
+    /// <summary>
+    /// Lebt über Szenenwechsel hinweg (DontDestroyOnLoad): Lobby im Hauptmenü,
+    /// Spielstand-Übertragung beim Start und Positions-Sync im Spiel.
+    /// </summary>
+    public class MultiplayerManager : MonoBehaviour
+    {
+        public static MultiplayerManager Instance;
+        public const int DefaultPort = 7777;
+        const float SendInterval = 0.05f; // 20 Updates pro Sekunde
+
+        NetSession session;
+        bool peerReady;          // Handshake abgeschlossen
+        bool saveSentThisLoad;   // Host: Spielstand für diesen Start schon verschickt
+        bool receivingSave;      // Client: Spielstand wird gerade empfangen
+        string status = "";
+
+        string ipInput = "127.0.0.1";
+        string portInput = DefaultPort.ToString();
+
+        PlayMakerFSM continueFsm;
+        FsmState continueState;
+        float nextContinueSearch;
+
+        Transform localPlayer;
+        RemotePlayer remotePlayer;
+        float sendTimer;
+        float nextPlayerSearch;
+
+        public static void Ensure()
+        {
+            if (Instance != null) return;
+            var go = new GameObject("MSCO_Multiplayer");
+            DontDestroyOnLoad(go);
+            Instance = go.AddComponent<MultiplayerManager>();
+        }
+
+        void Awake()
+        {
+            Application.runInBackground = true;
+            // Falls das Spiel beim letzten Mal abgestürzt ist: eigenen Spielstand zurückholen
+            TryRestoreBackup();
+        }
+
+        // ---------------------------------------------------------------- Verbindung
+
+        public void Host(int port)
+        {
+            Disconnect();
+            try
+            {
+                session = NetSession.StartHost(port);
+                SetStatus("Hosting on port " + port + " - waiting for player...");
+            }
+            catch (System.Exception e)
+            {
+                SetStatus("Could not host: " + e.Message);
+            }
+        }
+
+        public void Join(string ip, int port)
+        {
+            if (!MenuHelper.InMenu)
+            {
+                SetStatus("Join from the main menu!");
+                return;
+            }
+            Disconnect();
+            session = NetSession.StartClient(ip, port);
+            SetStatus("Connecting to " + ip + ":" + port + "...");
+        }
+
+        public void Disconnect()
+        {
+            if (session != null) session.Close();
+            OnSessionEnded("Disconnected");
+        }
+
+        void OnSessionEnded(string reason)
+        {
+            session = null;
+            peerReady = false;
+            DestroyRemotePlayer();
+            if (receivingSave)
+            {
+                // Abbruch mitten in der Übertragung: eigenen Spielstand zurück
+                receivingSave = false;
+                TryRestoreBackup();
+            }
+            SetStatus(reason);
+        }
+
+        // ---------------------------------------------------------------- Update
+
+        void Update()
+        {
+            if (session == null) return;
+
+            List<Message> messages = session.Poll();
+            if (session.ConsumeConnected()) OnConnected();
+            foreach (Message m in messages) Handle(m);
+
+            if (session.IsClosed)
+            {
+                OnSessionEnded(session.CloseReason);
+                return;
+            }
+
+            if (session.IsHost && peerReady && MenuHelper.InMenu && !saveSentThisLoad)
+                WatchHostContinue();
+
+            if (MenuHelper.InGame) UpdateInGame();
+        }
+
+        void OnConnected()
+        {
+            if (session.IsHost)
+            {
+                SetStatus("Player connecting...");
+            }
+            else
+            {
+                session.Send(MsgType.Hello, NetSession.Build(w => w.Write(MSCO.ModVersion)));
+                SetStatus("Connected, waiting for host...");
+            }
+        }
+
+        void Handle(Message m)
+        {
+            BinaryReader r = m.Reader();
+            switch (m.Type)
+            {
+                case MsgType.Hello:
+                    if (!session.IsHost) return;
+                    string version = r.ReadString();
+                    if (version != MSCO.ModVersion)
+                    {
+                        session.Send(MsgType.Reject, NetSession.Build(w =>
+                            w.Write("Version mismatch (host " + MSCO.ModVersion + ", you " + version + ")")));
+                        session.Close("Player rejected: wrong mod version " + version);
+                        return;
+                    }
+                    session.Send(MsgType.Welcome);
+                    peerReady = true;
+                    if (MenuHelper.InGame)
+                    {
+                        // Host spielt schon: letzten gespeicherten Stand schicken
+                        SendSaveAndStart();
+                        SetStatus("Player joined (sent last saved game)");
+                    }
+                    else
+                    {
+                        SetStatus("Player connected - press CONTINUE to start!");
+                    }
+                    break;
+
+                case MsgType.Welcome:
+                    peerReady = true;
+                    SetStatus("Connected - waiting for host to press CONTINUE...");
+                    break;
+
+                case MsgType.Reject:
+                    session.Close("Rejected by host: " + r.ReadString());
+                    break;
+
+                case MsgType.SaveBegin:
+                    if (session.IsHost) return;
+                    if (!MenuHelper.InMenu)
+                    {
+                        SetStatus("Host started - go back to the main menu to join");
+                        return;
+                    }
+                    SaveSync.BeginReceive();
+                    receivingSave = true;
+                    SetStatus("Receiving host's save...");
+                    break;
+
+                case MsgType.SaveFile:
+                    if (!receivingSave) return;
+                    string name = r.ReadString();
+                    byte[] data = r.ReadBytes(r.ReadInt32());
+                    SaveSync.WriteFile(name, data);
+                    break;
+
+                case MsgType.StartGame:
+                    if (!receivingSave) return;
+                    receivingSave = false;
+                    SetStatus("Loading host's game...");
+                    MenuHelper.StartGame();
+                    break;
+
+                case MsgType.Player:
+                    if (MenuHelper.InGame) ApplyRemoteState(PlayerState.Deserialize(r));
+                    break;
+            }
+        }
+
+        // ---------------------------------------------------------------- Host: Spielstart
+
+        void WatchHostContinue()
+        {
+            if (continueFsm == null)
+            {
+                if (Time.realtimeSinceStartup < nextContinueSearch) return;
+                nextContinueSearch = Time.realtimeSinceStartup + 1f;
+                if (!MenuHelper.FindContinueLoadState(out continueFsm, out continueState)) return;
+            }
+            // Host hat CONTINUE gedrückt und die FSM ist im Lade-Zustand
+            if (continueFsm.ActiveStateName == continueState.Name)
+                SendSaveAndStart();
+        }
+
+        void SendSaveAndStart()
+        {
+            saveSentThisLoad = true;
+            List<KeyValuePair<string, byte[]>> files = SaveSync.ReadLocalSave();
+            session.Send(MsgType.SaveBegin);
+            foreach (KeyValuePair<string, byte[]> file in files)
+            {
+                session.Send(MsgType.SaveFile, NetSession.Build(w =>
+                {
+                    w.Write(file.Key);
+                    w.Write(file.Value.Length);
+                    w.Write(file.Value);
+                }));
+            }
+            session.Send(MsgType.StartGame);
+            ModConsole.Print("[MSCO] Sent save (" + files.Count + " files) to player");
+        }
+
+        void OnLevelWasLoaded(int level)
+        {
+            if (MenuHelper.InGame)
+            {
+                // Falls der CONTINUE-Klick nicht erkannt wurde: jetzt nachholen
+                if (session != null && session.IsHost && peerReady && !saveSentThisLoad)
+                    SendSaveAndStart();
+                localPlayer = null;
+            }
+            else if (MenuHelper.InMenu)
+            {
+                saveSentThisLoad = false;
+                continueFsm = null;
+                localPlayer = null;
+                DestroyRemotePlayer();
+                if (!receivingSave) TryRestoreBackup();
+                if (session != null && peerReady && !session.IsHost)
+                    SetStatus("Connected - waiting for host to press CONTINUE...");
+            }
+        }
+
+        void TryRestoreBackup()
+        {
+            try { SaveSync.RestoreBackup(); }
+            catch (System.Exception e) { ModConsole.Error("[MSCO] Could not restore own save: " + e.Message); }
+        }
+
+        // ---------------------------------------------------------------- Im Spiel
+
+        void UpdateInGame()
+        {
+            if (localPlayer == null)
+            {
+                if (Time.realtimeSinceStartup < nextPlayerSearch) return;
+                nextPlayerSearch = Time.realtimeSinceStartup + 1f;
+                GameObject player = GameObject.Find("PLAYER");
+                if (player == null) return;
+                localPlayer = player.transform;
+            }
+
+            if (peerReady)
+            {
+                sendTimer += Time.deltaTime;
+                if (sendTimer >= SendInterval)
+                {
+                    sendTimer = 0f;
+                    session.Send(MsgType.Player, new PlayerState
+                    {
+                        Position = localPlayer.position,
+                        RotationY = localPlayer.eulerAngles.y
+                    }.Serialize());
+                }
+            }
+
+            if (remotePlayer != null) remotePlayer.Tick(Time.deltaTime);
+        }
+
+        void ApplyRemoteState(PlayerState state)
+        {
+            if (remotePlayer == null)
+            {
+                // Platzhalter-Modell: eine Kapsel
+                GameObject go = GameObject.CreatePrimitive(PrimitiveType.Capsule);
+                go.name = "MSCO_RemotePlayer";
+                Destroy(go.GetComponent<Collider>()); // stört sonst Physik/Trigger
+                go.GetComponent<Renderer>().material.color = Color.cyan;
+                go.transform.position = state.Position;
+                remotePlayer = go.AddComponent<RemotePlayer>();
+                ModConsole.Print("[MSCO] Other player is in the game");
+            }
+            remotePlayer.SetTarget(state);
+        }
+
+        void DestroyRemotePlayer()
+        {
+            if (remotePlayer != null) Destroy(remotePlayer.gameObject);
+            remotePlayer = null;
+        }
+
+        // ---------------------------------------------------------------- GUI
+
+        void OnGUI()
+        {
+            if (MenuHelper.InMenu) DrawLobby();
+            else if (session != null) GUI.Label(new Rect(10, 10, 500, 25), "[MSCO] " + status);
+        }
+
+        void DrawLobby()
+        {
+            GUILayout.BeginArea(new Rect(10, 10, 280, 200), GUI.skin.box);
+            GUILayout.Label("MSCO Multiplayer");
+
+            if (session == null)
+            {
+                GUILayout.BeginHorizontal();
+                GUILayout.Label("IP", GUILayout.Width(40));
+                ipInput = GUILayout.TextField(ipInput);
+                GUILayout.EndHorizontal();
+
+                GUILayout.BeginHorizontal();
+                GUILayout.Label("Port", GUILayout.Width(40));
+                portInput = GUILayout.TextField(portInput);
+                GUILayout.EndHorizontal();
+
+                GUILayout.BeginHorizontal();
+                if (GUILayout.Button("Host")) Host(ParsePort());
+                if (GUILayout.Button("Join")) Join(ipInput.Trim(), ParsePort());
+                GUILayout.EndHorizontal();
+            }
+            else
+            {
+                GUILayout.Label(session.IsHost ? "You are the HOST" : "You are a CLIENT");
+                if (GUILayout.Button("Disconnect")) Disconnect();
+            }
+
+            GUILayout.Label(status);
+            GUILayout.EndArea();
+        }
+
+        int ParsePort()
+        {
+            int port;
+            return int.TryParse(portInput, out port) ? port : DefaultPort;
+        }
+
+        void SetStatus(string text)
+        {
+            status = text;
+            ModConsole.Print("[MSCO] " + text);
+        }
+    }
+}

NetSession.cs

@@ -0,0 +1,235 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Net;
+using System.Net.Sockets;
+using UnityEngine;
+
+namespace MSCO
+{
+    public enum MsgType : byte
+    {
+        Hello = 1,      // Client -> Host: Mod-Version
+        Welcome = 2,    // Host -> Client: Handshake ok
+        Reject = 3,     // Host -> Client: Grund
+        Player = 4,     // Spielerposition
+        SaveBegin = 5,  // Host -> Client: Spielstand kommt
+        SaveFile = 6,   // Host -> Client: Dateiname + Inhalt
+        StartGame = 7,  // Host -> Client: jetzt laden
+    }
+
+    public struct Message
+    {
+        public MsgType Type;
+        public byte[] Payload;
+
+        public BinaryReader Reader()
+        {
+            return new BinaryReader(new MemoryStream(Payload));
+        }
+    }
+
+    public struct PlayerState
+    {
+        public Vector3 Position;
+        public float RotationY;
+
+        public byte[] Serialize()
+        {
+            Vector3 pos = Position;
+            float rotY = RotationY;
+            return NetSession.Build(w =>
+            {
+                w.Write(pos.x); w.Write(pos.y); w.Write(pos.z);
+                w.Write(rotY);
+            });
+        }
+
+        public static PlayerState Deserialize(BinaryReader r)
+        {
+            return new PlayerState
+            {
+                Position = new Vector3(r.ReadSingle(), r.ReadSingle(), r.ReadSingle()),
+                RotationY = r.ReadSingle()
+            };
+        }
+    }
+
+    /// <summary>
+    /// TCP-Verbindung zu genau einem Mitspieler. Nachrichten: [int Länge][byte Typ][Payload].
+    /// Lesen ist nicht-blockierend und wird jedes Frame über Poll() abgefragt.
+    /// </summary>
+    public class NetSession
+    {
+        const int MaxFrame = 32 * 1024 * 1024;
+
+        public bool IsHost { get; private set; }
+        public bool IsConnected { get { return stream != null; } }
+        public bool IsClosed { get; private set; }
+        public string CloseReason { get; private set; }
+
+        TcpListener listener;
+        TcpClient client;
+        NetworkStream stream;
+        IAsyncResult connecting;
+        bool justConnected;
+
+        byte[] buffer = new byte[64 * 1024];
+        int bufferCount;
+
+        public static NetSession StartHost(int port)
+        {
+            var s = new NetSession { IsHost = true };
+            s.listener = new TcpListener(IPAddress.Any, port);
+            s.listener.Start();
+            return s;
+        }
+
+        public static NetSession StartClient(string ip, int port)
+        {
+            var s = new NetSession();
+            s.client = new TcpClient();
+            s.connecting = s.client.BeginConnect(ip, port, null, null);
+            return s;
+        }
+
+        /// <summary>True genau einmal, direkt nachdem die Verbindung steht.</summary>
+        public bool ConsumeConnected()
+        {
+            bool c = justConnected;
+            justConnected = false;
+            return c;
+        }
+
+        public List<Message> Poll()
+        {
+            var messages = new List<Message>();
+            if (IsClosed) return messages;
+
+            try
+            {
+                AcceptOrConnect();
+                if (stream == null) return messages;
+
+                // Verbindung von der Gegenseite geschlossen?
+                if (client.Client.Poll(0, SelectMode.SelectRead) && client.Available == 0)
+                {
+                    Close("Connection closed by other player");
+                    return messages;
+                }
+
+                while (stream.DataAvailable)
+                {
+                    EnsureCapacity(bufferCount + client.Available);
+                    int read = stream.Read(buffer, bufferCount, buffer.Length - bufferCount);
+                    if (read <= 0) break;
+                    bufferCount += read;
+                }
+
+                ParseFrames(messages);
+            }
+            catch (Exception e)
+            {
+                Close("Network error: " + e.Message);
+            }
+            return messages;
+        }
+
+        void AcceptOrConnect()
+        {
+            if (IsHost)
+            {
+                while (listener.Pending())
+                {
+                    TcpClient incoming = listener.AcceptTcpClient();
+                    if (client != null) { incoming.Close(); continue; } // nur ein Mitspieler
+                    client = incoming;
+                    OnSocketReady();
+                }
+            }
+            else if (connecting != null && connecting.IsCompleted)
+            {
+                IAsyncResult result = connecting;
+                connecting = null;
+                client.EndConnect(result); // wirft, wenn nicht erreichbar
+                OnSocketReady();
+            }
+        }
+
+        void OnSocketReady()
+        {
+            client.NoDelay = true;
+            client.SendBufferSize = 4 * 1024 * 1024;
+            stream = client.GetStream();
+            justConnected = true;
+        }
+
+        void ParseFrames(List<Message> messages)
+        {
+            int offset = 0;
+            while (bufferCount - offset >= 5)
+            {
+                int length = BitConverter.ToInt32(buffer, offset);
+                if (length < 1 || length > MaxFrame) throw new IOException("Invalid packet");
+                if (bufferCount - offset - 4 < length) break;
+
+                var payload = new byte[length - 1];
+                Buffer.BlockCopy(buffer, offset + 5, payload, 0, payload.Length);
+                messages.Add(new Message { Type = (MsgType)buffer[offset + 4], Payload = payload });
+                offset += 4 + length;
+            }
+            if (offset > 0)
+            {
+                Buffer.BlockCopy(buffer, offset, buffer, 0, bufferCount - offset);
+                bufferCount -= offset;
+            }
+        }
+
+        void EnsureCapacity(int needed)
+        {
+            if (needed <= buffer.Length) return;
+            var bigger = new byte[Math.Max(needed, buffer.Length * 2)];
+            Buffer.BlockCopy(buffer, 0, bigger, 0, bufferCount);
+            buffer = bigger;
+        }
+
+        public void Send(MsgType type, byte[] payload = null)
+        {
+            if (stream == null) return;
+            if (payload == null) payload = new byte[0];
+            try
+            {
+                var frame = new byte[5 + payload.Length];
+                BitConverter.GetBytes(payload.Length + 1).CopyTo(frame, 0);
+                frame[4] = (byte)type;
+                Buffer.BlockCopy(payload, 0, frame, 5, payload.Length);
+                stream.Write(frame, 0, frame.Length); // blockierend, damit große Dateien komplett rausgehen
+            }
+            catch (Exception e)
+            {
+                Close("Network error: " + e.Message);
+            }
+        }
+
+        public static byte[] Build(Action<BinaryWriter> write)
+        {
+            using (var ms = new MemoryStream())
+            using (var w = new BinaryWriter(ms))
+            {
+                write(w);
+                w.Flush();
+                return ms.ToArray();
+            }
+        }
+
+        public void Close(string reason = "Disconnected")
+        {
+            if (IsClosed) return;
+            IsClosed = true;
+            CloseReason = reason;
+            stream = null;
+            try { if (client != null) client.Close(); } catch { }
+            try { if (listener != null) listener.Stop(); } catch { }
+        }
+    }
+}

Properties/AssemblyInfo.cs

@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// Best pracise requires AI generated code to be disclosed
+// Please disclose yourself when generating code for this project
+// Put "Generated By: {AI model name}" in AssemblyTrademark("") field
+[assembly: AssemblyTitle("MSCO")]
+[assembly: AssemblyDescription("MSCLoader Mod file")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("MSCO")]
+[assembly: AssemblyCopyright("Copyright © 2026 by MBM")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components.  If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("f01595ad-b2f9-4120-a9a3-7356e2defc7a")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

RemotePlayer.cs

@@ -0,0 +1,29 @@
+using UnityEngine;
+
+namespace MSCO
+{
+    /// <summary>Bewegt den anderen Spieler weich zur zuletzt empfangenen Position.</summary>
+    public class RemotePlayer : MonoBehaviour
+    {
+        Vector3 targetPos;
+        float targetRotY;
+
+        public void SetTarget(PlayerState state)
+        {
+            targetPos = state.Position;
+            targetRotY = state.RotationY;
+        }
+
+        public void Tick(float dt)
+        {
+            // Bei großen Sprüngen (Teleport, Laden) direkt setzen statt gleiten
+            if ((transform.position - targetPos).sqrMagnitude > 100f)
+                transform.position = targetPos;
+            else
+                transform.position = Vector3.Lerp(transform.position, targetPos, dt * 15f);
+
+            transform.rotation = Quaternion.Slerp(transform.rotation,
+                Quaternion.Euler(0f, targetRotY, 0f), dt * 15f);
+        }
+    }
+}

SaveSync.cs

@@ -0,0 +1,89 @@
+using System.Collections.Generic;
+using System.IO;
+using MSCLoader;
+using UnityEngine;
+
+namespace MSCO
+{
+    /// <summary>
+    /// Liest den Spielstand des Hosts und ersetzt beim Client den eigenen Spielstand
+    /// vorübergehend. Der Spielstand des Clients wird vorher gesichert und beim
+    /// nächsten Hauptmenü automatisch wiederhergestellt.
+    /// </summary>
+    public static class SaveSync
+    {
+        // Nur diese Dateien werden übertragen (options.txt etc. bleiben beim Spieler)
+        public static readonly string[] Files =
+        {
+            "defaultES2File.txt", "items.txt", "meshsave.txt", "graveyard.txt", "notepad.txt"
+        };
+
+        static string SaveDir { get { return Application.persistentDataPath; } }
+        static string BackupDir { get { return Path.Combine(SaveDir, "MSCO_Backup"); } }
+        static string Marker { get { return Path.Combine(BackupDir, "backup_active"); } }
+
+        public static bool HasBackup { get { return File.Exists(Marker); } }
+
+        public static List<KeyValuePair<string, byte[]>> ReadLocalSave()
+        {
+            var result = new List<KeyValuePair<string, byte[]>>();
+            foreach (string name in Files)
+            {
+                string path = Path.Combine(SaveDir, name);
+                if (File.Exists(path))
+                    result.Add(new KeyValuePair<string, byte[]>(name, File.ReadAllBytes(path)));
+            }
+            return result;
+        }
+
+        /// <summary>Eigenen Spielstand sichern (nur einmal) und die Spielstand-Dateien leeren.</summary>
+        public static void BeginReceive()
+        {
+            if (!HasBackup)
+            {
+                Directory.CreateDirectory(BackupDir);
+                foreach (string name in Files)
+                {
+                    string path = Path.Combine(SaveDir, name);
+                    if (File.Exists(path)) File.Copy(path, Path.Combine(BackupDir, name), true);
+                }
+                File.WriteAllText(Marker, "MSCO backup of the client's own save. Restored automatically.");
+                ModConsole.Print("[MSCO] Own save backed up to " + BackupDir);
+            }
+            DeleteSaveFiles();
+        }
+
+        public static void WriteFile(string name, byte[] data)
+        {
+            // Nur bekannte Dateinamen erlauben, damit der Host nichts anderes überschreiben kann
+            if (System.Array.IndexOf(Files, name) < 0)
+            {
+                ModConsole.Warning("[MSCO] Ignored unexpected save file: " + name);
+                return;
+            }
+            File.WriteAllBytes(Path.Combine(SaveDir, name), data);
+        }
+
+        public static void RestoreBackup()
+        {
+            if (!HasBackup) return;
+            DeleteSaveFiles();
+            foreach (string name in Files)
+            {
+                string backup = Path.Combine(BackupDir, name);
+                if (File.Exists(backup)) File.Copy(backup, Path.Combine(SaveDir, name), true);
+            }
+            Directory.Delete(BackupDir, true);
+            ModConsole.Print("[MSCO] Own save restored.");
+        }
+
+        static void DeleteSaveFiles()
+        {
+            foreach (string name in Files)
+            {
+                string path = Path.Combine(SaveDir, name);
+                if (File.Exists(path)) File.Delete(path);
+            }
+        }
+    }
+}