private void CheckValidLookahead(ILogicalTimeInterval theLookahead)
{
if (theLookahead.CompareTo(logicalTimeIntervalFactory.MakeZero()) == -1)
{
throw new InvalidLookahead("The lookahead's value is invalid");
}
}
protected void SimulationMoveActor(Actor anActor, Home aTarget)
{
if (isActorInLocation(anActor, anActor.Home))
{
if (anActor.Home.BoxesCount > 0 || initialTime)
{
// Función que calcule la llegada
ILogicalTime currentTime = rti.QueryLogicalTime();
ILogicalTimeInterval intervalTimeArriveAtTheTarget = GetArrivalTimeToTarget(anActor, aTarget);
ILogicalTime timeArriveAtTheTarget = currentTime.Add(intervalTimeArriveAtTheTarget);
NotifiesBoxInHouse(timeArriveAtTheTarget);
MoveActor(anActor, aTarget);
anActor.Home.BoxesCount = 0;
}
}
else
{
initialTime = false;
if (!isActorInTarget(anActor, aTarget))
{
MoveActor(anActor, aTarget);
}
// El muñeco está en el destino
else
{
scenario.MoveActorToHome(anActor.Home.PosX, anActor.Home.PosY);
sendedBoxInHouseInteraction = false;
}
}
}
public TimeManagementObjectModelInteractionListener(XrtiExecutiveAmbassador aRti,
ILogicalTimeFactory aTimeFactory, Home home, ILogicalTimeInterval moveActorInterval,
TimeManagementForm form, TimeManagementSimulation simulation)
{
this.rti = aRti;
this.timeFactory = aTimeFactory;
this.home = home;
this.moveActorInterval = moveActorInterval;
this.form = form;
this.simulation = simulation;
}
public TimeManagementObjectModelInteractionListener(XrtiExecutiveAmbassador aRti,
ILogicalTimeFactory aTimeFactory, Home home, ILogicalTimeInterval moveActorInterval,
TimeManagementForm form, TimeManagementSimulation simulation)
{
this.rti = aRti;
this.timeFactory = aTimeFactory;
this.home = home;
this.moveActorInterval = moveActorInterval;
this.form = form;
this.simulation = simulation;
}
/// <summary>
/// Adds the specified time interval to this logical time, returning
/// the result as a new <code>ILogicalTime</code>.
/// </summary>
/// <param name="val">the time interval to Add to this logical time
/// </param>
/// <returns> a new <code>ILogicalTime</code> that represents this logical time
/// plus the specified time interval
/// </returns>
/// <exception cref=""> IllegalTimeArithmetic if the operation cannot be performed
/// </exception>
public virtual ILogicalTime Add(ILogicalTimeInterval pVal)
{
long intervalValue = ((LongValuedLogicalTimeInterval)pVal).Value, newValue = val + intervalValue;
if (newValue < 0)
{
throw new IllegalTimeArithmetic("attempted to Create logical time greater than maximum");
}
else
{
return new LongValuedLogicalTime(newValue);
}
}
/// <summary>
/// Adds the specified time interval to this logical time, returning
/// the result as a new <code>ILogicalTime</code>.
/// </summary>
/// <param name="val">the time interval to Add to this logical time
/// </param>
/// <returns> a new <code>ILogicalTime</code> that represents this logical time
/// plus the specified time interval
/// </returns>
/// <exception cref=""> IllegalTimeArithmetic if the operation cannot be performed
/// </exception>
public virtual ILogicalTime Add(ILogicalTimeInterval pVal)
{
double intervalValue = ((DoubleValuedLogicalTimeInterval)pVal).Value, newValue = val + intervalValue;
if (newValue < 0)
{
throw new IllegalTimeArithmetic("attempted to Create logical time greater than maximum");
}
else
{
return(new DoubleValuedLogicalTime(newValue));
}
}
/// <summary>
/// Subtracts the specified time interval from this logical time, returning
/// the result as a new <code>ILogicalTime</code>.
/// </summary>
/// <param name="val">the time interval to Subtract from this logical time
/// </param>
/// <returns> a new <code>ILogicalTime</code> that represents this logical time
/// minus the specified time interval
/// </returns>
/// <exception cref=""> IllegalTimeArithmetic if the operation cannot be performed
/// </exception>
public virtual ILogicalTime Subtract(ILogicalTimeInterval pVal)
{
double intervalValue = ((DoubleValuedLogicalTimeInterval)pVal).Value, newValue = val - intervalValue;
if (newValue < 0)
{
throw new IllegalTimeArithmetic("attempted to Create logical time less than zero");
}
else
{
return(new DoubleValuedLogicalTime(newValue));
}
}
///<summary>
/// Writes this ILogicalTimeInterval to the specified stream.
///</summary>
///<param name="writer"> the output stream to write to</param>
///<param name="HLAfederationName"> the property to serialize</param>
///<exception cref="System.IO.IOException"> if an error occurs</exception>
public override void Serialize(HlaEncodingWriter writer, object HLAlogicalTimeInterval)
{
try
{
ILogicalTimeInterval logicalTimeInterval = (ILogicalTimeInterval)HLAlogicalTimeInterval;
byte[] logicalTimeIntervalBytesArray = new byte[logicalTimeInterval.EncodedLength()];
logicalTimeInterval.Encode(logicalTimeIntervalBytesArray, 0);
writer.WriteHLAopaqueData(logicalTimeIntervalBytesArray);
}
catch (IOException ioe)
{
throw new RTIinternalError(ioe.ToString());
}
}
/// <summary>
/// Subtracts the specified time interval from this logical time, returning
/// the result as a new <code>ILogicalTime</code>.
/// </summary>
/// <param name="val">the time interval to Subtract from this logical time
/// </param>
/// <returns> a new <code>ILogicalTime</code> that represents this logical time
/// minus the specified time interval
/// </returns>
/// <exception cref=""> IllegalTimeArithmetic if the operation cannot be performed
/// </exception>
public virtual ILogicalTime Subtract(ILogicalTimeInterval pVal)
{
long intervalValue = ((LongValuedLogicalTimeInterval)pVal).Value, newValue = val - intervalValue;
if (newValue < 0)
{
throw new IllegalTimeArithmetic("attempted to Create logical time less than zero");
}
else
{
return new LongValuedLogicalTime(newValue);
}
}
/// <summary>
/// Subtracts the specified logical time interval from this one,
/// returning a new <code>ILogicalTimeInterval</code> representing the
/// result.
/// </summary>
/// <param name="subtrahend">the logical time interval to Subtract from this one
/// </param>
/// <returns> a new <code>ILogicalTimeInterval</code> representing the
/// result of the operation
/// </returns>
public virtual ILogicalTimeInterval Subtract(ILogicalTimeInterval subtrahend)
{
return(new LongValuedLogicalTimeInterval(val - ((LongValuedLogicalTimeInterval)subtrahend).val));
}
/// <summary>
/// Subtracts the specified time interval from this logical time, returning
/// the result as a new <code>ILogicalTime</code>.
/// </summary>
/// <param name="val">the time interval to Subtract from this logical time
/// </param>
/// <returns> a new <code>ILogicalTime</code> that represents this logical time
/// minus the specified time interval
/// </returns>
/// <exception cref=""> IllegalTimeArithmetic if the operation cannot be performed
/// </exception>
public virtual ILogicalTime Subtract(ILogicalTimeInterval pVal)
{
throw new NotImplementedException("Not yet implemented");
}
protected ILogicalTimeInterval ConvertToFederationLogicalTimeIntervalRepresentation(ILogicalTimeInterval timeInterval)
{
if (Federation != null)
{
ILogicalTimeIntervalFactory factory = Federation.LogicalTimeIntervalFactory;
if (factory != null)
{
byte[] timeIntervalByteArray = new byte[timeInterval.EncodedLength()];
timeInterval.Encode(timeIntervalByteArray, 0);
return(factory.Decode(timeIntervalByteArray, 0));
}
else
{
return(timeInterval);
}
}
else
{
return(timeInterval);
}
}
/// <summary>
/// Subtracts the specified logical time interval from this one,
/// returning a new <code>ILogicalTimeInterval</code> representing the
/// result.
/// </summary>
/// <param name="subtrahend">the logical time interval to Subtract from this one
/// </param>
/// <returns> a new <code>ILogicalTimeInterval</code> representing the
/// result of the operation
/// </returns>
public virtual ILogicalTimeInterval Subtract(ILogicalTimeInterval subtrahend)
{
return new LongValuedLogicalTimeInterval(val - ((LongValuedLogicalTimeInterval)subtrahend).val);
}
private void CheckValidLookahead(ILogicalTimeInterval theLookahead)
{
if (theLookahead.CompareTo(logicalTimeIntervalFactory.MakeZero()) == -1)
throw new InvalidLookahead("The lookahead's value is invalid");
}
public void ModifyLookahead(ILogicalTimeInterval theLookahead)
{
// TODO ANGEL: Ojo! Si el lookahead es menor no sería correcto
this.federate.HLAlookahead = theLookahead;
}
public void EnableTimeRegulation(ILogicalTimeInterval theLookahead)
{
lock (this)
{
/* 1. Process exceptions */
VerifyFederateIsExecutionMember();
CheckIsRegulating();
// If the calling federate is in pending on calling the enabledTimeRegulation service
CheckTimeRegulationPending();
CheckValidLookahead(theLookahead);
// if the calling federate is in time advancing state
CheckAdvancing();
/* 2. Compute logical time */
ILogicalTime maxTime = federate.HLAlogicalTime.Add(theLookahead);
String federationName = ((Sxtafederate)this.federate).HLAfederationNameJoined;
IList<Sxtafederate> constrainedFederates = metaFederateAmbassador.GetConstrainedFederates(federationName);
foreach (Sxtafederate constrainedFederate in constrainedFederates)
{
// it is not the calling federate
if (constrainedFederate != this.federate)
{
if (constrainedFederate.HLAlogicalTime.CompareTo(maxTime) >= 0)
{
maxTime = constrainedFederate.HLAlogicalTime;
// COMMENT ANGEL: He omitido lo del EPSILON porque no entiendo que función tiene
// CONTESTACIÓN: Debe añadirse una cantidad suficientemente peq para que no sea justamente el tiempo lógico del regulado
maxTime = maxTime.Add(logicalTimeIntervalFactory.MakeEpsilon());
}
}
}
PendingTime = maxTime.Subtract(theLookahead);
/* 3. Set lookahead and pending flag */
federate.HLAlookahead = theLookahead;
TimeRegulating = Status.PENDING;
/* 4. Send all RO messages to the calling federate */
lrc.TickRO();
/* 5. Judge whether the calling federate is granted to be regulating */
if (this.federate.HLAtimeConstrained)
{
// The invocation of this service shall be considered an implicit TARA service invocation
bTimeAdvanceRequestAvailable = Status.PENDING;
ComputeGALT();
if (PendingTime.CompareTo(federate.HLAGALT) <= 0)
{
// All messages with time stamp <= pending time in the calling
// federate's TSO queue are sent to the federate
lrc.TickTSO(PendingTime);
bTimeAdvanceRequestAvailable = Status.ON;
TimeRegulating = Status.ON;
this.federate.HLAlogicalTime = PendingTime;
this.federateAmbassador.TimeRegulationEnabled(federate.HLAlogicalTime);
}
else
{
// All messages with time stamp <= GALT in the calling
// federate's TSO queue are sent to the federate
lrc.TickTSO(federate.HLAGALT);
}
}
else
{
bTimeAdvanceRequestAvailable = Status.ON;
TimeRegulating = Status.ON;
this.federate.HLAlogicalTime = PendingTime;
this.federateAmbassador.TimeRegulationEnabled(federate.HLAlogicalTime);
}
}
}
/// <summary>
/// Adds the specified time interval to this logical time, returning
/// the result as a new <code>ILogicalTime</code>.
/// </summary>
/// <param name="val">the time interval to Add to this logical time
/// </param>
/// <returns> a new <code>ILogicalTime</code> that represents this logical time
/// plus the specified time interval
/// </returns>
/// <exception cref=""> IllegalTimeArithmetic if the operation cannot be performed
/// </exception>
public virtual ILogicalTime Add(ILogicalTimeInterval pVal)
{
throw new NotImplementedException("Not yet implemented");
}
public void EnableTimeRegulation(ILogicalTimeInterval theLookahead)
{
lock (this)
{
/* 1. Process exceptions */
VerifyFederateIsExecutionMember();
CheckIsRegulating();
// If the calling federate is in pending on calling the enabledTimeRegulation service
CheckTimeRegulationPending();
CheckValidLookahead(theLookahead);
// if the calling federate is in time advancing state
CheckAdvancing();
/* 2. Compute logical time */
ILogicalTime maxTime = federate.HLAlogicalTime.Add(theLookahead);
String federationName = ((Sxtafederate)this.federate).HLAfederationNameJoined;
IList <Sxtafederate> constrainedFederates = metaFederateAmbassador.GetConstrainedFederates(federationName);
foreach (Sxtafederate constrainedFederate in constrainedFederates)
{
// it is not the calling federate
if (constrainedFederate != this.federate)
{
if (constrainedFederate.HLAlogicalTime.CompareTo(maxTime) >= 0)
{
maxTime = constrainedFederate.HLAlogicalTime;
// COMMENT ANGEL: He omitido lo del EPSILON porque no entiendo que función tiene
// CONTESTACIÓN: Debe añadirse una cantidad suficientemente peq para que no sea justamente el tiempo lógico del regulado
maxTime = maxTime.Add(logicalTimeIntervalFactory.MakeEpsilon());
}
}
}
PendingTime = maxTime.Subtract(theLookahead);
/* 3. Set lookahead and pending flag */
federate.HLAlookahead = theLookahead;
TimeRegulating = Status.PENDING;
/* 4. Send all RO messages to the calling federate */
lrc.TickRO();
/* 5. Judge whether the calling federate is granted to be regulating */
if (this.federate.HLAtimeConstrained)
{
// The invocation of this service shall be considered an implicit TARA service invocation
bTimeAdvanceRequestAvailable = Status.PENDING;
ComputeGALT();
if (PendingTime.CompareTo(federate.HLAGALT) <= 0)
{
// All messages with time stamp <= pending time in the calling
// federate's TSO queue are sent to the federate
lrc.TickTSO(PendingTime);
bTimeAdvanceRequestAvailable = Status.ON;
TimeRegulating = Status.ON;
this.federate.HLAlogicalTime = PendingTime;
this.federateAmbassador.TimeRegulationEnabled(federate.HLAlogicalTime);
}
else
{
// All messages with time stamp <= GALT in the calling
// federate's TSO queue are sent to the federate
lrc.TickTSO(federate.HLAGALT);
}
}
else
{
bTimeAdvanceRequestAvailable = Status.ON;
TimeRegulating = Status.ON;
this.federate.HLAlogicalTime = PendingTime;
this.federateAmbassador.TimeRegulationEnabled(federate.HLAlogicalTime);
}
}
}
/// <summary>
/// Subtracts the specified logical time interval from this one,
/// returning a new <code>ILogicalTimeInterval</code> representing the
/// result.
/// </summary>
/// <param name="subtrahend">the logical time interval to Subtract from this one
/// </param>
/// <returns> a new <code>ILogicalTimeInterval</code> representing the
/// result of the operation
/// </returns>
public virtual ILogicalTimeInterval Subtract(ILogicalTimeInterval subtrahend)
{
throw new NotImplementedException("Not yet implemented");
}
public void ModifyLookahead(ILogicalTimeInterval theLookahead)
{
// TODO ANGEL: Ojo! Si el lookahead es menor no sería correcto
this.federate.HLAlookahead = theLookahead;
}
