/// <summary>
/// Try to get contract lock
/// </summary>
public void LockReleased(LockDefinition lockDefinition)
{
if (lockDefinition.Type == LockType.Contract)
{
System.TryGetContractLock();
}
}
/// <summary>
/// Try to get asteroid lock
/// </summary>
public void LockReleased(LockDefinition lockDefinition)
{
if (lockDefinition.Type == LockType.Asteroid)
{
System.TryGetAsteroidLock();
}
}
public void OnLockRelease(LockDefinition lockdefinition)
{
if (KSCVesselMarkers.fetch)
{
KSCVesselMarkers.fetch.RefreshMarkers();
}
}
public static bool AcquireLock(LockDefinition lockDef, bool force, out bool repeatedAcquire)
{
repeatedAcquire = false;
//Player tried to acquire a lock that he already owns
if (LockQuery.LockBelongsToPlayer(lockDef.Type, lockDef.VesselId, lockDef.PlayerName))
{
repeatedAcquire = true;
return(true);
}
if (force || !LockQuery.LockExists(lockDef))
{
if (GeneralSettings.SettingsStore.DropControlOnVesselSwitching && lockDef.Type == LockType.Control)
{
//If he acquired a control lock he probably switched vessels or smth like that and he can only have 1 control lock.
//So remove the other control locks just for safety...
var controlLocks = LockQuery.GetAllPlayerLocks(lockDef.PlayerName).Where(l => l.Type == LockType.Control);
foreach (var control in controlLocks)
{
ReleaseLock(control);
}
}
LockStore.AddOrUpdateLock(lockDef);
return(true);
}
return(false);
}
/// <summary>
/// If we acquire the control of a ship set it's orbit color
/// </summary>
public void OnLockAcquire(LockDefinition lockDefinition)
{
if (System.Enabled && lockDefinition.Type == LockType.Control)
{
UpdateVesselColorsFromLockVesselId(lockDefinition.VesselId);
}
}
public void LockAcquire(LockDefinition lockDef)
{
if (lockDef.Type == LockType.Control && lockDef.PlayerName == SettingsSystem.CurrentSettings.PlayerName)
{
SubscribeToFieldChanges(FlightGlobals.ActiveVessel);
}
}
/// <summary>
/// If we release the control of a ship et it's orbit color back to normal
/// </summary>
public void OnLockRelease(LockDefinition lockDefinition)
{
if (lockDefinition.Type == LockType.Control)
{
UpdateVesselColorsFromLockVesselId(lockDefinition.VesselId);
}
}
/// <summary>
/// If we get the contract lock then generate contracts
/// </summary>
public void LockAcquire(LockDefinition lockDefinition)
{
if (lockDefinition.Type == LockType.Contract && lockDefinition.PlayerName == SettingsSystem.CurrentSettings.PlayerName)
{
ContractSystem.generateContractIterations = ShareContractsSystem.Singleton.DefaultContractGenerateIterations;
}
}
public static bool AcquireLock(LockDefinition lockDef, bool force, out bool repeatedAcquire)
{
repeatedAcquire = false;
//Player tried to acquire a lock that they already own
if (LockQuery.LockBelongsToPlayer(lockDef.Type, lockDef.VesselId, lockDef.KerbalName, lockDef.PlayerName))
{
repeatedAcquire = true;
return(true);
}
if (force || !LockQuery.LockExists(lockDef))
{
if (lockDef.Type == LockType.Control)
{
//If they acquired a control lock they probably switched vessels or something like that and they can only have one control lock.
//So remove the other control locks just for safety...
var controlLocks = LockQuery.GetAllPlayerLocks(lockDef.PlayerName).Where(l => l.Type == LockType.Control);
foreach (var control in controlLocks)
{
ReleaseLock(control);
}
}
LockStore.AddOrUpdateLock(lockDef);
return(true);
}
return(false);
}
/// <summary>
/// Aquire the specified lock by sending a message to the server.
/// </summary>
/// <param name="lockDefinition">The definition of the lock to acquire</param>
/// <param name="force">Force the aquire. Usually false unless in dockings.</param>
public void AcquireLock(LockDefinition lockDefinition, bool force = false)
{
MessageSender.SendMessage(new LockAcquireMsgData
{
Lock = lockDefinition,
Force = force
});
}
private static LockDefinition GetLockDefinitionFromBytes(Stream messageData)
{
var lockDefinition = new LockDefinition();
PrivDeserialize(messageData, lockDefinition);
return(lockDefinition);
}
/// <summary>
/// Aquire the specified lock by sending a message to the server.
/// </summary>
/// <param name="lockDefinition">The definition of the lock to acquire</param>
/// <param name="force">Force the aquire. Usually false unless in dockings.</param>
private void AcquireLock(LockDefinition lockDefinition, bool force = false)
{
var msgData = NetworkMain.CliMsgFactory.CreateNewMessageData <LockAcquireMsgData>();
msgData.Lock = lockDefinition;
msgData.Force = force;
MessageSender.SendMessage(msgData);
}
//Lock types
//control-vessel-(vesselid) - Replaces the old "inUse" messages, the active pilot will have the control-vessel lock.
//update-vessel-(vesselid) - Replaces the "only the closest player can update a vessel" code,
//Now you acquire locks to update crafts around you.
//asteroid - Held by the player that can spawn asteroids into the game.
public static bool AcquireLock(LockDefinition lockDef, bool force)
{
if (force || !LockQuery.LockExists(lockDef))
{
LockStore.AddOrUpdateLock(lockDef);
return(true);
}
return(false);
}
public static bool ReleaseLock(LockDefinition lockDef)
{
if (LockQuery.LockExists(lockDef) && LockQuery.GetLock(lockDef.Type, lockDef.PlayerName, lockDef.VesselId)
.PlayerName == lockDef.PlayerName)
{
LockStore.RemoveLock(lockDef);
return(true);
}
return(false);
}
public static bool ReleaseLock(LockDefinition lockDef)
{
if (LockQuery.LockBelongsToPlayer(lockDef.Type, lockDef.VesselId, lockDef.KerbalName, lockDef.PlayerName))
{
LockStore.RemoveLock(lockDef);
return(true);
}
return(false);
}
/// <summary>
/// Release the specified lock by sending a message to the server.
/// </summary>
/// <param name="lockDefinition">The definition of the lock to release</param>
private void ReleaseLock(LockDefinition lockDefinition)
{
var msgData = NetworkMain.CliMsgFactory.CreateNewMessageData <LockReleaseMsgData>();
msgData.Lock.CopyFrom(lockDefinition);
LockStore.RemoveLock(lockDefinition);
LockEvent.onLockRelease.Fire(lockDefinition);
MessageSender.SendMessage(msgData);
}
private static LockDefinition[] GetLockDefinitionArrayFromBytes(Stream messageData)
{
var numberOfElements = GetIntFromBytes(messageData);
var outputData = new LockDefinition[numberOfElements];
for (var element = 0; element < numberOfElements; element++)
{
outputData[element] = GetLockDefinitionFromBytes(messageData);
}
return(outputData);
}
/// <summary>
/// Handles the vessel immortal state when someone gets an update or control lock
/// </summary>
public void OnLockAcquire(LockDefinition lockDefinition)
{
if (lockDefinition.Type < LockType.Update)
{
return;
}
var vessel = FlightGlobals.fetch.LmpFindVessel(lockDefinition.VesselId);
System.SetImmortalStateBasedOnLock(vessel);
}
/// <summary>
/// Whenever a release/acquire lock fails, call this method to relay the correct lock definition to the player
/// </summary>
private static void SendStoredLockData(ClientStructure client, LockDefinition lockDefinition)
{
var storedLockDef = LockSystem.LockQuery.GetLock(lockDefinition.Type, lockDefinition.PlayerName, lockDefinition.VesselId, lockDefinition.KerbalName);
if (storedLockDef != null)
{
var msgData = ServerContext.ServerMessageFactory.CreateNewMessageData <LockAcquireMsgData>();
msgData.Lock = storedLockDef;
MessageQueuer.SendToClient <LockSrvMsg>(client, msgData);
}
}
/// <summary>
/// Handles the vessel immortal state when someone gets a lock
/// </summary>
public void OnLockAcquire(LockDefinition lockDefinition)
{
if (lockDefinition.Type < LockType.Update)
{
return;
}
var vessel = FlightGlobals.FindVessel(lockDefinition.VesselId);
System.SetVesselImmortalState(vessel, lockDefinition.PlayerName != SettingsSystem.CurrentSettings.PlayerName);
}
/// <summary>
/// Handles the vessel immortal state when YOU release an update or control lock
/// </summary>
public void OnLockRelease(LockDefinition lockDefinition)
{
if (lockDefinition.Type != LockType.Control && lockDefinition.Type != LockType.Update && lockDefinition.Type != LockType.UnloadedUpdate)
{
return;
}
var vessel = FlightGlobals.FindVessel(lockDefinition.VesselId);
System.SetImmortalStateBasedOnLock(vessel);
}
/// <summary>
/// Acquire the specified lock by sending a message to the server.
/// </summary>
/// <param name="lockDefinition">The definition of the lock to acquire</param>
/// <param name="force">Force the acquire. Usually false unless in dockings.</param>
/// <param name="immediate">Acquire the lock immediately without waiting confirmation from the server</param>
private void AcquireLock(LockDefinition lockDefinition, bool force = false, bool immediate = false)
{
var msgData = NetworkMain.CliMsgFactory.CreateNewMessageData <LockAcquireMsgData>();
msgData.Lock = lockDefinition;
msgData.Force = force;
MessageSender.SendMessage(msgData);
if (force && immediate)
{
LockStore.AddOrUpdateLock(lockDefinition);
}
}
/// <summary>
/// This event is triggered when some player acquired a lock
/// It then calls all the methods specified in the delegate
/// </summary>
public void FireAcquireEvent(LockDefinition lockDefinition, bool lockResult)
{
foreach (var methodObject in LockAcquireEvents)
{
try
{
methodObject(lockDefinition, lockResult);
}
catch (Exception e)
{
LunaLog.LogError($"[LMP]: Error thrown in acquire lock event, exception {e}");
}
}
}
/// <summary>
/// This event is triggered when some player released a lock
/// It then calls all the methods specified in the delegate
/// </summary>
public void FireReleaseEvent(LockDefinition lockDefinition)
{
foreach (var methodObject in LockReleaseEvents)
{
try
{
methodObject(lockDefinition);
}
catch (Exception e)
{
LunaLog.LogError($"[LMP]: Error thrown in release lock event, exception {e}");
}
}
}
/// <summary>
/// Handles the vessel immortal state when YOU release an update or control lock
/// </summary>
public void OnLockRelease(LockDefinition lockDefinition)
{
if (lockDefinition.Type < LockType.Update)
{
return;
}
if (lockDefinition.PlayerName != SettingsSystem.CurrentSettings.PlayerName)
{
return;
}
var vessel = FlightGlobals.fetch.LmpFindVessel(lockDefinition.VesselId);
System.SetImmortalStateBasedOnLock(vessel);
}
/// <summary>
/// If we get the Update lock, force the getting of the unloaded update lock.
/// If we get a control lock, force getting the update and unloaded update
/// </summary>
public void LockAcquire(LockDefinition lockDefinition)
{
switch (lockDefinition.Type)
{
case LockType.Control:
KscSceneSystem.Singleton.RefreshTrackingStationVessels();
if (lockDefinition.PlayerName == SettingsSystem.CurrentSettings.PlayerName)
{
VesselLockSystem.Singleton.StopSpectating();
LockSystem.Singleton.AcquireUpdateLock(lockDefinition.VesselId, true);
LockSystem.Singleton.AcquireUnloadedUpdateLock(lockDefinition.VesselId, true);
LockSystem.Singleton.AcquireKerbalLock(lockDefinition.VesselId, true);
//As we got the lock of that vessel, remove its FS and position updates
VesselCommon.RemoveVesselFromSystems(lockDefinition.VesselId);
}
else if (FlightGlobals.ActiveVessel && FlightGlobals.ActiveVessel.id == lockDefinition.VesselId)
{
System.StartSpectating(lockDefinition.VesselId);
}
break;
case LockType.Update:
if (lockDefinition.PlayerName != SettingsSystem.CurrentSettings.PlayerName)
{
return;
}
LockSystem.Singleton.AcquireUnloadedUpdateLock(lockDefinition.VesselId, true);
LockSystem.Singleton.AcquireKerbalLock(lockDefinition.VesselId, true);
//As we got the lock of that vessel, remove its FS and position updates
VesselCommon.RemoveVesselFromSystems(lockDefinition.VesselId);
break;
case LockType.UnloadedUpdate:
if (lockDefinition.PlayerName != SettingsSystem.CurrentSettings.PlayerName)
{
return;
}
//As we got the lock of that vessel, remove its FS and position updates
VesselCommon.RemoveVesselFromSystems(lockDefinition.VesselId);
break;
}
}
/// <summary>
/// Whenever we acquire a UnloadedUpdate/Update/Control lock of a vessel, remove it from the dictionaries
/// </summary>
public void OnLockAcquire(LockDefinition data)
{
if (data.PlayerName != SettingsSystem.CurrentSettings.PlayerName)
{
return;
}
switch (data.Type)
{
case LockType.UnloadedUpdate:
case LockType.Update:
case LockType.Control:
System.RemoveVessel(data.VesselId);
break;
}
}
public static void SendLockAquireMessage(LockDefinition lockDefinition, bool force)
{
var lockResult = LockSystem.AcquireLock(lockDefinition, force);
var newMessageData = new LockAcquireMsgData
{
Lock = lockDefinition,
LockResult = lockResult,
Force = force
};
MessageQueuer.SendToAllClients <LockSrvMsg>(newMessageData);
LunaLog.Debug(lockResult
? $"{lockDefinition.PlayerName} acquired lock {lockDefinition}"
: $"{lockDefinition.PlayerName} failed to acquire lock {lockDefinition}");
}
public static bool AcquireLock(LockDefinition lockDef, bool force, out bool repeatedAcquire)
{
repeatedAcquire = false;
//Player tried to acquire a lock that he already owns
if (LockQuery.LockBelongsToPlayer(lockDef.Type, lockDef.VesselId, lockDef.PlayerName))
{
repeatedAcquire = true;
return(true);
}
if (force || !LockQuery.LockExists(lockDef))
{
LockStore.AddOrUpdateLock(lockDef);
return(true);
}
return(false);
}
public static void ReleaseAndSendLockReleaseMessage(ClientStructure client, LockDefinition lockDefinition)
{
var lockReleaseResult = LockSystem.ReleaseLock(lockDefinition);
if (lockReleaseResult)
{
var msgData = ServerContext.ServerMessageFactory.CreateNewMessageData <LockReleaseMsgData>();
msgData.Lock = lockDefinition;
msgData.LockResult = true;
MessageQueuer.RelayMessage <LockSrvMsg>(client, msgData);
LunaLog.Debug($"{lockDefinition.PlayerName} released lock {lockDefinition}");
}
else
{
SendStoredLockData(client, lockDefinition);
LunaLog.Debug($"{lockDefinition.PlayerName} failed to release lock {lockDefinition}");
}
}
