public void StopListening(GraphStack stack)
{
var data = stack.GetElementData <Data>(this);
if (data.UpdateAction == null)
{
return;
}
var hook = new EventHook(EventHooks.Update, stack.machine);
EventBus.Unregister(hook, data.UpdateAction);
if (data.IsOpened)
{
data.Close();
}
data.UpdateAction = null;
}
/// <summary>
/// Add sync for doors on the vehicle.
/// </summary>
void AddVehicleDoorSync()
{
Transform[] children = ParentGameObject.GetComponentsInChildren <Transform>();
foreach (Transform child in children)
{
// Rear door of van, trunk of old car and Ferndale.
if (child.name == "RearDoor")
{
child.gameObject.AddComponent <ObjectSyncComponent>().Setup(ObjectSyncManager.ObjectTypes.VehicleDoor, ObjectSyncManager.AUTOMATIC_ID);
}
else if (child.name == "Bootlid")
{
child.gameObject.AddComponent <ObjectSyncComponent>().Setup(ObjectSyncManager.ObjectTypes.VehicleDoor, ObjectSyncManager.AUTOMATIC_ID);
}
// Side door of van
else if (child.name == "SideDoor")
{
GameObject fsmGO = child.FindChild("door").FindChild("Collider").gameObject;
PlayMakerFSM fsm = Utils.GetPlaymakerScriptByName(fsmGO, "Use");
if (fsm != null)
{
EventHook.AddWithSync(fsm, "Open door");
EventHook.AddWithSync(fsm, "Close door");
}
}
// Object containing drivers doors
else if (child.name == "DriverDoors")
{
// Van, Truck.
if (child.FindChild("doorl"))
{
child.FindChild("doorl").gameObject.AddComponent <ObjectSyncComponent>().Setup(ObjectSyncManager.ObjectTypes.VehicleDoor, ObjectSyncManager.AUTOMATIC_ID);
child.FindChild("doorr").gameObject.AddComponent <ObjectSyncComponent>().Setup(ObjectSyncManager.ObjectTypes.VehicleDoor, ObjectSyncManager.AUTOMATIC_ID);
}
// Ferndale.
else if (child.FindChild("door(leftx)"))
{
child.FindChild("door(leftx)").gameObject.AddComponent <ObjectSyncComponent>().Setup(ObjectSyncManager.ObjectTypes.VehicleDoor, ObjectSyncManager.AUTOMATIC_ID);
child.FindChild("door(right)").gameObject.AddComponent <ObjectSyncComponent>().Setup(ObjectSyncManager.ObjectTypes.VehicleDoor, ObjectSyncManager.AUTOMATIC_ID);
}
}
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="gameObject">The game object to pickup.</param>
public GamePlayer(GameObject gameObject)
{
this.gameObject = gameObject;
Instance = this;
pickupFsm = Utils.GetPlaymakerScriptByName(gameObject, "PickUp");
if (pickupFsm != null)
{
// Pickup events
EventHook.Add(pickupFsm, "Part picked", new Func <bool>(() => {
this.PickupObject();
return(false);
}));
EventHook.Add(pickupFsm, "Item picked", new Func <bool>(() => {
this.PickupObject();
return(false);
}));
// Throw event
EventHook.Add(pickupFsm, "Throw part", new Func <bool>(() => {
this.ThrowObject();
return(false);
}));
// Drop event
EventHook.Add(pickupFsm, "Drop part", new Func <bool>(() => {
this.DropObject();
return(false);
}));
}
GameObject trigger = GameObject.CreatePrimitive(PrimitiveType.Sphere);
trigger.transform.localScale = new Vector3(100, 100, 100);
trigger.GetComponent <SphereCollider>().isTrigger = true;
GameObject.Destroy(trigger.GetComponent <MeshRenderer>());
trigger.transform.position = gameObject.transform.position;
trigger.transform.parent = gameObject.transform;
ObjectSyncPlayerComponent ospc = trigger.AddComponent <ObjectSyncPlayerComponent>();
}
/// <summary>
/// Hook events.
/// </summary>
void HookEvents()
{
EventHook.AddWithSync(beerCaseFSM, "Remove bottle", new Func <bool>(() => {
if (beerCaseFSM.Fsm.LastTransition.EventName == "MP_Remove bottle")
{
return(true);
}
else
{
return(false);
}
}));
// Sync beer case bottle count with host.
if (Network.NetManager.Instance.IsOnline &&
!Network.NetManager.Instance.IsHost)
{
osc.RequestObjectSync();
}
}
/// <summary>
/// 派发事件
/// </summary>
/// <param name="EvtType">事件类型枚举</param>
/// <param name="EvtSender">发送者身份标识，不想让接收事件方知道就用 -1</param>
/// <param name="EvtParam">事件消息内容</param>
public static void DispatchEvent(string EvtType, int EvtSender, object EvtParam)
{
CheckValid();
if (m_EventHook.ContainsKey(EvtType))
{
List <EventHook> l = m_EventHook[EvtType];
if (l == null || l.Count == 0)
{
return;
}
for (int i = l.Count - 1; i >= 0; i--)
{
EventHook f = l[i];
if (f != null)
{
f(EvtSender, EvtParam);
}
}
}
}
public static void DoEvent(NDEventType evt,
int SceneID,
object Param)
{
CheckValid();
if (m_EventHook.ContainsKey(evt))
{
List <EventHook> l = m_EventHook[evt];
if (l == null || l.Count == 0)
{
return;
}
//foreach(EventHook f in l)
for (int i = 0; i < l.Count; i++)
{
EventHook f = l[i];
if (f != null)
{
f(SceneID, Param);
}
}
}
}
/// <summary>
/// Hook player trigger events.
/// </summary>
/// <param name="fsm">Player trigger FSM on vehicle drivers seat.</param>
void PlayerEventHooks(PlayMakerFSM fsm)
{
// Temp - use player trigger. (No idea what this comment meant, it's now many
// months later. :P) It's now 6+ months later, no idea what this means at all
// now. :p -Curtis
EventHook.Add(fsm, "Player in car", new Func <bool>(() => {
if (CurrentDrivingState == DrivingStates.Driver && !DriverIsLocal)
{
return(true);
}
else
{
CurrentDrivingState = DrivingStates.Driver;
DriverIsLocal = true;
SetRemoteSteering(false);
Network.NetLocalPlayer.Instance.EnterVehicle(syncComponent, false);
return(false);
}
}));
EventHook.Add(fsm, "Wait for player", new Func <bool>(() => {
if (CurrentDrivingState == DrivingStates.Driver && DriverIsLocal)
{
CurrentDrivingState = DrivingStates.None;
DriverIsLocal = false;
Network.NetLocalPlayer.Instance.LeaveVehicle();
}
return(false);
}));
SeatTransform = fsm.gameObject.transform;
if (SeatTransform.gameObject.name == "DriveTrigger" &&
!ParentGameObject.name.StartsWith("JONNEZ") &&
!ParentGameObject.name.StartsWith("KEKMET"))
{
AddPassengerSeat(fsm);
}
}
/// <summary>
/// Hook events related to the boat.
/// </summary>
void HookEvents()
{
// J A N K - Yes, it's called that.
EventHook.AddWithSync(jankFSM, "State 1");
EventHook.AddWithSync(jankFSM, "Fail");
EventHook.AddWithSync(jankFSM, "Start");
// Ignition
EventHook.AddWithSync(ignitionFSM, "State 1");
// Shut Off
EventHook.AddWithSync(shutOffFSM, "Shut Off");
// Gears
EventHook.AddWithSync(gearFSM, "First");
EventHook.AddWithSync(gearFSM, "Neutral");
EventHook.AddWithSync(gearFSM, "Reverse");
// Enter as driver
EventHook.Add(driveFSM, "Player in car", new Func <bool>(() => {
gameObject.GetComponent <Components.ObjectSyncComponent>().TakeSyncControl();
return(false);
}));
}
/// <summary>
/// Register world related network message handlers.
/// </summary>
/// <param name="netMessageHandler">The network message handler to register
/// messages to.</param>
void RegisterNetworkMessagesHandlers(NetMessageHandler netMessageHandler)
{
netMessageHandler.BindMessageHandler(
(Steamworks.CSteamID sender,
Messages.PickupableSetPositionMessage msg) => {
Client.Assert(ObjectSyncManager.Instance.ObjectIDs.ContainsKey(msg.id),
$"Tried to move pickupable that is not spawned {msg.id}.");
GameObject gameObject =
ObjectSyncManager.Instance.ObjectIDs[msg.id].gameObject;
gameObject.transform.position = Utils.NetVec3ToGame(msg.position);
});
netMessageHandler.BindMessageHandler(
(Steamworks.CSteamID sender, Messages.PickupableActivateMessage msg) => {
GameObject gameObject = null;
if (ObjectSyncManager.Instance.ObjectIDs.ContainsKey(msg.id))
{
gameObject = ObjectSyncManager.Instance.ObjectIDs[msg.id].gameObject;
}
Client.Assert(gameObject != null,
"Tried to activate pickupable but its not spawned!");
if (msg.activate)
{
gameObject.SetActive(true);
}
else
{
if (gameObject != null)
{
gameObject.SetActive(false);
}
}
});
netMessageHandler.BindMessageHandler(
(Steamworks.CSteamID sender, Messages.PickupableSpawnMessage msg) => {
SpawnPickupable(msg);
});
netMessageHandler.BindMessageHandler(
(Steamworks.CSteamID sender, Messages.PickupableDestroyMessage msg) => {
if (!ObjectSyncManager.Instance.ObjectIDs.ContainsKey(msg.id))
{
return;
}
GameObject go;
try {
go = ObjectSyncManager.Instance.ObjectIDs[msg.id].gameObject;
} catch {
Logger.Error(
"Failed to remove object: OSC found but can't get GameObject.");
return;
}
GameObject.Destroy(
ObjectSyncManager.Instance.ObjectIDs[msg.id].gameObject);
});
netMessageHandler.BindMessageHandler(
(Steamworks.CSteamID sender,
Messages.WorldPeriodicalUpdateMessage msg) => {
// Game reports 'next hour' - we want to have transition so correct it.
GameWorld.Instance.WorldTime = (float)msg.sunClock - 2.0f;
GameWorld.Instance.WorldDay = (int)msg.worldDay;
GameWeatherManager.Instance.SetWeather(msg.currentWeather);
});
netMessageHandler.BindMessageHandler((Steamworks.CSteamID sender,
Messages.PlayerSyncMessage msg) => {
NetPlayer player = netManager.GetPlayer(sender);
if (player == null)
{
Logger.Log(
$"Received synchronization packet from {sender} but there is not player registered using this id.");
return;
}
player.HandleSynchronize(msg);
});
netMessageHandler.BindMessageHandler((Steamworks.CSteamID sender,
Messages.AnimSyncMessage msg) => {
NetPlayer player = netManager.GetPlayer(sender);
if (player == null)
{
Logger.Log(
$"Received animation synchronization packet from {sender} but there is not player registered using this id.");
return;
}
player.HandleAnimSynchronize(msg);
});
netMessageHandler.BindMessageHandler((Steamworks.CSteamID sender,
Messages.OpenDoorsMessage msg) => {
NetPlayer player = netManager.GetPlayer(sender);
if (player == null)
{
Logger.Log(
$"Received OpenDoorsMessage however there is no matching player {sender}! (open: {msg.open}");
return;
}
GameDoor doors = GameDoorsManager.Instance.FindGameDoors(
Utils.NetVec3ToGame(msg.position));
if (doors == null)
{
Logger.Log(
$"Player tried to open door, however, the door could not be found!");
return;
}
doors.Open(msg.open);
});
netMessageHandler.BindMessageHandler(
(Steamworks.CSteamID sender, Messages.FullWorldSyncMessage msg) => {
NetPlayer player = netManager.GetPlayer(sender);
// This one should never happen - if happens there is something done
// miserably wrong.
Client.Assert(player != null,
$"There is no player matching given steam id {sender}.");
// Handle full world state synchronization.
HandleFullWorldSync(msg);
// Spawn host character.
player.Spawn();
// Set player state.
player.Teleport(Utils.NetVec3ToGame(msg.spawnPosition),
Utils.NetQuatToGame(msg.spawnRotation));
if (msg.pickedUpObject != NetPickupable.INVALID_ID)
{
player.PickupObject(msg.pickedUpObject);
}
// World is loaded! Notify network manager about that.
netManager.OnNetworkWorldLoaded();
});
netMessageHandler.BindMessageHandler(
(Steamworks.CSteamID sender, Messages.AskForWorldStateMessage msg) => {
var msgF = new Messages.FullWorldSyncMessage();
WriteFullWorldSync(msgF);
netManager.BroadcastMessage(
msgF, Steamworks.EP2PSend.k_EP2PSendReliable);
});
netMessageHandler.BindMessageHandler((Steamworks.CSteamID sender,
Messages.VehicleEnterMessage msg) => {
NetPlayer player = netManager.GetPlayer(sender);
if (player == null)
{
Logger.Error(
$"Steam user of id {sender} send message however there is no active player matching this id.");
return;
}
ObjectSyncComponent vehicle =
ObjectSyncManager.Instance.ObjectIDs[msg.objectID];
if (vehicle == null)
{
Logger.Error("Player " + player.SteamId +
" tried to enter vehicle with Object ID " + msg.objectID +
" but there is no vehicle with such id.");
return;
}
player.EnterVehicle(vehicle, msg.passenger);
});
netMessageHandler.BindMessageHandler((Steamworks.CSteamID sender,
Messages.VehicleLeaveMessage msg) => {
NetPlayer player = netManager.GetPlayer(sender);
if (player == null)
{
Logger.Error(
$"Steam user of id {sender} send message however there is no active player matching this id.");
return;
}
player.LeaveVehicle();
});
netMessageHandler.BindMessageHandler(
(Steamworks.CSteamID sender, Messages.VehicleStateMessage msg) => {
float startTime = -1;
ObjectSyncComponent vehicle =
ObjectSyncManager.Instance.ObjectIDs[msg.objectID];
if (vehicle == null)
{
Logger.Log("Remote player tried to set state of vehicle " +
msg.objectID + " but there is no vehicle with such id.");
return;
}
if (msg.HasStartTime)
{
startTime = msg.StartTime;
}
PlayerVehicle subType = vehicle.GetObjectSubtype() as PlayerVehicle;
subType.SetEngineState((PlayerVehicle.EngineStates)msg.state,
(PlayerVehicle.DashboardStates)msg.dashstate, startTime);
});
netMessageHandler.BindMessageHandler(
(Steamworks.CSteamID sender, Messages.VehicleSwitchMessage msg) => {
float newValueFloat = -1;
PlayerVehicle vehicle =
ObjectSyncManager.Instance.ObjectIDs[msg.objectID].GetObjectSubtype()
as PlayerVehicle;
if (vehicle == null)
{
Logger.Log("Remote player tried to change a switch in vehicle " +
msg.objectID + " but there is no vehicle with such id.");
return;
}
if (msg.HasSwitchValueFloat)
{
newValueFloat = msg.SwitchValueFloat;
}
vehicle.SetVehicleSwitch((PlayerVehicle.SwitchIDs)msg.switchID,
msg.switchValue, newValueFloat);
});
netMessageHandler.BindMessageHandler(
(Steamworks.CSteamID sender, Messages.LightSwitchMessage msg) => {
LightSwitch light = Game.LightSwitchManager.Instance.FindLightSwitch(
Utils.NetVec3ToGame(msg.pos));
light.TurnOn(msg.toggle);
});
netMessageHandler.BindMessageHandler((Steamworks.CSteamID sender,
Messages.ObjectSyncMessage msg) => {
ObjectSyncComponent osc;
ObjectSyncManager.SyncTypes type = (ObjectSyncManager.SyncTypes)msg.SyncType;
try {
osc = ObjectSyncManager.Instance.ObjectIDs[msg.objectID];
} catch {
Logger.Log(
$"Specified object is not yet added to the ObjectID's Dictionary! (Object ID: {msg.objectID})");
return;
}
if (osc != null)
{
// Set owner.
if (type == ObjectSyncManager.SyncTypes.SetOwner)
{
if (osc.Owner == ObjectSyncManager.NO_OWNER ||
osc.Owner == sender.m_SteamID)
{
osc.OwnerSetToRemote(sender.m_SteamID);
netManager.GetLocalPlayer().SendObjectSyncResponse(osc.ObjectID, true);
}
else
{
Logger.Debug(
$"Set owner request rejected for object: {osc.transform.name} (Owner: {osc.Owner} Sender: {sender.m_SteamID})");
}
}
// Remove owner.
else if (type == ObjectSyncManager.SyncTypes.RemoveOwner)
{
if (osc.Owner == sender.m_SteamID)
{
osc.OwnerRemoved();
}
}
// Force set owner.
else if (type == ObjectSyncManager.SyncTypes.ForceSetOwner)
{
osc.Owner = sender.m_SteamID;
netManager.GetLocalPlayer().SendObjectSyncResponse(osc.ObjectID, true);
osc.SyncTakenByForce();
osc.SyncEnabled = false;
}
// Set object's position and variables
if (osc.Owner == sender.m_SteamID ||
type == ObjectSyncManager.SyncTypes.PeriodicSync)
{
if (msg.HasSyncedVariables == true)
{
osc.HandleSyncedVariables(msg.SyncedVariables);
}
osc.SetPositionAndRotation(Utils.NetVec3ToGame(msg.position),
Utils.NetQuatToGame(msg.rotation));
}
}
});
netMessageHandler.BindMessageHandler(
(Steamworks.CSteamID sender, Messages.ObjectSyncResponseMessage msg) => {
ObjectSyncComponent osc =
ObjectSyncManager.Instance.ObjectIDs[msg.objectID];
if (msg.accepted)
{
osc.SyncEnabled = true;
osc.Owner = Steamworks.SteamUser.GetSteamID().m_SteamID;
}
});
netMessageHandler.BindMessageHandler((Steamworks.CSteamID sender,
Messages.ObjectSyncRequestMessage
msg) => {
try {
ObjectSyncComponent osc =
ObjectSyncManager.Instance.ObjectIDs[msg.objectID];
osc.SendObjectSync(ObjectSyncManager.SyncTypes.GenericSync, true, true);
} catch {
Logger.Error(
$"Remote client tried to request object sync of an unknown object, Object ID: {msg.objectID}");
}
});
netMessageHandler.BindMessageHandler(
(Steamworks.CSteamID sender, Messages.EventHookSyncMessage msg) => {
if (msg.request)
{
EventHook.SendSync(msg.fsmID);
}
else
{
if (msg.HasFsmEventName)
{
EventHook.HandleEventSync(
msg.fsmID, msg.fsmEventID, msg.FsmEventName);
}
else
{
EventHook.HandleEventSync(msg.fsmID, msg.fsmEventID);
}
}
});
}
/// <summary>
/// Hook events for pub food.
/// </summary>
void HookEvents()
{
PlayMakerFSM foodFSM = Utils.GetPlaymakerScriptByName(FoodGO, "Use");
EventHook.AddWithSync(foodFSM, "State 2");
}
public MonoMgr()
{
hookobj = GameObject.Find(EngineMacro.ENGINE_HOOK).GetComponent <EventHook>();
}
// Event hooks
public void EventHooks()
{
// Generic vehicle FSMs.
throttleFsm = Utils.GetPlaymakerScriptByName(parentGameObject, "Throttle");
EventHook.SyncAllEvents(throttleFsm, new Func <bool>(() => {
if (syncComponent.Owner != steamID && syncComponent.Owner != 0 || syncComponent.Owner == 0 && !Network.NetManager.Instance.IsHost)
{
return(true);
}
return(false);
}));
// Traffic FSMs.
EventHook.AddWithSync(directionFsm, "CW", new Func <bool>(() => {
isClockwise = 1;
return(false);
}));
EventHook.AddWithSync(directionFsm, "CCW", new Func <bool>(() => {
isClockwise = 0;
return(false);
}));
// Bus specific FSMs.
if (type == VehicleTypes.Bus)
{
PlayMakerFSM doorFsm = Utils.GetPlaymakerScriptByName(parentGameObject.transform.FindChild("Route").gameObject, "Door");
PlayMakerFSM startFsm = Utils.GetPlaymakerScriptByName(parentGameObject.transform.FindChild("Route").gameObject, "Start");
EventHook.SyncAllEvents(doorFsm, new Func <bool>(() => {
if (syncComponent.Owner != steamID && syncComponent.Owner != 0 || syncComponent.Owner == 0 && !Network.NetManager.Instance.IsHost)
{
return(true);
}
return(false);
}));
EventHook.SyncAllEvents(startFsm, new Func <bool>(() => {
if (syncComponent.Owner != steamID && syncComponent.Owner != 0 || syncComponent.Owner == 0 && !Network.NetManager.Instance.IsHost)
{
return(true);
}
return(false);
}));
}
// None traffic cars specific FSMs.
if (type == VehicleTypes.Amis || type == VehicleTypes.Fitan)
{
PlayMakerFSM crashFsm = Utils.GetPlaymakerScriptByName(parentGameObject.transform.FindChild("CrashEvent").gameObject, "Crash");
EventHook.SyncAllEvents(crashFsm, new Func <bool>(() => {
if (syncComponent.Owner != steamID && syncComponent.Owner != 0 || syncComponent.Owner == 0 && !Network.NetManager.Instance.IsHost)
{
return(true);
}
return(false);
}));
}
// Sync vehicle data with the host on spawn.
if (Network.NetManager.Instance.IsOnline && !Network.NetManager.Instance.IsHost)
{
syncComponent.RequestObjectSync();
}
}
public void SetEventHook(EventHook hook)
{
eventHook = hook;
}
private static Task SendHooks(string accountId, List <AccountTask> accountTaskList)
{
return(Task.Run(async() =>
{
Console.WriteLine(String.Format("{0}: Поток {1} запустился", DateTime.Now.ToString("T"), Thread.CurrentThread.ManagedThreadId));
var contextOptions = new DbContextOptionsBuilder <WebHooksContext>()
.UseSqlServer("")
.Options;
ApiClient apiClient = new ApiClient();
List <EventHook> eventHooks = new List <EventHook>();
EventHook hook = new EventHook();
while (true)
{
using (var context = new WebHooksContext(contextOptions))
{
context.Database.SetCommandTimeout(30);
IRepository <EventHook> eventHookRepository = new GenericRepository <EventHook>(context);
//IRepository<HookTry> hookTryRepository = new GenericRepository<HookTry>(context);
try
{
eventHooks = await eventHookRepository
.GetQuery(e => e.Subscription)
.AsNoTracking()
.Where(e => e.IsActual && e.Subscription.ExternalAccountId == accountId && e.Subscription.IsActual && e.SendTime <= DateTime.UtcNow && e.SendTime != null)
.OrderBy(e => e.SendTime)
.Take(50)
.ToListAsync();
Console.WriteLine(String.Format("{0}: Поток {1} получил записи из базы данных", DateTime.Now.ToString("T"), Thread.CurrentThread.ManagedThreadId));
}
catch (Exception ex)
{
Console.WriteLine(String.Format("{0}: Ошибка! {1}", DateTime.Now.ToString("T"), ex));
lock (accountTaskList)
{
accountTaskList.Remove(accountTaskList.Where(a => a.ExternalAccountId == accountId).FirstOrDefault());
Console.WriteLine(String.Format("{0}: В Потоке {1} удалена задача", DateTime.Now.ToString("T"), Thread.CurrentThread.ManagedThreadId));
}
return;
}
}
if (eventHooks.Count == 0)
{
Console.WriteLine(String.Format("{0}: В Потоке {1} нет записей, пытаемся удалить задачу", DateTime.Now.ToString("T"), Thread.CurrentThread.ManagedThreadId));
lock (accountTaskList)
{
accountTaskList.Remove(accountTaskList.Where(a => a.ExternalAccountId == accountId).FirstOrDefault());
Console.WriteLine(String.Format("{0}: В Потоке {1} удалена задача", DateTime.Now.ToString("T"), Thread.CurrentThread.ManagedThreadId));
}
return;
}
using (var context = new WebHooksContext(contextOptions))
{
context.Database.SetCommandTimeout(30);
IRepository <EventHook> eventHookRepository = new GenericRepository <EventHook>(context);
List <HookTry> hookTryes = new List <HookTry>();
for (int i = 0; i < eventHooks.Count(); i++)
{
HookTry hookTry = new HookTry();
hook = eventHooks[i];
hookTry.EventHookId = hook.Id;
hookTry.CreateTime = DateTime.UtcNow;
hookTry.IsActual = true;
HttpResponseMessage response = new HttpResponseMessage();
try
{
response = await apiClient.SendRequest(hook.Subscription.Url, hook.Subscription.HttpMethod, hook.Subscription.SecretKey, hook.Subscription.ContentType, hook.Event);
if (response.StatusCode != HttpStatusCode.OK && response.StatusCode != HttpStatusCode.Created && response.StatusCode != HttpStatusCode.NoContent)
{
hook.TryCount += 1;
if (hook.TryCount >= 3)
{
hook.Status = "FAILURE";
hook.SendTime = null;
}
else
{
hook.Status = "REPEAT";
if (hook.SendTime != null)
{
hook.SendTime = DateTime.UtcNow.AddMinutes(5.0);
}
}
}
else
{
hook.TryCount += 1;
hook.SendTime = null;
hook.Status = "DONE";
}
hookTry.Request = String.Format("Method: {0} {1}\nContent-Type: {2}\nParams: {3}", hook.Subscription.HttpMethod, hook.Subscription.Url, hook.Subscription.ContentType, hook.Event);
hookTry.Response = apiClient.GetResponseContent(response);
hookTry.HttpStatus = ((int)response.StatusCode).ToString();
hookTryes.Add(hookTry);
}
catch (Exception ex)
{
Console.WriteLine(String.Format("{0}: Ошибка! {1}", DateTime.Now.ToString("T"), ex));
continue;
}
finally
{
response.Dispose();
}
try
{
eventHookRepository.ExecuteQuery("UPDATE EventHooks set Status = {0}, TryCount = {1}, SendTime = {3} where Id = {2}", hook.Status, hook.TryCount, hook.Id, hook.SendTime);
}
catch (Exception ex)
{
Console.WriteLine(String.Format("{0}: Ошибка! {1}", DateTime.Now.ToString("T"), ex));
context.Dispose();
lock (accountTaskList)
{
accountTaskList.Remove(accountTaskList.Where(a => a.ExternalAccountId == accountId).FirstOrDefault());
Console.WriteLine(String.Format("{0}: В Потоке {1} удалена задача", DateTime.Now.ToString("T"), Thread.CurrentThread.ManagedThreadId));
}
return;
}
}
try
{
context.ChangeTracker.AutoDetectChangesEnabled = false;
context.HookTryes.AddRange(hookTryes.ToArray());
await context.SaveChangesAsync();
context.ChangeTracker.AutoDetectChangesEnabled = true;
}
catch (Exception ex)
{
Console.WriteLine(String.Format("{0}: Ошибка! {1}", DateTime.Now.ToString("T"), ex));
context.Dispose();
lock (accountTaskList)
{
accountTaskList.Remove(accountTaskList.Where(a => a.ExternalAccountId == accountId).FirstOrDefault());
Console.WriteLine(String.Format("{0}: В Потоке {1} удалена задача", DateTime.Now.ToString("T"), Thread.CurrentThread.ManagedThreadId));
}
return;
}
Console.WriteLine(String.Format("{0}: Поток {1} обновил {2} записей", DateTime.Now.ToString("T"), Thread.CurrentThread.ManagedThreadId, eventHooks.Count()));
}
}
}));
}
/**
* Removes a hook for when a game event is fired.
*
* @param name Name of event.
* @param callback An EventHook function pointer.
* @param mode Optional EventHookMode determining the type of hook.
* @error Invalid callback function or no active hook for specified event.
*/
public static void UnhookEvent(string name, EventHook callback, EventHookMode mode = EventHookMode.EventHookMode_Post)
{
throw new NotImplementedException();
}
/// <summary>
/// Register world related network message handlers.
/// </summary>
/// <param name="netMessageHandler">The network message handler to register messages to.</param>
void RegisterNetworkMessagesHandlers(NetMessageHandler netMessageHandler)
{
netMessageHandler.BindMessageHandler((Steamworks.CSteamID sender, Messages.PickupableSetPositionMessage msg) => {
Client.Assert(ObjectSyncManager.GetObjectByID(msg.id), $"Tried to move pickupable that is not spawned {msg.id}.");
GameObject gameObject = ObjectSyncManager.GetObjectByID(msg.id);
gameObject.transform.position = Utils.NetVec3ToGame(msg.position);
});
netMessageHandler.BindMessageHandler((Steamworks.CSteamID sender, Messages.PickupableActivateMessage msg) => {
GameObject gameObject = null;
if (ObjectSyncManager.GetObjectByID(msg.id))
{
gameObject = ObjectSyncManager.GetObjectByID(msg.id);
}
Client.Assert(gameObject != null, "Tried to activate a pickupable but it's not spawned! Does any connected client or you have other mods beside MSC:MP installed? Try uninstalling them!");
if (msg.activate)
{
gameObject.SetActive(true);
}
else
{
if (gameObject != null)
{
gameObject.SetActive(false);
}
}
});
netMessageHandler.BindMessageHandler((Steamworks.CSteamID sender, Messages.PickupableSpawnMessage msg) => {
SpawnPickupable(msg);
});
netMessageHandler.BindMessageHandler((Steamworks.CSteamID sender, Messages.PickupableDestroyMessage msg) => {
if (!ObjectSyncManager.GetSyncComponentByID(msg.id))
{
return;
}
ObjectSyncComponent osc = ObjectSyncManager.GetSyncComponentByID(msg.id);
GameObject.Destroy(ObjectSyncManager.GetObjectByID(msg.id));
});
netMessageHandler.BindMessageHandler((Steamworks.CSteamID sender, Messages.WorldPeriodicalUpdateMessage msg) => {
// Game reports 'next hour' - we want to have transition so correct it.
GameWorld.Instance.WorldTime = (float)msg.sunClock - 2.0f;
GameWorld.Instance.WorldDay = (int)msg.worldDay;
});
netMessageHandler.BindMessageHandler((Steamworks.CSteamID sender, Messages.PlayerSyncMessage msg) => {
NetPlayer player = netManager.GetPlayer(sender);
if (player == null)
{
Logger.Error($"Received synchronization packet from {sender} but there is not player registered using this id.");
return;
}
player.HandleSynchronize(msg);
});
netMessageHandler.BindMessageHandler((Steamworks.CSteamID sender, Messages.AnimSyncMessage msg) => {
NetPlayer player = netManager.GetPlayer(sender);
if (player == null)
{
Logger.Error($"Received animation synchronization packet from {sender} but there is not player registered using this id.");
return;
}
player.HandleAnimSynchronize(msg);
});
netMessageHandler.BindMessageHandler((Steamworks.CSteamID sender, Messages.OpenDoorsMessage msg) => {
NetPlayer player = netManager.GetPlayer(sender);
if (player == null)
{
Logger.Error($"Received OpenDoorsMessage however there is no matching player {sender}! (open: {msg.open}");
return;
}
GameDoor doors = GameDoorsManager.Instance.FindGameDoors(Utils.NetVec3ToGame(msg.position));
if (doors == null)
{
Logger.Error($"Player tried to open door, however, the door could not be found!");
return;
}
doors.Open(msg.open);
});
netMessageHandler.BindMessageHandler((Steamworks.CSteamID sender, Messages.FullWorldSyncMessage msg) => {
NetPlayer player = netManager.GetPlayer(sender);
// This one should never happen - if happens there is something done miserably wrong.
Client.Assert(player != null, $"There is no player matching given steam id {sender}.");
// Handle full world state synchronization.
HandleFullWorldSync(msg);
// Spawn host character.
player.Spawn();
// Set player state.
player.Teleport(Utils.NetVec3ToGame(msg.spawnPosition), Utils.NetQuatToGame(msg.spawnRotation));
if (msg.pickedUpObject != NetPickupable.INVALID_ID)
{
player.PickupObject(msg.pickedUpObject);
}
// World is loaded! Notify network manager about that.
netManager.OnNetworkWorldLoaded();
});
netMessageHandler.BindMessageHandler((Steamworks.CSteamID sender, Messages.AskForWorldStateMessage msg) => {
var msgF = new Messages.FullWorldSyncMessage();
WriteFullWorldSync(msgF);
netManager.SendMessage(netManager.GetPlayer(sender), msgF, Steamworks.EP2PSend.k_EP2PSendReliable);
});
netMessageHandler.BindMessageHandler((Steamworks.CSteamID sender, Messages.VehicleEnterMessage msg) => {
NetPlayer player = netManager.GetPlayer(sender);
if (player == null)
{
Logger.Error($"Steam user of id {sender} send message however there is no active player matching this id.");
return;
}
ObjectSyncComponent vehicle = ObjectSyncManager.Instance.ObjectIDs[msg.objectID];
if (vehicle == null)
{
Logger.Error("Player " + player.SteamId + " tried to enter vehicle with Object ID " + msg.objectID + " but there is no vehicle with such id.");
return;
}
player.EnterVehicle(vehicle, msg.passenger);
});
netMessageHandler.BindMessageHandler((Steamworks.CSteamID sender, Messages.VehicleLeaveMessage msg) => {
NetPlayer player = netManager.GetPlayer(sender);
if (player == null)
{
Logger.Error($"Steam user of id {sender} send message however there is no active player matching this id.");
return;
}
player.LeaveVehicle();
});
netMessageHandler.BindMessageHandler((Steamworks.CSteamID sender, Messages.VehicleSwitchMessage msg) => {
float newValueFloat = -1;
PlayerVehicle vehicle = ObjectSyncManager.Instance.ObjectIDs[msg.objectID].GetObjectSubtype() as PlayerVehicle;
if (vehicle == null)
{
Logger.Debug("Remote player tried to change a switch in vehicle " + msg.objectID + " but there is no vehicle with such id.");
return;
}
if (msg.HasSwitchValueFloat)
{
newValueFloat = msg.SwitchValueFloat;
}
vehicle.SetVehicleSwitch((PlayerVehicle.SwitchIDs)msg.switchID, msg.switchValue, newValueFloat);
});
netMessageHandler.BindMessageHandler((Steamworks.CSteamID sender, Messages.LightSwitchMessage msg) => {
LightSwitch light = LightSwitchManager.Instance.FindLightSwitch(Utils.NetVec3ToGame(msg.pos));
light.TurnOn(msg.toggle);
});
netMessageHandler.BindMessageHandler((Steamworks.CSteamID sender, Messages.ObjectSyncMessage msg) => {
ObjectSyncComponent osc;
ObjectSyncManager.SyncTypes type = (ObjectSyncManager.SyncTypes)msg.SyncType;
if (ObjectSyncManager.GetObjectByID(msg.objectID))
{
osc = ObjectSyncManager.GetSyncComponentByID(msg.objectID);
}
else
{
Logger.Error($"Specified object is not yet added to the ObjectID's Dictionary! (Object ID: {msg.objectID})");
return;
}
// This *should* never happen, but apparently it's possible.
Client.Assert(osc != null, $"Object Sync Component wasn't found for object with ID {msg.objectID}, however, the object had a dictionary entry!");
// Host controls who owns an object.
if (NetManager.Instance.IsHost)
{
// Set owner on host.
if (type == ObjectSyncManager.SyncTypes.SetOwner)
{
ObjectSyncManager.SetOwnerHandler(msg, osc, sender);
}
// Remove owner on host.
if (type == ObjectSyncManager.SyncTypes.RemoveOwner)
{
if (osc.Owner == netManager.GetLocalPlayer())
{
ObjectSyncManager.RemoveOwnerHandler(msg, osc, sender);
}
}
// Sync taken by force on host.
if (type == ObjectSyncManager.SyncTypes.ForceSetOwner)
{
ObjectSyncManager.SyncTakenByForceHandler(msg, osc, sender);
}
}
// Set ownership info on clients.
else
{
NetPlayer player = netManager.GetPlayerByPlayerID(msg.OwnerPlayerID);
// Check if player exists.
if (player == null)
{
return;
}
// Set owner.
if (type == ObjectSyncManager.SyncTypes.SetOwner)
{
if (osc.Owner != netManager.GetLocalPlayer())
{
osc.OwnerSetToRemote(player);
}
osc.Owner = player;
}
// Remove owner.
else if (type == ObjectSyncManager.SyncTypes.RemoveOwner)
{
if (osc.Owner != netManager.GetLocalPlayer())
{
osc.OwnerRemoved();
}
osc.Owner = null;
}
// Force set owner.
else if (type == ObjectSyncManager.SyncTypes.ForceSetOwner)
{
if (osc.Owner != netManager.GetLocalPlayer())
{
osc.SyncTakenByForce();
osc.SyncEnabled = false;
}
osc.Owner = player;
if (osc.Owner == netManager.GetLocalPlayer())
{
osc.SyncEnabled = true;
}
}
}
// Set object's position and variables.
if ((osc.Owner == netManager.GetPlayer(sender)) || type == ObjectSyncManager.SyncTypes.PeriodicSync)
{
// Send synced variables, or variables only sync in some cases.
if (msg.HasSyncedVariables)
{
osc.HandleSyncedVariables(msg.SyncedVariables);
}
// Full sync.
if (msg.HasPosition && msg.HasRotation)
{
osc.SetPositionAndRotation(Utils.NetVec3ToGame(msg.Position), Utils.NetQuatToGame(msg.Rotation));
}
// Position only sync.
else if (msg.HasPosition)
{
Quaternion zero = new Quaternion(0, 0, 0, 0);
osc.SetPositionAndRotation(Utils.NetVec3ToGame(msg.Position), zero);
}
// Rotation only sync.
else if (msg.HasRotation)
{
osc.SetPositionAndRotation(Vector3.zero, Utils.NetQuatToGame(msg.Rotation));
}
}
});
netMessageHandler.BindMessageHandler((Steamworks.CSteamID sender, Messages.ObjectSyncResponseMessage msg) => {
ObjectSyncComponent osc = ObjectSyncManager.GetSyncComponentByID(msg.objectID);
if (msg.accepted)
{
osc.SyncEnabled = true;
osc.Owner = NetManager.Instance.GetLocalPlayer();
}
});
netMessageHandler.BindMessageHandler((Steamworks.CSteamID sender, Messages.ObjectSyncRequestMessage msg) => {
Client.Assert(ObjectSyncManager.GetObjectByID(msg.objectID), $"Remote client tried to request object sync of an unknown object, remote ObjectID was: {msg.objectID}");
ObjectSyncComponent osc = ObjectSyncManager.GetSyncComponentByID(msg.objectID);
osc.SendObjectSync(ObjectSyncManager.SyncTypes.GenericSync, true, true);
});
netMessageHandler.BindMessageHandler((Steamworks.CSteamID sender, Messages.EventHookSyncMessage msg) => {
if (msg.request)
{
EventHook.SendSync(msg.fsmID);
return;
}
if (msg.HasFsmEventName)
{
EventHook.HandleEventSync(msg.fsmID, msg.fsmEventID, msg.FsmEventName);
}
else
{
EventHook.HandleEventSync(msg.fsmID, msg.fsmEventID);
}
});
}
public bool Equals(EventHook other)
{
return(name == other.name && Equals(target, other.target) && Equals(tag, other.tag));
}
/// <summary>
/// Hook vehicle events.
/// </summary>
void HookEvents()
{
// Engine states
string[] ignitionStateNames = { "Wait button", "Motor starting", "Motor OFF", "Test", "Shut off", "ACC on", "ACC on 2" };
foreach (string name in ignitionStateNames)
{
EventHook.AddWithSync(ignitionFsm, name);
}
// Dashboard states
string[] dashboardStateNames = { "ACC on", "Test", "ACC on 2", "Motor starting", "Shut off", "Motor OFF", "Wait button", "Wait player" };
foreach (string name in dashboardStateNames)
{
EventHook.Add(dashboardFsm, name, new Func <bool>(() => {
return(false);
}));
}
// Vehicle switches
// Range
if (hasRange)
{
if (isTruck)
{
EventHook.AddWithSync(rangeFsm, "Switch");
}
else if (isTractor)
{
EventHook.AddWithSync(rangeFsm, "Flip");
}
}
// Push parking brake
if (hasPushParkingBrake)
{
EventHook.Add(handbrakeFsm, "DECREASE", new Func <bool>(() => {
Network.NetLocalPlayer.Instance.WriteVehicleSwitchMessage(syncComponent, SwitchIDs.HandbrakePull, false, this.handbrakeFsm.Fsm.GetFsmFloat("KnobPos").Value);
return(false);
}), actionOnExit: true);
EventHook.Add(handbrakeFsm, "INCREASE", new Func <bool>(() => {
Network.NetLocalPlayer.Instance.WriteVehicleSwitchMessage(syncComponent, SwitchIDs.HandbrakePull, false, this.handbrakeFsm.Fsm.GetFsmFloat("KnobPos").Value);
return(false);
}), actionOnExit: true);
}
// Truck parking brake
if (hasLeverParkingBrake)
{
EventHook.Add(handbrakeFsm, "Flip", new Func <bool>(() => {
Network.NetLocalPlayer.Instance.WriteVehicleSwitchMessage(syncComponent, SwitchIDs.HandbrakeLever, !this.handbrakeFsm.Fsm.GetFsmBool("Brake").Value, -1);
return(false);
}));
}
// Fuel tap
if (fuelTapFsm != null)
{
EventHook.Add(fuelTapFsm, "Test", new Func <bool>(() => {
Network.NetLocalPlayer.Instance.WriteVehicleSwitchMessage(syncComponent, SwitchIDs.FuelTap, !this.fuelTapFsm.Fsm.GetFsmBool("FuelOn").Value, -1);
return(false);
}));
}
// Lights
if (lightsFsm != null)
{
EventHook.AddWithSync(lightsFsm, "Off");
EventHook.AddWithSync(lightsFsm, "Shorts");
EventHook.AddWithSync(lightsFsm, "Longs");
}
// Indicators
if (indicatorsFsm != null)
{
EventHook.AddWithSync(indicatorsFsm, "Activate dash");
EventHook.AddWithSync(indicatorsFsm, "Activate dash 2");
EventHook.AddWithSync(indicatorsFsm, "On", action: new Func <bool>(() => {
if (this.DriverIsLocal == false)
{
return(true);
}
return(false);
}));
EventHook.AddWithSync(indicatorsFsm, "On 2", action: new Func <bool>(() => {
if (this.DriverIsLocal == false)
{
return(true);
}
return(false);
}));
EventHook.AddWithSync(indicatorsFsm, "Off", action: new Func <bool>(() => {
if (this.DriverIsLocal == false)
{
return(true);
}
return(false);
}));
EventHook.AddWithSync(indicatorsFsm, "Off 2", action: new Func <bool>(() => {
if (this.DriverIsLocal == false)
{
return(true);
}
return(false);
}));
EventHook.AddWithSync(indicatorsFsm, "State 3", action: new Func <bool>(() => {
if (this.DriverIsLocal == false)
{
Logger.Log("Turning off indicators!");
GameObject left;
GameObject right;
left = this.gameObject.transform.FindChild("LOD/Electricity/PowerON/Blinkers/Left").gameObject;
right = this.gameObject.transform.FindChild("LOD/Electricity/PowerON/Blinkers/Right").gameObject;
// Ferndale has a different hierarchy. Why not, right?
if (left == null)
{
left = this.gameObject.transform.FindChild("LOD/Electricity 1/PowerON/Blinkers/Left").gameObject;
right = this.gameObject.transform.FindChild("LOD/Electricity 1/PowerON/Blinkers/Right").gameObject;
}
left.SetActive(false);
right.SetActive(false);
if (left == null)
{
Logger.Log("Left indicator not found!");
}
}
return(false);
}));
}
// Wipers
if (wipersFsm != null)
{
EventHook.Add(wipersFsm, "Test 2", new Func <bool>(() => {
int selection = this.wipersFsm.Fsm.GetFsmInt("Selection").Value;
if (selection == 2)
{
selection = 0;
}
else
{
selection++;
}
Network.NetLocalPlayer.Instance.WriteVehicleSwitchMessage(syncComponent, SwitchIDs.Wipers, false, selection);
return(false);
}));
}
// Interior light
if (lightsFsm != null)
{
if (isTruck)
{
EventHook.Add(interiorLightFsm, "Switch", new Func <bool>(() => {
Network.NetLocalPlayer.Instance.WriteVehicleSwitchMessage(syncComponent, SwitchIDs.InteriorLight, !this.interiorLightFsm.Fsm.GetFsmBool("On").Value, -1);
return(false);
}));
}
else
{
EventHook.Add(interiorLightFsm, "Flip 2", new Func <bool>(() => {
Network.NetLocalPlayer.Instance.WriteVehicleSwitchMessage(syncComponent, SwitchIDs.InteriorLight, !this.interiorLightFsm.Fsm.GetFsmBool("LightON").Value, -1);
return(false);
}));
}
}
// Truck related events
if (isTruck)
{
// Hydraulic pump
EventHook.Add(hydraulicPumpFsm, "Test", new Func <bool>(() => {
if (this.hydraulicPumpFirstRun == false)
{
Network.NetLocalPlayer.Instance.WriteVehicleSwitchMessage(syncComponent, SwitchIDs.HydraulicPump, !this.hydraulicPumpFsm.Fsm.GetFsmBool("On").Value, -1);
}
else
{
this.hydraulicPumpFirstRun = false;
}
return(false);
}));
// Spill valve
EventHook.Add(spillValveFsm, "Switch", new Func <bool>(() => {
Network.NetLocalPlayer.Instance.WriteVehicleSwitchMessage(syncComponent, SwitchIDs.SpillValve, !this.spillValveFsm.Fsm.GetFsmBool("Open").Value, -1);
return(false);
}));
// Axle lift
EventHook.Add(axleLiftFsm, "Test", new Func <bool>(() => {
if (this.axleLiftFirstRun == false)
{
Network.NetLocalPlayer.Instance.WriteVehicleSwitchMessage(syncComponent, SwitchIDs.AxleLift, !this.axleLiftFsm.Fsm.GetFsmBool("Up").Value, -1);
}
else
{
this.axleLiftFirstRun = false;
}
return(false);
}));
// Diff lock
EventHook.Add(diffLockFsm, "Test", new Func <bool>(() => {
if (this.diffLockFirstRun == false)
{
Network.NetLocalPlayer.Instance.WriteVehicleSwitchMessage(syncComponent, SwitchIDs.DiffLock, !this.diffLockFsm.Fsm.GetFsmBool("Lock").Value, -1);
}
else
{
this.diffLockFirstRun = false;
}
return(false);
}));
// Beacon
EventHook.AddWithSync(beaconFsm, "ON");
EventHook.AddWithSync(beaconFsm, "OFF");
}
// Wasp nest
if (waspNestFsm != null)
{
EventHook.AddWithSync(waspNestFsm, "State 2");
}
// Sync vehicle data with the host on spawn.
if (Network.NetManager.Instance.IsOnline && !Network.NetManager.Instance.IsHost)
{
syncComponent.RequestObjectSync();
}
}
public IActionResult MensagemEnviada([FromBody] EventHook eventHook)
{
var jsonEventHook = JsonConvert.SerializeObject(eventHook);
_logger.LogInformation($"Acessando POST mensagem-enviada {nameof(ClienteController)} {nameof(eventHook)}: {jsonEventHook}");
foreach (var conteudo in eventHook.Message.Contents.Where(x => x.Type == "text"))
{
var mensagem = new MensagemZAP
{
From = eventHook.Message.From,
Channel = eventHook.Message.Channel,
Direction = eventHook.Message.Direction,
To = eventHook.Message.To,
Conteudo = conteudo.Text,
VisitorFullName = eventHook.Message.Visitor.Name,
Data = DateTime.Now,
};
_context.MensagemZAP.Add(mensagem);
var cliente = _context.Cliente.Where(x => x.Celular == mensagem.From).FirstOrDefault();
if (cliente == null)
{
cliente = new Cliente();
cliente.Celular = mensagem.From;
cliente.Nome = mensagem.VisitorFullName;
_context.Cliente.Add(cliente);
}
_context.SaveChanges();
if (mensagem.Conteudo.ToLower().Contains("oi") && mensagem.Direction == "IN")
{
Autenticacao autenticacao = new Autenticacao();
autenticacao.ClienteId = cliente.ClienteId;
autenticacao.Data = DateTime.Now;
autenticacao.GerarCodigo();
_context.Autenticacao.Add(autenticacao);
_context.SaveChanges();
var mensagemAutenticacao = $"Digite:{autenticacao.Codigo} para completar a autenticação:";
var sender = new SenderMessageRequest();
sender.From = "furry-time";
sender.To = cliente.Celular;
sender.Contents = new List <Models.SendMessageZenvia.Content>();
sender.Contents.Add(new Models.SendMessageZenvia.Content {
Type = "text", Text = mensagemAutenticacao, Payload = string.Empty
});
var json = JsonConvert.SerializeObject(sender);
var httpRequestMessage = new HttpRequestMessage(HttpMethod.Post, $"https://api.zenvia.com/v1/channels/whatsapp/messages");
httpRequestMessage.Headers.Add("X-API-TOKEN", "sxyGdagDRB3AFLl51p_y5gGzXnIyx2w4qmzR");
httpRequestMessage.Content = new StringContent(json, Encoding.UTF8, "application/json");
var httpClient = new HttpClient();
var response = httpClient.SendAsync(httpRequestMessage).Result;
}
}
return(Ok());
}
