private void UpdateAttachControl()
{
if (KASAddonPointer.isRunning)
{
if (
Input.GetKeyDown(KeyCode.Escape) ||
Input.GetKeyDown(KeyCode.Space) ||
Input.GetKeyDown(KeyCode.Mouse1) ||
Input.GetKeyDown(KeyCode.Mouse2) ||
Input.GetKeyDown(KeyCode.Return) ||
Input.GetKeyDown(attachKey.ToLower())
)
{
KAS_Shared.DebugLog("Cancel key pressed, stop eva attach mode");
KASAddonPointer.StopPointer();
}
}
else if (Input.GetKeyDown(attachKey.ToLower()))
{
KASModuleGrab grabbedModule = KAS_Shared.GetGrabbedPartModule(FlightGlobals.ActiveVessel);
if (grabbedModule)
{
if (grabbedModule.attachOnPart || grabbedModule.attachOnEva || grabbedModule.attachOnStatic)
{
KASAddonPointer.StartPointer(grabbedModule.part, KASAddonPointer.PointerMode.MoveAndAttach, grabbedModule.attachOnPart, grabbedModule.attachOnEva, grabbedModule.attachOnStatic, grabbedModule.attachMaxDist, grabbedModule.part.transform, grabbedModule.attachSendMsgOnly);
}
}
}
}
private void StoreGrabbedPart()
{
KASModuleGrab moduleGrab = KAS_Shared.GetGrabbedPartModule(FlightGlobals.ActiveVessel);
if (!moduleGrab)
{
fxSndBipWrong.audio.Play();
ScreenMessages.PostScreenMessage("You didn't grab anything to store !", 5, ScreenMessageStyle.UPPER_CENTER);
return;
}
if (!moduleGrab.storable)
{
fxSndBipWrong.audio.Play();
ScreenMessages.PostScreenMessage("This part cannot be stored !", 5, ScreenMessageStyle.UPPER_CENTER);
return;
}
if (MaxSizeReached(moduleGrab.part.partInfo, 1))
{
fxSndBipWrong.audio.Play();
ScreenMessages.PostScreenMessage("Max size of the container reached !", 5, ScreenMessageStyle.UPPER_CENTER);
return;
}
Add(moduleGrab.part.partInfo, 1);
moduleGrab.Drop();
moduleGrab.part.Die();
fxSndStore.audio.Play();
}
public void Update()
{
if (Input.GetKey(KeyCode.LeftControl) && Input.GetKeyDown(KeyCode.K))
{
if (GuiConfigToogle)
{
Debug.Log("KASAddonDebugMenu - Closing KAS debug tools");
GuiConfigToogle = false;
}
else
{
Debug.Log("KASAddonDebugMenu - Opening KAS debug tools");
GuiConfigToogle = true;
}
}
if (GuiConfigToogle)
{
if (Input.GetKey(KeyCode.LeftControl) && Input.GetKeyDown(KeyCode.Mouse0))
{
Debug.Log("KASAddonDebugMenu - On click");
clickedPart = KAS_Shared.GetPartUnderCursor();
if (clickedPart)
{
moduleWinch = null;
moduleGrab = null;
moduleMagnet = null;
moduleSuctionCup = null;
moduleGrapple = null;
moduleTimedBomb = null;
modulePort = null;
moduleAnchor = null;
moduleStrut = null;
moduleRotor = null;
moduleWinch = clickedPart.GetComponent <KASModuleWinch>();
moduleGrab = clickedPart.GetComponent <KASModuleGrab>();
moduleMagnet = clickedPart.GetComponent <KASModuleMagnet>();
moduleSuctionCup = clickedPart.GetComponent <KASModuleSuctionCup>();
moduleGrapple = clickedPart.GetComponent <KASModuleGrapplingHook>();
moduleTimedBomb = clickedPart.GetComponent <KASModuleTimedBomb>();
modulePort = clickedPart.GetComponent <KASModulePort>();
moduleAnchor = clickedPart.GetComponent <KASModuleAnchor>();
moduleStrut = clickedPart.GetComponent <KASModuleStrut>();
moduleRotor = clickedPart.GetComponent <KASModuleRotor>();
}
}
}
if (FlightGlobals.ActiveVessel.heightFromTerrain == -1f)
{
if (FlightGlobals.ActiveVessel.Landed)
{
KAS_Shared.DebugWarning("Warning ! ActiveVessel is landed and heightFromTerrain are negative (" + FlightGlobals.ActiveVessel.heightFromTerrain + ")");
}
}
}
public void Update()
{
if (Input.GetKey(KeyCode.LeftControl) && Input.GetKeyDown(KeyCode.K))
{
if (GuiConfigToogle)
{
Debug.Log("KASAddonDebugMenu - Closing KAS debug tools");
GuiConfigToogle = false;
}
else
{
Debug.Log("KASAddonDebugMenu - Opening KAS debug tools");
GuiConfigToogle = true;
}
}
if (GuiConfigToogle)
{
if (Input.GetKey(KeyCode.LeftControl) && Input.GetKeyDown(KeyCode.Mouse0))
{
Debug.Log("KASAddonDebugMenu - On click");
clickedPart = KAS_Shared.GetPartUnderCursor();
if (clickedPart)
{
moduleWinch = null;
moduleGrab = null;
moduleMagnet = null;
moduleSuctionCup = null;
moduleGrapple = null;
moduleTimedBomb = null;
modulePort = null;
moduleAnchor = null;
moduleStrut = null;
moduleRotor = null;
moduleWinch = clickedPart.GetComponent<KASModuleWinch>();
moduleGrab = clickedPart.GetComponent<KASModuleGrab>();
moduleMagnet = clickedPart.GetComponent<KASModuleMagnet>();
moduleSuctionCup = clickedPart.GetComponent<KASModuleSuctionCup>();
moduleGrapple = clickedPart.GetComponent<KASModuleGrapplingHook>();
moduleTimedBomb = clickedPart.GetComponent<KASModuleTimedBomb>();
modulePort = clickedPart.GetComponent<KASModulePort>();
moduleAnchor = clickedPart.GetComponent<KASModuleAnchor>();
moduleStrut = clickedPart.GetComponent<KASModuleStrut>();
moduleRotor = clickedPart.GetComponent<KASModuleRotor>();
}
}
}
if (FlightGlobals.ActiveVessel.heightFromTerrain == -1f)
{
if (FlightGlobals.ActiveVessel.Landed)
{
KAS_Shared.DebugWarning("Warning ! ActiveVessel is landed and heightFromTerrain are negative (" + FlightGlobals.ActiveVessel.heightFromTerrain + ")");
}
}
}
private void Take(PartContent avPart)
{
if (waitAndGrabRunning)
{
KAS_Shared.DebugError("Take(Container) Take action is already running, please wait !");
return;
}
if (!FlightGlobals.ActiveVessel.isEVA)
{
KAS_Shared.DebugError("Take(Container) Can only grab from EVA!");
return;
}
KASModuleGrab grabbed = KAS_Shared.GetGrabbedPartModule(FlightGlobals.ActiveVessel);
if (grabbed && grabbed.part.packed)
{
KAS_Shared.DebugError("Take(Container) EVA holding a packed part!");
return;
}
if (avPart.pristine_count <= 0 && avPart.instances.Count > 0)
{
if (TakeStoredInstance(avPart.instances[0], FlightGlobals.ActiveVessel))
{
avPart.PopInstance();
RefreshTotalSize();
}
return;
}
KASModuleGrab prefabGrabModule = avPart.grabModule;
// get grabbed position and rotation
Vector3 pos = FlightGlobals.ActiveVessel.rootPart.transform.TransformPoint(prefabGrabModule.evaPartPos);
Quaternion rot = FlightGlobals.ActiveVessel.rootPart.transform.rotation * Quaternion.Euler(prefabGrabModule.evaPartDir);
//Move away the part at creation
pos += new Vector3(0f, 0f, 100);
//Part newPart = KAS_Shared.CreatePart(avPart, pos, rot, this.part);
Part newPart = KAS_Shared.CreatePart(avPart.name, pos, rot, this.part);
if (!newPart)
{
KAS_Shared.DebugError("Take(Container) failed to create the part !");
return;
}
KASModuleGrab moduleGrab = newPart.GetComponent <KASModuleGrab>();
if (!moduleGrab)
{
KAS_Shared.DebugError("Take(Container) Cannot grab the part taken, no grab module found !");
return;
}
avPart.pristine_count--;
RefreshTotalSize();
StartCoroutine(WaitAndGrab(moduleGrab, FlightGlobals.ActiveVessel));
}
private PartContent(AvailablePart avPart, KASModuleGrab grab)
{
part = avPart;
grabModule = grab;
pristine_mass = part.partPrefab.mass;
foreach (var res in part.partPrefab.GetComponents<PartResource>())
{
pristine_mass += (float)(res.amount * res.info.density);
}
}
private PartContent(AvailablePart avPart, KASModuleGrab grab)
{
part = avPart;
grabModule = grab;
pristine_mass = part.partPrefab.mass;
foreach (var res in part.partPrefab.GetComponents <PartResource>())
{
pristine_mass += (float)(res.amount * res.info.density);
}
}
private bool MaxSizeReached(AvailablePart avPart, int qty)
{
KASModuleGrab moduleGrab = avPart.partPrefab.GetComponent <KASModuleGrab>();
if (moduleGrab)
{
if (totalSize + (moduleGrab.storedSize * qty) > maxSize)
{
return(true);
}
}
return(false);
}
private PartContent(AvailablePart avPart, KASModuleGrab grab)
{
part = avPart;
grabModule = grab;
pristine_mass = part.partPrefab.mass;
pristine_cost = part.cost + part.partPrefab.GetModuleCosts(0);
foreach (var res in part.partPrefab.GetComponents <PartResource>())
{
pristine_mass += (float)(res.amount * res.info.density);
pristine_cost += (float)(res.amount - res.maxAmount) * res.info.unitCost;
}
}
private void RefreshTotalSize()
{
totalSize = 0;
this.part.mass = orgMass;
foreach (KeyValuePair <AvailablePart, int> contentPart in contents)
{
KASModuleGrab grabModule = contentPart.Key.partPrefab.GetComponent <KASModuleGrab>();
if (grabModule)
{
totalSize += contentPart.Value * grabModule.storedSize;
this.part.mass += contentPart.Value * contentPart.Key.partPrefab.mass;
}
}
}
private float GetPartSize(AvailablePart avPart)
{
KASModuleGrab grabModule = avPart.partPrefab.GetComponent <KASModuleGrab>();
if (grabModule)
{
return(grabModule.storedSize);
}
else
{
KAS_Shared.DebugError("Cannot retrieve part size, grab module not found !");
return(0);
}
}
private bool TakeStoredInstance(ConfigNode node, Vessel vessel)
{
Part newPart = KAS_Shared.LoadPartSnapshot(vessel, node, Vector3.zero, Quaternion.identity);
KASModuleGrab moduleGrab = newPart.GetComponent <KASModuleGrab>();
if (!moduleGrab || !moduleGrab.GrabPending())
{
KAS_Shared.DebugError("Take(Container) Cannot grab the part taken, no grab module found !");
newPart.Die();
return(false);
}
return(true);
}
public void Grab(Vessel kerbalEvaVessel)
{
//Validation
KASModuleGrab grabbedPartModule = KAS_Shared.GetGrabbedPartModule(kerbalEvaVessel);
if (grabbedPartModule)
{
if (grabbedPartModule.part.packed)
{
KAS_Shared.DebugWarning("Grab - cannot drop the current grabbed part ! (packed)");
return;
}
}
//Start grab
StartCoroutine(GrabCoroutine(kerbalEvaVessel));
}
private Dictionary <AvailablePart, int> GetAvailableContents()
{
Dictionary <AvailablePart, int> edct = new Dictionary <AvailablePart, int>();
foreach (AvailablePart avPart in PartLoader.LoadedPartsList)
{
KASModuleGrab grabModule = avPart.partPrefab.GetComponent <KASModuleGrab>();
if (grabModule)
{
if (grabModule.storable)
{
edct.Add(avPart, 0);
}
}
}
return(edct);
}
private IEnumerator WaitAndAttach(Part partToAttach, Vector3 position, Quaternion rotation, Part toPart = null)
{
while (!partToAttach.rigidbody)
{
KAS_Shared.DebugLog("WaitAndAttach(Pointer) - Waiting rigidbody to initialize...");
yield return(new WaitForFixedUpdate());
}
KASModuleGrab moduleGrab = partToAttach.GetComponent <KASModuleGrab>();
if (toPart)
{
KAS_Shared.DebugLog("WaitAndAttach(Pointer) - Rigidbody initialized, setting velocity...");
partToAttach.rigidbody.velocity = toPart.rigidbody.velocity;
partToAttach.rigidbody.angularVelocity = toPart.rigidbody.angularVelocity;
KAS_Shared.DebugLog("WaitAndAttach(Pointer) - Waiting velocity to apply by waiting 0.1 seconds...");
yield return(new WaitForSeconds(0.1f));
partToAttach.transform.position = position;
partToAttach.transform.rotation = rotation;
partToAttach.Couple(toPart);
if (moduleGrab)
{
moduleGrab.fxSndAttachPart.audio.Play();
}
else
{
KAS_Shared.DebugWarning("UpdatePointer(Pointer) No grab module found, cannot fire sound");
}
}
else
{
partToAttach.transform.position = position;
partToAttach.transform.rotation = rotation;
if (moduleGrab)
{
moduleGrab.AttachStatic();
moduleGrab.fxSndAttachStatic.audio.Play();
}
else
{
KAS_Shared.DebugWarning("UpdatePointer(Pointer) No grab module found, part cannot be attached on static");
}
}
KAS_Shared.ResetCollisionEnhancer(partToAttach);
}
private void StoreGrabbedPart()
{
KASModuleGrab moduleGrab = KAS_Shared.GetGrabbedPartModule(FlightGlobals.ActiveVessel);
if (!moduleGrab || moduleGrab.part.packed)
{
fxSndBipWrong.audio.Play();
ScreenMessages.PostScreenMessage("You didn't grab anything to store !", 5, ScreenMessageStyle.UPPER_CENTER);
return;
}
if (!moduleGrab.storable)
{
fxSndBipWrong.audio.Play();
ScreenMessages.PostScreenMessage("This part cannot be stored !", 5, ScreenMessageStyle.UPPER_CENTER);
return;
}
if (MaxSizeReached(moduleGrab, 1))
{
fxSndBipWrong.audio.Play();
ScreenMessages.PostScreenMessage("Max size of the container reached !", 5, ScreenMessageStyle.UPPER_CENTER);
return;
}
PartContent info = PartContent.Get(contents, moduleGrab.part.partInfo.name);
if (info == null)
{
fxSndBipWrong.audio.Play();
ScreenMessages.PostScreenMessage("Could not store part!", 5, ScreenMessageStyle.UPPER_CENTER);
return;
}
if (moduleGrab.stateless)
{
info.pristine_count++;
}
else
{
info.Load(KAS_Shared.SavePartSnapshot(moduleGrab.part));
}
RefreshTotalSize();
moduleGrab.Drop(true);
moduleGrab.part.Die();
fxSndStore.audio.Play();
}
private void Move(AvailablePart aPart, int qty, KASModuleContainer destContainer)
{
KASModuleGrab moduleGrab = aPart.partPrefab.GetComponent <KASModuleGrab>();
if (!moduleGrab)
{
fxSndBipWrong.audio.Play();
KAS_Shared.DebugError("Cannot grab the part taken, no grab module found !");
return;
}
if (destContainer.MaxSizeReached(aPart, 1))
{
fxSndBipWrong.audio.Play();
ScreenMessages.PostScreenMessage("Max size of the destination container reached !", 5, ScreenMessageStyle.UPPER_CENTER);
return;
}
Remove(aPart, qty);
destContainer.Add(aPart, qty);
}
private Dictionary <AvailablePart, int> GetAvailableContents()
{
Dictionary <AvailablePart, int> edct = new Dictionary <AvailablePart, int>();
foreach (AvailablePart avPart in PartLoader.LoadedPartsList)
{
if (!ResearchAndDevelopment.PartModelPurchased(avPart))
{
continue;
}
KASModuleGrab grabModule = avPart.partPrefab.GetComponent <KASModuleGrab>();
if (grabModule)
{
if (grabModule.storable)
{
edct.Add(avPart, 0);
}
}
}
return(edct);
}
private void Take(AvailablePart avPart)
{
if (waitAndGrabRunning)
{
KAS_Shared.DebugError("Take(Container) Take action is already running, please wait !");
return;
}
KASModuleGrab prefabGrabModule = avPart.partPrefab.GetComponent <KASModuleGrab>();
if (!prefabGrabModule)
{
KAS_Shared.DebugError("Take(Container) Can't find the prefab grab module !");
return;
}
// get grabbed position and rotation
Vector3 pos = FlightGlobals.ActiveVessel.rootPart.transform.TransformPoint(prefabGrabModule.evaPartPos);
Quaternion rot = FlightGlobals.ActiveVessel.rootPart.transform.rotation * Quaternion.Euler(prefabGrabModule.evaPartDir);
//Move away the part at creation
pos += new Vector3(0f, 0f, 100);
//Part newPart = KAS_Shared.CreatePart(avPart, pos, rot, this.part);
Part newPart = KAS_Shared.CreatePart(avPart.name, pos, rot, this.part);
if (!newPart)
{
KAS_Shared.DebugError("Take(Container) failed to create the part !");
return;
}
KASModuleGrab moduleGrab = newPart.GetComponent <KASModuleGrab>();
if (!moduleGrab)
{
KAS_Shared.DebugError("Take(Container) Cannot grab the part taken, no grab module found !");
return;
}
Remove(avPart, 1);
StartCoroutine(WaitAndGrab(moduleGrab, FlightGlobals.ActiveVessel));
}
private IEnumerator WaitAndGrab(KASModuleGrab moduleGrab, Vessel vess)
{
waitAndGrabRunning = true;
while (!moduleGrab.part.rigidbody)
{
KAS_Shared.DebugLog("WaitAndGrab(Container) - Waiting rigidbody to initialize...");
yield return(new WaitForFixedUpdate());
}
KAS_Shared.DebugLog("WaitAndGrab(Container) - Rigidbody initialized, setting velocity...");
moduleGrab.part.rigidbody.velocity = vess.rootPart.rigidbody.velocity;
moduleGrab.part.rigidbody.angularVelocity = vess.rootPart.rigidbody.angularVelocity;
KAS_Shared.DebugLog("WaitAndGrab(Container) - Waiting velocity to apply by waiting 0.1 seconds...");
yield return(new WaitForSeconds(0.1f));
KAS_Shared.DebugLog("WaitAndGrab(Container) - Grab part...");
if (!moduleGrab.evaHolderPart)
{
moduleGrab.Grab(vess);
}
KAS_Shared.DebugLog("WaitAndGrab(Container) - End of coroutine...");
waitAndGrabRunning = false;
}
public static PartContent Get(Dictionary <string, PartContent> table, string name, bool create = true)
{
PartContent item;
if (!table.TryGetValue(name, out item) && create)
{
AvailablePart avPart = PartLoader.getPartInfoByName(name);
if (avPart != null)
{
KASModuleGrab grab = avPart.partPrefab.GetComponent <KASModuleGrab>();
if (grab != null && grab.storable)
{
item = new PartContent(avPart, grab);
table.Add(name, item);
}
}
}
return(item);
}
public void ContextMenuStore()
{
KASModuleGrab moduleEvaGrab = KAS_Shared.GetGrabbedPartModule(FlightGlobals.ActiveVessel);
if (!moduleEvaGrab || moduleEvaGrab.part.packed)
{
ScreenMessages.PostScreenMessage("You need to grab a part before", 2, ScreenMessageStyle.UPPER_CENTER);
KAS_Shared.DebugWarning("ContextMenuStore - GetGrabbedPartModule return null !");
return;
}
// Select the nearest compatible bay
float shorterDist = Mathf.Infinity;
AttachNode nearestBayNode = null;
foreach (KeyValuePair <AttachNode, List <string> > bay in bays)
{
if (bay.Value != null)
{
if (!bay.Value.Contains(moduleEvaGrab.bayType))
{
KAS_Shared.DebugWarning("ContextMenuStore - Part type : " + moduleEvaGrab.bayType + " is not allowed | Attach node : " + bay.Key.id);
foreach (string type in bay.Value)
{
KAS_Shared.DebugWarning("ContextMenuStore - Allowed type : " + type);
}
continue;
}
}
if (bay.Key.attachedPart)
{
KAS_Shared.DebugWarning("ContextMenuStore - This node are used");
continue;
}
float distToBay = Vector3.Distance(FlightGlobals.ActiveVessel.transform.position, bay.Key.nodeTransform.position);
if (distToBay <= shorterDist)
{
shorterDist = distToBay;
nearestBayNode = bay.Key;
}
}
if (nearestBayNode == null)
{
ScreenMessages.PostScreenMessage("Part is not compatible or there is no free space", 2, ScreenMessageStyle.UPPER_CENTER);
KAS_Shared.DebugWarning("ContextMenuStore - Part is not compatible or there is no free space");
return;
}
AttachNode grabbedPartAn = moduleEvaGrab.part.findAttachNode(moduleEvaGrab.bayNode);
if (grabbedPartAn == null)
{
KAS_Shared.DebugError("ContextMenuStore - Grabbed part bay node not found !");
return;
}
KAS_Shared.DebugLog("ContextMenuStore - Drop part...");
moduleEvaGrab.Drop();
KAS_Shared.DebugLog("ContextMenuStore - Add node transform if not exist...");
KAS_Shared.AddNodeTransform(moduleEvaGrab.part, grabbedPartAn);
KAS_Shared.DebugLog("ContextMenuStore - Move part...");
KAS_Shared.MoveAlign(moduleEvaGrab.part.transform, grabbedPartAn.nodeTransform, nearestBayNode.nodeTransform);
moduleEvaGrab.part.transform.rotation *= Quaternion.Euler(moduleEvaGrab.bayRot);
//Couple part with bay
KAS_Shared.DebugLog("ContextMenuStore - Couple part with bay...");
moduleEvaGrab.part.Couple(this.part);
nearestBayNode.attachedPart = moduleEvaGrab.part;
fxSndStore.audio.Play();
moduleEvaGrab.part.SendMessage("OnBayStore", SendMessageOptions.DontRequireReceiver);
}
private IEnumerator GrabCoroutine(Vessel kerbalEvaVessel)
{
KAS_Shared.DebugLog("Grab - Grabbing part :" + this.part.partInfo.name);
//Send message to other modules
base.SendMessage("OnPartGrab", kerbalEvaVessel, SendMessageOptions.DontRequireReceiver);
//Set attach node on EVA
SetEvaNode(kerbalEvaVessel);
//Drop grabbed eva part if any
KASModuleGrab grabbbedPartModule = KAS_Shared.GetGrabbedPartModule(kerbalEvaVessel);
if (grabbbedPartModule)
{
grabbbedPartModule.Drop();
}
//Unplug winch connected head if any
KASModuleWinch moduleWinch = KAS_Shared.GetConnectedWinch(this.part);
if (moduleWinch)
{
moduleWinch.UnplugHead(false);
}
//Disable all colliders on part
DisableColliders();
//Detach if needed
Detach();
//Decouple part (if not already done, in case of loading after a save with the part grabbed)
if (this.part.vessel != kerbalEvaVessel)
{
KAS_Shared.DecoupleFromAll(this.part);
}
//Wait decouple action (x64 fix)
yield return(new WaitForFixedUpdate());
//Move part to eva node
KAS_Shared.MoveAlign(this.part.transform, partNode.nodeTransform, evaNodeTransform);
//Grab winch connected head if any
if (moduleWinch)
{
KASModulePort modulePort = this.part.GetComponent <KASModulePort>();
moduleWinch.GrabHead(kerbalEvaVessel, modulePort);
}
//Couple part to eva (if not already done, in case of loading after a save with the part grabbed)
if (this.part.vessel != kerbalEvaVessel)
{
this.part.Couple(kerbalEvaVessel.rootPart);
}
//Destroy joint to avoid buggy eva move
if (this.part.attachJoint)
{
this.part.attachJoint.DestroyJoint();
}
//Set part to physic join or kinematic with parent
if (physicJoint)
{
if (evaJoint)
{
Destroy(evaJoint);
}
evaJoint = this.part.gameObject.AddComponent <FixedJoint>();
evaJoint.connectedBody = evaCollider.attachedRigidbody;
evaJoint.breakForce = 5;
evaJoint.breakTorque = 5;
KAS_Shared.ResetCollisionEnhancer(this.part);
}
else
{
syncGrab = true;
KAS_Shared.ResetCollisionEnhancer(this.part, false);
}
//Add grabbed part mass to eva
if (addPartMass && !physicJoint)
{
orgKerbalMass = kerbalEvaVessel.rootPart.mass;
kerbalEvaVessel.rootPart.mass += this.part.mass;
}
//Add event
GameEvents.onCrewBoardVessel.Add(new EventData <GameEvents.FromToAction <Part, Part> > .OnEvent(this.OnCrewBoardVessel));
//Set variables
evaHolderVesselName = kerbalEvaVessel.vesselName;
evaHolderPart = kerbalEvaVessel.rootPart;
grabbed = true;
grab_pending = false;
//Refresh Context Menu
RefreshContextMenu();
//Play grab sound
fxSndGrab.audio.Play();
//Send message to other modules
base.SendMessage("OnPartGrabbed", kerbalEvaVessel, SendMessageOptions.DontRequireReceiver);
}
private bool MaxSizeReached(KASModuleGrab grab, int qty)
{
return (totalSize + (grab.storedSize * qty) > maxSize);
}
private void AddGrabModule(ConfigNode node)
{
foreach (ConfigNode grabNode in node.GetNodes("GRAB"))
{
// Check if the node has value
if (!grabNode.HasValue("stockPartName"))
{
KAS_Shared.DebugWarning("AddGrabModule(AddModule) Missing stockPartName node !");
continue;
}
// Add and Retrieve the module
string partName = grabNode.GetValue("stockPartName").Replace('_', '.');
AvailablePart aPart = PartLoader.getPartInfoByName(partName);
if (aPart == null)
{
KAS_Shared.DebugError("AddModule(AddModule) - " + partName + " not found in partloader");
continue;
}
// get or add grab module
KASModuleGrab grabModule = aPart.partPrefab.GetComponent <KASModuleGrab>();
if (grabModule)
{
KAS_Shared.DebugWarning("AddModule(AddModule) - KASModuleGrab already added to " + partName);
}
else
{
grabModule = aPart.partPrefab.AddModule("KASModuleGrab") as KASModuleGrab;
if (!grabModule)
{
KAS_Shared.DebugError("AddGrabModule(AddModule) Error when adding module !");
continue;
}
}
// Configure the module
if (grabNode.HasValue("evaPartPos"))
{
grabModule.evaPartPos = KAS_Shared.ParseCfgVector3(grabNode.GetValue("evaPartPos"));
}
if (grabNode.HasValue("evaPartDir"))
{
grabModule.evaPartDir = KAS_Shared.ParseCfgVector3(grabNode.GetValue("evaPartDir"));
}
if (grabNode.HasValue("customGroundPos"))
{
grabModule.customGroundPos = bool.Parse(grabNode.GetValue("customGroundPos"));
}
if (grabNode.HasValue("dropPartPos"))
{
grabModule.dropPartPos = KAS_Shared.ParseCfgVector3(grabNode.GetValue("dropPartPos"));
}
if (grabNode.HasValue("dropPartRot"))
{
grabModule.dropPartRot = KAS_Shared.ParseCfgVector3(grabNode.GetValue("dropPartRot"));
}
if (grabNode.HasValue("physicJoint"))
{
grabModule.physicJoint = bool.Parse(grabNode.GetValue("physicJoint"));
}
if (grabNode.HasValue("addPartMass"))
{
grabModule.addPartMass = bool.Parse(grabNode.GetValue("addPartMass"));
}
if (grabNode.HasValue("storable"))
{
grabModule.storable = bool.Parse(grabNode.GetValue("storable"));
}
if (grabNode.HasValue("stateless"))
{
grabModule.stateless = bool.Parse(grabNode.GetValue("stateless"));
}
if (grabNode.HasValue("storedSize"))
{
grabModule.storedSize = int.Parse(grabNode.GetValue("storedSize"));
}
if (grabNode.HasValue("bayType"))
{
grabModule.bayType = grabNode.GetValue("bayType").ToString();
}
if (grabNode.HasValue("bayNode"))
{
grabModule.bayNode = grabNode.GetValue("bayNode").ToString();
}
if (grabNode.HasValue("bayRot"))
{
grabModule.bayRot = KAS_Shared.ParseCfgVector3(grabNode.GetValue("bayRot"));
}
if (grabNode.HasValue("grabSndPath"))
{
grabModule.grabSndPath = grabNode.GetValue("grabSndPath").ToString();
}
if (grabNode.HasValue("attachMaxDist"))
{
grabModule.attachMaxDist = float.Parse(grabNode.GetValue("attachMaxDist"));
}
if (grabNode.HasValue("attachOnPart"))
{
grabModule.attachOnPart = bool.Parse(grabNode.GetValue("attachOnPart"));
}
if (grabNode.HasValue("attachOnEva"))
{
grabModule.attachOnEva = bool.Parse(grabNode.GetValue("attachOnEva"));
}
if (grabNode.HasValue("attachOnStatic"))
{
grabModule.attachOnStatic = bool.Parse(grabNode.GetValue("attachOnStatic"));
}
if (grabNode.HasValue("attachSendMsgOnly"))
{
grabModule.attachSendMsgOnly = bool.Parse(grabNode.GetValue("attachSendMsgOnly"));
}
if (grabNode.HasValue("attachPartSndPath"))
{
grabModule.attachPartSndPath = grabNode.GetValue("attachPartSndPath").ToString();
}
if (grabNode.HasValue("attachStaticSndPath"))
{
grabModule.attachStaticSndPath = grabNode.GetValue("attachStaticSndPath").ToString();
}
if (grabNode.HasValue("detachSndPath"))
{
grabModule.detachSndPath = grabNode.GetValue("detachSndPath").ToString();
}
KAS_Shared.DebugLog("AddGrabModule(AddModule) Module successfully configured on " + partName);
}
}
private bool MaxSizeReached(KASModuleGrab grab, int qty)
{
return(totalSize + (grab.storedSize * qty) > maxSize);
}
public void UpdatePointer()
{
if (!running)
{
if (pointer)
{
UnityEngine.Object.Destroy(pointer);
}
return;
}
//Cast ray
Ray ray = FlightCamera.fetch.mainCamera.ScreenPointToRay(Input.mousePosition);
RaycastHit hit;
if (!Physics.Raycast(ray, out hit, 500, 557059))
{
if (pointer)
{
UnityEngine.Object.Destroy(pointer);
}
return;
}
//Create pointer if needed
if (!pointer)
{
GameObject modelGo = partToAttach.FindModelTransform("model").gameObject;
pointer = Mesh.Instantiate(modelGo) as GameObject;
foreach (Collider col in pointer.GetComponentsInChildren <Collider>())
{
UnityEngine.Object.Destroy(col);
}
allModelMr = new List <MeshRenderer>();
// Remove attached tube mesh renderer if any
List <MeshRenderer> tmpAllModelMr = new List <MeshRenderer>(pointer.GetComponentsInChildren <MeshRenderer>() as MeshRenderer[]);
foreach (MeshRenderer mr in tmpAllModelMr)
{
if (mr.name == "KAStube" || mr.name == "KASsrcSphere" || mr.name == "KASsrcTube" || mr.name == "KAStgtSphere" || mr.name == "KAStgtTube")
{
Destroy(mr);
continue;
}
allModelMr.Add(mr);
mr.material = new Material(Shader.Find("Transparent/Diffuse"));
}
pointerNodeTransform = new GameObject("KASPointerPartNode").transform;
pointerNodeTransform.parent = pointer.transform;
pointerNodeTransform.localPosition = partToAttach.srfAttachNode.position;
pointerNodeTransform.localRotation = Quaternion.Inverse(Quaternion.LookRotation(partToAttach.srfAttachNode.orientation, Vector3.up));
}
//Set default color
Color color = Color.green;
// Check if object is valid
bool isValidObj = false;
Part hitPart = null;
KerbalEVA hitEva = null;
if (hit.rigidbody)
{
hitPart = hit.rigidbody.GetComponent <Part>();
hitEva = hit.rigidbody.GetComponent <KerbalEVA>();
if (hitPart && allowPart && !hitEva & hitPart != partToAttach)
{
isValidObj = true;
}
if (hitEva && allowEva)
{
isValidObj = true;
}
}
if (!hitPart && !hitEva && allowStatic)
{
isValidObj = true;
}
//Check distance
bool isValidSourceDist = true;
if (sourceTransform)
{
isValidSourceDist = Vector3.Distance(FlightGlobals.ActiveVessel.transform.position, sourceTransform.position) <= maxDist;
}
bool isValidTargetDist = Vector3.Distance(FlightGlobals.ActiveVessel.transform.position, hit.point) <= maxDist;
//Set color
if (!isValidObj)
{
color = Color.red;
}
else if (!isValidSourceDist || !isValidTargetDist)
{
color = Color.yellow;
}
color.a = 0.5f;
foreach (MeshRenderer mr in allModelMr)
{
mr.material.color = color;
}
//Rotation keys
Vector3 delta = new Vector3(0, 0, 1);
if (Input.GetKey(KeyCode.LeftAlt))
{
delta = new Vector3(1, 0, 0);
}
else if (Input.GetKey(KeyCode.RightAlt))
{
delta = new Vector3(0, -1, 0);
}
if (Input.GetKeyDown(KASAddonControlKey.rotateLeftKey.ToLower()))
{
customRot -= delta * 15;
}
if (Input.GetKeyDown(KASAddonControlKey.rotateRightKey.ToLower()))
{
customRot += delta * 15;
}
Quaternion rotAdjust = Quaternion.Euler(0, 0, customRot.z) * Quaternion.Euler(customRot.x, customRot.y, 0);
KAS_Shared.MoveAlign(pointer.transform, pointerNodeTransform, hit, rotAdjust);
//Attach on click
if (Input.GetKeyDown(KeyCode.Mouse0))
{
KAS_Shared.DebugLog("Attachment started...");
if (!isValidObj)
{
ScreenMessages.PostScreenMessage("Can't attach, target is not allowed !");
audioBipWrong.Play();
return;
}
if (!isValidSourceDist)
{
ScreenMessages.PostScreenMessage("Can't attach, too far from source !");
audioBipWrong.Play();
return;
}
if (!isValidTargetDist)
{
ScreenMessages.PostScreenMessage("Can't attach, too far from target !");
audioBipWrong.Play();
return;
}
KASModuleGrab modulegrab = partToAttach.GetComponent <KASModuleGrab>();
//Move and attach mode
if (pointerMode == PointerMode.MoveAndAttach)
{
// Drop and detach part if needed
if (modulegrab)
{
if (modulegrab.grabbed)
{
modulegrab.Drop();
}
modulegrab.Detach();
}
KASModuleWinch connectedWinch = KAS_Shared.GetConnectedWinch(partToAttach);
if (!connectedWinch)
{
KAS_Shared.DecoupleFromAll(partToAttach);
}
//Move part
partToAttach.transform.position = pointer.transform.position;
partToAttach.transform.rotation = pointer.transform.rotation;
if (connectedWinch)
{
//Set cable lenght to real lenght
connectedWinch.cableJointLength = connectedWinch.cableRealLenght;
}
KAS_Shared.ResetCollisionEnhancer(partToAttach);
if (msgOnly)
{
KAS_Shared.DebugLog("UpdatePointer(Pointer) Attach using send message");
if (hitPart)
{
partToAttach.SendMessage("OnAttachPart", hitPart, SendMessageOptions.DontRequireReceiver);
}
else
{
partToAttach.SendMessage("OnAttachStatic", SendMessageOptions.DontRequireReceiver);
}
}
else
{
KAS_Shared.DebugLog("UpdatePointer(Pointer) Attach with couple or static method");
if (!hitPart && !hitEva)
{
if (modulegrab)
{
modulegrab.AttachStatic();
modulegrab.fxSndAttachStatic.audio.Play();
}
else
{
KAS_Shared.DebugWarning("UpdatePointer(Pointer) No grab module found, part cannot be attached on static");
}
}
else
{
partToAttach.Couple(hitPart);
if (modulegrab)
{
modulegrab.fxSndAttachPart.audio.Play();
}
else
{
KAS_Shared.DebugWarning("UpdatePointer(Pointer) No grab module found, cannot fire sound");
}
}
partToAttach.SendMessage("OnAttach", SendMessageOptions.DontRequireReceiver);
}
}
if (pointerMode == PointerMode.CopyAndAttach)
{
// Not tested !
Part newPart = KAS_Shared.CreatePart(partToAttach.partInfo, pointer.transform.position, pointer.transform.rotation, partToAttach);
if (msgOnly)
{
if (hitPart)
{
StartCoroutine(WaitAndSendMsg(newPart, pointer.transform.position, pointer.transform.rotation, hitPart));
}
else
{
StartCoroutine(WaitAndSendMsg(newPart, pointer.transform.position, pointer.transform.rotation));
}
}
else
{
if (!hitPart && !hitEva)
{
StartCoroutine(WaitAndAttach(newPart, pointer.transform.position, pointer.transform.rotation, hitPart));
}
else
{
StartCoroutine(WaitAndAttach(newPart, pointer.transform.position, pointer.transform.rotation));
}
}
}
running = false;
}
}
private void UpdateGrab()
{
if (Input.GetKeyDown(grabPartKey.ToLower()))
{
if (FlightGlobals.ActiveVessel.isEVA)
{
// Check if a part is already grabbed
KASModuleGrab grabbedPart = KAS_Shared.GetGrabbedPartModule(FlightGlobals.ActiveVessel);
if (grabbedPart)
{
grabbedPart.Drop();
return;
}
List <Collider> nearestColliders = new List <Collider>(Physics.OverlapSphere(FlightGlobals.ActiveVessel.transform.position, radius, 557059));
float shorterDist = Mathf.Infinity;
KASModuleGrab nearestModuleGrab = null;
foreach (Collider col in nearestColliders)
{
// Check if if the collider have a rigidbody
if (!col.attachedRigidbody)
{
continue;
}
// Check if it's a part
Part p = col.attachedRigidbody.GetComponent <Part>();
if (!p)
{
continue;
}
// Check if it's grabbable part
KASModuleGrab moduleGrab = p.GetComponent <KASModuleGrab>();
if (!moduleGrab)
{
continue;
}
// Check if it's a part is connected
if (moduleGrab.part.isConnected)
{
continue;
}
// Check if it's a part grabbed by another kerbal eva
if (moduleGrab.evaHolderPart)
{
continue;
}
// Select the nearest grabbable part
float distToGrab = Vector3.Distance(FlightGlobals.ActiveVessel.transform.position, moduleGrab.part.transform.position);
if (distToGrab <= shorterDist)
{
shorterDist = distToGrab;
nearestModuleGrab = moduleGrab;
}
}
//Grab nearest part if exist
if (nearestModuleGrab)
{
nearestModuleGrab.Grab(FlightGlobals.ActiveVessel);
return;
}
}
}
}
private bool AlignEvaPosition(Vessel kerbalEvaVessel)
{
//Get eva transform
evaCollider = KAS_Shared.GetEvaCollider(kerbalEvaVessel, evaTransformName);
if (!evaCollider)
{
KAS_Shared.DebugLog("Grab - " + evaTransformName + "transform not found on eva !");
return(false);
}
//Get attach node
if (attachNodeName == null || attachNodeName == "")
{
if (this.part.srfAttachNode == null)
{
KAS_Shared.DebugLog("Grab - surface attach node cannot be found on the part !");
return(false);
}
KAS_Shared.AddNodeTransform(this.part, this.part.srfAttachNode);
partNode = this.part.srfAttachNode;
}
else
{
AttachNode an = this.part.findAttachNode(attachNodeName);
if (an == null)
{
KAS_Shared.DebugLog("Grab - " + attachNodeName + " node cannot be found on the part !");
return(false);
}
KAS_Shared.AddNodeTransform(this.part, an);
partNode = an;
}
//Send message to other modules
base.SendMessage("OnPartGrab", kerbalEvaVessel, SendMessageOptions.DontRequireReceiver);
//Drop grabbed part on eva if needed
KASModuleGrab tmpGrabbbedPartModule = KAS_Shared.GetGrabbedPartModule(kerbalEvaVessel);
if (tmpGrabbbedPartModule)
{
if (tmpGrabbbedPartModule.part.packed)
{
KAS_Shared.DebugWarning("Grab - cannot drop an incompletely grabbed part!");
return(false);
}
KAS_Shared.DebugWarning("Grab - Drop current grabbed part");
tmpGrabbbedPartModule.Drop();
}
if (evaNodeTransform)
{
Destroy(evaNodeTransform.gameObject);
}
evaNodeTransform = new GameObject("KASEvaNode").transform;
evaNodeTransform.parent = evaCollider.transform;
evaNodeTransform.localPosition = evaPartPos;
evaNodeTransform.rotation = KAS_Shared.DirectionToQuaternion(evaCollider.transform, evaPartDir);
KAS_Shared.MoveAlign(this.part.transform, partNode.nodeTransform, evaNodeTransform);
if (this.part.vessel == kerbalEvaVessel)
{
this.part.UpdateOrgPosAndRot(kerbalEvaVessel.rootPart);
}
return(true);
}
public void Grab(Vessel kerbalEvaVessel)
{
KAS_Shared.DebugLog("Grab - Grabbing part :" + this.part.partInfo.name);
//Get eva transform
evaCollider = KAS_Shared.GetEvaCollider(kerbalEvaVessel, evaTransformName);
if (!evaCollider)
{
KAS_Shared.DebugLog("Grab - " + evaTransformName + "transform not found on eva !");
return;
}
//Get attach node
if (attachNodeName == null || attachNodeName == "")
{
if (this.part.srfAttachNode == null)
{
KAS_Shared.DebugLog("Grab - surface attach node cannot be found on the part !");
return;
}
KAS_Shared.AddNodeTransform(this.part, this.part.srfAttachNode);
partNode = this.part.srfAttachNode;
}
else
{
AttachNode an = this.part.findAttachNode(attachNodeName);
if (an == null)
{
KAS_Shared.DebugLog("Grab - " + attachNodeName + " node cannot be found on the part !");
return;
}
KAS_Shared.AddNodeTransform(this.part, an);
partNode = an;
}
//Send message to other modules
base.SendMessage("OnPartGrab", kerbalEvaVessel, SendMessageOptions.DontRequireReceiver);
//Drop grabbed part on eva if needed
KASModuleGrab tmpGrabbbedPartModule = KAS_Shared.GetGrabbedPartModule(kerbalEvaVessel);
if (tmpGrabbbedPartModule)
{
KAS_Shared.DebugWarning("Grab - Drop current grabbed part");
tmpGrabbbedPartModule.Drop();
}
evaNodeTransform = new GameObject("KASEvaNode").transform;
evaNodeTransform.parent = evaCollider.transform;
evaNodeTransform.localPosition = evaPartPos;
evaNodeTransform.rotation = KAS_Shared.DirectionToQuaternion(evaCollider.transform, evaPartDir);
KAS_Shared.MoveAlign(this.part.transform, partNode.nodeTransform, evaNodeTransform);
//Grab winch connected head if any
KASModuleWinch moduleWinch = KAS_Shared.GetConnectedWinch(this.part);
if (moduleWinch)
{
KASModulePort modulePort = this.part.GetComponent <KASModulePort>();
moduleWinch.UnplugHead(false);
moduleWinch.GrabHead(kerbalEvaVessel, modulePort);
}
List <Collider> allColliders = new List <Collider>(this.part.GetComponentsInChildren <Collider>() as Collider[]);
foreach (Collider col in allColliders)
{
col.isTrigger = true;
}
Detach();
KAS_Shared.DecoupleFromAll(this.part);
this.part.Couple(kerbalEvaVessel.rootPart);
//Destroy joint to avoid buggy eva move
Destroy(this.part.attachJoint);
this.part.rigidbody.velocity = kerbalEvaVessel.rootPart.rigidbody.velocity;
if (physicJoint)
{
if (evaJoint)
{
Destroy(evaJoint);
}
evaJoint = this.part.gameObject.AddComponent <FixedJoint>();
evaJoint.connectedBody = evaCollider.attachedRigidbody;
evaJoint.breakForce = 5;
evaJoint.breakTorque = 5;
}
else
{
this.part.physicalSignificance = Part.PhysicalSignificance.NONE;
this.part.transform.parent = evaNodeTransform;
this.part.rigidbody.isKinematic = true;
}
//Add grabbed part mass to eva
if (addPartMass && !physicJoint)
{
orgKerbalMass = kerbalEvaVessel.rootPart.mass;
kerbalEvaVessel.rootPart.mass += this.part.mass;
}
evaHolderVesselName = kerbalEvaVessel.vesselName;
evaHolderPart = kerbalEvaVessel.rootPart;
grabbed = true;
RefreshContextMenu();
//Play grab sound
fxSndGrab.audio.Play();
base.SendMessage("OnPartGrabbed", kerbalEvaVessel, SendMessageOptions.DontRequireReceiver);
}
private IEnumerator WaitAndGrab(KASModuleGrab moduleGrab, Vessel vess)
{
waitAndGrabRunning = true;
while (!moduleGrab.part.rigidbody)
{
KAS_Shared.DebugLog("WaitAndGrab(Container) - Waiting rigidbody to initialize...");
yield return new WaitForFixedUpdate();
}
KAS_Shared.DebugLog("WaitAndGrab(Container) - Rigidbody initialized, setting velocity...");
moduleGrab.part.rigidbody.velocity = vess.rootPart.rigidbody.velocity;
moduleGrab.part.rigidbody.angularVelocity = vess.rootPart.rigidbody.angularVelocity;
KAS_Shared.DebugLog("WaitAndGrab(Container) - Waiting velocity to apply by waiting 0.1 seconds...");
yield return new WaitForSeconds(0.1f);
KAS_Shared.DebugLog("WaitAndGrab(Container) - Grab part...");
if (!moduleGrab.evaHolderPart) moduleGrab.Grab(vess);
KAS_Shared.DebugLog("WaitAndGrab(Container) - End of coroutine...");
waitAndGrabRunning = false;
}
void OnGUI()
{
if (!clickedWinch)
{
return;
}
GUI.skin = HighLogic.Skin;
GUI.skin.label.alignment = TextAnchor.MiddleCenter;
GUI.skin.button.alignment = TextAnchor.MiddleCenter;
guiButtonStyle = new GUIStyle(GUI.skin.button);
guiButtonStyle.normal.textColor = guiButtonStyle.focused.textColor = Color.white;
guiButtonStyle.hover.textColor = guiButtonStyle.active.textColor = Color.yellow;
guiButtonStyle.onNormal.textColor = guiButtonStyle.onFocused.textColor = guiButtonStyle.onHover.textColor = guiButtonStyle.onActive.textColor = Color.green;
guiButtonStyle.padding = new RectOffset(4, 4, 4, 4);
guiButtonStyle.alignment = TextAnchor.MiddleCenter;
Vector3 headScreenPoint = Camera.main.WorldToScreenPoint(clickedWinch.headTransform.position);
GUILayout.BeginArea(new Rect(headScreenPoint.x, Screen.height - headScreenPoint.y, 200, 200));
GUILayout.BeginVertical();
if (clickedWinch.evaHolderPart)
{
if (GUILayout.Button("Drop (Key " + grabHeadKey + ")", guiButtonStyle, GUILayout.Width(100f)))
{
clickedWinch.DropHead();;
clickedWinch = null;
}
}
else
{
if (GUILayout.Button("Grab (Key " + grabHeadKey + ")", guiButtonStyle, GUILayout.Width(100f)))
{
clickedWinch.GrabHead(FlightGlobals.ActiveVessel);
clickedWinch = null;
}
if (clickedWinch)
{
if (clickedWinch.headState == KASModuleWinch.PlugState.Deployed)
{
KASModuleGrab grabbedModule = KAS_Shared.GetGrabbedPartModule(FlightGlobals.ActiveVessel);
if (grabbedModule)
{
KASModulePort grabbedPort = grabbedModule.GetComponent <KASModulePort>();
if (grabbedPort)
{
if (GUILayout.Button("Plug grabbed", guiButtonStyle, GUILayout.Width(100f)))
{
grabbedModule.Drop();
grabbedPort.transform.rotation = Quaternion.FromToRotation(grabbedPort.portNode.forward, -clickedWinch.headPortNode.forward) * grabbedPort.transform.rotation;
grabbedPort.transform.position = grabbedPort.transform.position - (grabbedPort.portNode.position - clickedWinch.headPortNode.position);
clickedWinch.PlugHead(grabbedPort, KASModuleWinch.PlugState.PlugDocked);
clickedWinch = null;
}
}
}
}
}
}
GUILayout.EndHorizontal();
GUILayout.EndArea();
}
