public void CmdTaskFinish(CustomPayload payload)
{
if (CurrentTask == null)
{
return;
}
if (IsHunter && !CurrentTask.HunterActive || !IsHunter && !CurrentTask.VictimActive)
{
return;
}
if (!CurrentTask.OnTaskFinish(this, payload.Data))
{
return;
}
if (IsHunter)
{
CurrentTask.LastHunterOpened = (float)NetworkTime.time;
}
else
{
CurrentTask.LastVictimOpened = (float)NetworkTime.time;
}
TargetSetTaskFinishedClient(connectionToClient, CurrentTask.gameObject);
CurrentTask = null;
TargetSetTask(connectionToClient, null);
}
/// <summary>
///
/// </summary>
/// <param name="emulatorOffset">How many degrees away I am from the emulation point towards which my rotation is lerping to</param>
/// <param name="payload"></param>
/// <param name="extrapPoint"></param>
/// <param name="emulationPoint"></param>
/// <returns></returns>
public Quaternion ExtrapolateFrom(float emulatorOffset, CustomPayload payload, out Vector3 extrapPoint, out Vector3 emulationPoint)
{
transform.rotation = payload.quat;
forwardRotator.degsPerSec = payload.degsPerSecond;
if(BenchmarkController.instance.shouldRotateTest) {
BenchmarkController.instance.CreateLandmark(transform.rotation, 1);
}
double deltaTime = PhotonNetwork.time - payload.time;
float frames = (float)deltaTime / Time.fixedDeltaTime;
extrap(frames, payload);
extrapPoint = pivot.position;
if(BenchmarkController.instance.shouldRotateTest) {
BenchmarkController.instance.CreateLandmark(transform.rotation, 2);
}
float degreesPerFrame = payload.degsPerSecond * Time.fixedDeltaTime;
float emulationLagFrames = emulatorOffset / degreesPerFrame;
extrap(emulationLagFrames, payload);
emulationPoint = pivot.position;
if(BenchmarkController.instance.shouldRotateTest) {
BenchmarkController.instance.CreateLandmark(transform.rotation, 3);
}
return transform.rotation;
}
public void TargetTaskResponse(NetworkConnection conn, CustomPayload payload)
{
if (CurrentTask == null)
{
return;
}
CurrentTask.OnTaskResponseClient(payload.Data);
}
/// <summary>
/// Add APNS keys and values to this object as CustomPayload keys and value
/// </summary>
public void SetCustomPayloadWithAPNSPayload(APNSNotificationPayload apnsPayload)
{
foreach (var propertyInfo in typeof(APNSNotificationPayload).GetProperties())
{
var currentValue = propertyInfo.GetValue(apnsPayload);
CustomPayload.Add(propertyInfo.Name, currentValue);
}
}
protected virtual byte[] TransformResponse(byte[] response, X509Certificate2 certificate)
{
var creds = new X509EncryptingCredentials(certificate, SecurityAlgorithms.RsaPKCS1, SecurityAlgorithms.Aes128CbcHmacSha256);
var header = new JwtHeader(creds);
var payload = new CustomPayload(Encoding.UTF8.GetString(response));
var token = new JwtSecurityToken(header, payload);
var responseBody = _jwtHandler.WriteToken(token);
return(Encoding.UTF8.GetBytes(responseBody));
}
public void TargetSetTaskData(NetworkConnection conn, CustomPayload payload)
{
if (CurrentTask == null)
{
return;
}
if (!(CurrentTask is GameLocalTask gameLocalTask))
{
return;
}
gameLocalTask.SetDataInjection(this, payload);
}
void extrap(float frames, CustomPayload payload)
{
int frameNum = (int)frames;
float remainder = frames - (float)frameNum;
for(int i = 0; i < frameNum; ++i) {
payload.horizontalMove = InputDriver.instance.HorizontalUpdate(payload.horizontalAim, payload.horizontalMove, 1f);
sideRotator.myUpdate(payload.horizontalMove, 1);
forwardRotator.myUpdate(1);
}
payload.horizontalMove = InputDriver.instance.HorizontalUpdate(payload.horizontalAim, payload.horizontalMove, remainder);
sideRotator.myUpdate(payload.horizontalMove, remainder);
forwardRotator.myUpdate(remainder);
}
private void TargetSynchronizeTaskList(NetworkConnection conn, CustomPayload tasks)
{
if (TaskList == null)
{
TaskList = new List <GameLocalTask>();
}
Debug.Log("TASK SYNCHRONIZE");
foreach (object o in tasks.Data)
{
Debug.Log(o);
}
TaskList.Clear();
TaskList.AddRange(tasks.Data.Where(o => o != null).Select(o => ((GameObject)o).GetComponent <GameLocalTask>()));
TaskList.ForEach(task => task.ForceNotify());
}
public void CmdTaskStep(CustomPayload payload)
{
if (CurrentTask == null)
{
return;
}
if (CurrentTask.SetCooldownOnStep)
{
if (IsHunter)
{
CurrentTask.LastHunterOpened = (float)NetworkTime.time;
}
else
{
CurrentTask.LastVictimOpened = (float)NetworkTime.time;
}
}
CurrentTask.OnTaskStep(this, payload.Data);
}
public async Task RoutingTestForClassSubscriber()
{
var address = "tcp://localhost:6000";
var publisherSocket = new PublisherSocket();
publisherSocket.Bind(address);
var subscriberSocket = new SubscriberSocket();
subscriberSocket.Connect(address);
var subscriber = new ExampleSubscriber();
var router = NetmqMessageRouter
.WithPubSubConnecton(publisherSocket, subscriberSocket)
.WithWorkerPool(numberOfSerializationWorkes: 2, numberOfHandlingWorkes: 8)
.RegisterTypeSerializer(new RawDataTypeSerializer())
.RegisterTypeSerializer(new BasicTextTypeSerializer())
.RegisterGeneralSerializer(new JsonObjectSerializer())
.RegisterRoute("TestRoute", typeof(CustomPayload))
.RegisterSubscriber(subscriber)
.StartRouting();
router.SendMessage("TestRoute", new CustomPayload("Hellow world", 123));
router.OnException += exception =>
{
// handle any exception
};
await Task.Delay(TimeSpan.FromSeconds(5));
router
.StopRouting()
.Disconnect();
var expectedValue = new CustomPayload("Hellow world", 123);
Assert.AreEqual(expectedValue, subscriber.PassedValue);
}
void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
if(stream.isWriting) {
stream.SendNext(rotationDevice.transform.rotation);
stream.SendNext(finalSpeeder.degsPerSec);
stream.SendNext(InputDriver.instance.horizontalAim);
stream.SendNext(InputDriver.instance.horizontalMove);
} else {
Quaternion rotation = (Quaternion)stream.ReceiveNext();
float speed = (float)stream.ReceiveNext();
float horizontalAim = (float)stream.ReceiveNext();
float horizontalMove = (float)stream.ReceiveNext();
CustomPayload payload = new CustomPayload(rotation, speed, info.timestamp, horizontalAim, horizontalMove);
if(useExtrapolation) {
Vector3 extrapPoint, emulationPoint;
Quaternion extrapolateRotation = extrapolater.ExtrapolateFrom(emulator.emulationOffset, payload, out extrapPoint, out emulationPoint);
emulator.Emulate(extrapolateRotation, extrapPoint, emulationPoint, speed);
}
}
}
public void Test(CustomPayload value)
{
PassedValue = value;
}
public void SetDataInjection(Player player, CustomPayload payload)
{
_data[player] = payload;
}
protected void SetData(Player player, CustomPayload payload)
{
SetDataInjection(player, payload);
player.TargetSetTaskData(player.connectionToClient, payload);
}
