// 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);
}
public void UtilizeState(object data, StateMessage msg)
{
switch (msg)
{
case StateMessage.CMainPage_CProcess_RefreshProcessList:
RefreshProcessList();
break;
}
}
/// <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 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 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;
}
