public void ClearSelection()
{
reset_highlight(lhs);
reset_highlight(rhs);
lhs = rhs = null; lhs_selected = null;
if(storages != null) storages.ForEach(reset_highlight);
}
public override bool TryStoreVessel(PackedVessel v)
{
if(!(v is PackedConstruct))
{
ScreenMessager.showMessage("A vessel can be fixed inside this storage only during construction.");
return false;
}
return base.TryStoreVessel(v);
}
public override bool TryStoreVessel(PackedVessel v)
{
if(VesselsDocked > 0)
{
ScreenMessager.showMessage("The storage is already occupied");
return false;
}
return base.TryStoreVessel(v);
}
protected override bool can_restore(PackedVessel v)
{
if(!base.can_restore(v)) return false;
if(!vessel_fits_docking_space(v))
{
ScreenMessager.showMessage(6, "Vessel clearance is insufficient for safe launch.\n\n" +
"\"{0}\" cannot be launched", v.name);
return false;
}
return true;
}
public void TransferVessel()
{
if(lhs == null || rhs == null) return;
if(lhs_selected != null)
{
lhs.TryTransferTo(lhs_selected, rhs);
lhs_selected = null;
}
else if(rhs_selected != null)
{
rhs.TryTransferTo(rhs_selected, lhs);
rhs_selected = null;
}
}
protected override bool try_store_vessel(PackedVessel v)
{
if(!vessel_fits_docking_space(v))
{
ScreenMessager.showMessage(6, "Vessel clearance is insufficient for safe docking.\n\n" +
"\"{0}\" cannot be stored", v.name);
return false;
}
if(!entrance.CanTransferTo(v, Storage))
{
ScreenMessager.showMessage(8, "There's no room in the hangar for this vessel,\n" +
"OR vessel clearance is insufficient for safe docking.\n\n" +
"\"{0}\" cannot be stored", v.name);
return false;
}
Storage.StoreVessel(v);
return true;
}
static void vessels_list(HangarStorage storage, ref Vector2 scroll, ref PackedVessel selected, bool is_lhs=true)
{
if(storage == null) return;
scroll = GUILayout.BeginScrollView(scroll, GUILayout.Height(scroll_height), GUILayout.Width(scroll_width));
GUILayout.BeginVertical();
List<PackedVessel> vessels = storage.GetAllVesselsBase();
vessels.Sort((a, b) => a.name.CompareTo(b.name));
foreach(var v in vessels)
{
GUILayout.BeginHorizontal();
if(is_lhs) HangarGUI.PackedVesselLabel(v);
if(GUILayout.Button(is_lhs? ">>" : "<<", Styles.normal_button, GUILayout.ExpandWidth(true))) selected = v;
if(!is_lhs) HangarGUI.PackedVesselLabel(v);
GUILayout.EndHorizontal();
}
GUILayout.EndVertical();
GUILayout.EndScrollView();
}
public virtual bool TryStoreVessel(PackedVessel v)
{
if(!VesselFits(v))
{
ScreenMessager.showMessage(5, "Insufficient vessel clearance for safe docking\n" +
"\"{0}\" cannot be stored", v.name);
return false;
}
bool stored = false;
var pc = v as PackedConstruct;
var sv = v as StoredVessel;
if(pc != null) stored = packed_constructs.TryAdd(pc);
else if(sv != null) stored = stored_vessels.TryAdd(sv);
else { this.Log("Unknown PackedVessel type: {0}", v); return false; }
if(!stored)
{
ScreenMessager.showMessage("There's no room for \"{0}\"", v.name);
return false;
}
set_part_params();
return true;
}
public void StoreVessel(PackedVessel v)
{
var pc = v as PackedConstruct;
var sv = v as StoredVessel;
if(pc != null) packed_constructs.ForceAdd(pc);
else if(sv != null) stored_vessels.ForceAdd(sv);
else { this.Log("Unknown PackedVessel type: {0}", v); return; }
set_part_params();
}
public bool RemoveVessel(PackedVessel v)
{
var pc = v as PackedConstruct;
var sv = v as StoredVessel;
bool result = false;
if(pc != null) result = packed_constructs.Remove(pc);
else if(sv != null) result = stored_vessels.Remove(sv);
else { this.Log("Unknown PackedVessel type: {0}", v); return false; }
set_part_params();
return result;
}
public Transform GetSpawnTransform(PackedVessel v = null)
{
if(AutoPositionVessel && v != null)
{
var s_size = sort_vector(HangarMetric.size);
var v_size = sort_vector(v.size);
var r1 = swaps[s_size[0].Value, v_size[0].Value];
var i2 = s_size[0].Value == v_size[1].Value? 2 : 1;
var r2 = swaps[s_size[i2].Value, v_size[i2].Value];
spawn_transform.localPosition = Vector3.zero;
spawn_transform.localRotation = Quaternion.identity;
spawn_transform.rotation = part.transform.rotation * r2 * r1;
}
return spawn_transform;
}
public override bool CanHold(PackedVessel vsl)
{
if(!VesselFits(vsl)) return false;
var pc = vsl as PackedConstruct;
if(pc != null) return packed_constructs.CanAdd(pc);
var sv = vsl as StoredVessel;
if(sv != null) return stored_vessels.CanAdd(sv);
return false;
}
protected virtual bool try_store_vessel(PackedVessel v)
{
return Storage.TryStoreVessel(v);
}
protected virtual Transform get_spawn_transform(PackedVessel pv)
{
return Storage.GetSpawnTransform(pv);
}
public bool TryTransferTo(PackedVessel vsl, HangarStorage other)
{
if(!CanTransferTo(vsl, other))
{
ScreenMessager.showMessage("Unable to move \"{0}\" from \"{1}\" to \"{2}\"",
vsl.name, this.Title(), other.Title());
return false;
}
if(!RemoveVessel(vsl))
{
this.Log("TryTransferTo: trying to remove a PackedVessel that is not present.");
return false;
}
other.StoreVessel(vsl);
return true;
}
protected override Transform get_spawn_transform(PackedVessel pv)
{
return spawn_transform;
}
bool vessel_fits_docking_space(PackedVessel v)
{
if(docking_space == null) return true;
check_transform.position =
spawn_transform.TransformPoint(Vector3.up*v.size.y/2);
return v.metric.FitsAligned(check_transform, docking_space.transform, docking_space.sharedMesh);
}
public bool VesselFits(PackedVessel v)
{
var position = GetSpawnTransform(v);
return ComputeHull ?
v.metric.FitsAligned(position, hangar_space.transform, hangar_space.sharedMesh) :
v.metric.FitsAligned(position, part.partTransform, HangarMetric);
}
protected virtual bool can_restore(PackedVessel v)
{
//if hangar is not ready
if(hangar_state == HangarState.Inactive)
{
ScreenMessager.showMessage("Activate the hangar first");
return false;
}
if(launched_vessel != null)
{
ScreenMessager.showMessage("Launch is in progress");
return false;
}
if(hangar_gates.State != AnimatorState.Opened)
{
ScreenMessager.showMessage("Open hangar gates first");
return false;
}
//if something is docked to the hangar docking port (if its present)
if(!docks_checklist.TrueForAll(d => d.vesselInfo == null))
{
ScreenMessager.showMessage("Cannot launch a vessel while another one is docked");
return false;
}
//if rotating
if(vessel.angularVelocity.sqrMagnitude > HangarConfig.Globals.MaxSqrAngularVelocity)
{
ScreenMessager.showMessage("Cannot launch a vessel while rotating");
return false;
}
//if on the ground
if(vessel.LandedOrSplashed)
{
if(vessel.srf_velocity.sqrMagnitude > HangarConfig.Globals.MaxSqrSurfaceVelocity)
{
ScreenMessager.showMessage("Cannot launch a vessel while moving");
return false;
}
}
else //if flying
{
if(vessel.geeForce > HangarConfig.Globals.MaxGeeForce)
{
ScreenMessager.showMessage("Cannot launch a vessel under gee force above {0}",
HangarConfig.Globals.MaxGeeForce);
return false;
}
if(vessel.mainBody.atmosphere &&
FlightGlobals.getStaticPressure(vessel.altitude, vessel.mainBody) > HangarConfig.Globals.MaxStaticPressure)
{
ScreenMessager.showMessage("Cannot launch a vessel in low atmosphere");
return false;
}
}
return true;
}
