✅ Windows Development NamedPipeServerStream in dll halting communications with client

import time

pipe_name = r'\\.\pipe\RobotControlPipe'
waitingForResponse = True

# Wait until the pipe server (C#) creates the pipe and is ready
while True:
    try:
        pipe = open(pipe_name, 'r+b', buffering=0)
        break
    except FileNotFoundError:
        print("Waiting for pipe server...")
        time.sleep(0.1)

print("Connected to pipe!")
cmdNum = 0

while True:
    cmdNum+=1
    try:
        dataTemp = pipe.readline()
        noData = False
        if dataTemp == b'':
            noData = True
            print("No Data")

        data = dataTemp
        # Decode bytes to string and strip newline
        data_str = data.decode().strip()
        parts = data_str.split(',')

        # Unpack into individual variables
        if not noData:
            try:
                jump_state = int(parts[0])
                pos_x = float(parts[1])
                pos_y = float(parts[2])
                vel_x = float(parts[3])
                vel_y = float(parts[4])
                state = float(parts[5])
                print(f"Jump: {jump_state}, Pos: ({pos_x}, {pos_y}), Vel: ({vel_x}, {vel_y}), Game State:{state}")

            except (IndexError, ValueError, NameError) as e:
                print("Error parsing data:", data_str, "->", e)
        cmd1 = "0,0,0,1,0,0,0"
        cmd2 = "0,0,1,0,0,0,0"
        # if cmdNum < 10000:
        #     pipe.write((cmd1 + "\n").encode())
        # else:
        #     pipe.write((cmd2 + "\n").encode())
        pipe.write((cmd1 + "\n").encode())
        pipe.flush()

    except Exception as e:
        print("Exception (probably broken pipe):", e)
        time.sleep(0.01)

import time

pipe_name = r'\\.\pipe\RobotControlPipe'
waitingForResponse = True

# Wait until the pipe server (C#) creates the pipe and is ready
while True:
    try:
        pipe = open(pipe_name, 'r+b', buffering=0)
        break
    except FileNotFoundError:
        print("Waiting for pipe server...")
        time.sleep(0.1)

print("Connected to pipe!")
cmdNum = 0

while True:
    cmdNum+=1
    try:
        dataTemp = pipe.readline()
        noData = False
        if dataTemp == b'':
            noData = True
            print("No Data")

        data = dataTemp
        # Decode bytes to string and strip newline
        data_str = data.decode().strip()
        parts = data_str.split(',')

        # Unpack into individual variables
        if not noData:
            try:
                jump_state = int(parts[0])
                pos_x = float(parts[1])
                pos_y = float(parts[2])
                vel_x = float(parts[3])
                vel_y = float(parts[4])
                state = float(parts[5])
                print(f"Jump: {jump_state}, Pos: ({pos_x}, {pos_y}), Vel: ({vel_x}, {vel_y}), Game State:{state}")

            except (IndexError, ValueError, NameError) as e:
                print("Error parsing data:", data_str, "->", e)
        cmd1 = "0,0,0,1,0,0,0"
        cmd2 = "0,0,1,0,0,0,0"
        # if cmdNum < 10000:
        #     pipe.write((cmd1 + "\n").encode())
        # else:
        #     pipe.write((cmd2 + "\n").encode())
        pipe.write((cmd1 + "\n").encode())
        pipe.flush()

    except Exception as e:
        print("Exception (probably broken pipe):", e)
        time.sleep(0.01)

C#
            lock (Gary)
            {
                data = $"{jumpState},{pos.X},{pos.Y},{vel.X},{vel.Y},{gameState}";
            }
                
            lock (Nathaniel)
            {
                player.jumpDown = input[0];
                player.slideDown = input[1];
                player.leftDown = input[2];
                player.rightDown = input[3];
                player.grappleDown = input[4];
                player.boostDown = input[5];
                player.itemDown = input[6];
            }

C#
            lock (Gary)
            {
                data = $"{jumpState},{pos.X},{pos.Y},{vel.X},{vel.Y},{gameState}";
            }
                
            lock (Nathaniel)
            {
                player.jumpDown = input[0];
                player.slideDown = input[1];
                player.leftDown = input[2];
                player.rightDown = input[3];
                player.grappleDown = input[4];
                player.boostDown = input[5];
                player.itemDown = input[6];
            }

C#
                    {
                        for (int i = 0; i < input.Length && i < parts.Length; i++) input[i] = parts[i] == "1";
                    }

C#
                    {
                        for (int i = 0; i < input.Length && i < parts.Length; i++) input[i] = parts[i] == "1";
                    }

C#
                    lock (Gary)
                    {
                        local = data + "\n";
                    }

C#
                    lock (Gary)
                    {
                        local = data + "\n";
                    }

using SRPlayer = _MXY9EldIZvy8vwVKj9_8Ql5FrpIXR9t7Lm01azYMwjSsOOs_Niu5asGaYW4Wa0w;

using SRPlayer = _MXY9EldIZvy8vwVKj9_8Ql5FrpIXR9t7Lm01azYMwjSsOOs_Niu5asGaYW4Wa0w;

import time

write_pipe_name = r'\\.\pipe\WriteRobotControl'
read_pipe_name = r'\\.\pipe\ReadRobotControl'
waitingForResponse = True

# Wait until the pipe server (C#) creates the pipe and is ready
while True:
    try:
        pipe_to_read = open(write_pipe_name, 'rb', buffering=0)
        break
    except FileNotFoundError:
        print("Waiting for write server...")
        time.sleep(0.1)

print("Found Write Server - Connected")

while True:
    try:
        pipe_to_write = open(read_pipe_name, 'wb', buffering=0) 
        break
    except FileNotFoundError:
        print("Waiting for read server...")
        time.sleep(0.1)             

print("Connected to pipes!")

import time

write_pipe_name = r'\\.\pipe\WriteRobotControl'
read_pipe_name = r'\\.\pipe\ReadRobotControl'
waitingForResponse = True

# Wait until the pipe server (C#) creates the pipe and is ready
while True:
    try:
        pipe_to_read = open(write_pipe_name, 'rb', buffering=0)
        break
    except FileNotFoundError:
        print("Waiting for write server...")
        time.sleep(0.1)

print("Found Write Server - Connected")

while True:
    try:
        pipe_to_write = open(read_pipe_name, 'wb', buffering=0) 
        break
    except FileNotFoundError:
        print("Waiting for read server...")
        time.sleep(0.1)             

print("Connected to pipes!")

C#
        private static NamedPipeServerStream writePipe;
        private static NamedPipeServerStream readPipe;
        private static StreamWriter pipeWriter;
        private static StreamReader pipeReader;
        private static bool waitingForResponse = false;
        private static bool responseRequired = true;

        private static Thread writerThread;
        private static Thread readerThread;
        private static Thread RWThread;

        public static readonly object Nathaniel = new object(); // Nathaniel is just a nice guy who helps us lock resources so we dont have memory based errors
        public static readonly object Gary = new object(); // Gary is Nathaniels friend, he does a similar job

        public static void Log(string message, string file)
        {
            string logPath = Path.Combine(dllFolder, file);
            File.AppendAllText(logPath, $"[{DateTime.Now:HH:mm:ss}] {message}\n");
        }

        public static void PlayerInit(SRPlayer player)
        {
            Log("PlayerInit", "init_log.txt");
            SRPlayer.disableInputPolling = true; // Disable input polling to prevent the game from overwriting our input
            if (writePipe == null && readPipe == null)
            {
                writePipe = new NamedPipeServerStream("WriteRobotControl", PipeDirection.Out, 1, PipeTransmissionMode.Message, PipeOptions.None);
                readPipe = new NamedPipeServerStream("ReadRobotControl", PipeDirection.In, 1, PipeTransmissionMode.Message, PipeOptions.None);
                writePipe.WaitForConnection(); // Wait for the client to connect (No failsafe currently, ensure client is running first)
                readPipe.WaitForConnection(); // Wait for the client to connect (No failsafe currently, ensure client is running first)
                gameState = 0;
                lock (Gary)
                {
                    data = $"{0},{0},{0},{0},{0},{gameState}";
                }
                Log("Pipe connected","init_log.txt");
                writerThread = new Thread(Write) { IsBackground = true };
                writerThread.Start();
                readerThread = new Thread(Read) { IsBackground = true };
                readerThread.Start();
                Log("Reader and Writer threads started", "init_log.txt");
            }
        }

C#
        private static NamedPipeServerStream writePipe;
        private static NamedPipeServerStream readPipe;
        private static StreamWriter pipeWriter;
        private static StreamReader pipeReader;
        private static bool waitingForResponse = false;
        private static bool responseRequired = true;

        private static Thread writerThread;
        private static Thread readerThread;
        private static Thread RWThread;

        public static readonly object Nathaniel = new object(); // Nathaniel is just a nice guy who helps us lock resources so we dont have memory based errors
        public static readonly object Gary = new object(); // Gary is Nathaniels friend, he does a similar job

        public static void Log(string message, string file)
        {
            string logPath = Path.Combine(dllFolder, file);
            File.AppendAllText(logPath, $"[{DateTime.Now:HH:mm:ss}] {message}\n");
        }

        public static void PlayerInit(SRPlayer player)
        {
            Log("PlayerInit", "init_log.txt");
            SRPlayer.disableInputPolling = true; // Disable input polling to prevent the game from overwriting our input
            if (writePipe == null && readPipe == null)
            {
                writePipe = new NamedPipeServerStream("WriteRobotControl", PipeDirection.Out, 1, PipeTransmissionMode.Message, PipeOptions.None);
                readPipe = new NamedPipeServerStream("ReadRobotControl", PipeDirection.In, 1, PipeTransmissionMode.Message, PipeOptions.None);
                writePipe.WaitForConnection(); // Wait for the client to connect (No failsafe currently, ensure client is running first)
                readPipe.WaitForConnection(); // Wait for the client to connect (No failsafe currently, ensure client is running first)
                gameState = 0;
                lock (Gary)
                {
                    data = $"{0},{0},{0},{0},{0},{gameState}";
                }
                Log("Pipe connected","init_log.txt");
                writerThread = new Thread(Write) { IsBackground = true };
                writerThread.Start();
                readerThread = new Thread(Read) { IsBackground = true };
                readerThread.Start();
                Log("Reader and Writer threads started", "init_log.txt");
            }
        }

C#
                writePipe = new NamedPipeServerStream("WriteRobotControl", PipeDirection.Out, 1, PipeTransmissionMode.Message, PipeOptions.None);
                writePipe.WaitForConnection(); // Wait for the client to connect (No failsafe currently, ensure client is running first)
                readPipe = new NamedPipeServerStream("ReadRobotControl", PipeDirection.In, 1, PipeTransmissionMode.Message, PipeOptions.None);
                readPipe.WaitForConnection(); // Wait for the client to connect (No failsafe currently, ensure client is running first)

C#
                writePipe = new NamedPipeServerStream("WriteRobotControl", PipeDirection.Out, 1, PipeTransmissionMode.Message, PipeOptions.None);
                writePipe.WaitForConnection(); // Wait for the client to connect (No failsafe currently, ensure client is running first)
                readPipe = new NamedPipeServerStream("ReadRobotControl", PipeDirection.In, 1, PipeTransmissionMode.Message, PipeOptions.None);
                readPipe.WaitForConnection(); // Wait for the client to connect (No failsafe currently, ensure client is running first)

C#
using System.Text.Json;

var data = new
{
    jump = jumpState,
    posX = pos.X,
    posY = pos.Y,
    velX = vel.X,
    velY = vel.Y,
    game = gameState
};

string json = JsonSerializer.Serialize(data);

C#
using System.Text.Json;

var data = new
{
    jump = jumpState,
    posX = pos.X,
    posY = pos.Y,
    velX = vel.X,
    velY = vel.Y,
    game = gameState
};

string json = JsonSerializer.Serialize(data);

C#
public class GameData
{
    public bool JumpState { get; set; }
    public float PosX { get; set; }
    public float PosY { get; set; }
    public float VelX { get; set; }
    public float VelY { get; set; }
    public int GameState { get; set; }
}

C#
public class GameData
{
    public bool JumpState { get; set; }
    public float PosX { get; set; }
    public float PosY { get; set; }
    public float VelX { get; set; }
    public float VelY { get; set; }
    public int GameState { get; set; }
}

readonly record struct Data(
  bool Jumping,
  float PosX,
  ...);

readonly record struct Data(
  bool Jumping,
  float PosX,
  ...);

readonly struct Data
{
  public Data(
    bool jumping,
    ...)
  {
    Jumping = jumping;
    ...
  }

  public bool Jumping { get; }
}

readonly struct Data
{
  public Data(
    bool jumping,
    ...)
  {
    Jumping = jumping;
    ...
  }

  public bool Jumping { get; }
}

C#
        public struct GameData // This class is used to store the game data that is sent to the pipe
        {
            public int Jump { get; set; }
            public float PosX { get; set; }
            public float PosY { get; set; }
            public float VelX { get; set; }
            public float VelY { get; set; }
            public int Game { get; set; }
        }

C#
        public struct GameData // This class is used to store the game data that is sent to the pipe
        {
            public int Jump { get; set; }
            public float PosX { get; set; }
            public float PosY { get; set; }
            public float VelX { get; set; }
            public float VelY { get; set; }
            public int Game { get; set; }
        }

C#
            var game = new GameData
            {
                Jump = jumpState,
                PosX = pos.X,
                PosY = pos.Y,
                VelX = vel.X,
                VelY = vel.Y,
                Game = gameState
            };

C#
            var game = new GameData
            {
                Jump = jumpState,
                PosX = pos.X,
                PosY = pos.Y,
                VelX = vel.X,
                VelY = vel.Y,
                Game = gameState
            };

while True:
    cmdNum+=1
    try:
        dataTemp = pipe_to_read.readline()
        noData = False
        if dataTemp == b'':
            noData = True
            print("No Data")

        data = dataTemp
        # Decode bytes to string and strip newline
        game = json.loads(data)

        # Unpack into individual variables
        if not noData:
            try:
                jump_state = game["Jump"]
                pos_x = game["PosX"]
                pos_y = game["PosY"]
                vel_x = game["VelX"]
                vel_y = game["VelY"]
                state = game["Game"]
                print(f"Jump: {jump_state}, Pos: ({pos_x}, {pos_y}), Vel: ({vel_x}, {vel_y}), Game State:{state}")

            except (IndexError, ValueError, NameError) as e:
                print("Error parsing data:", data, "->", e)

while True:
    cmdNum+=1
    try:
        dataTemp = pipe_to_read.readline()
        noData = False
        if dataTemp == b'':
            noData = True
            print("No Data")

        data = dataTemp
        # Decode bytes to string and strip newline
        game = json.loads(data)

        # Unpack into individual variables
        if not noData:
            try:
                jump_state = game["Jump"]
                pos_x = game["PosX"]
                pos_y = game["PosY"]
                vel_x = game["VelX"]
                vel_y = game["VelY"]
                state = game["Game"]
                print(f"Jump: {jump_state}, Pos: ({pos_x}, {pos_y}), Vel: ({vel_x}, {vel_y}), Game State:{state}")

            except (IndexError, ValueError, NameError) as e:
                print("Error parsing data:", data, "->", e)

jumpDown = False
        slideDown = False
        leftDown = False
        rightDown = False
        grappleDown = False
        boostDown = False
        itemDown = False

        cmd = {
            "Jump": jumpDown,
            "Slide": slideDown,
            "Left": leftDown,
            "Right": rightDown,
            "Grapple": grappleDown,
            "Boost": boostDown,
            "Item": itemDown
        }

jumpDown = False
        slideDown = False
        leftDown = False
        rightDown = False
        grappleDown = False
        boostDown = False
        itemDown = False

        cmd = {
            "Jump": jumpDown,
            "Slide": slideDown,
            "Left": leftDown,
            "Right": rightDown,
            "Grapple": grappleDown,
            "Boost": boostDown,
            "Item": itemDown
        }

json.dump(result, pipe)

json.dump(result, pipe)

json.dump(cmd, pipe)
pipe.write("\n")
pipe.flush()

json.dump(cmd, pipe)
pipe.write("\n")
pipe.flush()