private void OnSuccess() { _networkedPhysics = NetworkedPhyiscs.Create(); _networkedPhysics.gameObject.AddComponent <ClientNetworkingHandler>(); if (NetworkUtils.IsServer) { _networkedPhysics.gameObject.AddComponent <ServerNetworkingHandler>(); _networkedPhysics.gameObject.AddComponent <NetworkedBotController>(); } NetworkClient.DisconnectHandler = () => { }; if (NetworkUtils.IsServer) { NetworkServer.ConnectHandler = ServerOnClientConnected; NetworkServer.DisconnectHandler = ServerOnClientDisconnected; } else { NetworkClient.SetTcpHandler(TcpPacketType.Server_State_Joined, buffer => { while (buffer.TotalBitsLeft >= 8) { CreateStructure(buffer.ReadByte()); } }); NetworkClient.SetTcpHandler(TcpPacketType.Server_State_Left, buffer => Destroy(BotCache.Get(buffer.ReadByte()).gameObject)); } CompleteStructure structure = CreateStructure(NetworkUtils.LocalId); InitializeLocalStructure(structure); }
private void ServerFixedUpdate() { BotCache.ForEachId(id => { byte[] packet = BotCache.TakeExtra <byte[]>(id, BotCache.Extra.NetworkedPhysics); if (packet == null) { return; } _sharedBuffer.SetContents(packet); if (_sharedBuffer.TotalBitsLeft >= BotState.InputSerializedBitsSize) { BotState.DeserializePlayerInput(_sharedBuffer, out Vector3 movementInput, out Vector3 trackedPosition); BotCache.Get(id).UpdateInputOnly(movementInput, trackedPosition); } }); Simulate(TimestepMillis); if (NetworkServer.ClientCount > 0) { int bitSize = 48 + BotState.SerializedBitsSize * BotCache.Count; _sharedBuffer.ClearContents(new byte[(bitSize + 7) / 8]); _sharedBuffer.WriteTimestamp(DoubleProtocol.TimeMillis); BotCache.ForEach(structure => structure.SerializeState(_sharedBuffer)); NetworkServer.UdpPayload = _sharedBuffer.Array; } else { NetworkServer.UdpPayload = null; } }
private string ReadUnitName(IntPtr activeObject, ulong guid) { if (BotCache.TryGetName(guid, out string cachedName)) { return(cachedName); } try { XMemory.Read(IntPtr.Add(activeObject, 0x964), out uint objName); XMemory.Read(IntPtr.Add(new IntPtr(objName), 0x05C), out objName); XMemory.ReadString(new IntPtr(objName), Encoding.UTF8, out string name, 32); if (name.Length > 0) { BotCache.CacheName(guid, name); } return(name); } catch { return("unknown"); } }
public WowUnitReaction GetUnitReaction(WowUnit wowUnitA, WowUnit wowUnitB) { WowUnitReaction reaction = WowUnitReaction.Unknown; if (wowUnitA == null || wowUnitB == null) { return(reaction); } if (BotCache.TryGetReaction(wowUnitA.FactionTemplate, wowUnitB.FactionTemplate, out WowUnitReaction cachedReaction)) { return(cachedReaction); } // integer to save the reaction XMemory.AllocateMemory(4, out IntPtr memAlloc); XMemory.Write(memAlloc, 0); string[] asm = new string[] { $"PUSH {wowUnitA.BaseAddress}", $"MOV ECX, {wowUnitB.BaseAddress}", $"CALL {OffsetList.FunctionGetUnitReaction}", $"MOV [{memAlloc}], EAX", "RETN", }; // we need this, to be very accurate, otherwise wow will crash if (XMemory.ReadStruct(IntPtr.Add(wowUnitA.DescriptorAddress, OffsetList.DescriptorUnitFlags.ToInt32()), out BitVector32 unitFlagsA) && XMemory.ReadStruct(IntPtr.Add(wowUnitB.DescriptorAddress, OffsetList.DescriptorUnitFlags.ToInt32()), out BitVector32 unitFlagsB)) { wowUnitA.UnitFlags = unitFlagsA; wowUnitB.UnitFlags = unitFlagsB; } else { return(reaction); } if (wowUnitA.IsDead || wowUnitB.IsDead) { return(reaction); } try { InjectAndExecute(asm, true); XMemory.Read(memAlloc, out reaction); BotCache.CacheReaction(wowUnitA.FactionTemplate, wowUnitB.FactionTemplate, reaction); } finally { XMemory.FreeMemory(memAlloc); } return(reaction); }
private void Start() { NetworkClient.SetTcpHandler(TcpPacketType.Server_Structure_Damage, buffer => BotCache.Get(buffer.ReadByte()).DamagedClient(buffer)); NetworkClient.SetTcpHandler(TcpPacketType.Server_System_Execute, buffer => ((WeaponSystem)BotCache.Get(buffer.ReadByte()).TryGetSystem(BlockPosition.Deserialize(buffer))) .ClientExecuteWeaponFiring(buffer)); }
/// <summary> /// Creates a new GameObject containing this component and also initializes, returns itself. /// </summary> public static NetworkedPhyiscs Create() { NetworkedPhyiscs instance = new GameObject("NetworkedPhysics").AddComponent <NetworkedPhyiscs>(); if (NetworkUtils.IsServer) { NetworkClient.UdpHandler = buffer => { }; NetworkServer.UdpHandler = (sender, buffer) => BotCache.SetExtra(sender.Id, BotCache.Extra.NetworkedPhysics, buffer.Array); } else { NetworkClient.UdpHandler = buffer => instance._lastClientUdpPacket = buffer.Array; } return(instance); }
private string ReadPlayerName(ulong guid) { if (BotCache.TryGetName(guid, out string cachedName)) { return(cachedName); } uint shortGuid; uint offset; XMemory.Read(IntPtr.Add(OffsetList.NameStore, OffsetList.NameMask.ToInt32()), out uint playerMask); XMemory.Read(IntPtr.Add(OffsetList.NameStore, OffsetList.NameBase.ToInt32()), out uint playerBase); shortGuid = (uint)guid & 0xfffffff; offset = 12 * (playerMask & shortGuid); XMemory.Read(new IntPtr(playerBase + offset + 8), out uint current); XMemory.Read(new IntPtr(playerBase + offset), out offset); if ((current & 0x1) == 0x1) { return(string.Empty); } XMemory.Read(new IntPtr(current), out uint testGuid); while (testGuid != shortGuid) { XMemory.Read(new IntPtr(current + offset + 4), out current); if ((current & 0x1) == 0x1) { return(string.Empty); } XMemory.Read(new IntPtr(current), out testGuid); } XMemory.ReadString(IntPtr.Add(new IntPtr(current), OffsetList.NameString.ToInt32()), Encoding.UTF8, out string name, 16); if (name.Length > 0) { BotCache.CacheName(guid, name); } return(name); }
private void ClientOnlyPacketReceived(CompleteStructure localStructure, out int toSimulate, out long lastMillis) { long currentMillis = DoubleProtocol.TimeMillis; lastMillis = _sharedBuffer.ReadTimestamp(); toSimulate = (int)(currentMillis - lastMillis); while (_sharedBuffer.TotalBitsLeft >= BotState.SerializedBitsSize) { _tempBotState.Update(_sharedBuffer); BotCache.Get(_tempBotState.Id).UpdateWholeState(_tempBotState); } if (toSimulate <= 0) { toSimulate = 0; _silentSkipFastForwardUntil = 0; } else if (toSimulate >= 500) { if (currentMillis < _silentSkipFastForwardUntil) { Debug.LogWarning($"Skipping {toSimulate}ms of networking fast-forward simulation to avoid delays." + "Hiding this error for at most 100ms."); _silentSkipFastForwardUntil = currentMillis + 100; } toSimulate = 0; } else { _silentSkipFastForwardUntil = 0; } while (_guessedInputs.Count > 0) { KeyValuePair <long, GuessedInput> guessed = _guessedInputs.First(); if (guessed.Value.MovementInput.Equals(localStructure.MovementInput)) { _guessedInputs.Remove(guessed.Key); } else { break; } } }
public async Task FillBotAsync() { BotCache botCache = null; List <BotCache> inCache = null; var apartments = await _apartmentService.GetAll(); //var infos = await _infoService.GetAll(); //var events = await _eventService.GetAll(); foreach (var apartment in apartments) { var split = apartment.Utilities.Split('&'); foreach (var utility in split) { var utilitySplit = utility.Split('='); botCache = new BotCache(utilitySplit[0], utilitySplit[1], apartment.ApartmentId); inCache = await(_botCacheRepository.GetAllWhere( m => m.ApartmentId == apartment.ApartmentId && m.Keyword == utilitySplit[0])); if (!inCache.Any()) { _botCacheRepository.Insert(botCache); } } var inTime = apartment.CheckIn.TimeOfDay.ToString(); var outTime = apartment.CheckOut.TimeOfDay.ToString(); botCache = new BotCache("check", inTime + "&" + outTime, apartment.ApartmentId); inCache = await _botCacheRepository.GetAllWhere(m => m.ApartmentId == apartment.ApartmentId && m.Keyword == "check"); if (!inCache.Any()) { _botCacheRepository.Insert(botCache); } } }
private static void Simulate(int millis) { int fullSteps = millis / TimestepMillis; while (fullSteps-- > 0) { BotCache.ForEach(structure => structure.SimulatedPhysicsUpdate(1f)); Physics.Simulate(TimestepSeconds); } int mod = millis % TimestepMillis; if (mod != 0) { float timestepMultiplier = (float)mod / TimestepMillis; BotCache.ForEach(structure => structure.SimulatedPhysicsUpdate(timestepMultiplier)); Physics.Simulate(mod / 1000f); } }
private void ClientOnlyFixedUpdate() { CompleteStructure localStructure = BotCache.Get(NetworkUtils.LocalId); int toSimulate; long lastMillis; if (_lastClientUdpPacket != null) { _sharedBuffer.SetContents(_lastClientUdpPacket); _lastClientUdpPacket = null; ClientOnlyPacketReceived(localStructure, out toSimulate, out lastMillis); if (toSimulate == 0) { return; } } else if (_silentSkipFastForwardUntil != 0) { return; //don't simulate normal steps if skipped the last state update simulation } else { toSimulate = TimestepMillis; lastMillis = DoubleProtocol.TimeMillis - TimestepMillis; } while (_guessedInputs.Count > 0) { KeyValuePair <long, GuessedInput> guessed = _guessedInputs.First(); if (guessed.Key >= lastMillis) { break; } _guessedInputs.Remove(guessed.Key); guessed.Value.RemainingDelay -= (int)(lastMillis - guessed.Key); if (guessed.Value.RemainingDelay > 0) { _guessedInputs.Remove(lastMillis); _guessedInputs.Add(lastMillis, guessed.Value); } } foreach (KeyValuePair <long, GuessedInput> guessed in _guessedInputs) { int delta = (int)(guessed.Key - lastMillis); if (delta > toSimulate) { break; } else if (delta == 0) { localStructure.UpdateInputOnly(guessed.Value.MovementInput, null); } else { Simulate(delta); localStructure.UpdateInputOnly(guessed.Value.MovementInput, null); toSimulate -= delta; lastMillis = guessed.Key; } } if (toSimulate != 0) { Simulate(toSimulate); } }
public void Update(BotCache botCache) { _botCacheRepository.Update(botCache); }
public void Add(BotCache botCache) { _botCacheRepository.Insert(botCache); }