private void ChildUpdateOnPositionChange(IObject own)
{
AgentCircuit c;
if (Circuits.TryGetValue(SceneID, out c))
{
var scene = c.Scene;
if (scene != null)
{
foreach (var kvp in ActiveChilds)
{
var m = new ChildAgentPositionUpdate
{
AgentID = ID,
AgentPosition = GlobalPosition,
AgentVelocity = Velocity,
ChangedGrid = false,
AtAxis = CameraAtAxis,
Center = CameraPosition,
LeftAxis = CameraLeftAxis,
RegionLocation = scene.GridPosition,
SessionID = SessionID,
Size = Size,
UpAxis = CameraUpAxis
};
var childUpdater = kvp.Value.ChildAgentUpdateService;
childUpdater?.SendMessage(m);
}
}
}
}
public void HandleAgentAnimation(Message m)
{
var req = (AgentAnimation)m;
SceneInterface scene;
AgentCircuit circuit;
if (!Circuits.TryGetValue(m.CircuitSceneID, out circuit))
{
return;
}
scene = circuit.Scene;
if (scene == null)
{
return;
}
AssetServiceInterface sceneAssetService = scene.AssetService;
if (sceneAssetService == null)
{
return;
}
AssetMetadata metadata;
foreach (var e in req.AnimationEntryList)
{
if (e.StartAnim)
{
if (!sceneAssetService.Metadata.TryGetValue(e.AnimID, out metadata))
{
AssetData data;
if (AssetService.TryGetValue(e.AnimID, out data))
{
sceneAssetService.Store(data);
if (data.Type != AssetType.Animation)
{
/* ignore non-animation content here */
continue;
}
}
else
{
/* asset not there so ignore */
continue;
}
}
else if (metadata.Type != AssetType.Animation)
{
/* ignore non-animation content here */
continue;
}
PlayAnimation(e.AnimID, UUID.Zero);
}
else
{
StopAnimation(e.AnimID, UUID.Zero);
}
}
}
private void RunHowLongTestFor(string[] connects, string[] costs, int expected, string assertMsg)
{
Circuits target = new Circuits();
int actual;
actual = target.howLong(connects, costs);
Assert.AreEqual(expected, actual, assertMsg);
}
static bool ReadCantilever()
{
myCantilever = new Cantilever(); //create a cantilever
Circuits.Insert(1, myCantilever); //insert it in the second place (after timer)
return myCantilever.ReadCantilever(FileNameMain);
}
public override void SendKillObject(UUID sceneID)
{
AgentCircuit circuit;
if (Circuits.TryGetValue(sceneID, out circuit))
{
circuit.SendKillObject();
}
}
public void Dispose()
{
if (Vehicle?.GetPedOnSeat(VehicleSeat.Driver) != Game.Player.Character)
{
Vehicle?.GetPedOnSeat(VehicleSeat.Driver)?.Delete();
}
Circuits?.StopAllHandlers();
Vehicle?.Delete();
}
private void HandleAppearanceUpdate(IAgent agent)
{
AgentCircuit circuit;
if (Circuits.TryGetValue(m_CurrentSceneID, out circuit))
{
circuit.Scene.SendAgentAppearanceToAllAgents(this);
}
}
public override void SendUpdateObject(UUID sceneID)
{
AgentCircuit circuit;
if (Circuits.TryGetValue(sceneID, out circuit))
{
#if DEBUG
m_Log.DebugFormat("Sending update for {0} at {1}", Owner, sceneID);
#endif
circuit.Scene?.ScheduleUpdate(GetUpdateInfo(sceneID));
}
}
private void ChildUpdateOnParamChange()
{
AgentCircuit c;
if (Circuits.TryGetValue(SceneID, out c))
{
var scene = c.Scene;
if (scene != null)
{
foreach (var kvp in ActiveChilds)
{
var m = new ChildAgentUpdate
{
RegionID = scene.ID,
RegionLocation = scene.GridPosition,
AgentID = ID,
SessionID = SessionID,
AgentPosition = GlobalPosition,
AgentVelocity = Velocity,
Center = CameraPosition,
Size = Size,
AtAxis = CameraAtAxis,
LeftAxis = CameraLeftAxis,
UpAxis = CameraUpAxis,
ChangedGrid = false,
Far = m_DrawDistance,
Aspect = 1,
Throttles = new byte[9],
//m.LocomotionState;
HeadRotation = HeadRotation,
BodyRotation = BodyRotation,
ControlFlags = m_ActiveAgentControlFlags,
EnergyLevel = 0,
GodLevel = 0,
AlwaysRun = m_IsRunning,
PreyAgent = UUID.Zero,
AgentAccess = 0,
//m.AgentTextures;
ActiveGroupID = Group.ID,
//m.GroupData;
//m.AnimationData;
//m_AnimationController.
//m.GranterBlock;
VisualParams = VisualParams
};
//m.AgentAccessList;
//m.AgentInfo;
var childUpdater = kvp.Value.ChildAgentUpdateService;
childUpdater?.SendMessage(m);
}
}
}
}
public void HandleAgentDataUpdateRequest(Message m)
{
var adur = (AgentDataUpdateRequest)m;
if (adur.AgentID == ID && adur.SessionID == adur.CircuitSessionID)
{
AgentCircuit circuit;
if (Circuits.TryGetValue(adur.CircuitSceneID, out circuit))
{
SendAgentDataUpdate(circuit);
}
}
}
static bool ReadInput()
{
if (!File.Exists(FileNameMain))
{
Console.WriteLine("FATAL! The input file was not found.");
return false;
}
Console.WriteLine("Opening input file: {0}", FileNameMain);
myScanner = new MainScanner(new string[]{"program","scanner"});
Circuits.Add(myScanner);
//Circuits.Insert(2, myScanner);
if (!ReadVariables(FileNameMain, null))
return false;
if (!ReadComposAlias(FileNameMain))
return false;
if (!ReadCircuits(FileNameMain, null)) //read all the circuits
return false;
if (!ReadCantilever()) //read the cantilever (which is a circuit)
return false;
if (!ReadOutput()) //now read the output
return false;
if (!ReadMainScannerScript()) //read the scanner (which is a circuit)
return false;
//add all feeds to the global list
foreach(Circuit listedcirc in Circuits)
foreach(Channel outchan in listedcirc.Output)
Program.AllFeeds.Add(outchan.Signal);
//if (!ReadSecondary(FileNameMain, null)) //now read the output
// return false;
if (!ReadConnections(FileNameMain, null)) //and finally the connections
return false;
/*
//makes sure the scanned has the same holder position as the cantilever
for(int i=0;i<3;i++)
{
myScanner.Output[i].Value = HolderPosition[i];
myCantilever.Input[i].Value = HolderPosition[i];
}
*/
Console.WriteLine("Input file read correctly!\n");
return true;
}
public async Task <IActionResult> OnGetAsync(string id)
{
if (id == null)
{
return(NotFound());
}
Circuits = await _context.Circuits.FirstOrDefaultAsync(m => m.circuitId == id);
if (Circuits == null)
{
return(NotFound());
}
return(Page());
}
public async Task <IActionResult> OnPostAsync(string id)
{
if (id == null)
{
return(NotFound());
}
Circuits = await _context.Circuits.FindAsync(id);
if (Circuits != null)
{
_context.Circuits.Remove(Circuits);
await _context.SaveChangesAsync();
}
return(RedirectToPage("./Index"));
}
public void HandleLandStatRequest(Message m)
{
var req = (LandStatRequest)m;
if (req.CircuitAgentID != req.AgentID ||
req.CircuitSessionID != req.SessionID)
{
return;
}
AgentCircuit circuit;
if (!Circuits.TryGetValue(req.CircuitSceneID, out circuit))
{
return;
}
SceneInterface scene = circuit.Scene;
if (scene == null)
{
return;
}
UGUIWithName agentID = circuit.Agent.NamedOwner;
if (!scene.IsRegionOwner(agentID) && !scene.IsEstateOwner(agentID) && !scene.IsEstateManager(agentID))
{
return;
}
switch (req.ReportType)
{
case LandStatReportEnum.TopScripts:
ProcessTopScripts(circuit, scene, req.RequestFlags, req.Filter);
break;
case LandStatReportEnum.TopColliders:
ProcessTopColliders(circuit, scene, req.RequestFlags, req.Filter);
break;
default:
break;
}
}
uint ILocalIDAccessor.this[UUID sceneID]
{
get
{
AgentCircuit circuit;
return(Circuits.TryGetValue(sceneID, out circuit) ? circuit.UpdateInfo.LocalID : 0);
}
set
{
AgentCircuit circuit;
if (Circuits.TryGetValue(sceneID, out circuit))
{
circuit.UpdateInfo.LocalID = value;
}
else
{
m_Log.DebugFormat("Setting LocalID on agent {0} for region {1} has no circuit", ID, sceneID);
}
}
}
private void GetPointsForCurrentCircuit()
{
_inCode = true;
try
{
if (Circuits != null && Circuits.Any() && CurrentCircuitPosition == -1)
{
CurrentCircuitPosition = 0;
}
if (Circuits != null)
{
SelectedCircuit = Circuits[CurrentCircuitPosition];
}
RaisePropertyChanged(() => CurrentCircuitPosition);
}
catch (Exception e)
{
}
_inCode = false;
}
public void HandleRegionHandshakeReply(Message m)
{
var rhr = (Messages.Region.RegionHandshakeReply)m;
AgentCircuit circuit;
if (Circuits.TryGetValue(rhr.CircuitSceneID, out circuit))
{
var scene = circuit.Scene;
/* Add our agent to scene */
scene.SendAllParcelOverlaysTo(this);
scene.Terrain.UpdateTerrainDataToSingleClient(this);
scene.Environment.UpdateWindDataToSingleClient(this);
scene.SendAgentObjectToAllAgents(this);
scene.SendRegionInfo(this);
ParcelInfo pinfo;
if (scene.Parcels.TryGetValue(GlobalPosition, out pinfo))
{
var props = scene.ParcelInfo2ParcelProperties(Owner.ID, pinfo, NextParcelSequenceId, ParcelProperties.RequestResultType.Single);
circuit.SendMessage(props);
}
circuit.ScheduleFirstUpdate();
}
}
public void HandleAvatarTexturesRequest(Message p)
{
var gm = (GenericMessage)p;
if (gm.AgentID != ID || gm.SessionID != gm.CircuitSessionID || gm.ParamList.Count < 1)
{
return;
}
UUID avatarId;
if (!UUID.TryParse(gm.ParamList[0].FromUTF8Bytes(), out avatarId))
{
return;
}
IAgent agent;
AgentCircuit circuit;
SceneInterface scene;
if (!Circuits.TryGetValue(gm.CircuitSceneID, out circuit))
{
return;
}
scene = circuit.Scene;
if (scene == null)
{
return;
}
if (scene.RootAgents.TryGetValue(avatarId, out agent))
{
SendMessageAlways(agent.GetAvatarAppearanceMsg(), SceneID);
}
}
public bool TryGetCameraConstraints(Vector3 wantedCamPosition, out Vector4 collisionplane)
{
AgentCircuit circuit;
SceneInterface scene;
collisionplane = new Vector4(0.9f, 0.0f, 0.361f, -10000f);
if (!Circuits.TryGetValue(m_CurrentSceneID, out circuit))
{
return(false);
}
scene = circuit.Scene;
if (scene == null)
{
return(false);
}
IPhysicsScene physicsScene = scene.PhysicsScene;
if (physicsScene == null)
{
return(false);
}
RayResult[] results = physicsScene.RayTest(GlobalPosition, wantedCamPosition, RayTestHitFlags.All, 1);
if (results.Length == 0)
{
return(false);
}
Vector3 normal = results[0].HitNormalWorld;
collisionplane.X = normal.X;
collisionplane.Y = normal.Y;
collisionplane.Z = normal.Z;
collisionplane.W = results[0].HitPointWorld.Dot(normal);
return(true);
}
public void HandleCompleteAgentMovement(Message m)
{
var cam = (CompleteAgentMovement)m;
AgentCircuit circuit;
if (cam.SessionID != cam.CircuitSessionID ||
cam.AgentID != cam.CircuitAgentID)
{
m_Log.InfoFormat("Unexpected CompleteAgentMovement with invalid details");
}
else if (Circuits.TryGetValue(cam.CircuitSceneID, out circuit))
{
var scene = circuit.Scene;
if (scene == null)
{
return;
}
/* switch agent region */
if (m_IsActiveGod && !scene.IsPossibleGod(Owner))
{
/* revoke god powers when changing region and new region has a different owner */
var gm = new GrantGodlikePowers
{
AgentID = ID,
SessionID = circuit.SessionID,
GodLevel = 0,
Token = UUID.Zero
};
SendMessageIfRootAgent(gm, SceneID);
m_IsActiveGod = false;
}
SceneID = scene.ID;
scene.TriggerAgentChangedScene(this);
if (circuit.LastTeleportFlags.NeedsInitialPosition())
{
try
{
scene.DetermineInitialAgentLocation(this, circuit.LastTeleportFlags, GlobalPosition, LookAt);
}
catch
{
/* TODO: how to do this? */
return;
}
}
var amc = new AgentMovementComplete
{
AgentID = cam.AgentID,
ChannelVersion = VersionInfo.SimulatorVersion,
LookAt = circuit.Agent.LookAt,
Position = GlobalPosition,
SessionID = cam.SessionID,
GridPosition = circuit.Scene.GridPosition,
Timestamp = (uint)Date.GetUnixTime()
};
amc.OnSendCompletion += (bool success) =>
{
if (success)
{
HandleChildAgentChanges(circuit);
}
};
circuit.SendMessage(amc);
SendAgentDataUpdate(circuit);
scene.SendAgentObjectToAllAgents(this);
var clu = new CoarseLocationUpdate
{
You = 0,
Prey = -1
};
var ad = new CoarseLocationUpdate.AgentDataEntry
{
X = (byte)(uint)GlobalPosition.X,
Y = (byte)(uint)GlobalPosition.Y,
Z = (byte)(uint)GlobalPosition.Z,
AgentID = ID
};
clu.AgentData.Add(ad);
circuit.SendMessage(clu);
scene.Environment.UpdateWindlightProfileToClientNoReset(this);
scene.Environment.SendSimulatorTimeMessageToClient(this);
foreach (var action in circuit.m_TriggerOnRootAgentActions)
{
action.TriggerOnRootAgent(ID, scene);
}
}
}
public CircuitCalculator()
{
InitializeComponent();
#region CIRCUITS
Circuits.Add(electronicCircuit, new Circuit()
{
Components = new Dictionary <string, int>()
{
{ "Circuit Board", 1 },
{ "SMD Resistor", 2 },
{ "1x Red Alloy Wire", 2 },
{ "Vaccum Tube", 2 }
}
});
Circuits.Add(integratedCircuit, new Circuit()
{
Components = new Dictionary <string, int>()
{
{ "Circuit Board", 1 },
{ "SMD Resistor", 2 },
{ "SMD Diode", 2 },
{ "Fine Copper Wire", 2 },
{ "Tin Bolt", 2 },
{ "Integrated Logic Circuit (Wafer-made)", 1 }
}
});
Circuits.Add(goodElectronicCircuit, new Circuit()
{
Components = new Dictionary <string, int>()
{
{ integratedCircuit, 2 },
{ "Good Circuit Board", 1 },
{ "SMD Diode", 2 },
{ "1x Copper Wire", 2 }
}
});
Circuits.Add(goodIntegratedCircuit, new Circuit()
{
Components = new Dictionary <string, int>()
{
{ integratedCircuit, 2 },
{ "Good Circuit Board", 1 },
{ "SMD Resistor", 4 },
{ "SMD Diode", 4 },
{ "Fine Gold Wire", 4 },
{ "Silver Bolt", 4 }
}
});
Circuits.Add(advancedCircuit, new Circuit()
{
Components = new Dictionary <string, int>()
{
{ goodIntegratedCircuit, 1 },
{ "Integrated Logic Circuit (Wafer-made)", 2 },
{ "Random Access Memory Chip", 2 },
{ "SMD Transistor", 4 },
{ "Fine Electrum Wire", 8 },
{ "Annealed Copper Bolt", 8 }
}
});
Circuits.Add(integratedProcessor, new Circuit()
{
Components = new Dictionary <string, int>()
{
{ "Plastic Circuit Board", 1 },
{ "Central Processing Unit", 1 },
{ "SMD Resistor", 4 },
{ "SMD Capacitor", 4 },
{ "SMD Transistor", 4 },
{ "Fine Red Alloy Wire", 4 }
}
});
Circuits.Add(processorAssembly, new Circuit()
{
Components = new Dictionary <string, int>()
{
{ integratedProcessor, 2 },
{ "Plastic Circuit Board", 1 },
{ "Small Coil", 4 },
{ "SMD Capacitor", 8 },
{ "Random Access Memory Chip", 4 },
{ "Fine Red Alloy Wire", 4 }
}
});
Circuits.Add(workstation, new Circuit()
{
Components = new Dictionary <string, int>()
{
{ processorAssembly, 2 },
{ "Plastic Circuit Board", 1 },
{ "SMD Diode", 4 },
{ "Random Access Memory Chip", 4 },
{ "Fine Electrum Wire", 16 },
{ "Platinum Bolt", 16 }
}
});
Circuits.Add(mainframe, new Circuit()
{
Components = new Dictionary <string, int>()
{
{ workstation, 2 },
{ "Aluminium Frame Box", 2 },
{ "Small Coil", 12 },
{ "SMD Capacitor", 16 },
{ "Random Access Memory Chip", 16 },
{ "1x Annealed Copper Wire", 16 },
}
});
Circuits.Add(nanoprocessor, new Circuit()
{
Components = new Dictionary <string, int>()
{
{ "Advanced Circuit Board", 1 },
{ "ASoC", 1 },
{ "Fine Electrum Wire", 8 },
{ "Platinum Bolt", 8 }
}
});
Circuits.Add(nanoprocessorAssembly, new Circuit()
{
Components = new Dictionary <string, int>()
{
{ nanoprocessor, 2 },
{ "Advanced Circuit Board", 1 },
{ "Small Coil", 8 },
{ "SMD Capacitor", 8 },
{ "Random Access Memory Chip", 8 },
{ "Fine Electrum Wire", 16 },
}
});
Circuits.Add(eliteNanocomputer, new Circuit()
{
Components = new Dictionary <string, int>()
{
{ nanoprocessorAssembly, 2 },
{ "Advanced Circuit Board", 1 },
{ "SMD Diode", 8 },
{ "NOR Memory Chip", 4 },
{ "Random Access Memory Chip", 16 },
{ "Fine Electrum Wire", 16 },
}
});
Circuits.Add(quantumprocessor, new Circuit()
{
Components = new Dictionary <string, int>()
{
{ "More Advanced Circuit Board", 1 },
{ "ASoC", 1 },
{ "Fine Electrum Wire", 16 },
{ "Niobium-Titanum Bolt", 8 }
}
});
Circuits.Add(quantumprocessorAssembly, new Circuit()
{
Components = new Dictionary <string, int>()
{
{ quantumprocessor, 2 },
{ "Advanced Circuit Board", 1 },
{ "Small Coil", 12 },
{ "SMD Capacitor", 16 },
{ "Random Access Memory Chip", 4 },
{ "Fine Platinum Wire", 24 },
}
});
Circuits.Add(crystalprocessor, new Circuit()
{
Components = new Dictionary <string, int>()
{
{ "Elite Circuit Board", 1 },
{ "Crystal SoC", 1 },
{ "Fine Niobium-Titanum Wire", 8 },
{ "Yttrium Barium Cuprate Bolt", 8 },
}
});
Circuits.Add(nanoprocessorMainframe, new Circuit()
{
Components = new Dictionary <string, int>()
{
{ eliteNanocomputer, 2 },
{ "Aluminium Frame Box", 2 },
{ "Small Coil", 16 },
{ "SMD Capacitor", 32 },
{ "Random Access Memory Chip", 16 },
{ "1x Annealed Copper Wire", 32 }
}
});
Circuits.Add(masterQuantumcomputer, new Circuit()
{
Components = new Dictionary <string, int>()
{
{ quantumprocessorAssembly, 2 },
{ "More Advanced Circuit Board", 1 },
{ "NOR Memory Chip", 4 },
{ "SMD Diode", 8 },
{ "Random Access Memory Chip", 16 },
{ "Fine Platinum Wire", 48 }
}
});
Circuits.Add(wetwareprocessor, new Circuit()
{
Components = new Dictionary <string, int>()
{
{ quantumprocessorAssembly, 2 },
{ "Neuro Processing Unit", 1 },
{ "Crystal Processing Unit", 1 },
{ "Nanocomponent Central Processing Unit", 1 },
{ "SMD Capacitor", 32 },
{ "SMD Transistor", 32 },
{ "Fine Yttrium Barium Cuprate Wire", 8 }
}
});
Circuits.Add(crystalprocessorAssembly, new Circuit()
{
Components = new Dictionary <string, int>()
{
{ crystalprocessor, 2 },
{ "Elite Circuit Board", 1 },
{ "Crystal Processing Unit", 1 },
{ "Small Coil", 24 },
{ "SMD Capacitor", 32 },
{ "Random Access Memory Chip", 24 },
{ "Fine Yttrium Barium Cuprate Wire", 16 }
}
});
#endregion
int tabIndex = 0;
int yOffset = 0;
int xOffset = 10;
int offsetDelta = 25;
int elementWidth = 250;
foreach (var pair in Circuits)
{
if (yOffset > 450)
{
yOffset = 0;
xOffset += elementWidth + 25;
}
var label = new Label()
{
Font = new System.Drawing.Font("Microsoft Sans Serif", 12F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(204))),
Location = new System.Drawing.Point(xOffset, yOffset),
Size = new System.Drawing.Size(elementWidth, offsetDelta),
Text = pair.Key,
TabIndex = tabIndex++,
};
Controls.Add(label);
yOffset += offsetDelta;
var numeric = new NumericUpDown()
{
Font = new System.Drawing.Font("Microsoft Sans Serif", 12F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(204))),
Location = new System.Drawing.Point(xOffset, yOffset),
Size = new System.Drawing.Size(elementWidth, offsetDelta),
Name = pair.Key,
TabIndex = tabIndex++,
Maximum = 65536
};
Numerics.Add(numeric);
numeric.ValueChanged += new System.EventHandler(CalculateAllCircuits);
Controls.Add(numeric);
yOffset += offsetDelta;
}
}
public void Tick()
{
Circuits?.Tick();
}
public void KeyDown(KeyEventArgs e)
{
Circuits?.KeyDown(e);
}
static bool ReadOutput()
{
string[] words;
StreamReader reader = new StreamReader(FileNameMain); //reopen the file
if (!StringReader.FindString("<output>", reader))
{
Console.WriteLine("FATAL! Output list is missing.");
return false;
}
Console.WriteLine("\n Reading output configuration:");
string line; string[] fields;
char[] delimiterChars = { ' ', '\t' };
Out = new Outputter();
while ((line = reader.ReadLine()) != null) //read each line
{
words = StringReader.TrimWords(line.Split(delimiterChars));
line = line.Trim();
if (line.StartsWith("<end>"))
break;
if (line.StartsWith("#") || line.Length == 0 || words.Length == 0)
continue;
//read the type and the name
if (words[0].StartsWith("#"))
continue;
if (words.Length < 3)
{
Console.WriteLine("FATAL! The output format is: filename frequency obj1.cha obj2.chb ...");
return false;
}
Out.filenames.Add(words[0]); //add a filename to the list
Out.dumpFreq.Add(Convert.ToInt32(words[1])); //add its dump frequency
Out.outchannels.Add(new List<string[]>());
Console.WriteLine("Generatin output file {0}.", words[0]);
char[] subdels = { '.' };
for (int i = 0; i < words.Length - 2; i++)
{
fields = StringReader.TrimWords(words[i + 2].Split(subdels));
if (fields.Length != 2)
{
Console.WriteLine("FATAL! The output format is: filename circ1.chA circ2.chB ...");
return false;
}
Circuit c1; Channel v1;
if (!Circuit.CheckCircuitChannel(fields, ChannelType.Any, out c1, out v1)) //find the first circuit
return false;
Out.outchannels[Out.outchannels.Count - 1].Add(fields);
Console.WriteLine(" adding channel {0}.{1}", c1.Name, v1.Name);
}
}
Out.InputInit(); //initialize the output
Circuits.Add(Out);
Console.WriteLine("---Output Read.");
reader.Dispose();
return true;
}
public override AgentUpdateInfo GetUpdateInfo(UUID sceneID)
{
AgentCircuit circuit;
return(Circuits.TryGetValue(sceneID, out circuit) ? circuit.UpdateInfo : null);
}
/// <summary>
/// Prevents the installer from being installed at a destination.
/// </summary>
public InstallBuilder ShortCircuitFor(string shortCircuiter)
{
Circuits.Add(shortCircuiter);
return(this);
}
private async Task GetCircuitsForCurrentBoard()
{
try
{
_inCode = true;
if (Boards != null && Boards.Any() && CurrentBoardPosition == -1)
{
CurrentBoardPosition = 0;
}
if (Boards != null)
{
SelectedBoard = Boards[CurrentBoardPosition];
}
var result = await _boardsService.GetTestedCircuits(CertificateId, SelectedBoard.BoardId);
if (!result.Success)
{
Dialogs.Toast(result.Message);
return;
}
var circuitTest = result.ResultObject as List <CircuitTest>;
if (circuitTest == null)
{
return;
}
CurrentCircuitPosition = 0;
Circuits.Clear();
var circuits = new List <CircuitTest>();
if (SelectedBoard.BoardPhase == "3" || SelectedBoard.BoardPhase == "TP&N")
{
var numberToSkip = 0;
var numbers = circuitTest.Select(x => x.CircuitReference).Distinct();
var threePhaseCircutes = new List <int>();
foreach (var number in numbers)
{
if (circuitTest.Any(x => x.CircuitReference == number && x.CircuitIs3Phase == "Y"))
{
threePhaseCircutes.Add(number);
}
}
if (!threePhaseCircutes.Any())
{
circuits.AddRange(circuitTest);
}
else
{
foreach (var circuit in circuitTest)
{
if (circuit.CircuitReference == numberToSkip)
{
continue;
}
if (threePhaseCircutes.Contains(circuit.CircuitReference))
{
if (circuit.CircuitIs3Phase == "Y")
{
circuit.NotBelongsToThreePhase = false;
circuit.ThreePhase = circuit.CircuitReference + SelectedBoard.BoardCircuitPhaseNaming;
circuits.Add(circuit);
numberToSkip = circuit.CircuitReference;
}
continue;
}
circuit.NotBelongsToThreePhase = true;
circuits.Add(circuit);
}
}
}
else
{
circuits.AddRange(circuitTest);
}
Circuits = new ObservableCollectionFast <CircuitTest>(circuits.OrderBy(x => x.ThreePhaseRepresentation));
//Circuits.AddRange(new List<CircuitTest>(circuitTest.OrderBy(x => x.CircuitIdentity)));
GetPointsForCurrentCircuit();
_inCode = false;
}
catch (ServiceAuthenticationException e)
{
var result = await TryToLogin();
if (!result)
{
await NavigationService.NavigateToAsync <LoginViewModel>();
}
else
{
await GetCircuitsForCurrentBoard();
}
}
catch (Exception e)
{
//await ShowErrorAlert(e.Message);
}
}
public void HandleEstateOwnerMessage(Message m)
{
var req = (EstateOwnerMessage)m;
if (req.SessionID != SessionID ||
req.AgentID != ID)
{
return;
}
AgentCircuit circuit;
if (!Circuits.TryGetValue(req.CircuitSceneID, out circuit))
{
return;
}
if (!circuit.Scene.IsEstateManager(Owner) && circuit.Scene.Owner != Owner)
{
/* only RO, EO and EM allowed behind */
/* some messages later will be limited further */
return;
}
switch (req.Method)
{
case "getinfo":
EstateOwner_GetInfo(circuit, req);
break;
case "setregioninfo":
EstateOwner_SetRegionInfo(circuit, req);
break;
#if TEXTUREBASE
case "texturebase":
break;
#endif
case "texturedetail":
EstateOwner_TextureDetail(circuit, req);
break;
case "textureheights":
EstateOwner_TextureHeights(circuit, req);
break;
case "texturecommit":
EstateOwner_TextureCommit(circuit, req);
break;
case "setregionterrain":
EstateOwner_SetRegionTerrain(circuit, req);
break;
case "restart":
EstateOwner_Restart(circuit, req);
break;
case "estatechangecovenantid":
if (!circuit.Scene.IsEstateManager(Owner))
{
/* only EO and EM */
return;
}
EstateOwner_EstateChangeCovenantId(circuit, req);
break;
case "estateaccessdelta":
if (!circuit.Scene.IsEstateManager(Owner))
{
/* only EO and EM */
return;
}
EstateOwner_EstateAccessDelta(circuit, req);
break;
case "estateexperiencedelta":
if (!circuit.Scene.IsEstateManager(Owner))
{
/* only EO and EM */
return;
}
EstateOwner_EstateExperienceDelta(circuit, req);
break;
case "simulatormessage":
EstateOwner_SimulatorMessage(circuit, req);
break;
case "instantmessage":
EstateOwner_InstantMessage(circuit, req);
break;
case "setregiondebug":
EstateOwner_SetRegionDebug(circuit, req);
break;
case "teleporthomeuser":
EstateOwner_TeleportHomeUser(circuit, req);
break;
case "teleporthomeallusers":
EstateOwner_TeleportHomeAllUsers(circuit, req);
break;
case "colliders":
EstateOwner_Colliders(circuit, req);
break;
case "scripts":
EstateOwner_Scripts(circuit, req);
break;
case "terrain":
EstateOwner_Terrain(circuit, req);
break;
case "estatechangeinfo":
if (!circuit.Scene.IsEstateManager(Owner))
{
/* only EO and EM */
return;
}
EstateOwner_EstateChangeInfo(circuit, req);
break;
case "telehub":
EstateOwner_Telehub(circuit, req);
break;
case "kickestate":
EstateOwner_KickEstate(circuit, req);
break;
default:
m_Log.DebugFormat("EstateOwnerMessage: Unknown method {0} requested", req.Method);
break;
}
}
