public void Update()
{
TransitionTimer.Update();
if (IsTransitioning)
{
var to = GetScreenByName(TransitioningIn);
if (to != null)
{
to.anchoredPosition = HermiteVector(toStart, toEnd, TransitionTimer.Ratio);
//to.rotation = Quaternion.Lerp(toRotate, Quaternion.identity, TransitionTimer.Ratio);
}
if (!IsTransitioningForModal)
{
var from = GetScreenByName(TransitioningOut);
if (from != null && from != to)
{
from.anchoredPosition = HermiteVector(fromStart, fromEnd, TransitionTimer.Ratio);
}
}
}
else
{
if (ScreenQueue.Count > 0)
{
string nextScreen = ScreenQueue.Dequeue();
SwitchToScreen(nextScreen);
}
}
}
public void TestBackwardSchedulingTransitionTimeForeachOperationIsCorrect(
string testConfigurationFileName)
{
InitThisTest(testConfigurationFileName);
IDbTransactionData dbTransactionData =
ZppConfiguration.CacheManager.ReloadTransactionData();
foreach (var productionOrderBomAsDemand in dbTransactionData.ProductionOrderBomGetAll())
{
ProductionOrderBom productionOrderBom =
(ProductionOrderBom)productionOrderBomAsDemand;
int expectedStartBackward = productionOrderBom.GetStartTimeBackward().GetValue() +
TransitionTimer.GetTransitionTimeFactor() *
productionOrderBom.GetDurationOfOperation().GetValue();
int actualStartBackward = productionOrderBom.GetStartTimeOfOperation().GetValue();
Assert.True(expectedStartBackward.Equals(actualStartBackward),
$"The transition time before operationStart is not correct: " +
$"expectedStartBackward: {expectedStartBackward}, actualStartBackward {actualStartBackward}");
int expectedEndBackward = productionOrderBom.GetStartTimeOfOperation().GetValue() +
productionOrderBom.GetDurationOfOperation().GetValue();
int actualEndBackward = productionOrderBom.GetEndTimeBackward().GetValue();
Assert.True(expectedEndBackward.Equals(actualEndBackward),
$"EndBackward is not correct: " +
$"expectedEndBackward: {expectedEndBackward}, actualEndBackward {actualEndBackward}");
}
}
void CancelTransitionTimer()
{
if (TransitionTimer != null)
{
TransitionTimer.Stop();
}
}
public override Duration GetDuration()
{
EnsureOperationIsLoadedIfExists();
Duration operationDuration = GetDurationOfOperation();
Duration transitionTime =
new Duration(TransitionTimer.CalculateTransitionTime(operationDuration));
return(transitionTime.Plus(operationDuration));
}
public DueTime GetStartTimeBackward()
{
if (_productionOrderOperation.StartBackward == null)
{
return(null);
}
DueTime transitionTime =
new DueTime(TransitionTimer.CalculateTransitionTime(GetDuration()));
DueTime startTimeOfOperation =
new DueTime(_productionOrderOperation.StartBackward.GetValueOrDefault());
DueTime startTime = startTimeOfOperation.Minus(transitionTime);
return(startTime);
}
/**
* Bottom-Up-Traversal
*/
private void ValidatePredecessorOperationsTransitionTimeIsCorrect(
IStackSet <ProductionOrderOperation> predecessorOperations,
ProductionOrderOperation lastOperation,
IDirectedGraph <INode> operationGraph,
IStackSet <INode> traversedOperations)
{
if (predecessorOperations == null)
{
return;
}
foreach (var currentPredecessor in predecessorOperations)
{
if (currentPredecessor.GetType() == typeof(ProductionOrderOperation))
{
ProductionOrderOperation currentOperation = currentPredecessor;
traversedOperations.Push(new Node(currentPredecessor));
// transition time MUST be before the start of Operation
int expectedStartBackwardLowerLimit =
lastOperation.GetValue().EndBackward.GetValueOrDefault() +
TransitionTimer.GetTransitionTimeFactor() *
currentOperation.GetValue().Duration;
int actualStartBackward = currentOperation.GetValue().StartBackward
.GetValueOrDefault();
Assert.True(actualStartBackward >= expectedStartBackwardLowerLimit,
$"The transition time between the operations is not correct: " +
$"expectedStartBackward: {expectedStartBackwardLowerLimit}, actualStartBackward {actualStartBackward}");
INodes predecessorNodesRecursive =
operationGraph.GetPredecessorNodesRecursive(new Node(currentPredecessor));
if (predecessorNodesRecursive != null)
{
IStackSet <ProductionOrderOperation> newPredecessorNodes =
new StackSet <ProductionOrderOperation>(
predecessorNodesRecursive.Select(x =>
(ProductionOrderOperation)x.GetEntity()));
ValidatePredecessorOperationsTransitionTimeIsCorrect(newPredecessorNodes,
currentOperation, operationGraph, traversedOperations);
}
}
else
{
throw new MrpRunException(
"ProductionOrderToOperationGraph should only contain productionOrders/operations.");
}
}
}
public void SetStartTimeBackward(DueTime startTime)
{
if (_productionOrderOperation.IsReadOnly)
{
throw new MrpRunException("A readOnly entity cannot be changed anymore.");
}
DueTime transitionTime =
new DueTime(TransitionTimer.CalculateTransitionTime(GetDuration()));
// startBackwards
DueTime startTimeOfOperation = startTime.Plus(transitionTime);
_productionOrderOperation.StartBackward = startTimeOfOperation.GetValue();
// endBackwards
_productionOrderOperation.EndBackward =
startTimeOfOperation.GetValue() + GetDuration().GetValue();
}
public TransitionState(TransitionTimer timer, int maximumOpacity)
{
Duration = timer.Duration;
MaxOpacity = Convert.ToDouble(maximumOpacity) / 100;
RemainingMilliseconds = Convert.ToInt32(timer.RemainingMilliseconds);
if (Duration == 0 || RemainingMilliseconds <= 0)
{
Ratio = 0;
}
else if (timer.RemainingMilliseconds > Duration)
{
Ratio = 1;
}
else
{
Ratio = timer.RemainingMilliseconds / Duration;
}
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
currentGate = (UltimaMoongate_Frame)reader.ReadItem();
// If opentime is non-zero, assume this was a summoned gate and delete it.
// If summoned by an UltimaMoongate by the moon phase, it'll re-create it when it loads.
// If summoned by spell or GM, it was intended to be temporary anyways.
if (OpenTime > 0)
{
this.Delete();
}
// If zero, it was supposed to be open forever. Raise the gate!
else
{
gateTimer = new TransitionTimer(this);
gateTimer.Start();
}
}
public override void initGate()
{
Name = "Manager for an Ultima IV-style moongate.";
gateTimer = new TransitionTimer(this);
gateTimer.Start();
}
