IEnumerator WinReset()
{
CameraOverhead();
if (SoundtrackManager.s_instance != null)
{
SoundtrackManager.s_instance.PlayAudioSource(SoundtrackManager.s_instance.bell);
}
yield return(new WaitForSeconds(3f));
if (setup2.activeSelf == false)
{
setup2.SetActive(true);
setup1.SetActive(false);
playerBoat.transform.position = setup2transform.position;
playerBoat.transform.rotation = setup2transform.rotation;
curState = DockingState.instructions2;
playerBoat.GetComponent <Rigidbody>().isKinematic = true;
gameplayUi.SetActive(false);
parallelMethodUI.SetActive(true);
instructionsUI.GetComponent <InstructionsPanel>().GoToPanel(instructionsUI.transform.GetChild(0).GetChild(0).gameObject);
}
else
{
curState = DockingState.win;
if (SoundtrackManager.s_instance != null)
{
SoundtrackManager.s_instance.PlayAudioSource(SoundtrackManager.s_instance.bell);
}
CongratulationsPopUp.s_instance.InitializeCongratulationsPanel("Docking");
}
}
/// <summary>
/// Unsubscribes from manipulation events.
/// </summary>
private void OnDisable()
{
if (objectManipulator != null)
{
objectManipulator.OnManipulationStarted.RemoveListener(OnManipulationStarted);
objectManipulator.OnManipulationEnded.RemoveListener(OnManipulationEnded);
objectManipulator = null;
}
if (manipulationHandler != null)
{
manipulationHandler.OnManipulationStarted.RemoveListener(OnManipulationStarted);
manipulationHandler.OnManipulationEnded.RemoveListener(OnManipulationEnded);
manipulationHandler = null;
}
if (dockedPosition != null)
{
dockedPosition.DockedObject = null;
dockedPosition = null;
}
overlappingPositions.Clear();
dockingState = DockingState.Undocked;
}
public void StartUndocking()
{
DockingState = DockingState.Undocking;
var dockingSequence = Game.ModData.ObjectCreator.CreateObject <DockingSequence>(Dockable.Info.DockingSequenceActivity + "DockingSequence");
dockingSequence.Undock(DockableActor, Dockable, DockActor, Dock);
QueueChild(dockingSequence);
}
public void StartUndocking()
{
this.DockingState = DockingState.Undocking;
this.QueueChild(
new Drag(this.dockableActor, this.DockActor.CenterPosition + this.Dock.Info.Position, this.initialPosition, this.Dock.Info.DragLength)
);
}
public Docking(Actor dockableActor, Actor dockActor, Dock dock)
{
this.dockableActor = dockableActor;
this.DockActor = dockActor;
this.Dock = dock;
this.DockingState = DockingState.Approaching;
}
public Docking(Actor dockableActor, Dockable dockable, Actor dockActor, Dock dock)
{
DockableActor = dockableActor;
Dockable = dockable;
DockActor = dockActor;
Dock = dock;
DockingState = DockingState.Approaching;
}
public override Activity Tick(Actor self)
{
switch (dockingState)
{
case DockingState.Wait:
return(this);
case DockingState.Turn:
dockingState = DockingState.Dock;
if (IsDragRequired)
{
return(ActivityUtils.SequenceActivities(new Turn(self, DockAngle), new Drag(self, StartDrag, EndDrag, DragLength), this));
}
return(ActivityUtils.SequenceActivities(new Turn(self, DockAngle), this));
case DockingState.Dock:
if (Refinery.IsInWorld && !Refinery.IsDead)
{
foreach (var nd in Refinery.TraitsImplementing <INotifyDocking>())
{
nd.Docked(Refinery, self);
}
}
return(OnStateDock(self));
case DockingState.Loop:
if (!Refinery.IsInWorld || Refinery.IsDead || Harv.TickUnload(self, Refinery))
{
dockingState = DockingState.Undock;
}
return(this);
case DockingState.Undock:
return(OnStateUndock(self));
case DockingState.Complete:
if (Refinery.IsInWorld && !Refinery.IsDead)
{
foreach (var nd in Refinery.TraitsImplementing <INotifyDocking>())
{
nd.Undocked(Refinery, self);
}
}
Harv.LastLinkedProc = Harv.LinkedProc;
Harv.LinkProc(self, null);
if (IsDragRequired)
{
return(ActivityUtils.SequenceActivities(new Drag(self, EndDrag, StartDrag, DragLength), NextActivity));
}
return(NextActivity);
}
throw new InvalidOperationException("Invalid harvester dock state.");
}
/// <summary>
/// Updates the transform and state of this object every frame, depending on
/// manipulations and docking state.
/// </summary>
public void Update()
{
if (isDragging && overlappingPositions.Count > 0)
{
var closestPosition = GetClosestPosition();
if (closestPosition.IsOccupied)
{
closestPosition.GetComponentInParent <Dock>().TryMoveToFreeSpace(closestPosition);
}
}
if (dockingState == DockingState.Docked || dockingState == DockingState.Docking)
{
Assert.IsNotNull(dockedPosition, "When a dockable is docked, its dockedPosition must be valid.");
Assert.AreEqual(dockedPosition.DockedObject, this, "When a dockable is docked, its dockedPosition reference the dockable.");
var lerpTime = dockingState == DockingState.Docked ? moveLerpTimeWhenDocked : moveLerpTime;
if (!isDragging)
{
// Don't override dragging
transform.position = Solver.SmoothTo(transform.position, dockedPosition.transform.position, Time.deltaTime, lerpTime);
transform.rotation = Solver.SmoothTo(transform.rotation, dockedPosition.transform.rotation, Time.deltaTime, lerpTime);
}
transform.localScale = Solver.SmoothTo(transform.localScale, dockedPositionScale, Time.deltaTime, lerpTime);
if (VectorExtensions.CloseEnough(dockedPosition.transform.position, transform.position, distanceTolerance) &&
QuaternionExtensions.AlignedEnough(dockedPosition.transform.rotation, transform.rotation, angleTolerance) &&
AboutTheSameSize(dockedPositionScale.x, transform.localScale.x))
{
// Finished docking
dockingState = DockingState.Docked;
// Snap to position
transform.position = dockedPosition.transform.position;
transform.rotation = dockedPosition.transform.rotation;
transform.localScale = dockedPositionScale;
}
}
else if (dockedPosition == null && dockingState == DockingState.Undocking)
{
transform.localScale = Solver.SmoothTo(transform.localScale, originalScale, Time.deltaTime, moveLerpTime);
if (AboutTheSameSize(originalScale.x, transform.localScale.x))
{
// Finished undocking
dockingState = DockingState.Undocked;
// Snap to size
transform.localScale = originalScale;
}
}
}
private DockData GetDockData(ContentDocument pane)
{
if (pane.PreferredDockData != null)
{
return(pane.PreferredDockData);
}
DockingState dockState = pane.Control.DockingContainer.DockState == DockingState.Unknown ||
pane.Control.DockingContainer.DockState == DockingState.Hidden ?
DockingState.Document : pane.Control.DockingContainer.DockState;
return(new DockData(dockState, Rectangle.Empty));
}
public HarvesterDockSequence(Actor self, Actor refinery, int dockAngle, bool isDragRequired, WVec dragOffset, int dragLength)
{
dockingState = DockingState.Turn;
Refinery = refinery;
DockAngle = dockAngle;
IsDragRequired = isDragRequired;
DragOffset = dragOffset;
DragLength = dragLength;
Harv = self.Trait <Harvester>();
StartDrag = self.CenterPosition;
EndDrag = refinery.CenterPosition + DragOffset;
}
/// <summary>
/// Undocks this <see cref="Dockable"/> from the current <see cref="DockPosition"/> where it is docked.
/// </summary>
public void Undock()
{
if (!CanUndock)
{
Debug.LogError($"Trying to undock an object that was not docked. State = {dockingState}");
return;
}
Debug.Log($"Undocking object {gameObject.name} from position {dockedPosition.gameObject.name}");
dockedPosition.DockedObject = null;
dockedPosition = null;
dockedPositionScale = Vector3.one;
dockingState = DockingState.Undocking;
}
void Update()
{
switch (curState)
{
case DockingState.instructions1:
case DockingState.instructions2:
{
if (switchToGamePlay)
{
playerBoat.GetComponent <Rigidbody> ().isKinematic = false;
switchToGamePlay = false;
curState = DockingState.gameplay;
}
break;
}
case DockingState.gameplay:
{
if (switchToReset)
{
switchToReset = false;
curState = DockingState.reset;
}
break;
}
case DockingState.reset:
{
// StartCoroutine ("PauseBoats");
if (switchToGamePlay)
{
NavBoatControl.s_instance.boomSlider.value = 80f;
switchToGamePlay = false;
DieOnHitBoat[] arrows = GameObject.FindObjectsOfType <DieOnHitBoat> ();
foreach (DieOnHitBoat x in arrows)
{
x.Reset();
}
curState = DockingState.gameplay;
StartCoroutine("HackyBSFix");
}
break;
}
}
}
public void Show(IInteractiveWindow theWindow, DockingState state)
{
DockContent dockableWindow = theWindow as DockContent;
if (dockableWindow != null)
{
DockState dockState = DockState.Document;
if (state == DockingState.DockRight)
{
dockState = DockState.DockRight;
}
else if (state == DockingState.Float)
{
dockState = DockState.Float;
}
this.dockPanel.Invoke((MethodInvoker) delegate
{
dockableWindow.Show(this.dockPanel, dockState);
});
}
}
public void ClosedInstructionsPanel()
{
switch( curState ) {
case DockingState.briefing:
briefingUI.SetActive( false );
perpendicularMethodUI.SetActive( true );
curState = DockingState.instructions1;
break;
case DockingState.instructions1:
perpendicularMethodUI.SetActive( false );
gameplayUi.SetActive( true );
StartGame();
break;
case DockingState.instructions2:
parallelMethodUI.SetActive (false);
gameplayUi.SetActive (true);
CameraMain ();
switchToGamePlay = true;
break;
}
}
public void ClosedInstructionsPanel()
{
switch (curState)
{
case DockingState.briefing:
briefingUI.SetActive(false);
perpendicularMethodUI.SetActive(true);
curState = DockingState.instructions1;
break;
case DockingState.instructions1:
perpendicularMethodUI.SetActive(false);
gameplayUi.SetActive(true);
StartGame();
break;
case DockingState.instructions2:
parallelMethodUI.SetActive(false);
gameplayUi.SetActive(true);
CameraMain();
switchToGamePlay = true;
break;
}
}
/// <summary>
/// Docks this object in a given <see cref="DockPosition"/>.
/// </summary>
/// <param name="position">The <see cref="DockPosition"/> where we'd like to dock this object.</param>
public void Dock(DockPosition position)
{
if (!CanDock)
{
Debug.LogError($"Trying to dock an object that was not undocked. State = {dockingState}");
return;
}
Debug.Log($"Docking object {gameObject.name} on position {position.gameObject.name}");
dockedPosition = position;
dockedPosition.DockedObject = this;
float scaleToFit = gameObject.GetComponent <Collider>().bounds.GetScaleToFitInside(dockedPosition.GetComponent <Collider>().bounds);
dockedPositionScale = transform.localScale * scaleToFit;
if (dockingState == DockingState.Undocked)
{
// Only register the original scale when first docking
originalScale = transform.localScale;
}
dockingState = DockingState.Docking;
}
public override bool Tick(Actor self)
{
if ((this.DockActor.IsDead || !this.DockActor.IsInWorld || this.Dock.IsTraitDisabled) && !this.IsCanceling)
{
this.Cancel(self, true);
}
switch (this.DockingState)
{
case DockingState.Approaching:
if (this.State == ActivityState.Canceling)
{
return(true);
}
if (this.ChildActivity != null)
{
break;
}
var distance = WDist.FromCells(this.Dock.Info.QueueDistance);
if ((this.dockableActor.CenterPosition - this.DockActor.CenterPosition).Length > distance.Length)
{
this.QueueChild(new Move(this.dockableActor, Target.FromActor(this.DockActor), distance));
}
else
{
this.DockingState = DockingState.Waiting;
this.Dock.Add(this.dockableActor);
}
break;
case DockingState.Waiting:
if (this.State == ActivityState.Canceling)
{
this.Dock.Remove(this.dockableActor);
return(true);
}
break;
case DockingState.PrepareDocking:
if (this.State == ActivityState.Canceling)
{
this.Dock.Remove(this.dockableActor);
return(true);
}
if (this.ChildActivity != null)
{
break;
}
var target = this.DockActor.World.Map.CellContaining(this.DockActor.CenterPosition + this.Dock.Info.Position + this.Dock.Info.DragOffset);
if (this.dockableActor.Location != target)
{
this.QueueChild(new Move(this.dockableActor, target));
}
else
{
this.DockingState = DockingState.Docking;
this.QueueChild(new Turn(this.dockableActor, this.Dock.Info.Angle));
this.initialPosition = this.dockableActor.CenterPosition;
this.QueueChild(
new Drag(
this.dockableActor,
this.dockableActor.CenterPosition,
this.DockActor.CenterPosition + this.Dock.Info.Position,
this.Dock.Info.DragLength
)
);
}
break;
case DockingState.Docking:
if (this.State == ActivityState.Canceling)
{
this.StartUndocking();
return(false);
}
if (this.ChildActivity == null)
{
this.DockingState = DockingState.Docked;
this.Dock.OnDock(this.DockActor);
}
break;
case DockingState.Docked:
if (this.State == ActivityState.Canceling)
{
this.StartUndocking();
return(false);
}
break;
case DockingState.Undocking:
if (this.ChildActivity == null)
{
this.DockingState = DockingState.None;
this.Dock.OnUndock();
this.Dock.Remove(this.dockableActor);
if (!this.DockActor.IsDead && this.DockActor.IsInWorld)
{
var rallyPoint = this.DockActor.TraitOrDefault <RallyPoint>();
if (rallyPoint != null && rallyPoint.Path.Any())
{
foreach (var cell in rallyPoint.Path)
{
this.dockableActor.QueueActivity(new Move(this.dockableActor, cell));
}
}
}
}
break;
case DockingState.None:
return(true);
default:
throw new ArgumentOutOfRangeException(Enum.GetName(this.DockingState));
}
return(false);
}
void OnMoored(SpaceStation station)
{
localStation = station;
state = DockingState.Docked;
}
public override bool Tick(Actor self)
{
if ((DockActor.IsDead || !DockActor.IsInWorld || Dock.IsTraitDisabled) && !IsCanceling)
{
Cancel(self, true);
}
switch (DockingState)
{
case DockingState.Approaching:
if (State == ActivityState.Canceling)
{
return(true);
}
if (ChildActivity != null)
{
break;
}
var distance = WDist.FromCells(Dock.Info.QueueDistance);
if ((dockableActor.CenterPosition - DockActor.CenterPosition).Length > distance.Length)
{
QueueChild(new Move(dockableActor, Target.FromActor(DockActor), distance));
}
else
{
DockingState = DockingState.Waiting;
Dock.Add(dockableActor);
}
break;
case DockingState.Waiting:
if (State == ActivityState.Canceling)
{
Dock.Remove(dockableActor);
return(true);
}
break;
case DockingState.PrepareDocking:
if (State == ActivityState.Canceling)
{
Dock.Remove(dockableActor);
return(true);
}
if (ChildActivity != null)
{
break;
}
var target = DockActor.World.Map.CellContaining(DockActor.CenterPosition + Dock.Info.Position + Dock.Info.DragOffset);
if (dockableActor.Location != target)
{
QueueChild(new Move(dockableActor, target));
}
else
{
DockingState = DockingState.Docking;
QueueChild(new Turn(dockableActor, Dock.Info.Angle));
initialPosition = dockableActor.CenterPosition;
QueueChild(new Drag(dockableActor, dockableActor.CenterPosition, DockActor.CenterPosition + Dock.Info.Position, Dock.Info.DragLength));
}
break;
case DockingState.Docking:
if (State == ActivityState.Canceling)
{
StartUndocking();
return(false);
}
if (ChildActivity == null)
{
DockingState = DockingState.Docked;
Dock.OnDock();
}
break;
case DockingState.Docked:
if (State == ActivityState.Canceling)
{
StartUndocking();
return(false);
}
break;
case DockingState.Undocking:
if (ChildActivity == null)
{
DockingState = DockingState.None;
Dock.Remove(dockableActor);
if (!DockActor.IsDead && DockActor.IsInWorld)
{
var rallyPoint = DockActor.TraitOrDefault <RallyPoint>();
if (rallyPoint != null && rallyPoint.Path.Any())
{
foreach (var cell in rallyPoint.Path)
{
dockableActor.QueueActivity(new Move(dockableActor, cell));
}
}
}
}
break;
case DockingState.None:
return(true);
}
return(false);
}
public void StartUndocking()
{
DockingState = DockingState.Undocking;
QueueChild(new Drag(dockableActor, DockActor.CenterPosition + Dock.Info.Position, initialPosition, Dock.Info.DragLength));
}
public virtual void Show(DockingState state)
{
this.mainWindow.Show(this, state);
}
public void StartDocking()
{
this.DockingState = DockingState.PrepareDocking;
}
private IEnumerator AutoUndockingRoutine(SpaceStation station)
{
//station should undock us in a safe place pointing the right way
var dest = transform.position + transform.forward * DOCK_DISTANCE;
var proximity = GetDockProximity();
while ((ship.transform.position - dest).sqrMagnitude > proximity)
{
ship.ResetControls(thrust: 1);
ship.RotateToPoint(dest);
yield return null;
}
state = DockingState.InSpace;
localStation = null;
var shipAi = ship.GetComponent<AITaskFollower>();
if (shipAi)
{
shipAi.ClearTasks();
}
}
void Update()
{
switch (curState) {
case DockingState.instructions1:
case DockingState.instructions2:
{
if (switchToGamePlay) {
playerBoat.GetComponent<Rigidbody> ().isKinematic = false;
switchToGamePlay = false;
curState = DockingState.gameplay;
}
break;
}
case DockingState.gameplay:
{
if (switchToReset) {
switchToReset = false;
curState = DockingState.reset;
}
break;
}
case DockingState.reset:
{
// StartCoroutine ("PauseBoats");
if (switchToGamePlay) {
NavBoatControl.s_instance.boomSlider.value = 80f;
switchToGamePlay = false;
DieOnHitBoat[] arrows = GameObject.FindObjectsOfType<DieOnHitBoat> ();
foreach (DieOnHitBoat x in arrows) {
x.Reset ();
}
curState = DockingState.gameplay;
StartCoroutine ("HackyBSFix");
}
break;
}
}
}
public DockData(DockingState dockState, Rectangle location)
{
DockState = dockState;
Location = location;
}
void Start()
{
ship = GetComponent<Ship>();
localStation = null;
state = DockingState.InSpace;
}
public override void Cancel(Actor self, bool keepQueue = false)
{
dockingState = DockingState.Undock;
base.Cancel(self);
}
public void BeginAutoDocking(SpaceStation station)
{
if (LocalStation != station)
{
return;
}
state = DockingState.AutoDocking;
StartCoroutine(AutoDockingRoutine(station));
}
void Start()
{
curState = DockingState.briefing;
}
public override bool Tick(Actor self)
{
switch (dockingState)
{
case DockingState.Wait:
return(false);
case DockingState.Turn:
dockingState = DockingState.Drag;
QueueChild(new Turn(self, DockAngle));
return(false);
case DockingState.Drag:
if (IsCanceling || !Refinery.IsInWorld || Refinery.IsDead)
{
return(true);
}
dockingState = DockingState.Dock;
if (IsDragRequired)
{
QueueChild(new Drag(self, StartDrag, EndDrag, DragLength));
}
return(false);
case DockingState.Dock:
if (!IsCanceling && Refinery.IsInWorld && !Refinery.IsDead)
{
OnStateDock(self);
}
else
{
dockingState = DockingState.Undock;
}
return(false);
case DockingState.Loop:
if (IsCanceling || !Refinery.IsInWorld || Refinery.IsDead || Harv.TickUnload(self, Refinery))
{
dockingState = DockingState.Undock;
}
return(false);
case DockingState.Undock:
OnStateUndock(self);
return(false);
case DockingState.Complete:
Harv.LastLinkedProc = Harv.LinkedProc;
Harv.LinkProc(self, null);
if (IsDragRequired)
{
QueueChild(new Drag(self, EndDrag, StartDrag, DragLength));
}
return(true);
}
throw new InvalidOperationException("Invalid harvester dock state");
}
IEnumerator WinReset()
{
CameraOverhead ();
if (SoundtrackManager.s_instance != null)
SoundtrackManager.s_instance.PlayAudioSource (SoundtrackManager.s_instance.bell);
yield return new WaitForSeconds (3f);
if (setup2.activeSelf == false) {
setup2.SetActive (true);
setup1.SetActive (false);
playerBoat.transform.position = setup2transform.position;
playerBoat.transform.rotation = setup2transform.rotation;
curState = DockingState.instructions2;
playerBoat.GetComponent<Rigidbody>().isKinematic = true;
gameplayUi.SetActive (false);
parallelMethodUI.SetActive (true);
instructionsUI.GetComponent<InstructionsPanel>().GoToPanel( instructionsUI.transform.GetChild (0).GetChild(0).gameObject );
} else {
curState = DockingState.win;
if (SoundtrackManager.s_instance != null)
SoundtrackManager.s_instance.PlayAudioSource (SoundtrackManager.s_instance.bell);
CongratulationsPopUp.s_instance.InitializeCongratulationsPanel( "Docking" );
}
}
private void BeginAutoUndocking(SpaceStation station)
{
state = DockingState.AutoDocking;
//make sure our local station is set, so AutoDockingStation points to it
localStation = station;
StartCoroutine(AutoUndockingRoutine(station));
}
public override bool Cancel(Actor self)
{
dockingState = DockingState.Undock;
return(base.Cancel(self));
}
public override bool Tick(Actor self)
{
if (!shouldCancel && (DockActor == null || DockActor.IsDead || !DockActor.IsInWorld || Dock.GetDockAction(DockableActor) == null))
{
shouldCancel = true;
}
if (ChildActivity != null)
{
if (shouldCancel)
{
ChildActivity.Cancel(self);
}
if (ChildActivity != null)
{
ChildActivity.Tick(self);
}
}
switch (DockingState)
{
case DockingState.Approaching:
if (shouldCancel)
{
DockingState = DockingState.Undocked;
break;
}
// TODO does not null when target reached...?
if (ChildActivity != null)
{
break;
}
var distance = (DockableActor.CenterPosition - DockActor.CenterPosition).Length;
if (distance > WDist.FromCells(Dock.Info.QueueDistance).Length)
{
QueueChild(new Move(DockableActor, Target.FromActor(DockActor), WDist.FromCells(Dock.Info.QueueDistance)));
}
else
{
DockingState = DockingState.Waiting;
Dock.Add(DockableActor);
}
break;
case DockingState.Waiting:
if (shouldCancel)
{
DockingState = DockingState.Undocked;
Dock.Remove(DockableActor);
}
break;
case DockingState.Docking:
if (ChildActivity == null)
{
if (shouldCancel)
{
DockingState = DockingState.Undocked;
Dock.Remove(DockableActor);
}
else
{
DockingState = DockingState.Docked;
Dock.OnDock();
}
}
break;
case DockingState.Docked:
if (shouldCancel)
{
StartUndocking();
}
break;
case DockingState.Undocking:
if (ChildActivity == null)
{
DockingState = DockingState.Undocked;
Dock.Remove(DockableActor);
if (!DockActor.IsDead && DockActor.IsInWorld)
{
var rallyPoint = DockActor.TraitOrDefault <RallyPoint>();
if (rallyPoint != null && rallyPoint.Path.Any())
{
DockableActor.QueueActivity(new Move(DockableActor, rallyPoint.Path.First()));
}
}
}
break;
case DockingState.Undocked:
break;
}
return(DockingState == DockingState.Undocked && ChildActivity == null);
}
void Start()
{
curState = DockingState.briefing;
}
public DockData(DockingState dockState, Rectangle location)
{
DockState = dockState;
Location = location;
}
public override bool Tick(Actor self)
{
switch (dockingState)
{
case DockingState.Wait:
return(false);
case DockingState.Turn:
dockingState = DockingState.Dock;
QueueChild(new Turn(self, DockAngle));
if (IsDragRequired)
{
QueueChild(new Drag(self, StartDrag, EndDrag, DragLength));
}
return(false);
case DockingState.Dock:
if (Refinery.IsInWorld && !Refinery.IsDead)
{
foreach (var nd in Refinery.TraitsImplementing <INotifyDocking>())
{
nd.Docked(Refinery, self);
}
}
OnStateDock(self);
return(false);
case DockingState.Loop:
if (!Refinery.IsInWorld || Refinery.IsDead || Harv.TickUnload(self, Refinery))
{
dockingState = DockingState.Undock;
}
return(false);
case DockingState.Undock:
OnStateUndock(self);
return(false);
case DockingState.Complete:
if (Refinery.IsInWorld && !Refinery.IsDead)
{
foreach (var nd in Refinery.TraitsImplementing <INotifyDocking>())
{
nd.Undocked(Refinery, self);
}
}
Harv.LastLinkedProc = Harv.LinkedProc;
Harv.LinkProc(self, null);
if (IsDragRequired)
{
QueueChild(new Drag(self, EndDrag, StartDrag, DragLength));
}
return(true);
}
throw new InvalidOperationException("Invalid harvester dock state");
}
public override bool Cancel(Actor self, bool keepQueue = false)
{
dockingState = DockingState.Undock;
return(base.Cancel(self));
}
private IEnumerator AutoDockingRoutine(SpaceStation spaceStation)
{
var points = spaceStation.UndockPoints.ToList();
var pointIndex = UnityEngine.Random.Range(0, points.Count);
var endPoint = points[pointIndex];
var startPoint = points[pointIndex].position + (endPoint.position - spaceStation.transform.position).normalized * DOCK_DISTANCE; //TODO
var proximity = GetDockProximity();
//TODO
var shipAi = ship.GetComponent<AITaskFollower>();
if (!shipAi)
{
shipAi = ship.gameObject.AddComponent<AITaskFollower>();
yield return null; //Start() needs to run
}
var goToEnd = FlyToPointTask.Create(endPoint.position, proximity);
shipAi.AssignTask(goToEnd);
if (!ship.CanSee(endPoint.position) && !goToEnd.Done)
{
var goToStart = FlyToPointTask.Create(startPoint, proximity);
shipAi.AssignTask(goToStart);
while (!goToStart.Done)
{
yield return null;
}
}
while (!goToEnd.Done)
{
yield return null;
}
state = DockingState.Docked;
spaceStation.AddDockedShip(this);
shipAi.ClearTasks();
}
