private void Awake()
{
if (!Instance)
{
Instance = this;
DontDestroyOnLoad(gameObject);
}
else
{
Destroy(gameObject);
}
}
public override void OnEnable()
{
base.OnEnable();
RoomComponents.OnAdd().Subscribe(entity1 =>
{
var roomComponent = entity1.GetComponent <RoomComponent>();
UserComponents.Entities.OnAdd().Subscribe(entity2 =>
{
var userComponent = entity2.GetComponent <UserComponent>();
userComponent.IsRoomOwner.DistinctUntilChanged().Subscribe(_ =>
{
UpdateRoomState(roomComponent);
}).AddTo(this.Disposer).AddTo(userComponent.Disposer);
}).AddTo(this.Disposer);
UserComponents.Entities.OnRemove().Select(_ => true)
.Merge(Observable.ReturnUnit().Select(_ => true))
.Subscribe(_ =>
{
UpdateRoomState(roomComponent);
}).AddTo(this.Disposer);
roomComponent.StartButton.OnClickAsObservable().Subscribe(_ =>
{
foreach (var entity3 in UserComponents.Entities)
{
var userComponent = entity3.GetComponent <UserComponent>();
if (userComponent.IsLocalPlayer)
{
LockstepUtility.AddInput(new EventInput().WithType(EventCode.GameStart).Add(userComponent.IsRoomOwner.Value));
break;
}
}
}).AddTo(this.Disposer).AddTo(roomComponent.Disposer);
roomComponent.ExitButton.OnClickAsObservable().Subscribe(_ =>
{
foreach (var entity4 in UserComponents.Entities)
{
var userComponent = entity4.GetComponent <UserComponent>();
if (userComponent.IsLocalPlayer)
{
NetworkSystem.Publish(RequestCode.QuitRoom, userComponent.UserId.ToString());
break;
}
}
}).AddTo(this.Disposer).AddTo(roomComponent.Disposer);
}).AddTo(this.Disposer);
}
// Use this for initialization
void Start()
{
networkSystem_ = NetworkSystem.Instance;
fsm_.addState("logo", logo());
fsm_.addState("device", device());
fsm_.addState("whoIsServer", whoIsServer(), "device");
fsm_.addState("IAmClient", IAmClient(), "device");
fsm_.addState("alone", alone(), "device");
fsm_.addState("whoIsGod", whoIsGod(), "device");
fsm_.addState("running", running(), "device");
fsm_.init("whoIsServer");
}
public static void Handle(byte[] buffer)
{
var msgPing = (MsgPing)buffer;
if (msgPing.Ping == 0)
{
NetworkSystem.Send(msgPing);
}
else
{
FConsole.WriteLine("[Net][MsgPing] Ping: " + msgPing.Ping);
}
}
internal static void Execute(object msg, NetConnection conn, NetworkSystem networkSystem)
{
Msg_RC_NpcSkill targetmsg = msg as Msg_RC_NpcSkill;
if (null == targetmsg)
{
return;
}
if (networkSystem.Robot.OwnedNpcs.Contains(targetmsg.npc_id))
{
networkSystem.Robot.NotifyNpcSkill(targetmsg.npc_id, targetmsg.skill_id, targetmsg.stand_pos.x, targetmsg.stand_pos.z, targetmsg.face_direction);
}
}
private void OnConnectionEstablished(ConnectionId hostConnectionId, IPEndPoint endPoint)
{
Debug.Log("Connection established to " + endPoint + " with " + hostConnectionId);
var preExistingObjects = PreExistingObjects.FindAll();
var messageRouter = _networkSystems.DefaultMessageRouter;
NetworkSystem.InstallBasicClientHandlers(messageRouter, _networkSystems, preExistingObjects);
messageRouter.RegisterHandler <BasicMessage.Pong>(OnClockSync);
_networkSystems.GroupRouter.SetDataHandler(ConnectionGroups.Default, messageRouter);
_pingRoutine = _coroutineScheduler.Run(PingRepeatedly(hostConnectionId));
}
public override void OnDisconnect(NetworkSystem system, NetworkConnection connection, NetIncomingMessage message)
{
string reason = message.PeekString();
if ("MANUAL_DISCONNECT".Equals(reason))
{
return;
}
StatusMenu statusMenu = GameManager.Instance.menus.SelectMenu <StatusMenu>(1);
statusMenu.SetStatus("Disconnected", reason);
statusMenu.SetAction("Main Menu", () => StatusMenu.GoToMain());
}
/// <summary>
/// LoadContent will be called once per game and is the place to load
/// all of your content.
/// </summary>
protected override void LoadContent()
{
// Create a new SpriteBatch, which can be used to draw textures.
spriteBatch = new SpriteBatch(GraphicsDevice);
// Create game systems
InputSystem = new InputSystem(this);
NetworkSystem = new NetworkSystem(this);
RenderingSystem = new RenderingSystem(this);
MovementSystem = new MovementSystem(this);
// Testing code
AggregateFactory.CreateFromAggregate(Aggregate.FairyPlayer);
}
public Connection(TcpClient client, Server server, string netId)
{
this.server = server;
this.client = client;
this.netId = netId;
this.isHost = netId.Equals("0");
stream = client.GetStream();
receiveThread = new Thread(ReceiveThread);
receiveThread.Start();
Send(netId);
NetworkSystem.CallProcessConnection(this);
Log("已连接。");
}
public Client()
{
try
{
port = NetworkSystem.GetValidPort();
Log("客户端已启用……:" + port);
}
catch (Exception ex)
{
Log(ex);
NetworkSystem.ShutdownClient();
return;
}
}
internal static void Execute(object msg, NetConnection conn, NetworkSystem networkSystem)
{
Msg_RC_DestroyNpc destroyMsg = msg as Msg_RC_DestroyNpc;
if (destroyMsg == null)
{
return;
}
List <int> ownedNpcs = networkSystem.Robot.OwnedNpcs;
ownedNpcs.Remove(destroyMsg.npc_id);
List <int> otherIds = networkSystem.Robot.OtherIds;
otherIds.Remove(destroyMsg.npc_id);
}
public void Destroy()
{
if (isDestroyed)
{
Log("Disposed.");
return;
}
isDestroyed = true;
Log("Destroy");
receiveThread?.Abort();
NetworkSystem.CallProcessDisconnection(this);
stream?.Close();
client?.Close();
}
private void Start()
{
networkDiscovery_ = NetworkSystem.Instance;
if (isLocalPlayer)
{
string name = Platform.LocalComputerName;
string ip = Platform.LocalIp;
Debug.Log("!!!" + ip);
CmdPlayerMessage(name, ip);
}
_netId = this.netId.Value;
Debug.Log(_netId.ToString());
}
/// <summary>Initializes the scene.</summary>
public ConfigSceneMenu(bool IsMultiplayer, string[] args)
{
mIsMultiplayer = IsMultiplayer;
if (IsMultiplayer)
{
if (args != null && args.Length > 0)
{
_networkSystem = new NetworkSystem(50002);
}
else
{
_networkSystem = new NetworkSystem();
}
AddSystem(_networkSystem);
}
}
internal static void Execute(object msg, NetConnection conn, NetworkSystem networkSystem)
{
Msg_RC_SetBlockedShader _msg = msg as Msg_RC_SetBlockedShader;
if (null == _msg)
{
return;
}
uint rimColor1 = _msg.rim_color_1;
float rimPower1 = _msg.rim_power_1;
float rimCutValue1 = _msg.rim_cutvalue_1;
uint rimColor2 = _msg.rim_color_2;
float rimPower2 = _msg.rim_power_2;
float rimCutValue2 = _msg.rim_cutvalue_2;
}
public WorldSceneConfig(int numFlocks, int numPowerUps, int numTriggers, string map, NetworkSystem network)
{
NumFlocks = numFlocks;
NumPowerUps = numPowerUps;
NumTriggers = numTriggers;
Map = map;
Network = network;
Map = map;
LightConfig = new LightingConfig();
LightConfig.DiffuseColor = new Vector3(1, 0.9607844f, 0.8078432f);
LightConfig.Direction = new Vector3(-0.5265408f, -0.5735765f, -0.6275069f);
LightConfig.SpecularColor = new Vector3(1, 0.9607844f, 0.8078432f);
LightConfig.AmbientColor = new Vector3(0.05333332f, 0.09882354f, 0.1819608f);
if (Map == "Tropical") //"DinoIsland"
{
IsRaining = false;
WaterHeight = -7;
HeightMapScale = 300;
YScaleMap = 0.1f;
Playerz = 0;
Playerx = 0;
colorsMap = createColorsTropical();
LightConfig.FogEnabled = true;
LightConfig.FogStart = 35;
LightConfig.FogEnd = 100;
LightConfig.ClearColor = new Vector3(0.4f, 0.7f, 0.9f);
}
else if (Map == "UpNorth")
{
IsRaining = true;
//HeightMap
HeightMapScale = 300;
YScaleMap = 0.5f;
WaterHeight = -58;
Playerz = -49;
Playerx = -62;
colorsMap = createColors();
LightConfig.FogEnabled = true;
LightConfig.FogStart = 10;
LightConfig.FogEnd = 90;
LightConfig.ClearColor = new Vector3(0.45f, 0.5f, 0.6f);
}
}
public override void OnEnable()
{
base.OnEnable();
EventSystem.OnEvent <SpawnUserEvent>(true).Subscribe(evt =>
{
foreach (var entity in UserComponents.Entities)
{
var userComponent = entity.GetComponent <UserComponent>();
if (userComponent.UserId == evt.UserId)
{
userComponent.IsRoomOwner.Value = evt.IsRoomOwner;
return;
}
}
CreateUser(evt.IsLocalPlayer, evt.IsRoomOwner, evt.UserId, evt.Username, evt.TotalCount, evt.WinCount);
}).AddTo(this.Disposer);
NetworkSystem.Receive(RequestCode.QuitRoom).Subscribe(data =>
{
foreach (var entity in UserComponents.Entities)
{
var userComponent = entity.GetComponent <UserComponent>();
var viewComponent = entity.GetComponent <ViewComponent>();
if (userComponent.UserId == int.Parse(data.StringValue))
{
if (userComponent.IsLocalPlayer || userComponent.IsRoomOwner.Value)
{
ClearOtherPlayers();
}
else
{
Destroy(viewComponent.Transforms[0].gameObject);
}
break;
}
}
}).AddTo(this.Disposer);
if (offline)
{
CreateUser(true, true, 0, "Offline Player", 0, 0);
NetworkSystem.Mode = SessionMode.Offline;
LockstepUtility.AddInput(new EventInput().WithType(EventCode.GameStart).Add(true));
}
}
public override void Init()
{
_network = new NetworkSystem(port);
AddSystems(
new FpsCounterSystem(updatesPerSec: 10),
_network,
new Rendering2DSystem(),
new InputSystem(),
new ChatSystem()
);
#if DEBUG
AddSystem(new DebugOverlay());
#endif
base.Init();
int player = AddEntity();
AddComponent(player, new CInput());
AddComponent(player, new CTransform()
{
Position = new Vector3(0, -40, 0), Scale = new Vector3(1f)
});
AddComponent <C2DRenderable>(player, new CText()
{
font = Game1.Inst.Content.Load <SpriteFont>("Fonts/DroidSans"),
format = "Type Here",
color = Color.White,
position = new Vector2(300, 750),
origin = Vector2.Zero
});
var statusbar = AddEntity();
AddComponent <C2DRenderable>(statusbar, new CText()
{
font = Game1.Inst.Content.Load <SpriteFont>("Fonts/DroidSans"),
format = "Waiting for players to join",
color = Color.White,
position = new Vector2(300, 20),
origin = Vector2.Zero
});
Game1.Inst.Scene.OnEvent("startgamerequest", data =>
{
Game1.Inst.EnterScene(new WorldScene(new WorldSceneConfig(5, 5, 5, "DinoIsland06", _network)));
});
//new Thread(NewThread).Start();
}
internal static void Execute(object msg, NetConnection conn, NetworkSystem networkSystem)
{
Msg_CRC_Exit targetmsg = msg as Msg_CRC_Exit;
if (null == targetmsg)
{
return;
}
List <int> otherIds = networkSystem.Robot.OtherIds;
otherIds.Remove(targetmsg.role_id);
if (networkSystem.Robot.MyselfId == targetmsg.role_id)
{
networkSystem.QuitBattlePassive();
}
}
public void LaunchServer()
{
try
{
NetworkSystem.LaunchServer();
NetworkSystem.server.TurnOnTCP();
NetworkSystem.ConnectTo(NetworkSystem.LocalIPAddress);
}
catch (SocketException ex)
{
if (ex.SocketErrorCode == SocketError.AddressAlreadyInUse)
{
NetworkSystem.ShutdownServer();
NotificationSystem.ShowNotification("相同地址已经存在一个服务器");
}
}
}
public override void OnEnable()
{
base.OnEnable();
NetwrokTimeline.OnForward(data =>
{
if (NetworkSystem.Mode != SessionMode.Offline && data.TickId % Interval == 0)
{
string msg = PackMessage();
analyzedDataDict.Add(data.TickId, msg);
NetworkSystem.Publish(RequestCode.LockstepAnalysis, data.TickId.ToString() + VerticalBar + msg);
}
return(null);
}).AddTo(this.Disposer);
NetworkSystem.Receive(RequestCode.LockstepAnalysis).Subscribe(data =>
{
int tickId;
int returnCode;
string[] strs = data.StringValue.Split(VerticalBar);
if (strs.Length == 2 && int.TryParse(strs[0], out tickId))
{
if (analyzedDataDict.ContainsKey(tickId))
{
if (analyzedDataDict[tickId] == strs[1])
{
Debug.Log(string.Format(DataMatchSuccess, tickId, analyzedDataDict[tickId], strs[1]));
}
else
{
Debug.LogError(string.Format(DataMatchFailed, tickId, analyzedDataDict[tickId], strs[1]));
}
}
else
{
Debug.LogWarning(InsufficientDataWarning);
}
}
else if (int.TryParse(data.StringValue, out returnCode) && (ReturnCode)returnCode == ReturnCode.Success)
{
}
else
{
Debug.LogError(DataError);
}
}).AddTo(this.Disposer);
}
public World(Game game, Renderer renderer)
{
this.Game = game;
this.Renderer = renderer;
Entities = new SparseArray <Entity>();
Transformations = new SparseArray <Transformation>();
Primitives = new SparseArray <Primitive>();
Newtonians = new SparseArray <Newtonian>();
Models = new SparseArray <Microsoft.Xna.Framework.Graphics.Model>();
Players = new SparseArray <Player>();
PlayerControls = new SparseArray <PlayerControl>();
newtonianSystem = new NewtonianSystem(this);
renderingSystem = new RenderingSystem(this, renderer);
networkSystem = new NetworkSystem(this);
inputSystem = new InputManager(this);
}
public string[] OnCall(ICommandSender sender, string[] args)
{
if (sender is Player player)
{
if (!player.HasPermission("scpdiscord.reconnect"))
{
return(new[] { "You don't have permission to use that command." });
}
}
if (NetworkSystem.IsConnected())
{
NetworkSystem.Disconnect();
return(new[] { "Connection closed, reconnecting will begin shortly." });
}
else
{
return(new[] { "Connection was already closed, reconnecting is in progress." });
}
}
void ReceiveThread()
{
string receiveString;
int count;
try
{
while (true)
{
count = stream.Read(buffer, 0, buffer.Length);
// Block --------------------------------
if (count <= 0)
{
Log("与客户端断开连接");
server.CloseConnection(this);
return;
}
receiveString = Encoding.UTF8.GetString(buffer, 0, count);
Log($"Receive{client.Client.LocalEndPoint}:{receiveString}");
receiveStringBuffer += receiveString;
Match match = PacketCutter.Match(receiveStringBuffer);
while (match.Success)
{
NetworkSystem.CallProcessPacket(match.Groups[1].Value, this);
receiveStringBuffer = match.Groups[2].Value;
match = PacketCutter.Match(receiveStringBuffer);
}
}
}
catch (ThreadAbortException)
{
Log("Receive Thread Aborted.");
}
catch (Exception ex)
{
Log(ex);
server.CloseConnection(this);
}
}
public string[] OnCall(ICommandSender sender, string[] args)
{
if (sender is Player player)
{
if (!player.HasPermission("scpdiscord.reload"))
{
return(new[] { "You don't have permission to use that command." });
}
}
SCPDiscord.plugin.Info("Reloading plugin...");
SCPDiscord.plugin.LoadConfig();
Language.Reload();
SCPDiscord.plugin.roleSync.Reload();
if (NetworkSystem.IsConnected())
{
NetworkSystem.Disconnect();
}
return(new[] { "Reload complete." });
}
public async Task OnExecute(CommandContext command)
{
if (!ConfigParser.IsCommandChannel(command.Channel.Id))
{
return;
}
if (!ConfigParser.ValidatePermission(command))
{
return;
}
Interface.MessageWrapper message = new Interface.MessageWrapper
{
ListCommand = new Interface.ListCommand
{
ChannelID = command.Channel.Id
}
};
NetworkSystem.SendMessage(message);
Logger.Debug("Sending '" + command.Message.Content + "' to plugin from " + command.Member.Username + "#" + command.Member.Discriminator, LogID.Discord);
}
public override void OnEnable()
{
base.OnEnable();
NetworkSystem.Receive(RequestCode.Input).Subscribe(data =>
{
if (data.Mode == SessionMode.Offline)
{
UserInputs userInputs = MessagePackUtility.Deserialize <UserInputs>(data.Value);
userInputs.UserId = 0;
LockstepInputs lockstepInputs = LockstepUtility.CreateLockstepInputs(userInputs);
NetworkSystem.Publish(RequestCode.Lockstep, MessagePackUtility.Serialize(lockstepInputs));
}
}).AddTo(this.Disposer);
NetworkSystem.Receive(RequestCode.Lockstep).Subscribe(data =>
{
LockstepInputs lockstepInputs = MessagePackUtility.Deserialize <LockstepInputs>(data.Value);
LockstepUtility.AddToTimeline(lockstepInputs);
}).AddTo(this.Disposer);
}
internal static void Execute(object msg, NetConnection conn, NetworkSystem networkSystem)
{
Msg_RC_PublishEvent _msg = msg as Msg_RC_PublishEvent;
if (null == _msg)
{
return;
}
try {
bool isLogic = _msg.is_logic_event;
string name = _msg.ev_name;
string group = _msg.group;
ArrayList args = new ArrayList();
foreach (Msg_RC_PublishEvent.EventArg arg in _msg.args)
{
switch (arg.val_type)
{
case 0://null
args.Add(null);
break;
case 1://int
args.Add(int.Parse(arg.str_val));
break;
case 2://float
args.Add(float.Parse(arg.str_val));
break;
default://string
args.Add(arg.str_val);
break;
}
}
object[] objArgs = args.ToArray();
} catch (Exception ex) {
LogSystem.Error("Msg_RC_PublishEvent_Handler throw exception:{0}\n{1}", ex.Message, ex.StackTrace);
}
}
void ListenThread()
{
try
{
listener.Start();
while (true)
{
Log("Listening……");
CallConnect(listener.AcceptTcpClient());
// Block --------------------------------
}
}
catch (ThreadAbortException)
{
Log("Listen Thread Aborted");
}
catch (Exception ex)
{
Log(ex);
NetworkSystem.ShutdownServer();
}
}
/// <summary>
/// Gets the RefreshCommand for the ViewModel;
/// </summary>
/// <summary>
/// 방 데이터를 새로 고침하는데 사용되는 메소드
/// </summary>
public void DownloadRoomData()
{
#region Initializes valuables
Console.WriteLine("=================================================");
Console.WriteLine("Start RoomListWindowViewModel::DownloadRoomData(void)");
NetworkSystem networkSystem = NetworkSystem.Instance;
_roomItemHandler.Clear();
byte[] buf = new byte[1024];
buf = System.Text.Encoding.UTF8.GetBytes("REQUEST_ROOMINFO\r\n");
#endregion
#region Checks Network Connection Status
if (networkSystem.tcpc.Connected == false)
{
Console.WriteLine("Socket closed. you can't send a message.");
Console.WriteLine("-------------------------------------------------");
return;
}
if (networkSystem.Stream == null)
{
Console.WriteLine("NetworkStream is null. ");
Console.WriteLine("-------------------------------------------------");
return;
}
#endregion
#region Send "REQUEST_ROOMINFO" Message
try
{
Console.WriteLine("Send Message ... ");
networkSystem.Stream.Write(buf, 0, buf.Length);
}
catch (Exception e)
{
Console.WriteLine("Send Failed\n{0}", e);
Console.WriteLine("-------------------------------------------------");
return;
}
Console.WriteLine("REQUEST_ROOMINFO Send Success");
#endregion
}
