[Brainstorm] Seperate Game/Npc etc Servers

    public delegate void PipeReceives(PipeClient Client, byte[] Arguments);
    public class PipeServer
    {
        private Thread readThread, EnableThread;
        private SafeFileHandle cHandle;
        public event PipeReceives PipeReceived;
        public string Name;
        private uint BufferSize = 4096;

        public PipeServer()
        {
            EnableThread = new Thread(new ThreadStart(Run));
        }

        public void Enable(string Input)
        {
            this.Name = Input;
            EnableThread.Start();
        }

        private void Run()
        {
            while (true)
            {
                this.cHandle = Native.CreateNamedPipe(
                    @"\\.\pipe\"+Name+"",
                    Native.DUPLEX | Native.FILE_FLAG_OVERLAPPED,
                    0,
                    255,
                    this.BufferSize,
                    this.BufferSize,
                    0,
                    IntPtr.Zero);

                switch (this.cHandle.IsInvalid)
                {
                    case true: return;
                    case false:
                        switch (Native.ConnectNamedPipe(this.cHandle, IntPtr.Zero))
                        {
                            case 0: return;
                            default:
                                PipeClient Instance = new PipeClient();
                                Instance.sHandle = this.cHandle;
                                Instance.ID = CPX.LastConnected++;

                                lock (CPX.ClientPool)
                                    CPX.ClientPool.Add(Instance.ID, Instance);

                                this.readThread = new Thread(new ParameterizedThreadStart(Accept));
                                this.readThread.Start(Instance);
                                break;
                        }
                        break;
                }
            }
        }

        private void Accept(object Param)
        {
            PipeClient Instance = (Param as PipeClient);
            Instance.fStream = new FileStream(Instance.sHandle, FileAccess.ReadWrite, 4096, true);
            int BytesReadedSoFar;
            byte[] Buffer = new byte[this.BufferSize];

            while (true)
            {
                BytesReadedSoFar = Instance.fStream.Read(Buffer, 0, (int)this.BufferSize);

                switch (BytesReadedSoFar)
                {
                    case 0: return;
                    default:
                        if (this.PipeReceived != null)
                            this.PipeReceived.Invoke(Instance, Buffer);
                        break;
                }
            }

            Instance.fStream.Close();
            Instance.sHandle.Close();

            lock (CPX.ClientPool)
                CPX.ClientPool.Remove(Instance.ID);
        }
    }

        [DllImport("kernel32.dll", SetLastError = true)]
        public static extern SafeFileHandle CreateNamedPipe(
           String pipeName,
           uint dwOpenMode,
           uint dwPipeMode,
           uint nMaxInstances,
           uint nOutBufferSize,
           uint nInBufferSize,
           uint nDefaultTimeOut,
           IntPtr lpSecurityAttributes);

        [DllImport("kernel32.dll", SetLastError = true)]
        public static extern int ConnectNamedPipe(
           SafeFileHandle hNamedPipe,
           IntPtr lpOverlapped);

        public const uint DUPLEX = (0x00000003);
        public const uint GENERIC_READ = (0x80000000);
        public const uint GENERIC_WRITE = (0x40000000);
        public const uint OPEN_EXISTING = 3;
        public const uint FILE_FLAG_OVERLAPPED = (0x40000000);

        //Networking
        [DllImport("msvcrt.dll")]
        public static extern void* memcpy(void* dest, void* src, int size);

        public static void MemCopy(byte[] Dest, byte[] Src, int Size)
        {
            fixed (byte* src = Src, dst = Dest)
                memcpy(dst, src, Size);
        }

        public static void MemCopy(byte[] Dest, int DestOffset, byte[] Src, int Size)
        {
            fixed (byte* src = Src, dst = Dest)
                memcpy(dst + DestOffset, src, Size);
        }

        public static void MemCopy(byte[] Dest, int DestOffset, byte[] Src, int SourceOffset, int Size)
        {
            fixed (byte* src = Src, dst = Dest)
                memcpy(dst + DestOffset, src + SourceOffset, Size);
        }

        public static void MemCopy(byte[] Dest, byte[] Src, int SourceOffset, int Size)
        {
            fixed (byte* src = Src, dst = Dest)
                memcpy(dst, src + SourceOffset, Size);
        }

    public class PipeClient
    {
        public SafeFileHandle sHandle;
        public FileStream fStream;
        public uint ID;

        public void AppendBytes(byte[] Args)
        {
            lock (this.fStream)
            {
                this.fStream.Write(Args, 0, Args.Length);
                this.fStream.Flush();
            }
        }
    }