internal void SendCompBaseData(CoreComponent comp) { if (IsServer) { const PacketType type = PacketType.CompBase; comp.Data.Repo.Base.UpdateCompBasePacketInfo(comp, true); PacketInfo oldInfo; CompBasePacket iPacket; if (PrunedPacketsToClient.TryGetValue(comp.Data.Repo.Base, out oldInfo)) { iPacket = (CompBasePacket)oldInfo.Packet; iPacket.EntityId = comp.MyCube.EntityId; iPacket.Data = comp.Data.Repo.Base; } else { iPacket = PacketCompBasePool.Get(); iPacket.MId = ++comp.MIds[(int)type]; iPacket.EntityId = comp.MyCube.EntityId; iPacket.SenderId = MultiplayerId; iPacket.PType = type; iPacket.Data = comp.Data.Repo.Base; } PrunedPacketsToClient[comp.Data.Repo.Base] = new PacketInfo { Entity = comp.MyCube, Packet = iPacket, }; } else { Log.Line($"SendCompData should never be called on Client"); } }
internal void SendTrackReticleUpdate(CoreComponent comp, bool track) { if (IsClient) { uint[] mIds; if (PlayerMIds.TryGetValue(MultiplayerId, out mIds)) { PacketsToServer.Add(new BoolUpdatePacket { MId = ++mIds[(int)PacketType.ReticleUpdate], EntityId = comp.MyCube.EntityId, SenderId = MultiplayerId, PType = PacketType.ReticleUpdate, Data = track }); } else { Log.Line($"SendTrackReticleUpdate no player MIds found"); } } else if (HandlesInput) { comp.Data.Repo.Base.State.TrackingReticle = track; SendCompBaseData(comp); } }
/// <summary> /// Returns all the properties in the given component /// </summary> /// <param name="comp"></param> public static PropertyInfo[] GetProperties(CoreComponent comp) { List <PropertyInfo> returnProps = new List <PropertyInfo>(); System.Reflection.PropertyInfo[] properties = comp.GetType().GetProperties(); foreach (PropertyInfo prop in properties) { bool ignoreProp = false; var attributes = prop.GetCustomAttributes(true); foreach (Attribute at in attributes) { if (at is IgnoreInSaveAttribute) { ignoreProp = true; break; } } if (!ignoreProp) { returnProps.Add(prop); } else { continue; } } return(returnProps.ToArray()); }
/// <summary> /// Returns all the fields in the given component /// </summary> /// <param name="comp"></param> public static FieldInfo[] GetFields(CoreComponent comp) { List <FieldInfo> returnFields = new List <FieldInfo>(); System.Reflection.FieldInfo[] fields = comp.GetType().GetFields(); foreach (System.Reflection.FieldInfo field in fields) { bool ignoreField = false; var attributes = field.GetCustomAttributes(true); foreach (Attribute at in attributes) { if (at is IgnoreInSaveAttribute) { ignoreField = true; break; } } if (!ignoreField) { returnFields.Add(field); } else { continue; } } return(returnFields.ToArray()); }
internal void SendOverRidesClientComp(CoreComponent comp, string settings, int value) { if (IsClient) { uint[] mIds; if (PlayerMIds.TryGetValue(MultiplayerId, out mIds)) { PacketsToServer.Add(new OverRidesPacket { MId = ++mIds[(int)PacketType.OverRidesUpdate], PType = PacketType.OverRidesUpdate, EntityId = comp.MyCube.EntityId, SenderId = MultiplayerId, Setting = settings, Value = value, }); } else { Log.Line($"SendOverRidesClientComp no player MIds found"); } } else { Log.Line($"SendOverRidesClientComp should only be called on clients"); } }
public void SetProxy_UnknownResult( [Frozen] Mock <IHttpClient> httpClientMock, [Greedy] CoreComponent sut, string host, int port) { // ARRANGE var proxy = new JObject( new JProperty("type", 1), new JProperty("http", new JObject( new JProperty("host", host), new JProperty("port", port)))); httpClientMock.SetupApiCall(sut, CallType.Other, "setproxy", new Parameters { { "proxy", proxy } }, DataType.Other) .Returns("FAILED") .Verifiable(); // ACT Action act = () => sut.SetProxy(host, port); // ASSERT act.ShouldThrow <ZapException>().WithMessage(Resources.UnknownSetProxyResult); httpClientMock.Verify(); }
/// <summary> /// Initialize Camera config string /// </summary> private void InitializeCameraDevice() { CoreComponent component = null; string cameraDevices = ""; //get camera friendly names from try { component = new CoreComponent(); cameraDevices = component.GetCameraDevice(); } catch (Exception ex) { Log.LogError("Cannot get Camera devices: " + ex.ToString()); } finally { if (component != null) { component.Dispose(); component = null; } } CameraConfig.Text = cameraDevices; }
public void SetProxy( [Frozen] Mock <IHttpClient> httpClientMock, [Greedy] CoreComponent sut, string host, int port) { // ARRANGE var proxy = new JObject( new JProperty("type", 1), new JProperty("http", new JObject( new JProperty("host", host), new JProperty("port", port)))); httpClientMock.SetupApiCall(sut, CallType.Other, "setproxy", new Parameters { { "proxy", proxy } }, DataType.Other) .Returns("OK") .Verifiable(); // ACT sut.SetProxy(host, port); // ASSERT httpClientMock.Verify(); }
internal void ServerUpdate(CoreComponent comp) { long aTermId; if (!ServerTerminalMaps.TryGetValue(comp, out aTermId)) { ServerTerminalMaps[comp] = comp.MyCube.EntityId; //if (!Session.LocalVersion) Log.Line($"ServerUpdate added Id"); } else { var cube = MyEntities.GetEntityByIdOrDefault(aTermId) as MyCubeBlock; if (cube != null && cube.CubeGrid.EntityId != comp.Ai.MyGrid.EntityId) { ServerTerminalMaps[comp] = 0; //if (!Session.LocalVersion) Log.Line($"ServerUpdate reset Id"); } } comp.Ai.Data.Repo.ActiveTerminal = comp.MyCube.EntityId; if (comp.IsAsleep) { comp.WakeupComp(); } if (Session.MpActive) { Session.SendAiData(comp.Ai); } }
public void GetMessagesHar( [Frozen] Mock <IHttpClient> httpClientMock, [Greedy] CoreComponent sut, string baseUrl, int start, int count, Har messages) { // ARRANGE httpClientMock.SetupApiCall(sut, CallType.Other, "messagesHar", new Parameters { { "baseurl", baseUrl }, { "start", start }, { "count", count } }, DataType.Other) .Returns(Har.Serialize(messages)) .Verifiable(); // ACT var result = sut.GetMessagesHar(baseUrl, start, count); // ASSERT result.ShouldBeEquivalentTo(messages); httpClientMock.Verify(); }
//Connect components to eachother - called in audio engine public void createConnection(CoreComponent input, CoreComponent output, CoreSocketCasing inputSocket, CoreSocketCasing outputSocket) { if (inputSocket is AudioInputSocketCasing && outputSocket is AudioOutputSocketCasing) { AudioSocketComponent inSocComp = audioInputs[inputSocket.getSocketNum()]; AudioSocketComponent outSocComp = output.io.audioOutputs[outputSocket.getSocketNum()]; inSocComp.connect(outSocComp); inSocComp.setSocketNum(inputSocket.getSocketNum()); outSocComp.connect(inSocComp); outSocComp.setSocketNum(outputSocket.getSocketNum()); } else if (inputSocket is DataInputSocketCasing && outputSocket is DataOutputSocketCasing) { DataSocketComponent inSocComp = dataInputs[inputSocket.getSocketNum()]; DataSocketComponent outSocComp = output.io.dataOutputs[outputSocket.getSocketNum()]; DataSocketCasing dataInputSocket = inputSocket as DataSocketCasing; DataSocketCasing dataOutputSocket = outputSocket as DataSocketCasing; inSocComp.connect(outSocComp); inSocComp.setSocketNum(dataInputSocket.getSocketNum()); inSocComp.setControlNum(dataInputSocket.getControlNum()); outSocComp.connect(inSocComp); outSocComp.setSocketNum(dataOutputSocket.getSocketNum()); outSocComp.setControlNum(dataOutputSocket.getControlNum()); } }
private bool ServerOverRidesUpdate(PacketObj data) { var packet = data.Packet; var overRidesPacket = (OverRidesPacket)packet; var ent = MyEntities.GetEntityByIdOrDefault(packet.EntityId, null, true); var comp = ent?.Components.Get <CoreComponent>(); if (comp?.Ai == null || comp.Platform.State != CorePlatform.PlatformState.Ready) { return(Error(data, Msg("Comp", comp != null), Msg("Ai", comp?.Ai != null), Msg("Ai", comp?.Platform.State == CorePlatform.PlatformState.Ready))); } uint[] mIds; if (PlayerMIds.TryGetValue(packet.SenderId, out mIds) && mIds[(int)packet.PType] < packet.MId) { mIds[(int)packet.PType] = packet.MId; CoreComponent.RequestSetValue(comp, overRidesPacket.Setting, overRidesPacket.Value, SteamToPlayer[overRidesPacket.SenderId]); data.Report.PacketValid = true; } else { Log.Line($"ServerOverRidesUpdate: MidsHasSenderId:{PlayerMIds.ContainsKey(packet.SenderId)} - midsNull:{mIds == null} - senderId:{packet.SenderId}"); } return(true); }
//Connect two components sockets together -- Receiving Socket --> Sending Socket public void createConnection(CoreSocketCasing socket1, CoreSocketCasing socket2) { //Interprets the correct way around - input->output CoreComponent input = null, output = null; CoreSocketCasing inSoc = null, outSoc = null; if (socket1 is AudioInputSocketCasing || socket1 is DataInputSocketCasing) { input = socket1.GetComponentInParent <CoreCasing>().getComponent(); output = socket2.GetComponentInParent <CoreCasing>().getComponent(); inSoc = socket1; outSoc = socket2; } else if (socket1 is AudioOutputSocketCasing || socket1 is DataOutputSocketCasing) { input = socket2.GetComponentInParent <CoreCasing>().getComponent(); output = socket1.GetComponentInParent <CoreCasing>().getComponent(); inSoc = socket2; outSoc = socket1; } else { return; } input.io.createConnection(input, output, inSoc, outSoc); socket1.drawCable(socket2); print("Connection made"); }
internal void HandleInputUpdate(CoreComponent comp) { if (Active && (Comp != comp || OriginalAiVersion != comp.Ai.Version)) { Clean(); } Session.LastTerminal = (IMyTerminalBlock)comp.MyCube; Comp = comp; OriginalAiVersion = comp.Ai.Version; if (comp.IsAsleep) { comp.WakeupComp(); } if (Session.IsClient && !Active) { Session.SendActiveTerminal(comp); } else if (Session.IsServer) { ServerUpdate(Comp); } Active = true; }
void Start() { //Go up parents until an audio component is found CoreCasing casing = null; GameObject level = this.gameObject; component = null; while (casing == null) { if (level.transform.parent != null) { level = level.transform.parent.gameObject; } else { break; } casing = level.GetComponent <CoreCasing>(); } if (casing != null) { component = casing.getComponent(); } //Run the child's intitialisation initialise(); }
internal void Clean(bool purge = false) { if (Session.MpActive && Session.HandlesInput && Comp != null && !purge) { uint[] mIds; if (Session.PlayerMIds.TryGetValue(Session.MultiplayerId, out mIds)) { Session.PacketsToServer.Add(new TerminalMonitorPacket { SenderId = Session.MultiplayerId, PType = PacketType.TerminalMonitor, EntityId = Comp.MyCube.EntityId, State = TerminalMonitorPacket.Change.Clean, MId = ++mIds[(int)PacketType.TerminalMonitor], }); } } if (!purge && Session.IsServer) { ServerClean(Comp); } Comp = null; OriginalAiVersion = -1; Active = false; }
public void GetAlert( [Frozen] Mock <IHttpClient> httpClientMock, [Greedy] CoreComponent sut, int id, Alert alert) { // ARRANGE var json = new JObject( new JProperty("alert", JObject.FromObject(alert))); httpClientMock.SetupApiCall(sut, CallType.View, "alert", new Parameters { { "id", id } }) .Returns(json.ToString()) .Verifiable(); // ACT var result = sut.GetAlert(id); // ASSERT result.ShouldBeEquivalentTo(alert); httpClientMock.Verify(); }
public void UpdateCompBasePacketInfo(CoreComponent comp, bool clean = false) { ++Revision; ++State.Revision; Session.PacketInfo info; if (clean && comp.Session.PrunedPacketsToClient.TryGetValue(comp.Data.Repo.Base.State, out info)) { comp.Session.PrunedPacketsToClient.Remove(comp.Data.Repo.Base.State); comp.Session.PacketStatePool.Return((CompStatePacket)info.Packet); } for (int i = 0; i < Targets.Length; i++) { var t = Targets[i]; var wr = Reloads[i]; if (clean) { if (comp.Session.PrunedPacketsToClient.TryGetValue(t, out info)) { comp.Session.PrunedPacketsToClient.Remove(t); comp.Session.PacketTargetPool.Return((TargetPacket)info.Packet); } if (comp.Session.PrunedPacketsToClient.TryGetValue(wr, out info)) { comp.Session.PrunedPacketsToClient.Remove(wr); comp.Session.PacketReloadPool.Return((WeaponReloadPacket)info.Packet); } } ++wr.Revision; ++t.Revision; t.WeaponRandom.ReInitRandom(); } }
public ZapClient(string host, int port, Protocols protocol = Protocols.http) { Protocol = protocol; Host = host; Port = port; Acsrf = new AcsrfComponent(this); AjaxSpider = new AjaxSpiderComponent(this); Ascan = new AscanComponent(this); Authentication = new AuthenticationComponent(this); Authorization = new AuthorizationComponent(this); Autoupdate = new AutoupdateComponent(this); Break = new BreakComponent(this); Context = new ContextComponent(this); Core = new CoreComponent(this); ForcedUser = new ForcedUserComponent(this); HttpSessions = new HttpSessionsComponent(this); Params = new ParamsComponent(this); Pscan = new PscanComponent(this); Reveal = new RevealComponent(this); Script = new ScriptComponent(this); Search = new SearchComponent(this); Selenium = new SeleniumComponent(this); SessionManagement = new SessionManagementComponent(this); Spider = new SpiderComponent(this); Users = new UsersComponent(this); }
public void SendRequest( [Frozen] Mock <IHttpClient> httpClientMock, [Greedy] CoreComponent sut, string httpRequest, bool followRedirects, IEnumerable <Message> messages) { // ARRANGE var json = new JObject( new JProperty("sendRequest", JArray.FromObject(messages))); httpClientMock.SetupApiCall(sut, CallType.Action, "sendRequest", new Parameters { { "request", httpRequest }, { "followRedirects", followRedirects } }) .Returns(json.ToString()) .Verifiable(); // ACT var result = sut.SendRequest(httpRequest, followRedirects); // ASSERT result.ShouldBeEquivalentTo(messages); httpClientMock.Verify(); }
public void GetAlerts( [Frozen] Mock <IHttpClient> httpClientMock, [Greedy] CoreComponent sut, string baseUrl, int start, int count, IEnumerable <Alert> alerts) { // ARRANGE var json = new JObject( new JProperty("alerts", JArray.FromObject(alerts))); httpClientMock.SetupApiCall(sut, CallType.View, "alerts", new Parameters { { "baseurl", baseUrl }, { "start", start }, { "count", count } }) .Returns(json.ToString()) .Verifiable(); // ACT var result = sut.GetAlerts(baseUrl, start, count); // ASSERT result.ShouldBeEquivalentTo(alerts); httpClientMock.Verify(); }
public void GetNumberOfMessages( [Frozen] Mock <IHttpClient> httpClientMock, [Greedy] CoreComponent sut, string baseUrl, int numberOfMessages) { // ARRANGE var json = new JObject( new JProperty("numberOfMessages", numberOfMessages)); httpClientMock.SetupApiCall(sut, CallType.View, "numberOfMessages", new Parameters { { "baseurl", baseUrl } }) .Returns(json.ToString()) .Verifiable(); // ACT var result = sut.GetNumberOfMessages(baseUrl); // ASSERT result.Should().Be(numberOfMessages); httpClientMock.Verify(); }
internal PlatformState Init(CoreComponent comp) { if (comp.MyCube.MarkedForClose) { return(PlatformCrash(comp, true, false, $"Your block subTypeId ({comp.MyCube.BlockDefinition.Id.SubtypeId.String}) markedForClose, init platform invalid, I am crashing now Dave.")); } if (!comp.MyCube.IsFunctional) { State = PlatformState.Delay; return(State); } //Get or init Ai var newAi = false; if (!Comp.Session.GridTargetingAIs.TryGetValue(Comp.MyCube.CubeGrid, out Comp.Ai)) { newAi = true; Comp.Ai = Comp.Session.GridAiPool.Get(); Comp.Ai.Init(Comp.MyCube.CubeGrid, Comp.Session); Comp.Session.GridTargetingAIs.TryAdd(Comp.MyCube.CubeGrid, Comp.Ai); } var blockDef = Comp.MyCube.BlockDefinition.Id.SubtypeId; if (!Comp.Ai.WeaponCounter.ContainsKey(blockDef)) { Comp.Ai.WeaponCounter[blockDef] = Comp.Session.WeaponCountPool.Get(); } var wCounter = comp.Ai.WeaponCounter[blockDef]; wCounter.Max = Structure.GridWeaponCap; if (newAi) { Comp.SubGridInit(); if (Comp.Ai.MarkedForClose) { Log.Line($"PlatFormInit and AI MarkedForClose: CubeMarked:{Comp.MyCube.MarkedForClose}"); } } if (wCounter.Max == 0 || Comp.Ai.Construct.GetWeaponCount(blockDef) + 1 <= wCounter.Max) { wCounter.Current++; GridAi.Constructs.UpdateWeaponCounters(Comp.Ai); State = PlatformState.Valid; } else { return(PlatformCrash(comp, true, false, $"{blockDef.String} over block limits: {wCounter.Current}.")); } Parts.Entity = comp.Entity as MyEntity; return(GetParts(comp)); }
public void ComponentName( [Greedy] CoreComponent sut) { // ACT var result = sut.ComponentName; // ASSERT result.Should().Be("core"); }
public static ICoreComponent CreateCoreComponent(IGraphUiContainer uiContainer, bool enableGeometricPreview) { if (null != CoreComponent.Instance) { throw new InvalidOperationException("'ClassFactory.CreateCoreComponent' called twice!"); } return(CoreComponent.CreateSingleton(uiContainer, enableGeometricPreview)); }
internal void ResetParts(CoreComponent comp) { Parts.Clean(comp.Entity as MyEntity); Parts.CheckSubparts(); ResetTurret(comp); comp.Status = Started; }
public CorePart(string name, int width, int height, RotateChar[] structure, CoreComponent cc, StabilityComponent sc, Direction facing = Direction.N) : base(name, width, height, structure, facing) { CoreComponent = cc; StabilityComponent = sc; Components.Add(cc); Components.Add(sc); }
public void SetSelectedMenuEntry(CoreComponent option) { if (option == null) { throw new InvalidOperationException("Attempting to set selected menu entry to null"); } selectedMenuEntry = option; selectedMenuEntry.SetMenuHighlight(true); }
public void SetSelectedEntry(CoreComponent coreComp) { if (coreComp == null) { throw new InvalidOperationException("Attempting to set selected entry to null"); } selectedEntry = coreComp; selectedEntry.SetHighlight(true); }
internal static void RequestControlMode(IMyTerminalBlock block, long newValue) { var comp = block?.Components?.Get <CoreComponent>(); if (comp == null || comp.Platform.State != CorePlatform.PlatformState.Ready) { return; } CoreComponent.RequestSetValue(comp, "ControlModes", (int)newValue, comp.Session.PlayerId); }