private void VesselControls()
{
CPacket = (ControlPacket)ByteArrayToStructure(buffer, CPacket);
VControls.SAS = BitMathByte(CPacket.MainControls, 7);
VControls.RCS = BitMathByte(CPacket.MainControls, 6);
VControls.Lights = BitMathByte(CPacket.MainControls, 5);
VControls.Gear = BitMathByte(CPacket.MainControls, 4);
VControls.Brakes = BitMathByte(CPacket.MainControls, 3);
VControls.Precision = BitMathByte(CPacket.MainControls, 2);
VControls.Abort = BitMathByte(CPacket.MainControls, 1);
VControls.Stage = BitMathByte(CPacket.MainControls, 0);
VControls.Pitch = (float)CPacket.Pitch / 1000.0F;
VControls.Roll = (float)CPacket.Roll / 1000.0F;
VControls.Yaw = (float)CPacket.Yaw / 1000.0F;
VControls.TX = (float)CPacket.TX / 1000.0F;
VControls.TY = (float)CPacket.TY / 1000.0F;
VControls.TZ = (float)CPacket.TZ / 1000.0F;
VControls.WheelSteer = (float)CPacket.WheelSteer / 1000.0F;
VControls.Throttle = (float)CPacket.Throttle / 1000.0F;
VControls.WheelThrottle = (float)CPacket.WheelThrottle / 1000.0F;
VControls.SASMode = (int)CPacket.SASMode;
for (int j = 1; j <= 10; j++)
{
VControls.ControlGroup[j] = BitMathUshort(CPacket.ControlGroup, j);
}
ControlReceived = true;
//Debug.Log("KSPSerialIO: ControlPacket received");
}
public void send(ControlPacket packet)
{
//ControlPacket packet = new ControlPacket(ControlInterface.CALL_REQUEST, 0, resourceIdentifier);
string data = JMessage.Serialize(JMessage.FromValue(packet));
writer.Write(data);
}
public static VesselControls CPToVC(ControlPacket cp)
{
VesselControls vc = new VesselControls
{
SAS = (cp.MainControls & (1 << 0)) != 0,
RCS = (cp.MainControls & (1 << 1)) != 0,
Lights = (cp.MainControls & (1 << 2)) != 0,
Gear = (cp.MainControls & (1 << 3)) != 0,
Brakes = (cp.MainControls & (1 << 4)) != 0,
Abort = (cp.MainControls & (1 << 5)) != 0,
Stage = (cp.MainControls & (1 << 6)) != 0,
SASMode = (int)cp.SASMode,
SpeedMode = (int)cp.SpeedMode,
targetHeading = cp.targetHeading,
targetPitch = cp.targetPitch,
targetRoll = cp.targetRoll,
timeWarpRateIndex = cp.timeWarpRateIndex,
ActionGroups = new Boolean[10],
};
for (int j = 0; j < 10; j++)
{
vc.ActionGroups[j] = (cp.ActionGroups & (1 << j)) != 0;
}
return(vc);
}
public static AxisControls CPToAC(ControlPacket cp)
{
AxisControls ac = new AxisControls
{
SASTol = cp.SASTol,
RotMode = cp.ControlerMode & 0b00000011,
Pitch = (float)cp.Pitch / 1000.0F,
Roll = (float)cp.Roll / 1000.0F,
Yaw = (float)cp.Yaw / 1000.0F,
TransMode = (cp.ControlerMode & 0b00001100) >> 2,
TX = (float)cp.TX / 1000.0F,
TY = (float)cp.TY / 1000.0F,
TZ = (float)cp.TZ / 1000.0F,
ThrottleMode = (cp.ControlerMode & 0b00110000) >> 4,
Throttle = (float)cp.Throttle / 1000.0F,
WheelMode = (cp.ControlerMode & 0b11000000) >> 6,
WheelSteer = (float)cp.WheelSteer / 1000.0F,
WheelThrottle = (float)cp.WheelThrottle / 1000.0F,
};
return(ac);
}
protected void NotifyCPacketReceived(ControlPacket CPacket)
{
foreach (IPacketHandlerListener l in listeners)
{
l.ControlPacketReceived(CPacket);
}
}
public void sendRequest(string clientName, int speed)
{
ControlPacket packet = new ControlPacket(ControlInterface.CALL_REQUEST, ControlPacket.IN_PROGRESS, speed, clientName, clientWindowHandler.virtualIP, 0);
string data = JMessage.Serialize(JMessage.FromValue(packet));
writer.Write(data);
clientWindowHandler.Log2("CONTROL", " CPCC -> NCC Send Call Request");
}
public void sendRelease(int id, string to)
{
ControlPacket packet = new ControlPacket(ControlInterface.CALL_RELEASE_IN, ControlPacket.IN_PROGRESS, 0, to, clientWindowHandler.virtualIP, id);
string data = JMessage.Serialize(JMessage.FromValue(packet));
writer.Write(data);
clientWindowHandler.Log2("CONTROL", "CPCC -> NCC Send Call Release");
}
public void sendInit()
{
Address address = new Address(clientWindowHandler.virtualIP);
int cpccID = address.type + address.domain + address.subnet + address.space;
ControlPacket packet = new ControlPacket(ControlInterface.INIT_CPCC_CONNECTION, ControlPacket.IN_PROGRESS, 0, "", clientWindowHandler.virtualIP, cpccID);
string data = JMessage.Serialize(JMessage.FromValue(packet));
writer.Write(data);
clientWindowHandler.Log2("CONTROL", "Init CPCC <-> NCC connection");
}
/*
* private static T ReadUsingMarshalUnsafe<T>(byte[] data) where T : struct
* {
* unsafe
* {
* fixed (byte* p = &data[0])
* {
* return (T)Marshal.PtrToStructure(new IntPtr(p), typeof(T));
* }
* }
* }
*/
void initializeDataPackets()
{
VData = new VesselData();
VData.id = VDid;
HPacket = new HandShakePacket();
HPacket.id = HSPid;
HPacket.M1 = 1;
HPacket.M2 = 2;
HPacket.M3 = 3;
CPacket = new ControlPacket();
VControls.ControlGroup = new Boolean[11];
VControlsOld.ControlGroup = new Boolean[11];
}
/// <summary>
/// Handle received packet.
/// </summary>
/// <param name="packet">Packet data starting with packet id</param>
private void InboundPacketHandler(byte[] packet)
{
switch (packet[0])
{
//Save if correct HS was received
case HSPid:
//Debug.Log("[KSPEthernetIO]: HandshakePacket received");
HandshakePacket HPacket = new HandshakePacket();
HPacket = (HandshakePacket)ByteArrayToStructure(packet, HPacket);
_dataReceiveMutex.WaitOne();
//Check hard coded HS values
if ((HPacket.M1 == 3) && (HPacket.M2 == 1) && (HPacket.status == 4))
{
Debug.Log("[KSPEthernetIO]: Handshake complete");
_handshakeReceived = true;
}
else
{
_handshakeReceived = false;
}
_dataReceiveMutex.ReleaseMutex();
break;
//Stack received ControlPackets
case Cid:
//Debug.Log("[KSPEthernetIO]: ControlPacket received");
_dataReceiveMutex.WaitOne();
if (_cPacketStack.Count < 256 && _enableControl)
{
ControlPacket cPacket = new ControlPacket();
cPacket = (ControlPacket)ByteArrayToStructure(packet, cPacket);
_cPacketStack.Push(cPacket);
if (_cPacketStack.Count >= 256)
{
Debug.LogWarning("[KSPEthernetIO]: ControlPacket buffer overflow!");
}
}
_dataReceiveMutex.ReleaseMutex();
break;
default:
Debug.LogWarning("[KSPEthernetIO]: Packet ID " + packet[0] + " unknown");
break;
}
}
private void RunRecieve()
{
IntPtr ptr = Marshal.AllocHGlobal(256);
while (Connected)
{
// Debug.Log("recieving");
try
{
Marshal.Copy(ReadBytes(Marshal.SizeOf(typeof(Header))), 0, ptr, Marshal.SizeOf(typeof(Header)));
Header header = (Header)Marshal.PtrToStructure(ptr, typeof(Header));
if (header.type == 1)
{
Marshal.Copy(ReadBytes(Marshal.SizeOf(typeof(ControlPacket))), 0, ptr, Marshal.SizeOf(typeof(ControlPacket)));
ControlPacket cp = (ControlPacket)Marshal.PtrToStructure(ptr, typeof(ControlPacket));
if (cp.ID > lastCPID)
{
lastCPID = cp.ID;
VCList.Enqueue(CPToVC(cp));
axisControls = CPToAC(cp);
}
}
else if (header.type == 2)
{
Marshal.Copy(ReadBytes(Marshal.SizeOf(typeof(ManChangePacket))), 0, ptr, Marshal.SizeOf(typeof(ManChangePacket)));
ManChangePacket mcp = (ManChangePacket)Marshal.PtrToStructure(ptr, typeof(ManChangePacket));
MCPList.Enqueue(mcp);
}
else
{
Debug.Log("Incorrect header");
}
}
catch (IOException)
{
Debug.Log("Error Recieving");
Connected = false;
}
}
Marshal.FreeHGlobal(ptr);
}
/// <summary>
/// Has to be called in the Update() routine. Checks for new Packets in the PacketStack
/// and creates an Event if new data is avaiable. Event can be received from the PacketHandler
/// by IPacketHandlerListeners.
/// </summary>
public void CheckForNewPacket()
{
ControlPacket cPacket = new ControlPacket();
bool newcpacket = false;
_dataReceiveMutex.WaitOne();
if (_cPacketStack.Count > 0)
{
newcpacket = true;
cPacket = _cPacketStack.Pop();
}
_dataReceiveMutex.ReleaseMutex();
if (newcpacket)
{
NotifyCPacketReceived(cPacket);
}
}
/// <summary>
/// Callback for ControlData received event
/// </summary>
/// <param name="CPacket">New ControlData</param>
public void ControlPacketReceived(ControlPacket CPacket)
{
//Output for debugging
packetCounter++;
double time = Time.unscaledTime;
double dt = time - lastUpdateTime;
if (KSPEthernetIO.Server.ClientConnected && dt > 30)
{
lastUpdateTime = time;
Debug.Log("[KSPEthernetIO]: " + packetCounter + " ControlPackets received [" + 1000 * dt / packetCounter + "ms]");
packetCounter = 0;
}
if (!KSPEthernetIO.Server.ClientConnected)
{
lastUpdateTime = Time.unscaledTime;
packetCounter = 0;
}
//Handle received packet
control.ControlsReceived(CPacket, data.getVesselSync());
}
private void Listen()
{
try
{
client = new TcpClient("127.0.0.1", this.port);
BinaryReader reader = new BinaryReader(client.GetStream());
writer = new BinaryWriter(client.GetStream());
while (true)
{
string received_data = reader.ReadString();
JSON received_object = JSON.Deserialize(received_data);
Management.ManagmentProtocol received_Protocol = received_object.Value.ToObject <Management.ManagmentProtocol>();
if (received_object.Type == typeof(Management.ManagmentProtocol))
{
Management.ManagmentProtocol management_packet = received_object.Value.ToObject <Management.ManagmentProtocol>();
if (management_packet.State == Management.ManagmentProtocol.TOOTHERNCC)
{
foreach (int port in management_packet.ConnectionToOtherNcc)
{
TcpClient connection = new TcpClient("127.0.0.1", port);
ControlConnectionService service = new ControlConnectionService(connection, control);
Thread.Sleep(500);
ControlPacket packetToNCC = new ControlPacket(ControlInterface.NETWORK_CALL_COORDINATION_IN, ControlPacket.IN_PROGRESS, 0, "", "", control.domainNumber);
service.send(packetToNCC);
}
}
else if (management_packet.State == Management.ManagmentProtocol.SOFTPERNAMENT)
{
control.consoleWriter("[NCC <- Management] Soft pernament from " + management_packet.NodeStart + " to " + management_packet.NodeEnd);
int RequestID = control.generateRequestID();
Address address = new Address(management_packet.NodeStart);
int cpccID = address.type + address.domain + address.subnet + address.space;
control.addCpccRequest(RequestID, cpccID);
ControlPacket packetToCPCC = new ControlPacket(ControlInterface.CALL_INDICATION_CPCC, ControlPacket.IN_PROGRESS, management_packet.Speed, management_packet.NodeEnd, management_packet.NodeStart, RequestID);
packetToCPCC.Vc11 = 1;
packetToCPCC.Vc12 = 1;
packetToCPCC.Vc13 = 1;
ControlConnectionService cpccService = control.getCpccServiceByAddr(management_packet.NodeEnd);
cpccService.send(packetToCPCC);
control.consoleWriter("[NCC -> CPCC] Send Call Indication");
}
else if (management_packet.State == Management.ManagmentProtocol.RELEASESOFTPERNAMENT)
{
int id = management_packet.Connection;
control.consoleWriter("[NCC <- CPCC] Call release id: " + id);
if (!control.checkIfInterdomainRequest(id))
{
control.consoleWriter("[NCC -> CC]Send connection release");
CCtoNCCSingallingMessage packetToCC = new CCtoNCCSingallingMessage();
packetToCC.State = CCtoNCCSingallingMessage.NCC_RELEASE_WITH_ID;
packetToCC.RequestID = id;
ControlConnectionService CCService = control.getCCService();
CCService.sendCCRequest(packetToCC);
}
else
{
control.consoleWriter("[NCC -> CC]Send connection release");
CCtoNCCSingallingMessage packetToCC = new CCtoNCCSingallingMessage();
packetToCC.State = CCtoNCCSingallingMessage.NCC_RELEASE_WITH_ID;
packetToCC.RequestID = id;
ControlConnectionService CCService = control.getCCService();
CCService.sendCCRequest(packetToCC);
}
}
}
}
}
catch (SocketException e)
{
}
catch (IOException e)
{
Thread.Sleep(1000);
Environment.Exit(1);
}
}
private void callThread()
{
writer = new BinaryWriter(connection.GetStream());
reader = new BinaryReader(connection.GetStream());
while (true)
{
try
{
string received_data = reader.ReadString();
JMessage received_object = JMessage.Deserialize(received_data);
if (received_object.Type == typeof(ControlPacket))
{
ControlPacket packet = received_object.Value.ToObject <ControlPacket>();
if (packet.virtualInterface == ControlInterface.CALL_ACCEPT)
{
if (packet.state == ControlPacket.ACCEPT)
{
clientWindowHandler.addToConnectionCombobox(packet.RequestID, packet.destinationIdentifier);
clientWindowHandler.slots.Clear();
if (packet.Vc11 != 0)
{
clientWindowHandler.slots.Add(11);
}
if (packet.Vc12 != 0)
{
clientWindowHandler.slots.Add(12);
}
if (packet.Vc13 != 0)
{
clientWindowHandler.slots.Add(13);
}
clientWindowHandler.Log2("CONTROL", "CPCC <- NCC Call Request Accepted");
}
else
{
clientWindowHandler.Log2("CONTROL", "CPCC <- NCC Call Request Rejected");
}
}
else if (packet.virtualInterface == ControlInterface.INIT_CPCC_CONNECTION_CONFIRM)
{
clientWindowHandler.Log2("CONTROL", "CPCC <-> NCC connection established");
}
else if (packet.virtualInterface == ControlInterface.CALL_INDICATION_CPCC)
{
clientWindowHandler.Log2("CPCC <- NCC", "Receive Call Indication");
ControlPacket packetToNCC = new ControlPacket(ControlInterface.CALL_INDICATION_CPCC_ACCEPT, packet.state, packet.speed, packet.destinationIdentifier, packet.originIdentifier, packet.RequestID);
packetToNCC.Vc11 = packet.Vc11;
packetToNCC.Vc12 = packet.Vc12;
packetToNCC.Vc13 = packet.Vc13;
string data = JMessage.Serialize(JMessage.FromValue(packetToNCC));
writer.Write(data);
clientWindowHandler.Log2("CPCC -> NCC", "Send Call Indication Confirmation");
}
}
else
{
clientWindowHandler.Log2("CONTROL", "Wrong control packet format");
}
}
catch (IOException e)
{
clientWindowHandler.Log2("CONTROL", "CPCC <-> NCC Connection closed");
break;
}
}
}
private void ListenThread(Object client)
{
TcpClient clienttmp = (TcpClient)client;
BinaryReader reader = new BinaryReader(clienttmp.GetStream());
writer = new BinaryWriter(clienttmp.GetStream());
while (true)
{
try
{
string received_data = reader.ReadString();
JMessage received_object = JMessage.Deserialize(received_data);
if (received_object.Type == typeof(ControlPacket))
{
ControlPacket packet = received_object.Value.ToObject <ControlPacket>();
if (packet.virtualInterface == ControlInterface.CALL_REQUEST)
{
//request service cpcc
int requestID = handlerNCC.generateRequestID();
handlerNCC.addCpccRequest(requestID, myServiceID);
handlerNCC.consoleWriter("[NCC <- CPCC] Receive Call Request for " + packet.destinationIdentifier);
handlerNCC.consoleWriter("[NCC -> DIRECTORY] Send Directory Request");
if (handlerNCC.checkIfInDirectory(packet.destinationIdentifier))
{
handlerNCC.consoleWriter("[NCC <- DIRECTORY] Receive Local Name");
handlerNCC.consoleWriter("[NCC -> POLICY] Send Policy Out");
handlerNCC.consoleWriter("[NCC <- POLICY] Call Accept");
ControlPacket packetToCPCC = new ControlPacket(ControlInterface.CALL_INDICATION_CPCC, packet.state, packet.speed, packet.destinationIdentifier, packet.originIdentifier, requestID);
packetToCPCC.Vc11 = 1;
packetToCPCC.Vc12 = 1;
packetToCPCC.Vc13 = 1;
ControlConnectionService cpccService = handlerNCC.getCpccServiceByAddr(packet.destinationIdentifier);
cpccService.send(packetToCPCC);
handlerNCC.consoleWriter("[NCC -> CPCC] Send Call Indication");
}
else
{
handlerNCC.consoleWriter("[NCC <- DIRECTORY] Directory Request Reject");
Address address = new Address(packet.destinationIdentifier);
ControlConnectionService serviceToNCC = handlerNCC.getService(address.domain);
handlerNCC.addCNAddressesForInterdomainCalls(requestID, packet.originIdentifier);
Address addressFromOtherDomain = new Address(packet.destinationIdentifier);
List <string> borderGWAddresses = new List <string>();
borderGWAddresses = handlerNCC.returnBorderGateway(addressFromOtherDomain.domain);
string borderGWAddress = borderGWAddresses.First();
handlerNCC.initInterdomanCallTask(requestID, borderGWAddress);
ControlPacket packetToNCC = new ControlPacket(ControlInterface.CALL_INDICATION, ControlPacket.IN_PROGRESS, packet.speed, packet.destinationIdentifier, borderGWAddress, requestID);
packetToNCC.domain = handlerNCC.domainNumber;
packetToNCC.Vc11 = 1;
packetToNCC.Vc12 = 1;
packetToNCC.Vc13 = 1;
serviceToNCC.send(packetToNCC);
handlerNCC.consoleWriter("[NCC -> NCC]Send Call Coordination: " + packet.destinationIdentifier + " origin(BG address): " + borderGWAddress);
}
}
else if (packet.virtualInterface == ControlInterface.INIT_CPCC_CONNECTION)
{
handlerNCC.addService(packet.RequestID, this);
this.myServiceID = packet.RequestID;
ControlPacket packetToCpcc = new ControlPacket(ControlInterface.INIT_CPCC_CONNECTION_CONFIRM, 0, 0, "", "", 0);
send(packetToCpcc);
}
else if (packet.virtualInterface == ControlInterface.CALL_RELEASE_IN)
{
//RELEASE
int id = packet.RequestID;
handlerNCC.consoleWriter("[NCC <- CPCC] Call release id: " + id);
if (!handlerNCC.checkIfInterdomainRequest(id))
{
handlerNCC.consoleWriter("[NCC -> CC]Send connection release");
CCtoNCCSingallingMessage packetToCC = new CCtoNCCSingallingMessage();
packetToCC.State = CCtoNCCSingallingMessage.NCC_RELEASE_WITH_ID;
packetToCC.RequestID = packet.RequestID;
ControlConnectionService CCService = this.handlerNCC.getCCService();
CCService.sendCCRequest(packetToCC);
}
else
{
handlerNCC.consoleWriter("[NCC -> CC]Send connection release");
CCtoNCCSingallingMessage packetToCC = new CCtoNCCSingallingMessage();
packetToCC.State = CCtoNCCSingallingMessage.NCC_RELEASE_WITH_ID;
packetToCC.RequestID = packet.RequestID;
ControlConnectionService CCService = this.handlerNCC.getCCService();
CCService.sendCCRequest(packetToCC);
}
}
else if (packet.virtualInterface == ControlInterface.NETWORK_CALL_COORDINATION_IN)
{
handlerNCC.consoleWriter("[NCC <- NCC] Receive NCC invitation from NCC in domain" + packet.RequestID);
handlerNCC.addService(packet.RequestID, this);
ControlPacket packetToNCCResponse = new ControlPacket(ControlInterface.NETWORK_CALL_COORDINATION_OUT, ControlPacket.IN_PROGRESS, 0, "", "", handlerNCC.domainNumber);
send(packetToNCCResponse);
handlerNCC.consoleWriter("[NCC -> NCC] Send invitation response to NCC in domain" + packetToNCCResponse.RequestID);
}
else if (packet.virtualInterface == ControlInterface.NETWORK_CALL_COORDINATION_OUT)
{
handlerNCC.consoleWriter("[NCC <- NCC] NCC handshake completed with NCC in doman" + packet.RequestID);
handlerNCC.addService(packet.RequestID, this);
}
else if (packet.virtualInterface == ControlInterface.CALL_INDICATION)
{
if (packet.state == ControlPacket.IN_PROGRESS)
{
handlerNCC.consoleWriter("[NCC <- NCC] Recived Call Coordination " + packet.originIdentifier + " to: " + packet.destinationIdentifier);
if (handlerNCC.interdomainRequests.ContainsKey(packet.RequestID))
{
//Console.WriteLine("KOLEJNA PROBA Z INNYM GW: " + packet.originIdentifier);
}
else
{
handlerNCC.addInterdomainRequest(packet.RequestID, packet.domain);
}
// ZAKLADAMY TU ZE KAZDE NCC MA HANDLER NA INNE, INACZEJ SPRAWDZ DOMENE CZY TWOJA, NIE TO SLIJ DALEJ
handlerNCC.consoleWriter("[NCC -> DIRECTORY] Send Directory Request");
handlerNCC.consoleWriter("[NCC <- DIRECTORY] Receive Local Name");
handlerNCC.consoleWriter("[NCC -> POLICY] Send Policy Out");
handlerNCC.consoleWriter("[NCC <- POLICY] Call Accept");
ControlPacket packetToCPCC = new ControlPacket(ControlInterface.CALL_INDICATION_CPCC, packet.state, packet.speed, packet.destinationIdentifier, packet.originIdentifier, packet.RequestID);
packetToCPCC.Vc11 = packet.Vc11;
packetToCPCC.Vc12 = packet.Vc12;
packetToCPCC.Vc13 = packet.Vc13;
ControlConnectionService cpccService = handlerNCC.getCpccServiceByAddr(packet.destinationIdentifier);
cpccService.send(packetToCPCC);
handlerNCC.consoleWriter("[NCC -> CPCC] Send Call Indication");
}
else if (packet.state == ControlPacket.REJECT)
{
handlerNCC.consoleWriter("[NCC <- NCC] Receive Call Release, from previous NCC");
CCtoNCCSingallingMessage packetToCC = new CCtoNCCSingallingMessage();
packetToCC.State = CCtoNCCSingallingMessage.NCC_RELEASE_WITH_ID;
packetToCC.RequestID = packet.RequestID;
ControlConnectionService CCService = handlerNCC.getCCService();
CCService.sendCCRequest(packetToCC);
}
}
else if (packet.virtualInterface == ControlInterface.CALL_INDICATION_CPCC_ACCEPT)
{
handlerNCC.consoleWriter("[NCC <- CPCC] Call Indication Confirmed");
handlerNCC.consoleWriter("[NCC -> CC]Send Connection Request");
CCtoNCCSingallingMessage packetToCC = new CCtoNCCSingallingMessage();
packetToCC.State = CCtoNCCSingallingMessage.NCC_SET_CONNECTION;
packetToCC.NodeFrom = packet.originIdentifier;
packetToCC.NodeTo = packet.destinationIdentifier;
handlerNCC.rejectedDestinations.Add(packet.RequestID, packet.destinationIdentifier);
packetToCC.Rate = packet.speed;
packetToCC.RequestID = packet.RequestID;
packetToCC.Vc11 = packet.Vc11;
packetToCC.Vc12 = packet.Vc12;
packetToCC.Vc13 = packet.Vc13;
ControlConnectionService CCService = this.handlerNCC.getCCService();
CCService.sendCCRequest(packetToCC);
}
else if (packet.virtualInterface == ControlInterface.CALL_REQUEST_ACCEPT)
{
// ZAKLADAMY TU ZE KAZDE NCC MA HANDLER NA INNE, INACZEJ SPRAWDZ DOMENE CZY TWOJA, NIE TO ODESLIJ DALEJ
if (packet.state == ControlPacket.ACCEPT)
{
handlerNCC.consoleWriter("[NCC <- NCC] Call Coordination Accept");
CCtoNCCSingallingMessage packetToCC = new CCtoNCCSingallingMessage();
packetToCC.State = CCtoNCCSingallingMessage.NCC_SET_CONNECTION;
packetToCC.NodeFrom = handlerNCC.getCNAddressesForInterdomainCalls(packet.RequestID);
packetToCC.NodeTo = packet.destinationIdentifier;
handlerNCC.consoleWriter("[NCC->CC]Send Connection Request, from: " + packetToCC.NodeFrom + " to: " + packetToCC.NodeTo);
packetToCC.Rate = packet.speed;
packetToCC.RequestID = packet.RequestID;
packetToCC.Vc11 = packet.Vc11;
packetToCC.Vc12 = packet.Vc12;
packetToCC.Vc13 = packet.Vc13;
ControlConnectionService CCService = this.handlerNCC.getCCService();
CCService.sendCCRequest(packetToCC);
}
else
{
//counter--;
//if (counter < 0)
// break;
handlerNCC.consoleWriter("[NCC <- NCC] Call Coordination Rejected");
// handlerNCC.showInterdomainAttemptsForRequestID(packet.RequestID);
// Console.WriteLine("Szukam borderow dla ip: " + packet.destinationIdentifier);
String anotherBorderGWAddress = handlerNCC.getAnotherBorderGatewayAddress(packet.RequestID, packet.originIdentifier);
//Console.WriteLine("Znaleziony border GW: " + anotherBorderGWAddress);
if (anotherBorderGWAddress == null)
{
//wez service odpowiedni
ControlConnectionService cpccCallService = handlerNCC.getService(handlerNCC.getCpccService(packet.RequestID));
ControlPacket packetToCPCC = new ControlPacket(ControlInterface.CALL_ACCEPT, ControlPacket.REJECT, packet.speed, packet.originIdentifier, handlerNCC.getCNAddressesForInterdomainCalls(packet.RequestID), packet.RequestID);
cpccCallService.send(packetToCPCC);
handlerNCC.consoleWriter("[NCC -> CPCC] Call Request Reject");
handlerNCC.clearCNAddressesForInterdomainCalls(packet.RequestID);
handlerNCC.clearInterdomainCallAttempt(packet.RequestID);
handlerNCC.removeCpccRequest(packet.RequestID);
//NIE UDALO SIE U NAS, WYSLAC DO TAMTEGO NCC NIECH ROZLACZY JEDNAK
//W DOMAIN Z TMATEGO NCC JEGO DOMAIN, ZEBY ODESLAC MU NIECH ROZLACZY
// ControlConnectionService nccCallService = handlerNCC.getService(packet.domain);
// ControlPacket packetToNCC = new ControlPacket(ControlInterface.CALL_INDICATION, ControlPacket.REJECT, packet.speed, "BORDER_GATEWAY", packet.destinationIdentifier, packet.RequestID);
//nccCallService.send(packetToNCC);
}
else
{
//Console.WriteLine("Znalazłem nowy border wyjsciowy: " + anotherBorderGWAddress);
handlerNCC.addIntrerdomainCallsAttempts(packet.RequestID, anotherBorderGWAddress);
Address address = new Address(packet.originIdentifier);
ControlConnectionService serviceToNCC = handlerNCC.getService(address.domain);
ControlPacket packetToNCC = new ControlPacket(ControlInterface.CALL_INDICATION, ControlPacket.IN_PROGRESS, packet.speed, packet.originIdentifier, anotherBorderGWAddress, packet.RequestID);
packetToNCC.domain = handlerNCC.domainNumber;
packetToNCC.Vc11 = 1;
packetToNCC.Vc12 = 1;
packetToNCC.Vc13 = 1;
packetToNCC.speed = packet.speed;
handlerNCC.consoleWriter("[NCC -> NCC] Send Call Coordination with another border GW, destination: " + packetToNCC.destinationIdentifier + " borderGW: " + anotherBorderGWAddress);
serviceToNCC.send(packetToNCC);
}
}
}
}
else if (received_object.Type == typeof(CCtoNCCSingallingMessage))
{
CCtoNCCSingallingMessage packet = received_object.Value.ToObject <CCtoNCCSingallingMessage>();
if (packet.State == CCtoNCCSingallingMessage.INIT_FROM_CC)
{
handlerNCC.consoleWriter("[NCC <- CC]Connection established");
handlerNCC.setCCService(this);
}
else if (packet.State == CCtoNCCSingallingMessage.CC_CONFIRM)
{
handlerNCC.consoleWriter("[NCC <- CC] Receive Connection Request Confirm");
if (handlerNCC.rejectedDestinations.ContainsKey(packet.RequestID))
{
handlerNCC.rejectedDestinations.Remove(packet.RequestID);
}
if (handlerNCC.checkIfInterdomainRequest(packet.RequestID))
{
ControlConnectionService NCCService = handlerNCC.getService(handlerNCC.getDomainService(packet.RequestID));
//Console.WriteLine("[CC]Border gateway to previous ncc: " + packet.NodeTo);
//Nodeto GW, NodeFrom CN in other domain address
ControlPacket packetToNCC = new ControlPacket(ControlInterface.CALL_REQUEST_ACCEPT, ControlPacket.ACCEPT, packet.Rate, packet.NodeTo, packet.NodeFrom, packet.RequestID);
packetToNCC.domain = handlerNCC.domainNumber;
packetToNCC.Vc11 = packet.Vc11;
packetToNCC.Vc12 = packet.Vc12;
packetToNCC.Vc13 = packet.Vc13;
NCCService.send(packetToNCC);
handlerNCC.clearCNAddressesForInterdomainCalls(packet.RequestID);
handlerNCC.consoleWriter("[NCC -> NCC] Send Call Coordination Confirm");
}
else
{
ControlConnectionService cpccCallService = handlerNCC.getService(handlerNCC.getCpccService(packet.RequestID));
ControlPacket packetToCPCC = new ControlPacket(ControlInterface.CALL_ACCEPT, ControlPacket.ACCEPT, packet.Rate, packet.NodeTo, packet.NodeTo, packet.RequestID);
List <int> slots = new List <int>();
if (packet.Vc11 != 0)
{
packetToCPCC.Vc11 = 1;
slots.Add(11);
}
if (packet.Vc12 != 0)
{
packetToCPCC.Vc12 = 1;
slots.Add(12);
}
if (packet.Vc13 != 0)
{
packetToCPCC.Vc13 = 1;
slots.Add(13);
}
cpccCallService.send(packetToCPCC);
handlerNCC.management.send(packet.RequestID, packet.NodeTo);
handlerNCC.consoleWriter("[NCC -> CPCC] Send Call Request Accept");
}
}
else if (packet.State == CCtoNCCSingallingMessage.CC_REJECT)
{
handlerNCC.consoleWriter("[NCC <- CC] Receive Connection Request Reject");
if (handlerNCC.checkIfInterdomainRequest(packet.RequestID))
{
ControlConnectionService NCCService = handlerNCC.getService(handlerNCC.getDomainService(packet.RequestID));
//Nodeto GW, NodeFrom CN in other domain address
// Console.WriteLine("[CC]Destination node to previous ncc: " + handlerNCC.rejectedDestinations[packet.RequestID]);
ControlPacket packetToNCC = new ControlPacket(ControlInterface.CALL_REQUEST_ACCEPT, ControlPacket.REJECT, packet.Rate, packet.NodeTo, handlerNCC.rejectedDestinations[packet.RequestID], packet.RequestID);
packetToNCC.domain = handlerNCC.domainNumber;
NCCService.send(packetToNCC);
handlerNCC.rejectedDestinations.Remove(packet.RequestID);
handlerNCC.consoleWriter("[NCC -> NCC] Send Call Coordination Reject");
}
else
{
ControlConnectionService cpccCallService = handlerNCC.getService(handlerNCC.getCpccService(packet.RequestID));
ControlPacket packetToCPCC = new ControlPacket(ControlInterface.CALL_ACCEPT, ControlPacket.REJECT, packet.Rate, packet.NodeTo, packet.NodeTo, packet.RequestID);
handlerNCC.consoleWriter("[NCC -> CPCC] Send Call Request Reject");
cpccCallService.send(packetToCPCC);
}
}
else if (packet.State == CCtoNCCSingallingMessage.BORDER_NODE)
{
handlerNCC.consoleWriter("[NCC <- CC]Get border node address: " + packet.BorderNode + " to domain: " + packet.BorderDomain);
handlerNCC.addBorderGateway(packet.BorderDomain, packet.BorderNode);
}
}
else
{
handlerNCC.consoleWriter("Wrong control packet format");
}
}
catch (IOException e)
{
handlerNCC.consoleWriter("Connection closed");
break;
}
}
}
/**
* receiver algorithm
* see specification P11.
*/
public void ReceiverAlgorithm()
{
//check ACK timer
long currentTime = Util.getCurrentTime();
if (nextACK < currentTime)
{
nextACK = currentTime + ackTimerInterval;
ProcessACKEvent(true);
}
//check NAK timer
if (nextNAK < currentTime)
{
nextNAK = currentTime + nakTimerInterval;
ProcessNAKEvent();
}
//check EXP timer
if (nextEXP < currentTime)
{
nextEXP = currentTime + expTimerInterval;
ProcessEXPEvent();
}
//perform time-bounded UDP receive
IUDTPacket packet = null;
handoffQueue.TryTake(out packet, (int)Util.GetSYNTime());
if (packet != null)
{
//reset exp count to 1
expCount = 1;
//If there is no unacknowledged data packet, or if this is an
//ACK or NAK control packet, reset the EXP timer.
bool needEXPReset = false;
if (packet.IsControlPacket())
{
ControlPacket cp = (ControlPacket)packet;
int cpType = cp.GetControlPacketType();
if (cpType == (int)ControlPacketType.ACK || cpType == (int)ControlPacketType.NAK)
{
needEXPReset = true;
}
}
if (needEXPReset)
{
nextEXP = Util.getCurrentTime() + expTimerInterval;
}
if (storeStatistics)
{
processTime.Begin();
}
ProcessUDTPacket(packet);
if (storeStatistics)
{
processTime.End();
}
}
Thread.Yield();
}
public void Update()
{
if (conn != null)
{
if (!conn.GetConnected())
{
msg("YARK: client disconneted");
conn = null;
}
else
{
if (SceneManager.GetActiveScene().buildIndex == 7) //in flight?
{
currentTime = (UInt32)Planetarium.GetUniversalTime();
if (inFlight != 1 || AV.id != FlightGlobals.ActiveVessel.id || lastTime > currentTime)
{
inFlight = 1;
if (AV != null)
{
AV.OnPostAutopilotUpdate -= AxisInput.Callback;
}
AV = FlightGlobals.ActiveVessel;
AV.OnPostAutopilotUpdate += AxisInput.Callback;
//sync inputs on vessel switch
ControlPacket cp = new ControlPacket
{
MainControls = CalcMainControls(),
ActionGroups = CalcActionGroups(),
SASMode = GetSASMode(true),
SpeedMode = (byte)(FlightGlobals.speedDisplayMode + 1),
timeWarpRateIndex = GetTimeWarpIndex()
};
cp.targetHeading = cp.targetPitch = cp.targetRoll = cp.WheelSteer = cp.WheelThrottle = cp.Throttle = cp.Pitch = cp.Roll = cp.Yaw = cp.TX = cp.TY = cp.TZ = 0;
conn.SyncControls(CPToVC(cp));
msg("rysync");
UpdateSP();
conn.SendStatusPacket(SP);
}
lastTime = currentTime;
if (AxisInput.holdTargetVector) //custom SAS vectoring WIP
{
Quaternion relativeOrientation = Quaternion.identity * Quaternion.Euler((-AxisInput.targetHeading + 90) * new Vector3(1, 0, 0));
relativeOrientation = relativeOrientation * Quaternion.Euler((AxisInput.targetPitch) * new Vector3(0, 0, 1));
relativeOrientation = relativeOrientation * Quaternion.Euler((AxisInput.targetRoll + 90) * new Vector3(0, 1, 0));
Quaternion goalOrientation = Quaternion.LookRotation(north, east) * relativeOrientation;
Quaternion currentOrientation = AV.Autopilot.SAS.lockedRotation;
float delta = Quaternion.Angle(goalOrientation, currentOrientation);
float slurp;
slurp = (float)(Math.Log(delta + 1) / Math.Log(90) * 0.3);
AV.Autopilot.SAS.LockRotation(Quaternion.Slerp(currentOrientation, goalOrientation, slurp));
}
float time = Time.unscaledTime;
VP.deltaTime = time - TimeOFLastSend;
if (Config.UpdatesPerSecond == 0 || ((VP.deltaTime) > (1.0f / (float)(Config.UpdatesPerSecond)))) //Limit send rate to config rate
{
TimeOFLastSend = time;
UpdateVP();
conn.SendVesselPacket(VP);
OrbitPlanSkipRateC++;
if ((Config.OrbitPlanSkipRate == 0) || ((OrbitPlanSkipRateC % Config.OrbitPlanSkipRate) == 0))
{
conn.SendFlightPlanPacket(GenerateRawOrbitPlanData());
}
}
if (conn != null)
{
while (conn.HaveVCPackets())
{
VCDifference vcDiff = conn.GetVC();
UpdateControls(vcDiff.oldVC, vcDiff.newVC);
}
while (conn.HaveMCPPackets())
{
ManChangePacket mcp = conn.GetMCP();
switch (mcp.mode)
{
case 0: //set
AV.patchedConicSolver.maneuverNodes[mcp.manID].OnGizmoUpdated(new Vector3d(mcp.X, mcp.Y, mcp.Z), mcp.UT);
break;
case 1: //new
AV.patchedConicSolver.AddManeuverNode(mcp.UT);
break;
case 2: //delete
AV.patchedConicSolver.maneuverNodes[mcp.manID].RemoveSelf();
break;
}
}
}
}
else
{
if (inFlight != 0)
{
msg("switched to NOT FLYING");
inFlight = 0;
UpdateSP();
conn.SendStatusPacket(SP);
}
if (conn != null)
{
while (conn.HaveVCPackets())
{
conn.GetVC(); //ignore results
}
}
}
}
}
else if (server.Pending())
{
msg("YARK: Client connected");
conn = new Connection(server.AcceptTcpClient());
UpdateSP();
conn.SendStatusPacket(SP);
inFlight = SP.status;
TimeOFLastSend = Time.unscaledTime;
}
}
/// <summary>
/// Send new control data to the active vessel.
/// Checks the vesselSync value to prevent using old ControlPackets after vessel change.
/// </summary>
/// <param name="CPacket">Control data</param>
/// <param name="sync">Current VesselData sync value</param>
public void ControlsReceived(ControlPacket CPacket, byte sync)
{
if (CPacket.vesselSync == sync)
{
//Detect vessel change
_vControls.vesselSync = CPacket.vesselSync;
bool vesselChanged = _vControls.vesselSync != _vControlsOld.vesselSync;
_vControlsOld.vesselSync = _vControls.vesselSync;
_vControls.SAS = BitMathByte(CPacket.MainControls, 7);
_vControls.RCS = BitMathByte(CPacket.MainControls, 6);
_vControls.Lights = BitMathByte(CPacket.MainControls, 5);
_vControls.Gear = BitMathByte(CPacket.MainControls, 4);
_vControls.Brakes = BitMathByte(CPacket.MainControls, 3);
_vControls.Precision = BitMathByte(CPacket.MainControls, 2);
_vControls.Abort = BitMathByte(CPacket.MainControls, 1);
_vControls.Stage = BitMathByte(CPacket.MainControls, 0);
_vControls.Pitch = (float)CPacket.Pitch / 1000.0F;
_vControls.Roll = (float)CPacket.Roll / 1000.0F;
_vControls.Yaw = (float)CPacket.Yaw / 1000.0F;
_vControls.TX = (float)CPacket.TX / 1000.0F;
_vControls.TY = (float)CPacket.TY / 1000.0F;
_vControls.TZ = (float)CPacket.TZ / 1000.0F;
_vControls.WheelSteer = (float)CPacket.WheelSteer / 1000.0F;
_vControls.Throttle = (float)CPacket.Throttle / 1000.0F;
_vControls.WheelThrottle = (float)CPacket.WheelThrottle / 1000.0F;
_vControls.SASMode = (int)CPacket.NavballSASMode & 0x0F;
_vControls.SpeedMode = (int)(CPacket.NavballSASMode >> 4);
_vControls.UiMode = (int)CPacket.Mode & 0x0F;
_vControls.CameraMode = (int)(CPacket.Mode >> 4);
_vControls.OpenMenu = BitMathByte(CPacket.AdditionalControlByte1, 0);
_vControls.OpenMap = BitMathByte(CPacket.AdditionalControlByte1, 1);
for (int j = 1; j <= 10; j++)
{
_vControls.ControlGroup[j] = BitMathUshort(CPacket.ControlGroup, j);
}
//if (FlightInputHandler.RCSLock != VControls.RCS)
if (_vControls.RCS != _vControlsOld.RCS || vesselChanged)
{
_activeVessel.ActionGroups.SetGroup(KSPActionGroup.RCS, _vControls.RCS);
_vControlsOld.RCS = _vControls.RCS;
//ScreenMessages.PostScreenMessage("RCS: " + VControls.RCS.ToString(), 10f, KSPIOScreenStyle);
}
//if (ActiveVessel.ctrlState.killRot != VControls.SAS)
if (_vControls.SAS != _vControlsOld.SAS || vesselChanged)
{
_activeVessel.ActionGroups.SetGroup(KSPActionGroup.SAS, _vControls.SAS);
_vControlsOld.SAS = _vControls.SAS;
//ScreenMessages.PostScreenMessage("SAS: " + VControls.SAS.ToString(), 10f, KSPIOScreenStyle);
}
if (_vControls.Lights != _vControlsOld.Lights || vesselChanged)
{
_activeVessel.ActionGroups.SetGroup(KSPActionGroup.Light, _vControls.Lights);
_vControlsOld.Lights = _vControls.Lights;
}
if (_vControls.Gear != _vControlsOld.Gear || vesselChanged)
{
_activeVessel.ActionGroups.SetGroup(KSPActionGroup.Gear, _vControls.Gear);
_vControlsOld.Gear = _vControls.Gear;
}
if (_vControls.Brakes != _vControlsOld.Brakes || vesselChanged)
{
_activeVessel.ActionGroups.SetGroup(KSPActionGroup.Brakes, _vControls.Brakes);
_vControlsOld.Brakes = _vControls.Brakes;
}
if (_vControls.Abort != _vControlsOld.Abort || vesselChanged)
{
_activeVessel.ActionGroups.SetGroup(KSPActionGroup.Abort, _vControls.Abort);
_vControlsOld.Abort = _vControls.Abort;
}
if (_vControls.Stage != _vControlsOld.Stage || vesselChanged)
{
if (_vControls.Stage)
{
StageManager.ActivateNextStage();
}
_activeVessel.ActionGroups.SetGroup(KSPActionGroup.Stage, _vControls.Stage);
_vControlsOld.Stage = _vControls.Stage;
}
//================ control groups
if (_vControls.ControlGroup[1] != _vControlsOld.ControlGroup[1] || vesselChanged)
{
_activeVessel.ActionGroups.SetGroup(KSPActionGroup.Custom01, _vControls.ControlGroup[1]);
_vControlsOld.ControlGroup[1] = _vControls.ControlGroup[1];
}
if (_vControls.ControlGroup[2] != _vControlsOld.ControlGroup[2] || vesselChanged)
{
_activeVessel.ActionGroups.SetGroup(KSPActionGroup.Custom02, _vControls.ControlGroup[2]);
_vControlsOld.ControlGroup[2] = _vControls.ControlGroup[2];
}
if (_vControls.ControlGroup[3] != _vControlsOld.ControlGroup[3] || vesselChanged)
{
_activeVessel.ActionGroups.SetGroup(KSPActionGroup.Custom03, _vControls.ControlGroup[3]);
_vControlsOld.ControlGroup[3] = _vControls.ControlGroup[3];
}
if (_vControls.ControlGroup[4] != _vControlsOld.ControlGroup[4] || vesselChanged)
{
_activeVessel.ActionGroups.SetGroup(KSPActionGroup.Custom04, _vControls.ControlGroup[4]);
_vControlsOld.ControlGroup[4] = _vControls.ControlGroup[4];
}
if (_vControls.ControlGroup[5] != _vControlsOld.ControlGroup[5] || vesselChanged)
{
_activeVessel.ActionGroups.SetGroup(KSPActionGroup.Custom05, _vControls.ControlGroup[5]);
_vControlsOld.ControlGroup[5] = _vControls.ControlGroup[5];
}
if (_vControls.ControlGroup[6] != _vControlsOld.ControlGroup[6] || vesselChanged)
{
_activeVessel.ActionGroups.SetGroup(KSPActionGroup.Custom06, _vControls.ControlGroup[6]);
_vControlsOld.ControlGroup[6] = _vControls.ControlGroup[6];
}
if (_vControls.ControlGroup[7] != _vControlsOld.ControlGroup[7] || vesselChanged)
{
_activeVessel.ActionGroups.SetGroup(KSPActionGroup.Custom07, _vControls.ControlGroup[7]);
_vControlsOld.ControlGroup[7] = _vControls.ControlGroup[7];
}
if (_vControls.ControlGroup[8] != _vControlsOld.ControlGroup[8] || vesselChanged)
{
_activeVessel.ActionGroups.SetGroup(KSPActionGroup.Custom08, _vControls.ControlGroup[8]);
_vControlsOld.ControlGroup[8] = _vControls.ControlGroup[8];
}
if (_vControls.ControlGroup[9] != _vControlsOld.ControlGroup[9] || vesselChanged)
{
_activeVessel.ActionGroups.SetGroup(KSPActionGroup.Custom09, _vControls.ControlGroup[9]);
_vControlsOld.ControlGroup[9] = _vControls.ControlGroup[9];
}
if (_vControls.ControlGroup[10] != _vControlsOld.ControlGroup[10] || vesselChanged)
{
_activeVessel.ActionGroups.SetGroup(KSPActionGroup.Custom10, _vControls.ControlGroup[10]);
_vControlsOld.ControlGroup[10] = _vControls.ControlGroup[10];
}
//Set sas mode
if (_vControls.SASMode != _vControlsOld.SASMode || vesselChanged)
{
if (_vControls.SASMode != 0 && _vControls.SASMode < 11)
{
if (!_activeVessel.Autopilot.CanSetMode((VesselAutopilot.AutopilotMode)(_vControls.SASMode - 1)))
{
ScreenMessages.PostScreenMessage("[KSPEthernetIO]: SAS mode " + _vControls.SASMode.ToString() + " not avalible");
}
else
{
_activeVessel.Autopilot.SetMode((VesselAutopilot.AutopilotMode)_vControls.SASMode - 1);
}
}
_vControlsOld.SASMode = _vControls.SASMode;
}
//set navball mode
if (_vControls.SpeedMode != _vControlsOld.SpeedMode || vesselChanged)
{
if (!((_vControls.SpeedMode == 0) || ((_vControls.SpeedMode == 3) && !TargetExists())))
{
FlightGlobals.SetSpeedMode((FlightGlobals.SpeedDisplayModes)(_vControls.SpeedMode - 1));
}
_vControlsOld.SpeedMode = _vControls.SpeedMode;
}
if (Math.Abs(_vControls.Pitch) > Settings.SASTol ||
Math.Abs(_vControls.Roll) > Settings.SASTol ||
Math.Abs(_vControls.Yaw) > Settings.SASTol)
{
if ((_activeVessel.ActionGroups[KSPActionGroup.SAS]) && (_wasSASOn == false))
{
_wasSASOn = true;
_activeVessel.ActionGroups.SetGroup(KSPActionGroup.SAS, false);
}
}
else
{
if (_wasSASOn == true)
{
_wasSASOn = false;
_activeVessel.ActionGroups.SetGroup(KSPActionGroup.SAS, true);
}
}
if (_vControlsOld.UiMode != _vControls.UiMode || vesselChanged)
{
if (FlightUIModeController.Instance != null)
{
switch (_vControls.UiMode)
{
case 0:
FlightUIModeController.Instance.SetMode(FlightUIMode.STAGING);
break;
case 1:
FlightUIModeController.Instance.SetMode(FlightUIMode.DOCKING);
break;
case 2:
FlightUIModeController.Instance.SetMode(FlightUIMode.MAPMODE);
break;
default:
break;
}
_vControlsOld.UiMode = _vControls.UiMode;
}
}
if (_vControlsOld.CameraMode != _vControls.CameraMode || vesselChanged)
{
if (FlightCamera.fetch != null)
{
switch (_vControls.CameraMode)
{
case 0:
FlightCamera.fetch.setMode(FlightCamera.Modes.AUTO);
break;
case 1:
FlightCamera.fetch.setMode(FlightCamera.Modes.FREE);
break;
case 2:
FlightCamera.fetch.setMode(FlightCamera.Modes.ORBITAL);
break;
case 3:
FlightCamera.fetch.setMode(FlightCamera.Modes.CHASE);
break;
case 4:
FlightCamera.fetch.setMode(FlightCamera.Modes.LOCKED);
break;
default:
break;
}
_vControlsOld.CameraMode = _vControls.CameraMode;
}
}
if (_vControlsOld.OpenMenu != _vControls.OpenMenu || vesselChanged)
{
if (_vControls.OpenMenu)
{
PauseMenu.Display();
}
else
{
PauseMenu.Close();
}
_vControlsOld.OpenMenu = _vControls.OpenMenu;
}
if (_vControlsOld.OpenMap != _vControls.OpenMap || vesselChanged)
{
if (_vControls.OpenMap)
{
MapView.EnterMapView();
}
else
{
MapView.ExitMapView();
}
_vControlsOld.OpenMap = _vControls.OpenMap;
}
}
}
