simple world server

GraphPeer

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using Photon.SocketServer;
using PhotonHostRuntimeInterfaces;
using System.ComponentModel;

namespace PhotonGraphServer
{
    public class GraphPeer : PeerBase
    {
        private static readonly object syncRoot = new object();
        private static event Action<GraphPeer, EventData, SendParameters> BroadcastMessage;
        private GraphModel _model;

        public GraphPeer(IRpcProtocol protocol, IPhotonPeer unmanagedPeer, GraphModel model)
            : base(protocol, unmanagedPeer)
        {
            _model = model;
            foreach (var kvp in model.PhysicalEntities)
            {
                SendEvent(
                    new EventData((byte)OpCodeEnum.Entity, kvp.Value),
                    new SendParameters() { Unreliable = false });
            }
            lock (syncRoot)
            {
                BroadcastMessage += OnBroadcastMessage;
            }
        }

        protected override void OnDisconnect()
        {
            lock (syncRoot)
            {
                BroadcastMessage -= OnBroadcastMessage;
            }
        }

        enum ParamEnum : byte
        {
            Id = 0,
            Action = 1,
        };

        protected override void OnOperationRequest(OperationRequest request, SendParameters sendParameters)
        {
            var op = (OpCodeEnum)Enum.ToObject(typeof(OpCodeEnum), request.OperationCode);
            switch(op) {
                case OpCodeEnum.Join:
                    break;
                case OpCodeEnum.Leave:
                    break;
                case OpCodeEnum.Entity:
                    var id = (int)request.Parameters[(byte)ParamEnum.Id];
                    var action = ToEnum<CollectionChangeAction>(request.Parameters[(byte)ParamEnum.Action]);
                    _model.UpdatePhysicalEntity(id, action, request.Parameters);
                    break;
                default:
                    break;
            }

            lock (syncRoot)
            {
                BroadcastMessage(this, new EventData((byte)OpCodeEnum.Entity, request.Parameters), sendParameters);
            }

            var response = new OperationResponse(request.OperationCode);
            SendOperationResponse(response, sendParameters);
        }

        private void OnBroadcastMessage(GraphPeer peer, EventData e, SendParameters sendParameters)
        {
            if (peer != this)
            {
                SendEvent(e, sendParameters);
            }
        }

        public static T ToEnum<T>(object value)
        {
            return (T)Enum.ToObject(typeof(T), value);
        }
    }
}