public RequestWaterHub(WaterDbContext dbContext, ILogger <RequestWaterHub> logger, UserManager <ApplicationUser> userManager)
{
_dbContext = dbContext;
_logger = logger;
_userManager = userManager;
requestorConnections = RequestorConnectionSingleton.Instance;
}
// Use this for initialization
void Start()
{
choosenCorridorId = 0;
isCorridorChoosen = false;
idOfPopup = 0;
popupWidth = (float)(Screen.width * 0.8);
popupHeight = (float)(Screen.height * 0.6);
popupOptionWidth = (float)(popupWidth * 0.45);
popupOptionHeight = (float)(popupHeight * 0.4);
popupBorderSpaceWidth = (float)(popupWidth * 0.03);
popupBorderSpaceHeight = (float)(popupHeight * 0.03);
popupSpaceBetweenWidth = (float)(popupWidth * 0.04);
popupSpaceBetweenHeight = (float)(popupHeight * 0.04);
popupHeightSpaceForTitle = (float)(popupHeight * 0.1);
//Width has 10% of spaces between - 2x3% for border and 4% between
//Height has 10% of spaces between and 10% for title - 2x3% for border and 4% between
connectionMap = GameObject.Find("Dungeon").GetComponent <ConnectionMap>();
//Now we are going to gain some information about near corridors
listOfAllLevels = GameObject.Find("Dungeon").GetComponent <DungeonManager>().getLevelsArray();
randomNumber = new System.Random(DateTime.Now.Millisecond);
int howManyCorridorsToChoose = randomNumber.Next(1, 5);
corridorsIdArray = new List <int>();
//Random numbers for dev purposes
for (int i = 0; i < howManyCorridorsToChoose; i++)
{
corridorsIdArray.Add(randomNumber.Next(0, 10));
}
}
static void ReadConnections()
{
Dictionary <string, ClientConnectionModel> connectionMap = new Dictionary <string, ClientConnectionModel>();
while (true)
{
Thread.Sleep(5000);
var newConnectionMap = ConnectionMap.GetConnectionMap();
if (connectionMap.Count == newConnectionMap.Count)
{
continue;
}
Console.WriteLine("Connection Created: " + ConnectionMap.Count);
foreach (KeyValuePair <string, ClientConnectionModel> e in newConnectionMap)
{
Console.WriteLine(string.Format("{0} => {1} => [{2}]", e.Key, e.Value.IsRequesting, string.Join(", ", e.Value.ConnectionIds)));
}
connectionMap = newConnectionMap;
}
}
public void ConnectionTest()
{
var map = new ConnectionMap();
var component0 = new Component(0);
var component1 = new Component(1);
var component2 = new Component(2);
var component3 = new Component(3);
var component4 = new Component(4);
var component5 = new Component(5);
var component6 = new Component(6);
var component7 = new Component(7);
var component8 = new Component(8);
var component9 = new Component(9);
map.Union(component0, component1);
map.Union(component2, component3);
map.Union(component4, component5);
map.Union(component6, component2);
map.Union(component7, component8);
map.Union(component8, component0);
Assert.IsTrue(map.Connected(component7, component0));
Assert.IsFalse(map.Connected(component0, component2));
map.Union(component0, component2);
Assert.IsTrue(map.Connected(component6, component7));
Assert.IsFalse(map.Connected(component9, component0));
Assert.IsFalse(map.Connected(component9, component3));
}
public async Task <IActionResult> SendMessageAsync([FromBody] MessageViewModel message)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var msg = Mapper.Map <Message>(message);
msg.Date = DateTime.Now;
var sentMsg = await ChatContext.MessageManager.SendMessageAsync(msg);
if (sentMsg == null)
{
ModelState.AddModelError("Invalid Message", "ChatId is not valid !");
return(BadRequest(ModelState));
}
var sentMsgDto = Mapper.Map <MessageViewModel>(sentMsg);
if (ConnectionMap.GetConnections(ChatContext.CurrentUser.Id).Count() > 1)
{
_ = HubContext.Clients.Group(sentMsgDto.ChatId).SendAsync(SignalRClientMethod.ReceiveMessage, sentMsgDto);
return(Ok());
}
else
{
_ = HubContext.Clients.GroupExcept(sentMsgDto.ChatId, ConnectionMap.GetConnections(ChatContext.CurrentUser.Id).First()).SendAsync(SignalRClientMethod.ReceiveMessage, sentMsgDto);
return(Ok(sentMsgDto));
}
}
public void ClientCommand(string message)
{
var json = Newtonsoft.Json.JsonConvert.DeserializeObject <RequestMessage>(message);
var connection = ConnectionMap.GetConnectionMap(json.clientId);
if (connection.Value.IsRequesting)
{
return;
}
var paramMessage = Newtonsoft.Json.JsonConvert.DeserializeObject <RequestParameter>(json.message);
if (paramMessage.TipeRepository.Contains("DATABASE"))
{
connection.Value.IsRequesting = true;
}
System.Collections.Generic.List <string> connValue = connection.Value.ConnectionIds.ToList();
var context = GlobalHost.ConnectionManager.GetHubContext <MonitorHub>();
for (int iClient = 0; iClient < connValue.Count; iClient++)
{
string connID = connValue[iClient];
context.Clients.Client(connID).addMessage(json.message);
}
}
static ConnectionMap GetInputMap(ConnectionMap result, int noOfInitialNodes)
{
ConnectionMap input = ConnectionMap.CreateEmpty(Connection.Removed, noOfInitialNodes);
input.AddReverse(result);
return(input);
}
public async Task <IActionResult> Accept([FromRoute] string requestId)
{
var contact = await ChatContext.ContactManager.AcceptAddFriendRequestAsync(requestId);
if (contact != null)
{
var contactDto = Mapper.Map <ContactViewModel>(contact);
var currUserDto = Mapper.Map <ContactViewModel>(ChatContext.CurrentUser);
var contactConnections = new List <string>(ConnectionMap.GetConnections(contact.Id));
_ = HubContext.Clients.Clients(contactConnections).SendAsync(SignalRClientMethod.ReceiveFriendRequestResponse, requestId, currUserDto);
var currConnections = new List <string>(ConnectionMap.GetConnections(ChatContext.CurrentUser.Id));
_ = HubContext.Clients.Clients(currConnections).SendAsync(SignalRClientMethod.ReceiveFriendRequestResponse, requestId, contactDto);
var chat = await ChatContext.ChatManager.GetChatWithAsync(contact.Id);
foreach (var connection in contactConnections.Concat(currConnections))
{
_ = HubContext.Groups.AddToGroupAsync(connection, chat.Id);
}
return(Ok(new { requestId, contact = contactDto }));
}
return(BadRequest());
}
public static List <IElectricityIO> FindPossibleConnections(Vector2 searchVec, Matrix matrix, HashSet <PowerTypeCategory> CanConnectTo, ConnPoint ConnPoints)
{
List <IElectricityIO> possibleConns = new List <IElectricityIO>();
List <IElectricityIO> connections = new List <IElectricityIO>();
int progress = 0;
searchVec.x -= 1;
searchVec.y -= 1;
for (int x = 0; x < 3; x++)
{
for (int y = 0; y < 3; y++)
{
Vector3Int pos = new Vector3Int((int)searchVec.x + x,
(int)searchVec.y + y, 0);
var conns = matrix.GetElectricalConnections(pos);
foreach (IElectricityIO io in conns)
{
possibleConns.Add(io);
if (CanConnectTo.Contains
(io.InData.Categorytype))
{
//Check if InputPosition and OutputPosition connect with this wire
if (ConnectionMap.IsConnectedToTile(ConnPoints, (AdjDir)progress, io.GetConnPoints()))
{
connections.Add(io);
}
}
}
progress++;
}
}
return(connections);
}
void FindPossibleConnections()
{
possibleConns.Clear();
connections.Clear();
int progress = 0;
Vector2 searchVec = transform.localPosition;
searchVec.x -= 1;
searchVec.y -= 1;
for (int x = 0; x < 3; x++)
{
for (int y = 0; y < 3; y++)
{
Vector3Int pos = new Vector3Int((int)searchVec.x + x,
(int)searchVec.y + y, 0);
var conns = matrix.GetElectricalConnections(pos);
foreach (IElectricityIO io in conns)
{
possibleConns.Add(io);
//Check if InputPosition and OutputPosition connect with this wire
if (ConnectionMap.IsConnectedToTile(GetConnPoints(), (AdjDir)progress, io.GetConnPoints()))
{
connections.Add(io);
}
}
progress++;
}
}
}
public RegisteredUsersController(ILogger <RegisteredUsersController> logger,
IHubContext <RequestWaterHub> requestorsHubContext, WaterDbContext dbContext)
{
_logger = logger;
_requestorsHubContext = requestorsHubContext;
_requestorConnections = RequestorConnectionSingleton.Instance;
_dbContext = dbContext;
}
public DonateWaterHub(ILogger <DonateWaterHub> logger, IHubContext <RequestWaterHub> requestHubContext, UserManager <ApplicationUser> userManager)
{
_logger = logger;
_requestHubContext = requestHubContext;
_userManager = userManager;
_donatorConnections = DonatorConnectionSingleton.Instance;
_requestorConnections = RequestorConnectionSingleton.Instance;
}
private void HandleOnEndpointConnected(object sender, EndpointEventArgs e)
{
var map = new ConnectionMap(e.Endpoint)
{
NextConnectionTime = m_Now() + m_MaximumTimeBetweenConnectionConfirmations,
NumberOfConnectionFailures = 0,
};
m_RegisteredConnections.TryAdd(e.Endpoint, map);
}
public async Task <IActionResult> Remove([FromRoute] string requestId)
{
var request = await ChatContext.ContactManager.RemoveFriendRequestByIdAsync(requestId);
if (request != null)
{
var userId = request.ToUserId == ChatContext.CurrentUser.Id ? request.FromUserId : request.ToUserId;
var connections = new List <string>(ConnectionMap.GetConnections(userId));
_ = HubContext.Clients.Clients(connections).SendAsync(SignalRClientMethod.ReceiveFriendRequestResponse, requestId, null);
return(Ok(true));
}
return(BadRequest());
}
public void SendMessage(string username, string message)
{
var connection = ConnectionMap.GetConnectionMap(username);
List <string> connValue = connection.Value.ConnectionIds.ToList();
var context = GlobalHost.ConnectionManager.GetHubContext <MonitorHub>();
for (int iClient = 0; iClient < connValue.Count; iClient++)
{
string connID = connValue[iClient];
context.Clients.User(connID).addMessage(message);
}
}
static ConnectionMap ExtractMap(IList <TrackableNode> processed)
{
Connection[] connections = new Connection[processed.Count];
int[] map = new int[processed.Count];
for (int i = 0; i < processed.Count; ++i)
{
connections[i] = processed[i].Type.Type;
map[i] = processed[i].Type.J;
}
ConnectionMap backwardsMap = new ConnectionMap(connections, map);
return(backwardsMap);
}
public async Task <IActionResult> Send([FromRoute] string toUserId)
{
var request = await ChatContext.ContactManager.SendAddFriendRequestAsync(toUserId);
if (request != null)
{
var requestDto = Mapper.Map <FriendRequestViewModel>(request);
var connections = new List <string>(ConnectionMap.GetConnections(request.ToUserId));
_ = HubContext.Clients.Clients(connections).SendAsync(SignalRClientMethod.ReceiveFriendRequest, requestDto);
return(Ok(requestDto));
}
return(BadRequest());
}
public MappedVoronoiGrid CreateGrid(VoronoiNodes nodes, int firstCornerNodeIndice)
{
List <TrackableNode> mesherNodes = WrapInMesherNodes(nodes.Nodes);
VoronoiGrid grid = CreateGrid(mesherNodes, firstCornerNodeIndice);
ConnectionMap resultMap = ExtractMap(base.mesh.Nodes);
ConnectionMap inputMap = GetInputMap(resultMap, nodes.Count);
MappedVoronoiGrid movingGrid = new MappedVoronoiGrid
{
Result = grid,
InputNodesToResultNodes = inputMap,
ResultNodesToInputNodes = resultMap
};
return(movingGrid);
}
public override Task OnDisconnected(bool stopCalled)
{
string key = Context.QueryString["Key"];
string connectionId = Context.ConnectionId;
if (string.IsNullOrEmpty(key))
{
return(base.OnDisconnected(stopCalled));
}
ConnectionMap.Remove(key, connectionId);
BroadcastConnectionMap();
return(base.OnDisconnected(stopCalled));
}
public override Task OnConnected()
{
string key = Context.QueryString["Key"];
string connectionId = Context.ConnectionId;
if (string.IsNullOrEmpty(key))
{
return(base.OnConnected());
}
ConnectionMap.Add(key, connectionId);
BroadcastConnectionMap();
return(base.OnConnected());
}
void FindPossibleConnections()
{
var conns = matrix.GetElectricalConnections(Vector3Int.RoundToInt(transform.localPosition));
foreach (IElectricityIO io in conns)
{
//Check if InputPosition and OutputPosition connect with this wire
if (ConnectionMap.IsConnectedToTile(GetConnPoints(), AdjDir.Overlap, io.GetConnPoints()) &&
io.GameObject() != gameObject)
{
connectedWire = io;
connected = true;
break;
}
}
}
public int randomizeChoiseOfCorridor()
{
int howManyAreThere;
int randomizedOne;
ConnectionMap conMap = dungeonCanvas.GetComponent <ConnectionMap>();
System.Random randomNumber = new System.Random();
howManyAreThere = conMap.getCorridorDependenciesList()[currentCorridorId].getNeighbourCorridor().Count;
randomizedOne = randomNumber.Next(0, howManyAreThere);
string devLog = "Out of following neighbours: ";
for (int i = 0; i < howManyAreThere; i++)
{
devLog += " " + conMap.getCorridorDependenciesList()[currentCorridorId].getSpecificNeighbourCorridor(i).ToString();
}
Debug.Log(devLog + " of corridor: " + currentCorridorId);
return(conMap.getCorridorDependenciesList()[currentCorridorId].getSpecificNeighbourCorridor(randomizedOne));
}
// Use this for initialization
void Start()
{
//Array of levels
levelsArray = new List <DungeonLevel>();
tempChunkObject = new DungeonLevelChunk();
tempChunkObject.setWasCreated(false);
conMap = GameObject.Find("Dungeon").GetComponent <ConnectionMap>();
numberOfDungeonLevels = conMap.getNumberOfCorridors();
levelChunks = new List <DungeonLevelChunk>();
for (int i = 0; i < numberOfDungeonLevels; i++)
{
tempChunkObject.setIdOfChunk(i);
levelChunks.Add(tempChunkObject);
}
}
public static HashSet <IntrinsicElectronicData> SwitchCaseConnections(Vector2 searchVec,
Matrix matrix,
HashSet <PowerTypeCategory> CanConnectTo,
Connection connectionPoint,
IntrinsicElectronicData OIinheritance,
HashSet <IntrinsicElectronicData> connections,
// used in SurroundingTiles connection
Connection otherConnectionPoint = Connection.NA)
{
var searchVecInt = new Vector3Int((int)searchVec.x, (int)searchVec.y, 0);
{ // LogError Duplicate wires
var eConnsAtSearchVec = matrix.GetElectricalConnections(searchVecInt);
foreach (var con in eConnsAtSearchVec)
{
if (OIinheritance != con)
{
if ((OIinheritance.WireEndA == con.WireEndA && OIinheritance.WireEndB == con.WireEndB) ||
(OIinheritance.WireEndA == con.WireEndB && OIinheritance.WireEndB == con.WireEndA))
{
Logger.LogErrorFormat("{0} < duplicate Please remove {1}",
Category.Electrical,
searchVecInt,
OIinheritance);
}
}
}
eConnsAtSearchVec.Clear();
ElectricalPool.PooledFPCList.Add(eConnsAtSearchVec);
}
if (connectionPoint == Connection.SurroundingTiles)
{
foreach (var dir in NeighbourDirections)
{
// check all nearby connections except connection that is specified in other wire end
if (dir.Key == otherConnectionPoint)
{
continue;
}
var pos = searchVecInt + dir.Value;
var conns = matrix.GetElectricalConnections(pos);
// get connections pointing towards our tile [ex. if neighbour is at north, get all south connections(SW, S, SE)]
HashSet <Connection> possibleConnections = ConnectionMap.GetConnectionsTargeting(dir.Key);
if (possibleConnections != null)
{
foreach (var con in conns)
{
if (OIinheritance != con &&
CanConnectTo.Contains(con.Categorytype)
// check if possibleConnections contains our WireEnd A or B
&& (possibleConnections.Contains(con.WireEndA) || possibleConnections.Contains(con.WireEndB))
// check if contains to avoid errors
&& !connections.Contains(con))
{
connections.Add(con);
}
}
}
conns.Clear();
ElectricalPool.PooledFPCList.Add(conns);
}
return(connections);
}
// Connect to machine connnectors
if (connectionPoint == Connection.MachineConnect)
{
foreach (var dir in MachineConnectorDirections)
{
var pos = searchVecInt + dir;
var conns = matrix.GetElectricalConnections(pos);
foreach (var con in conns)
{
if (OIinheritance != con && CanConnectTo.Contains(con.Categorytype) &&
ConnectionMap.IsConnectedToTile(Connection.MachineConnect, con.GetConnPoints()) && !connections.Contains(con))
{
connections.Add(con);
}
}
conns.Clear();
ElectricalPool.PooledFPCList.Add(conns);
}
return(connections);
}
// Make a vector representing the connection direction
Vector3Int connVectorInt = ConnectionMap.GetDirectionFromConnection(connectionPoint);
Vector3Int position = searchVecInt + connVectorInt;
// Connect wires
{
var eConnsAtPosition = matrix.GetElectricalConnections(position);
bool connectionsAdded = false;
foreach (var con in eConnsAtPosition)
{
if (CanConnectTo.Contains(con.Categorytype) &&
ConnectionMap.IsConnectedToTile(connectionPoint, con.GetConnPoints()))
{
connections.Add(con);
connectionsAdded = true;
}
}
eConnsAtPosition.Clear();
ElectricalPool.PooledFPCList.Add(eConnsAtPosition);
if (connectionsAdded)
{
return(connections);
}
}
// Connect to overlap
{
var eConnsAtSearchVec = matrix.GetElectricalConnections(searchVecInt);
foreach (var con in eConnsAtSearchVec)
{
if (OIinheritance != con && CanConnectTo.Contains(con.Categorytype) &&
ConnectionMap.IsConnectedToTileOverlap(connectionPoint, con.GetConnPoints()))
{
connections.Add(con);
}
}
eConnsAtSearchVec.Clear();
ElectricalPool.PooledFPCList.Add(eConnsAtSearchVec);
}
return(connections);
}
public static HashSet <ElectricalOIinheritance> SwitchCaseConnections(Vector2 searchVec, Matrix matrix, HashSet <PowerTypeCategory> CanConnectTo, Connection ConnPoints, ElectricalOIinheritance OIinheritance)
{
HashSet <ElectricalOIinheritance> connections = new HashSet <ElectricalOIinheritance>();
Connection Direction = Connection.Overlap;
Vector3Int Position = new Vector3Int();
bool MachineConnect = false;
switch (ConnPoints)
{
case Connection.North:
{
Direction = Connection.North;
Position = new Vector3Int((int)searchVec.x + 0, (int)searchVec.y + 1, 0);
}
break;
case Connection.NorthEast:
{
Direction = Connection.NorthEast;
Position = new Vector3Int((int)searchVec.x + 1, (int)searchVec.y + 1, 0);
}
break;
case Connection.East:
{
Direction = Connection.East;
Position = new Vector3Int((int)searchVec.x + 1, (int)searchVec.y + 0, 0);
}
break;
case Connection.SouthEast:
{
Direction = Connection.SouthEast;
Position = new Vector3Int((int)searchVec.x + 1, (int)searchVec.y - 1, 0);
}
break;
case Connection.South:
{
Direction = Connection.South;
Position = new Vector3Int((int)searchVec.x + 0, (int)searchVec.y - 1, 0);
}
break;
case Connection.SouthWest:
{
Direction = Connection.SouthWest;
Position = new Vector3Int((int)searchVec.x + -1, (int)searchVec.y - 1, 0);
}
break;
case Connection.West:
{
Direction = Connection.West;
Position = new Vector3Int((int)searchVec.x + -1, (int)searchVec.y + 0, 0);
}
break;
case Connection.NorthWest:
{
Direction = Connection.NorthWest;
Position = new Vector3Int((int)searchVec.x + -1, (int)searchVec.y + 1, 0);
}
break;
case Connection.Overlap:
{
Direction = Connection.Overlap;
Position = new Vector3Int((int)searchVec.x + 0, (int)searchVec.y + 0, 0);
}
break;
case Connection.MachineConnect:
{
Direction = Connection.MachineConnect;
MachineConnect = true;
}
break;
}
Vector3Int PositionE = new Vector3Int((int)searchVec.x, (int)searchVec.y, 0);
var Econns = matrix.GetElectricalConnections(PositionE);
foreach (var con in Econns)
{
if (OIinheritance != con)
{
if ((OIinheritance.WireEndA == con.WireEndA && OIinheritance.WireEndB == con.WireEndB) ||
(OIinheritance.WireEndA == con.WireEndB && OIinheritance.WireEndB == con.WireEndA))
{
Logger.LogErrorFormat("{0} < duplicate Please remove {1}", Category.Electrical, PositionE, OIinheritance.InData.Categorytype);
}
}
}
if (!MachineConnect)
{
var conns = matrix.GetElectricalConnections(Position);
foreach (var con in conns)
{
if (CanConnectTo.Contains(con.InData.Categorytype))
{
if (ConnectionMap.IsConnectedToTile(Direction, con.GetConnPoints()))
{
connections.Add(con);
}
}
}
if (connections.Count == 0)
{
Position = new Vector3Int((int)searchVec.x, (int)searchVec.y, 0);
conns = matrix.GetElectricalConnections(Position);
foreach (var con in conns)
{
if (OIinheritance != con)
{
if (CanConnectTo.Contains(con.InData.Categorytype))
{
if (ConnectionMap.IsConnectedToTileOverlap(Direction, con.GetConnPoints()))
{
connections.Add(con);
}
}
}
}
}
}
else
{
for (int x = 0; x < 3; x++)
{
for (int y = 0; y < 3; y++)
{
Vector3Int pos = new Vector3Int((int)searchVec.x + (x - 1), (int)searchVec.y + (y - 1), 0);
var conns = matrix.GetElectricalConnections(pos);
foreach (var con in conns)
{
if (OIinheritance != con)
{
if (CanConnectTo.Contains(con.InData.Categorytype))
{
if (ConnectionMap.IsConnectedToTile(Direction, con.GetConnPoints()))
{
connections.Add(con);
}
}
}
}
}
}
}
return(connections);
}
public void BroadcastConnectionMap()
{
var context = GlobalHost.ConnectionManager.GetHubContext <ServerMonitorHub>();
context.Clients.All.addMessage(ConnectionMap.GetConnectionMap());
}
public ChatCoreHub(ConnectionMap connectionMap, ChatCoreContext chatContext)
{
ConnectionMap = connectionMap;
ChatContext = chatContext;
}
public static HashSet <IntrinsicElectronicData> SwitchCaseConnections(Vector2 searchVec,
Matrix matrix,
HashSet <PowerTypeCategory> CanConnectTo,
Connection ConnPoints,
IntrinsicElectronicData OIinheritance,
HashSet <IntrinsicElectronicData> connections)
{
var searchVecInt = new Vector3Int((int)searchVec.x, (int)searchVec.y, 0);
{ // LogError Duplicate wires
var eConnsAtSearchVec = matrix.GetElectricalConnections(searchVecInt);
foreach (var con in eConnsAtSearchVec)
{
if (OIinheritance != con)
{
if ((OIinheritance.WireEndA == con.WireEndA && OIinheritance.WireEndB == con.WireEndB) ||
(OIinheritance.WireEndA == con.WireEndB && OIinheritance.WireEndB == con.WireEndA))
{
Logger.LogErrorFormat("{0} < duplicate Please remove {1}",
Category.Electrical,
searchVecInt,
OIinheritance);
}
}
}
eConnsAtSearchVec.Clear();
ElectricalPool.PooledFPCList.Add(eConnsAtSearchVec);
}
// Connect to machine connnectors
if (ConnPoints == Connection.MachineConnect)
{
foreach (var dir in MachineConnectorDirections)
{
var pos = searchVecInt + dir;
var conns = matrix.GetElectricalConnections(pos);
foreach (var con in conns)
{
if (OIinheritance != con && CanConnectTo.Contains(con.Categorytype) &&
ConnectionMap.IsConnectedToTile(Connection.MachineConnect, con.GetConnPoints()))
{
connections.Add(con);
}
}
conns.Clear();
ElectricalPool.PooledFPCList.Add(conns);
}
return(connections);
}
// Make a vector representing the connection direction
Vector3Int connVectorInt;
switch (ConnPoints)
{
case Connection.North:
{
connVectorInt = new Vector3Int(0, 1, 0);
break;
}
case Connection.NorthEast:
{
connVectorInt = new Vector3Int(1, 1, 0);
break;
}
case Connection.East:
{
connVectorInt = new Vector3Int(1, 0, 0);
break;
}
case Connection.SouthEast:
{
connVectorInt = new Vector3Int(1, -1, 0);
break;
}
case Connection.South:
{
connVectorInt = new Vector3Int(0, -1, 0);
break;
}
case Connection.SouthWest:
{
connVectorInt = new Vector3Int(-1, -1, 0);
break;
}
case Connection.West:
{
connVectorInt = new Vector3Int(-1, 0, 0);
break;
}
case Connection.NorthWest:
{
connVectorInt = new Vector3Int(-1, 1, 0);
break;
}
case Connection.Overlap:
{
connVectorInt = new Vector3Int(0, 0, 0);
break;
}
default:
{
// No defined behaviour for any other types
return(connections);
}
}
Vector3Int position = searchVecInt + connVectorInt;
// Connect wires
{
var eConnsAtPosition = matrix.GetElectricalConnections(position);
bool connectionsAdded = false;
foreach (var con in eConnsAtPosition)
{
if (CanConnectTo.Contains(con.Categorytype) &&
ConnectionMap.IsConnectedToTile(ConnPoints, con.GetConnPoints()))
{
connections.Add(con);
connectionsAdded = true;
}
}
eConnsAtPosition.Clear();
ElectricalPool.PooledFPCList.Add(eConnsAtPosition);
if (connectionsAdded)
{
return(connections);
}
}
// Connect to overlap
{
var eConnsAtSearchVec = matrix.GetElectricalConnections(searchVecInt);
foreach (var con in eConnsAtSearchVec)
{
if (OIinheritance != con && CanConnectTo.Contains(con.Categorytype) &&
ConnectionMap.IsConnectedToTileOverlap(ConnPoints, con.GetConnPoints()))
{
connections.Add(con);
}
}
eConnsAtSearchVec.Clear();
ElectricalPool.PooledFPCList.Add(eConnsAtSearchVec);
}
return(connections);
}
public static HashSet <IntrinsicElectronicData> SwitchCaseConnections(Vector2 searchVec,
Matrix matrix,
HashSet <PowerTypeCategory> CanConnectTo,
Connection ConnPoints,
IntrinsicElectronicData OIinheritance,
HashSet <IntrinsicElectronicData> connections)
{
var Direction = Connection.Overlap;
var Position = new Vector3Int();
var MachineConnect = false;
switch (ConnPoints)
{
case Connection.North:
{
Direction = Connection.North;
Position = new Vector3Int((int)searchVec.x + 0, (int)searchVec.y + 1, 0);
}
break;
case Connection.NorthEast:
{
Direction = Connection.NorthEast;
Position = new Vector3Int((int)searchVec.x + 1, (int)searchVec.y + 1, 0);
}
break;
case Connection.East:
{
Direction = Connection.East;
Position = new Vector3Int((int)searchVec.x + 1, (int)searchVec.y + 0, 0);
}
break;
case Connection.SouthEast:
{
Direction = Connection.SouthEast;
Position = new Vector3Int((int)searchVec.x + 1, (int)searchVec.y - 1, 0);
}
break;
case Connection.South:
{
Direction = Connection.South;
Position = new Vector3Int((int)searchVec.x + 0, (int)searchVec.y - 1, 0);
}
break;
case Connection.SouthWest:
{
Direction = Connection.SouthWest;
Position = new Vector3Int((int)searchVec.x + -1, (int)searchVec.y - 1, 0);
}
break;
case Connection.West:
{
Direction = Connection.West;
Position = new Vector3Int((int)searchVec.x + -1, (int)searchVec.y + 0, 0);
}
break;
case Connection.NorthWest:
{
Direction = Connection.NorthWest;
Position = new Vector3Int((int)searchVec.x + -1, (int)searchVec.y + 1, 0);
}
break;
case Connection.Overlap:
{
Direction = Connection.Overlap;
Position = new Vector3Int((int)searchVec.x + 0, (int)searchVec.y + 0, 0);
}
break;
case Connection.MachineConnect:
{
Direction = Connection.MachineConnect;
MachineConnect = true;
}
break;
}
var PositionE = new Vector3Int((int)searchVec.x, (int)searchVec.y, 0);
var Econns = matrix.GetElectricalConnections(PositionE);
foreach (var con in Econns)
{
if (OIinheritance != con)
{
if (OIinheritance.WireEndA == con.WireEndA && OIinheritance.WireEndB == con.WireEndB ||
OIinheritance.WireEndA == con.WireEndB && OIinheritance.WireEndB == con.WireEndA)
{
Logger.LogErrorFormat("{0} < duplicate Please remove {1}",
Category.Electrical,
PositionE,
OIinheritance);
}
}
}
Econns.Clear();
ElectricalPool.PooledFPCList.Add(Econns);
if (!MachineConnect)
{
var conns = matrix.GetElectricalConnections(Position);
foreach (var con in conns)
{
if (CanConnectTo.Contains(con.Categorytype))
{
if (ConnectionMap.IsConnectedToTile(Direction, con.GetConnPoints()))
{
connections.Add(con);
}
}
}
conns.Clear();
ElectricalPool.PooledFPCList.Add(conns);
if (connections.Count == 0)
{
Position = new Vector3Int((int)searchVec.x, (int)searchVec.y, 0);
conns = matrix.GetElectricalConnections(Position);
foreach (var con in conns)
{
if (OIinheritance != con)
{
if (CanConnectTo.Contains(con.Categorytype))
{
if (ConnectionMap.IsConnectedToTileOverlap(Direction, con.GetConnPoints()))
{
connections.Add(con);
}
}
}
}
conns.Clear();
ElectricalPool.PooledFPCList.Add(conns);
}
}
else
{
foreach (var Direction_ in MachineConnectorDirections)
{
var pos = new Vector3Int((int)searchVec.x + (int)Direction_.x,
(int)searchVec.y + (int)Direction_.y, 0);
var conns = matrix.GetElectricalConnections(pos);
foreach (var con in conns)
{
if (OIinheritance != con)
{
if (CanConnectTo.Contains(con.Categorytype))
{
if (ConnectionMap.IsConnectedToTile(Direction, con.GetConnPoints()))
{
connections.Add(con);
}
}
}
}
conns.Clear();
ElectricalPool.PooledFPCList.Add(conns);
}
}
return(connections);
}
