// Update is called once per frame void Update() { if (nextState != null) { switch (nextState.state) { case State.World: keyboard.target = worldSystem; keyboardDisplay.gameObject.SetActive(false); break; case State.Combat: keyboard.target = combatSystem; combatSystem.StartCombat(((CombatState)nextState).entity); keyboardDisplay.gameObject.SetActive(true); break; default: break; } keyboard.Clear(); nextState = null; } }
public Effect Load(IEffectPartInfo info) { var spawnInfo = (SpawnEffectPartInfo)info; Effect posEff = null; if (spawnInfo.Position != null) { posEff = _posLoader.Load(spawnInfo.Position); } return(entity => { GameEntity spawn = entity.Spawn(spawnInfo.Name); if (spawn == null) { return; } StateMessage msg = new StateMessage(entity, spawnInfo.State); spawn.SendMessage(msg); if (posEff != null) { posEff(spawn); } }); }
// Start is called before the first frame update void Start() { nextState = BASE_STATE.Init(State.World); worldSystem.OnCombatStarted += handleCombatStarted; combatSystem.OnCombatComplete += handleCombatFinished; }
public override int GetHashCode() { int hash = 1; if (State != global::Google.Cloud.DocumentAI.V1Beta3.CommonOperationMetadata.Types.State.Unspecified) { hash ^= State.GetHashCode(); } if (StateMessage.Length != 0) { hash ^= StateMessage.GetHashCode(); } if (createTime_ != null) { hash ^= CreateTime.GetHashCode(); } if (updateTime_ != null) { hash ^= UpdateTime.GetHashCode(); } if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } return(hash); }
public void OnGameUpdate(EndPoint endPoint, byte[] buffer) { Debug.Log("[Server][" + DateTime.Now + "] Receive Update " + endPoint); StateMessage msg = StateMessage.Parser.ParseFrom(buffer); toDos.Enqueue(() => { manager.Apply(msg); }); }
private void HandleStateMessage(StateMessage stateMessage) { Debug.Log("handling state message!"); foreach (KeyValuePair <string, string> entry in stateMessage.playerPositions) { string nameOfPeer = entry.Key; Vector3 positionOfPeer = Message.ConvertStringToVector3(entry.Value); Debug.Log("adding player +" + nameOfPeer + "!"); //multiplayersystem.addplayer returns MultiplayerObject which will be stored in players dict if (!nameOfPeer.Equals(myClientName)) { Debug.Log("Manager of " + myClientName + ": i received a new player! Adding him now: " + nameOfPeer); players.Add(nameOfPeer, multiplayerSystem.AddPlayer(nameOfPeer, positionOfPeer)); } } foreach (KeyValuePair <string, int> entry in stateMessage.blockPositions) { int textureID = entry.Value; Vector3 positionOfBlock = Message.ConvertStringToVector3(entry.Key); if (blockList.ContainsKey(positionOfBlock)) { blockList.Remove(positionOfBlock); } blockList.Add(positionOfBlock, textureID); buildingSystem.PlaceBlockByPos(positionOfBlock, textureID); } }
private void HandleStateMessage(string stateMessage) { Debug.Log("P2PConnection: Handling state msessage!" + stateMessage); JObject jObj = JObject.Parse(stateMessage); JToken blockPositions = jObj.GetValue("blockPositions"); JToken playerPositions = jObj.GetValue("playerPositions"); Debug.Log("parsing block positions " + blockPositions.ToString()); Dictionary <string, int> dictionaryBlockPositions = JsonConvert.DeserializeObject <Dictionary <string, int> >(blockPositions.ToString()); Debug.Log("parsing player positions " + playerPositions.ToString()); Dictionary <string, string> dictionaryPlayerPositions = JsonConvert.DeserializeObject <Dictionary <string, string> >(playerPositions.ToString()); Dictionary <Vector3, int> actualBlocks = new Dictionary <Vector3, int>(); Debug.Log("Serialization done!"); //StateMessage stateMessageInstance = JsonUtility.FromJson<StateMessage>(stateMessage); StateMessage stateMessageInstance = new StateMessage(dictionaryPlayerPositions, dictionaryBlockPositions); Debug.Log("P2PConnection: State message content = " + stateMessageInstance.ToString()); peerToPeerManager.AddIncommingMessage(stateMessageInstance); //JArray a = JArray.Parse(stateMessageObject.GetValue("positions").ToString()); //Debug.Log(a.ToString()); //TODO handle state! -> push data to Multiplayer System }
/// <summary> /// Called when an inbound message been received /// </summary> /// <param name="request">The request message.</param> /// <param name="channel">The incoming channel.</param> /// <param name="instanceContext">The current service instance.</param> /// <returns> /// The object used to correlate stateMsg. /// This object is passed back in the method. /// </returns> public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext) { StateMessage stateMsg = null; HttpRequestMessageProperty requestProperty = null; if (request.Properties.ContainsKey(HttpRequestMessageProperty.Name)) { requestProperty = request.Properties[HttpRequestMessageProperty.Name] as HttpRequestMessageProperty; } if (requestProperty != null) { var origin = requestProperty.Headers["Origin"]; if (!string.IsNullOrEmpty(origin)) { stateMsg = new StateMessage(); // if a cors options request (preflight) is detected, // we create our own reply message and don't invoke any // operation at all. if (requestProperty.Method == "OPTIONS") { stateMsg.Message = Message.CreateMessage(request.Version, null); } request.Properties.Add("CrossOriginResourceSharingState", stateMsg); } } return(stateMsg); }
public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info) { if (stream.IsWriting) { stream.SendNext(currentState); } else { StateMessage recivepack = (StateMessage)stream.ReceiveNext(); if (newStateMessages != null) { newStateMessages.Enqueue(recivepack); if (InterpolationOn) { if (LastSavedState.tick_number == 0) { LastSavedState = recivepack; InterpolationBuffer.Enqueue(recivepack); } else { float dis = Vector3.Distance(LastSavedState.getPosition(), recivepack.getPosition()); float angDis = Quaternion.Angle(LastSavedState.getRotation(), recivepack.getRotation()); if (dis > 0.2f || angDis > 10) //0.2 10 { //Debug.Log("distance " + dis + " angle dis " + angDis); LastSavedState = recivepack; InterpolationBuffer.Enqueue(recivepack); } } } } } }
public void OnEvent(EventData photonEvent) { if (photonEvent.Code == 1) { if (!isGreen && photonView.IsMine) { StateMessage state = (StateMessage)photonEvent.CustomData; SimulateFromInput(state.getInput()); SaveCurrentStateToFile(); byte evCode = 1; RaiseEventOptions raiseEventOptions = new RaiseEventOptions { Receivers = ReceiverGroup.Others }; SendOptions sendOptions = new SendOptions { Reliability = true }; PhotonNetwork.RaiseEvent(evCode, currentState, raiseEventOptions, sendOptions); } else if (isGreen && photonView.IsMine) { StateMessage state = (StateMessage)photonEvent.CustomData; if (newStateMessages != null) { newStateMessages.Enqueue(state); } } } }
void SetInterpolation() { if (InterpolationBuffer != null && InterpolationBuffer.Count > 1 && !interpolationg) { Debug.Log("interpolation"); interpolationg = true; if (LastState.tick_number == 0) { LastState = InterpolationBuffer.Dequeue(); } else { LastState = goalState; } goalState = InterpolationBuffer.Dequeue(); MyLocalTime = Time.time; } if (interpolationg) { SimulateFromStateInterpolationHermite(LastState, goalState); float distance = Mathf.Abs(Vector3.Distance(cube_rigidbody.position, goalState.getPosition())); //transform for linear //Debug.Log("distance interpolation " + distance); if (distance < 0.03f) //was 0.01f { interpolationg = false; } } }
private void SimulateFromStateInterpolationHermite(StateMessage LastStateMsg, StateMessage CurrentStateMsg) { //Debug.Log("hermite ~!"); float speedof = 6f; journeyLength = Vector3.Distance(LastStateMsg.getPosition(), CurrentStateMsg.getPosition()); float distCovered = Vector3.Distance(LastStateMsg.getPosition(), cube_rigidbody.position); float fractionOfJourney = (distCovered / journeyLength); if ((fractionOfJourney + 0.1f) < 1) { //Debug.Log(" fract of journey " + fractionOfJourney); fractionOfJourney += 0.1f; Vector3 hermite = Hermite(LastStateMsg.getPosition(), CurrentStateMsg.getPosition(), fractionOfJourney); Debug.Log("my postion " + transform.position + " hermite postion " + hermite + " goal " + CurrentStateMsg.getPosition() + " dist coverd " + distCovered + " fract of journey " + fractionOfJourney); cube_rigidbody.position = hermite; } else { fractionOfJourney = 1f; Debug.Log("my postion " + transform.position + " hermite postion " + CurrentStateMsg.getPosition() + " goal " + CurrentStateMsg.getPosition() + " dist coverd " + distCovered + " fract of journey " + fractionOfJourney); cube_rigidbody.position = CurrentStateMsg.getPosition(); } //transform.position = hermite; cube_rigidbody.rotation = Quaternion.Slerp(LastStateMsg.getRotation(), CurrentStateMsg.getRotation(), Time.time * speedof); //cube_rigidbody.velocity = Hermite(LastStateMsg.getVelocity(), CurrentStateMsg.getVelocity(), fractionOfJourney); cube_rigidbody.velocity = CurrentStateMsg.getVelocity(); cube_rigidbody.angularVelocity = CurrentStateMsg.getVelocity_Angular(); }
static T SafeReadFromStream <T>(Stream objectStream) { byte[] serializedBytes = Utils.ReadBytesFromStream(objectStream); try { return(Utils.ReadObjectFromByteArray <T>(serializedBytes)); } catch (JsonSerializationException jex) when(typeof(T) == typeof(TaskMessage)) { //If deserialization to TaskMessage fails attempt to deserialize to the now deprecated StateMessage type #pragma warning disable 618 var originalException = ExceptionDispatchInfo.Capture(jex); StateMessage stateMessage = null; try { stateMessage = Utils.ReadObjectFromByteArray <StateMessage>(serializedBytes); } catch (JsonSerializationException) { originalException.Throw(); } return((dynamic) new TaskMessage { Event = new HistoryStateEvent(-1, stateMessage.State), OrchestrationInstance = stateMessage.State.OrchestrationInstance }); #pragma warning restore 618 } }
public void Apply(StateMessage msg) { foreach (ShipMessage shipMessage in msg.Ships) { Transform childTransform = transform.Find(shipMessage.Id); if (childTransform == null) { GameObject shipObject = CreateCapitalShip(shipMessage.Id, shipMessage.Model); childTransform = shipObject.transform; CapitalShip ship = childTransform.GetComponent <CapitalShip>(); ship.FromProtobuf(shipMessage); if (client != null && client.guid == ship.ownerGuid) { GameObject camera = CreateCamera(shipObject, shipMessage.Model); } } else { childTransform.GetComponent <CapitalShip>().FromProtobuf(shipMessage); } childTransform.hasChanged = false; } }
/// <summary> /// Gets the current state of the object from the model. /// </summary> /// <returns>The current state message.</returns> public override StateMessage GetCurrentState() { StateMessage sm = new StateMessage(); sm.SetValue("color", model.color); return(sm); }
public void MessageController_Load() { try { var state = new StateMessage { MeasureUnit = 1, Message = "OK", MeterDt = DateTime.Now, State = 1, Volume = 200 }; var meterMess = new MeterMessage { Id = 1, Address = 234, Env = 0, Maker = "lora", SerialNumber = 1, SetupIdentity = 243, Body = state }; var hubMess = new HubMessage { HubId = 1, Messages = new System.Collections.Generic.List <MeterMessage> { meterMess } }; Assert.DoesNotThrow(() => { _messageController.Load(hubMess); }); } finally { _mqManager.DeleteQueues(); _mqManager.DeleteExchange(_exchangeName); } }
private void HandleGetStateMessage(GetStateMessage getStateMessage) { // generate State Message of all playerpositions and blockpositions and send it back! Dictionary <string, string> playersPositions = new Dictionary <string, string>(); playersPositions.Add(myClientName, Message.GetStringFromVector3(playersPosition)); foreach (KeyValuePair <string, MutliplayerObject> entry in players) { string name; Vector3 position; (position, name) = entry.Value.GetPlayer(); playersPositions.Add(name, Message.GetStringFromVector3(position)); } Dictionary <string, int> blockPositions = new Dictionary <string, int>(); foreach (KeyValuePair <Vector3, int> entry in blockList) { blockPositions.Add(Message.GetStringFromVector3(entry.Key), entry.Value); } StateMessage messageToSend = new StateMessage(playersPositions, blockPositions); Debug.Log("P2PConnection: Sending my State of the World with " + blockPositions.Count + " blocks and " + playersPositions.Count + " players"); sockets[getStateMessage.senderName].CreateAndSendMessage(messageToSend); }
/// <summary> /// 处理核验 服务器发挥的状态 /// </summary> /// <param name="fixedDeltaTime"></param> /// <param name="client_rigidbody"></param> /// <param name="client_tick_number"></param> private void DealWithCheckServerState(float fixedDeltaTime, Rigidbody client_rigidbody, uint client_tick_number) { if (this.ClientHasStateMessage()) { StateMessage state_msg = commonData.server_input_state_msgs.Dequeue(); // 确保当前是最新的 可用状态消息 while (this.ClientHasStateMessage()) { state_msg = commonData.server_input_state_msgs.Dequeue(); } this.client_last_received_state_tick = state_msg.tick_number; this.proxy_player.transform.position = state_msg.position; this.proxy_player.transform.rotation = state_msg.rotation; if (this.client_enable_corrections) { uint buffer_slot = state_msg.tick_number % c_client_buffer_size; Vector3 position_error = state_msg.position - this.client_state_buffer[buffer_slot].position; float rotation_error = 1.0f - Quaternion.Dot(state_msg.rotation, this.client_state_buffer[buffer_slot].rotation); if (position_error.sqrMagnitude > 0.0000001f || rotation_error > 0.00001f) { Debug.Log("当前错误帧 " + state_msg.tick_number + " (倒回 " + (client_tick_number - state_msg.tick_number) + " 帧)"); // capture the current predicted pos for smoothing Vector3 prev_pos = client_rigidbody.position + this.client_pos_error; Quaternion prev_rot = client_rigidbody.rotation * this.client_rot_error; // rewind & replay client_rigidbody.position = state_msg.position; client_rigidbody.rotation = state_msg.rotation; client_rigidbody.velocity = state_msg.velocity; client_rigidbody.angularVelocity = state_msg.angular_velocity; uint rewind_tick_number = state_msg.tick_number; while (rewind_tick_number < client_tick_number) { buffer_slot = rewind_tick_number % c_client_buffer_size; this.ClientStoreCurrentStateAndStep(ref this.client_state_buffer[buffer_slot], client_rigidbody, this.client_input_buffer[buffer_slot], fixedDeltaTime); ++rewind_tick_number; } // if more than 2ms apart, just snap if ((prev_pos - client_rigidbody.position).sqrMagnitude >= 4.0f) { this.client_pos_error = Vector3.zero; this.client_rot_error = Quaternion.identity; } else { this.client_pos_error = prev_pos - client_rigidbody.position; this.client_rot_error = Quaternion.Inverse(client_rigidbody.rotation) * prev_rot; } } } } }
public void UPDATE() { Debug.Log("[Client][" + DateTime.Now + "] Send UPDATE"); StateMessage message = manager.Collect(); byte[] buffer = message.ToByteArray(); SEND(NetworkSettings.ServiceType.GAMEUPDATE, buffer); }
public void SendInputStatePacketToClient(StateMessage stateMessage) { if (Random.value < packet_loss_chance) { return; } server_input_state_msgs.Enqueue(stateMessage); }
public void UtilizeState(object data, StateMessage msg) { switch (msg) { case StateMessage.CMainPage_CProcess_RefreshProcessList: RefreshProcessList(); break; } }
public static StateMessage Parse(byte[] Data) { var parsedStateMessage = new StateMessage(); parsedStateMessage.Unused_0 = BitConverter.ToInt32(Data, 0); parsedStateMessage.UserStateAndAppID = BitConverter.ToInt32(Data, 4); return(parsedStateMessage); }
/// <summary> /// Handler that processes the current state message received from the server /// after AskCurrentState is called. /// </summary> /// <param name="msg">Message.</param> public override void OnCurrentStateReceived(NetworkMessage msg) { StateMessage sm = msg.ReadMessage <StateMessage>(); Debug.Log("state message received " + sm.ToString() + " " + gameObject.name); Color c = (Color)sm.GetValue("color"); Debug.Log("color " + sm.ToString() + " " + gameObject.name); view.SetColor(c); }
public void UtilizeState(object data, StateMessage msg) { switch (msg) { case StateMessage.CProcess_CMainPage_setProcess: this.process = (Process)data; Console.WriteLine(process.MainWindowTitle + "\nPID: " + process.Id + "\nHWND: " + process.MainWindowHandle); break; } }
public override void OnStateMessage(StateMessage message) { OnEnterState enter = message as OnEnterState; if (enter != null) { serverManager.StartGameTimer(); serverManager.networkManager.GamePlayStarted(); } }
public void broadcastUPDATE() { StateMessage message = manager.Collect(); byte[] buffer = message.ToByteArray(); foreach (EndPoint endPoint in clients) { SENDTO(endPoint, NetworkSettings.ServiceType.GAMEUPDATE, buffer); } }
public static void Switch(string name, StateMessage msg, object data) { UserControl uc; if (pages.TryGetValue(name, out uc)) { Switch(uc, msg, data); } else { throw new ArgumentException("UserControl for Name [" + name + "] is not registered!"); } }
public StateMessage SendInfoMessage(string text, uint timeoutMilliseconds = 0) { var msg = new StateMessage(false, text); Messages.Add(msg); MostRecentStateMessageUpdatedEvent(this, new MostRecentStateMessageUpdatedEventArgs(msg)); if (timeoutMilliseconds > 0) { MessageTimeoutRequestedEvent(this, new MessageTimeoutRequestedEventArgs(timeoutMilliseconds, msg)); } return(msg); }
public override void OnStateMessage(StateMessage message) { OnEnterState enter = message as OnEnterState; if (enter != null) { clientManager.Die(); if (clientManager.OnMatchEnded != null) { clientManager.OnMatchEnded(); } } }
/// <summary> /// 获取返回信息 /// </summary> /// <param name="state"></param> /// <param name="data"></param> /// <returns></returns> protected StateMessage GetResult(StateCode state, object data) { //获取状态码信息 string description = EnumHelper.GetEnumDescByValue(typeof(StateCode), state); //全局返回信息 StateMessage stateMessage = new StateMessage(); stateMessage.Code = state; stateMessage.Message = description; stateMessage.Data = data; return(stateMessage); }
public static void Switch(Type type, StateMessage msg, object data) { UserControl uc; if (pagec.TryGetValue(type, out uc)) { Switch(uc, msg, data); } else { throw new ArgumentException("UserControl for Name [" + type + "] is not registered!"); } }
public void Navigate(UserControl newPage, object data, StateMessage msg) { this.Content = newPage; ISwitchable i = newPage as ISwitchable; if (i != null) { i.UtilizeState(data, msg); } else { throw new ArgumentException("NewPage is not Switchable!"); } }
public Effect Load(IEffectPartInfo info) { var spawnInfo = (SpawnEffectPartInfo)info; Effect posEff = null; if (spawnInfo.Position != null) { posEff = _posLoader.Load(spawnInfo.Position); } return entity => { GameEntity spawn = entity.Spawn(spawnInfo.Name); if (spawn == null) return; StateMessage msg = new StateMessage(entity, spawnInfo.State); spawn.SendMessage(msg); if (posEff != null) posEff(spawn); }; }
public static void Switch(UserControl newPage, StateMessage msg, object data) { pageSwitcher.Navigate(newPage, data, msg); }
public void RuntimeRestartClick() { panels.ShowShadow(); PauseRequest(); panels.ShowMessage(textRestart); state = StateMessage.Restart; }
public void RuntimeCloseClick() { panels.ShowShadow(); PauseRequest(); panels.ShowMessage(textQuit); state = StateMessage.Quit; }
public void FinishLevelClick() { panels.ShowShadow(); PauseRequest(); string text = LastLevelRequest() ? textPass : textFinish; panels.ShowMessage(text); state = StateMessage.Finish; }
public void DieClick() { panels.ShowShadow(); PauseRequest(); panels.ShowMessage(textDie); state = StateMessage.Die; }