public void PlayAnimationOfEventExecuter(MapEvent mapEvent, Consequence consequence = null)
{
foreach (AnimationPerEvent animationPerEvent in animationsAsEventExecuter)
{
if (animationPerEvent.mapEvent != mapEvent)
{
continue;
}
PlayAnimation(animationPerEvent.animationClip);
return;
}
if (consequence == null)
{
foreach (Consequence mapEventConsequence in mapEvent.consequences)
{
if (mapEventConsequence.affectedMapElement == AffectedMapElement.eventExecuter)
{
consequence = mapEventConsequence;
break;
}
}
}
PlayAnimationOfStateType(consequence.stateUpdate.stateType);
}
public async Task <IActionResult> Edit(int id, [Bind("ConsequenceId,SubmitedDate,Score,ExamId,CorrectCount,WrongCount,UserId")] Consequence consequence)
{
if (id != consequence.ConsequenceId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(consequence);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ConsequenceExists(consequence.ConsequenceId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["ExamId"] = new SelectList(_context.Exams, "ExamId", "ExamId", consequence.ExamId);
return(View(consequence));
}
public static List <Consequence> getConsequencesFromNode(JSONNode node)
{
if (node != null)
{
List <Consequence> consequences = new List <Consequence> ();
foreach (JSONNode x in node["Consequences"].AsArray)
{
Consequence c = new Consequence();
c.label = x ["Label"];
if (x ["Value"].ToString().Contains("+"))
{
c.action = actions.Increment;
c.value = float.Parse(x ["Value"].ToString().Replace("+", "").Replace("\"", "")) / 100;
}
else if (x ["Value"].ToString().Contains("-"))
{
c.action = actions.Decrement;
c.value = float.Parse(x ["Value"].ToString().Replace('-', ' ').Replace("\"", "")) / 100;
}
else
{
c.action = actions.Replace;
c.value = float.Parse(x ["Value"].ToString().Replace("\"", "")) / 100;
}
consequences.Add(c);
}
return(consequences);
}
else
{
return(null);
}
}
/// <summary>
/// This Factory method returns a Constraint corresponding to the supplied constraint name.
/// The name must match the corresponding class name. Matching is case-insensitive.
/// An ArgumentException is thrown if a matching constraint cannot be found.
/// </summary>
/// <param name="name"></param>
/// <param name="consequence"></param>
/// <returns>A Constraint</returns>
public static IConstraint CreateConstraint(string name, Consequence consequence)
{
var type = GetExtraTypes().Single(t => t.Name.Equals(name, StringComparison.CurrentCultureIgnoreCase));
var toReturn = (IConstraint)Activator.CreateInstance(type);
toReturn.Consequence = consequence;
return(toReturn);
}
public string Str()
{
var res = $"if{Condition.Str()} {Consequence.Str()}";
if (!(Alternative is null))
{
res = $"{res} else {Alternative.Str()}";
}
return(res);
}
public async Task <IActionResult> Create([Bind("ConsequenceId,SubmitedDate,Score,ExamId,CorrectCount,WrongCount,UserId")] Consequence consequence)
{
if (ModelState.IsValid)
{
_context.Add(consequence);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["ExamId"] = new SelectList(_context.Exams, "ExamId", "ExamId", consequence.ExamId);
return(View(consequence));
}
public override string ToString()
{
var sb = new StringBuilder();
sb.Append($"if {Condition.ToString()} {Consequence.ToString()}");
if (Alternative != null)
{
sb.Append($" else {Alternative.ToString()}");
}
return(sb.ToString());
}
private Message GetConsequenceData(Consequence consequence)
{
var message = new ConsequenceDataMessage();
message.characterID = consequence.Belong == null ? "" : consequence.Belong.ID;
message.consequenceID = consequence.ID;
message.persistenceType = (int)consequence.PersistenceType;
message.benefitCharacterID = consequence.Benefiter == null ? "" : consequence.Benefiter.ID;
message.benefitTimes = consequence.BenefitTimes;
message.counteractLevel = consequence.CounteractLevel;
message.mentalDamage = consequence.MentalDamage;
return(message);
}
public GameVariable(string _name, string _unit, float _value, float _CO2Emission, float _maxValue, float _minValue, float _scalingFactor = 1)
{
name = _name;
unit = _unit;
value = _value;
CO2Emission = _CO2Emission;
maxValue = _maxValue;
minValue = _minValue;
scalingFactor = _scalingFactor;
changeValue = _value;
actionsArgs = new List <Tuple <int, float> >();
minConsequence = new Consequence();
maxConsequence = new Consequence();
}
public RegularLine(XmlElement element, LineCatalogue catalogue, Conversation conversation)
: base(element, catalogue, conversation)
{
text = element.GetAttribute("text");
speakerName = element.GetAttribute("speaker");
if (speakerName.Equals("")){
speakerName = "Abby";
}
prerequisite = new Prerequisite(element.GetAttribute("prerequisite"), speakerName, conversation);
consequence = new Consequence(element.GetAttribute("consequence"), speakerName, conversation);
cameraAngle = CameraAngle.GetCameraAngle(element.GetAttribute("camera_angle"));
emotion = Emotion.GetEmotion(element.GetAttribute("expression"));
id = element.GetAttribute("id");
}
public override string ToString()
{
var sb = new StringBuilder();
sb.Append("if")
.Append(Condition.ToString())
.Append(" ")
.Append(Consequence.ToString());
if (Alternative != null)
{
sb.Append("else")
.Append(Alternative.ToString());
}
return(sb.ToString());
}
public static List <Indicator> getIndicatorsFromNode(JSONNode node)
{
if (node != null)
{
List <Indicator> indicators = new List <Indicator> ();
foreach (JSONNode x in node["Indicators"].AsArray)
{
Indicator i = new Indicator();
i.facts = Fact.getFactsFromNode(x);
i.consequences = Consequence.getConsequencesFromNode(x);
indicators.Add(i);
}
return(indicators);
}
else
{
return(null);
}
}
public override void AddConsequences()
{
Consequence consequence = new Consequence("Poll", "Consumer");
consequence.Runnable = () =>
{
BrokerClient brokerClient = new BrokerClient(new HostInfo(TestContext.GetValue("agent1-host"), Int32.Parse(TestContext.GetValue("agent1-port"))));
NetNotification notification = brokerClient.Poll(DestinationName, 10000);
if (notification != null)
{
consequence.Sucess = true;
brokerClient.Acknowledge(notification.Subscription, notification.Message.MessageId);
}
brokerClient.Close();
consequence.Done = true;
};
this.AddConsequence(consequence);
}
public override string ToString()
{
var output = new StringBuilder();
output.Append("if");
output.Append(" ");
output.Append(Condition.ToString());
output.Append("\n");
output.Append(Consequence.ToString());
if (Alternative != null)
{
output.Append("\n");
output.Append("else\n");
output.Append(Alternative.ToString());
}
output.Append("\nend");
return(output.ToString());
}
public override string ToString()
{
var sb = new StringBuilder();
var jsonObject = new JsonObject(sb);
sb.Append(JsonObject.OpenBrace);
jsonObject.AddStringValue(TranscriptTag, TranscriptID);
jsonObject.AddStringValue(BioTypeTag, BioType);
jsonObject.AddStringValue(AminoAcidsTag, AminoAcids);
jsonObject.AddStringValue(CdnaPosTag, ComplementaryDnaPosition);
jsonObject.AddStringValue(CodonsTag, Codons);
jsonObject.AddStringValue(CdsPosTag, CdsPosition);
jsonObject.AddStringValue(ExonsTag, Exons);
jsonObject.AddStringValue(IntronsTag, Introns);
jsonObject.AddStringValue(GeneIdTag, Gene);
jsonObject.AddStringValue(HgncTag, Hgnc);
jsonObject.AddStringValues(ConsequenceTag, Consequence?.ToArray());
jsonObject.AddStringValue(HgvscTag, HgvsCodingSequenceName);
jsonObject.AddStringValue(HgvspTag, HgvsProteinSequenceName);
jsonObject.AddStringValue(GeneFusionTag, GeneFusion, false);
jsonObject.AddStringValue(IsCanonicalTag, IsCanonical, false);
jsonObject.AddStringValue(PolyPhenScoreTag, PolyPhenScore, false);
jsonObject.AddStringValue(PolyPhenPredictionTag, PolyPhenPrediction);
jsonObject.AddStringValue(ProteinIdTag, ProteinID);
jsonObject.AddStringValue(ProteinPosTag, ProteinPosition);
jsonObject.AddStringValue(SiftScoreTag, SiftScore, false);
jsonObject.AddStringValue(SiftPredictionTag, SiftPrediction);
if (AdditionalInfo != null && AdditionalInfo.Count > 0)
{
foreach (var kvp in AdditionalInfo)
{
jsonObject.AddStringValue(kvp.Key, kvp.Value, false);
}
}
sb.Append(JsonObject.CloseBrace);
return(sb.ToString());
}
public virtual void AddConsequences()
{
foreach (TestClientInfo tci in ConsumersInfo)
{
Consequence consequence = new Consequence("Consume", "Consumer");
consequence.Runnable = () =>
{
bool signaled = tci.notificationHandler.ManualResetEvent.WaitOne(this.Timeout, false);
if (!signaled)
{
consequence.Sucess = false;
consequence.Done = false;
return;
}
foreach (NetNotification notification in tci.notificationHandler.Notifications)
{
if (!notification.Destination.Equals(this.SubscriptionName))
{
consequence.ReasonForFailure = String.Format("Unexpected Destination. Expected '{0}', Received: '{1}'", this.SubscriptionName, notification.Destination);
return;
}
//if ( !System.Array.Equals(notification.Message.Payload, Payload ) )
if (!EqualArray(notification.Message.Payload, Payload))
{
consequence.ReasonForFailure = String.Format("Message Payload was different (content). Expected size '{0}', Received size: '{1}'", this.Payload.Length, notification.Message.Payload.Length);
return;
}
}
tci.brokerClient.Close();
consequence.Sucess = true;
consequence.Done = true;
};
this.AddConsequence(consequence);
}
}
public override void MessageReceived(Message message)
{
switch (message.MessageType)
{
case SyncAbilityTypeListMessage.MESSAGE_TYPE: {
var msg = (SyncAbilityTypeListMessage)message;
AbilityType.AbilityTypes.Clear();
foreach (var typeInfo in msg.abilityTypes)
{
var abilityType = new AbilityType(IdentificationConverter.GetID(typeInfo.id), typeInfo.name);
AbilityType.AbilityTypes.Add(abilityType.ID, abilityType);
}
}
break;
case CreateCharacterMessage.MESSAGE_TYPE: {
var msg = (CreateCharacterMessage)message;
var pool = CharacterManager.Instance.CharacterPool;
var character = new Character(IdentificationConverter.GetID(msg.id), msg.avatar);
character.Name = msg.description.name;
character.Description = msg.description.text;
pool.Add(character);
}
break;
case CreateTemporaryCharacterMessage.MESSAGE_TYPE: {
var msg = (CreateTemporaryCharacterMessage)message;
var pool = CharacterManager.Instance.TemporaryCharacterPool;
var character = new Character(IdentificationConverter.GetID(msg.id), msg.avatar);
character.Name = msg.description.name;
character.Description = msg.description.text;
pool.Add(character);
}
break;
case ClearTemporaryCharacterListMessage.MESSAGE_TYPE: {
CharacterManager.Instance.TemporaryCharacterPool.Clear();
}
break;
case UpdateCharacterBaseDataMessage.MESSAGE_TYPE: {
var msg = (UpdateCharacterBaseDataMessage)message;
int characterID = IdentificationConverter.GetID(msg.characterID);
var character = CharacterManager.Instance.FindCharacter(characterID);
character.Destroyed = msg.destroyed;
character.Token = msg.token;
character.FatePoint = msg.fatePoint;
character.RefreshPoint = msg.refreshPoint;
character.PhysicsStress = msg.physicsStress;
character.PhysicsStressMax = msg.physicsStressMax;
character.PhysicsInvincible = msg.physicsInvincible;
character.MentalStress = msg.mentalStress;
character.MentalStressMax = msg.mentalStressMax;
character.MentalInvincible = msg.mentalInvincible;
}
break;
case UpdateCharacterAbilityDataMessage.MESSAGE_TYPE: {
var msg = (UpdateCharacterAbilityDataMessage)message;
int characterID = IdentificationConverter.GetID(msg.characterID);
var character = CharacterManager.Instance.FindCharacter(characterID);
var abilityType = AbilityType.AbilityTypes[IdentificationConverter.GetID(msg.typeID)];
character.Abilities[abilityType] = new AbilityData()
{
customName = msg.customName,
level = msg.level,
damageMental = msg.damageMental
};
}
break;
case CharacterAddAspectMessage.MESSAGE_TYPE: {
var msg = (CharacterAddAspectMessage)message;
int characterID = IdentificationConverter.GetID(msg.characterID);
var character = CharacterManager.Instance.FindCharacter(characterID);
var aspect = new Aspect(IdentificationConverter.GetID(msg.aspectID));
aspect.Name = msg.description.name;
aspect.Description = msg.description.text;
character.Aspects.Add(aspect);
}
break;
case CharacterRemoveAspectMessage.MESSAGE_TYPE: {
var msg = (CharacterRemoveAspectMessage)message;
int characterID = IdentificationConverter.GetID(msg.characterID);
var character = CharacterManager.Instance.FindCharacter(characterID);
character.Aspects.Remove(IdentificationConverter.GetID(msg.aspectID));
}
break;
case CharacterUpdateAspectDataMessage.MESSAGE_TYPE: {
var msg = (CharacterUpdateAspectDataMessage)message;
int characterID = IdentificationConverter.GetID(msg.characterID);
var character = CharacterManager.Instance.FindCharacter(characterID);
var aspect = character.Aspects[IdentificationConverter.GetID(msg.aspectID)];
aspect.PersistenceType = msg.persistenceType;
int benefiterID = IdentificationConverter.GetID(msg.benefiterID);
if (benefiterID == -1)
{
aspect.Benefiter = null;
}
else
{
aspect.Benefiter = CharacterManager.Instance.FindCharacter(benefiterID);
}
aspect.BenefitTimes = msg.benefitTimes;
}
break;
case CharacterClearAspectListMessage.MESSAGE_TYPE: {
var msg = (CharacterClearAspectListMessage)message;
int characterID = IdentificationConverter.GetID(msg.characterID);
var character = CharacterManager.Instance.FindCharacter(characterID);
character.Aspects.Clear();
}
break;
case CharacterAddConsequenceMessage.MESSAGE_TYPE: {
var msg = (CharacterAddConsequenceMessage)message;
int characterID = IdentificationConverter.GetID(msg.characterID);
var character = CharacterManager.Instance.FindCharacter(characterID);
var consequence = new Consequence(IdentificationConverter.GetID(msg.consequenceID));
consequence.Name = msg.description.name;
consequence.Description = msg.description.text;
character.Consequences.Add(consequence);
}
break;
case CharacterRemoveConsequenceMessage.MESSAGE_TYPE: {
var msg = (CharacterRemoveConsequenceMessage)message;
int characterID = IdentificationConverter.GetID(msg.characterID);
var character = CharacterManager.Instance.FindCharacter(characterID);
character.Consequences.Remove(IdentificationConverter.GetID(msg.consequenceID));
}
break;
case CharacterUpdateConsequenceMessage.MESSAGE_TYPE: {
var msg = (CharacterUpdateConsequenceMessage)message;
int characterID = IdentificationConverter.GetID(msg.characterID);
var character = CharacterManager.Instance.FindCharacter(characterID);
var consequence = character.Consequences[IdentificationConverter.GetID(msg.consequenceID)];
consequence.PersistenceType = msg.persistenceType;
int benefiterID = IdentificationConverter.GetID(msg.benefiterID);
if (benefiterID == -1)
{
consequence.Benefiter = null;
}
else
{
consequence.Benefiter = CharacterManager.Instance.FindCharacter(benefiterID);
}
consequence.BenefitTimes = msg.benefitTimes;
consequence.CounteractLevel = msg.counteractLevel;
consequence.ActualDamage = msg.actualDamage;
consequence.Mental = msg.mental;
}
break;
case CharacterClearConsequenceListMessage.MESSAGE_TYPE: {
var msg = (CharacterClearConsequenceListMessage)message;
int characterID = IdentificationConverter.GetID(msg.characterID);
var character = CharacterManager.Instance.FindCharacter(characterID);
character.Consequences.Clear();
}
break;
case CharacterAddStuntMessage.MESSAGE_TYPE: {
var msg = (CharacterAddStuntMessage)message;
int characterID = IdentificationConverter.GetID(msg.characterID);
var character = CharacterManager.Instance.FindCharacter(characterID);
var stunt = new Stunt(IdentificationConverter.GetID(msg.stuntID));
stunt.Name = msg.description.name;
stunt.Description = msg.description.text;
character.Stunts.Add(stunt);
}
break;
case CharacterRemoveStuntMessage.MESSAGE_TYPE: {
var msg = (CharacterRemoveStuntMessage)message;
int characterID = IdentificationConverter.GetID(msg.characterID);
var character = CharacterManager.Instance.FindCharacter(characterID);
character.Stunts.Remove(IdentificationConverter.GetID(msg.stuntID));
}
break;
case CharacterUpdateStuntMessage.MESSAGE_TYPE: {
var msg = (CharacterUpdateStuntMessage)message;
int characterID = IdentificationConverter.GetID(msg.characterID);
var character = CharacterManager.Instance.FindCharacter(characterID);
var stunt = character.Stunts[IdentificationConverter.GetID(msg.stuntID)];
///////////////////////////////////
}
break;
case CharacterClearStuntListMessage.MESSAGE_TYPE: {
var msg = (CharacterClearStuntListMessage)message;
int characterID = IdentificationConverter.GetID(msg.characterID);
var character = CharacterManager.Instance.FindCharacter(characterID);
character.Stunts.Clear();
}
break;
case CharacterAddExtraMessage.MESSAGE_TYPE: {
var msg = (CharacterAddExtraMessage)message;
int characterID = IdentificationConverter.GetID(msg.characterID);
int itemID = IdentificationConverter.GetID(msg.boundCharacterID);
var character = CharacterManager.Instance.FindCharacter(characterID);
var item = CharacterManager.Instance.FindCharacter(itemID);
var extra = new Extra(IdentificationConverter.GetID(msg.extraID), item);
extra.Name = msg.description.name;
extra.Description = msg.description.text;
character.Extras.Add(extra);
}
break;
case CharacterRemoveExtraMessage.MESSAGE_TYPE: {
var msg = (CharacterRemoveExtraMessage)message;
int characterID = IdentificationConverter.GetID(msg.characterID);
var character = CharacterManager.Instance.FindCharacter(characterID);
character.Extras.Remove(IdentificationConverter.GetID(msg.extraID));
}
break;
case CharacterUpdateExtraMessage.MESSAGE_TYPE: {
var msg = (CharacterUpdateExtraMessage)message;
int characterID = IdentificationConverter.GetID(msg.characterID);
var character = CharacterManager.Instance.FindCharacter(characterID);
var extra = character.Extras[IdentificationConverter.GetID(msg.extraID)];
extra.IsLongRangeWeapon = msg.isLongRangeWeapon;
extra.IsVehicle = msg.isVehicle;
}
break;
case CharacterClearExtraListMessage.MESSAGE_TYPE: {
var msg = (CharacterClearExtraListMessage)message;
int characterID = IdentificationConverter.GetID(msg.characterID);
var character = CharacterManager.Instance.FindCharacter(characterID);
character.Extras.Clear();
}
break;
}
}
public string ToString()
{
return("Trigger: " + Trigger.ToString() +
"\n" + "Consequence: " + Consequence.ToString() +
"\n" + "Children: " + Children.Count.ToString());
}
public Consequence ProcessException(ValidationFailure rootValidationFailure)
{
try
{
ConfirmIntegrityOfValidationException(rootValidationFailure);
Dictionary <ItemValidator, Consequence> worstConsequences = new Dictionary <ItemValidator, Consequence>();
foreach (var subException in rootValidationFailure.GetExceptionList())
{
if (!subException.SourceConstraint.Consequence.HasValue)
{
throw new NullReferenceException("ItemValidator of type " + subException.SourceItemValidator.GetType().Name + " on column " + subException.SourceItemValidator.TargetProperty + " has not had it's Consequence configured");
}
//we have encountered a rule that will invalidate the entire row, it's a good idea to keep a track of each of these since it would be rubbish to get a report out the other side that simply says 100% of rows invalid!
if (subException.SourceConstraint.Consequence == Consequence.InvalidatesRow)
{
if (!ReasonsRowsInvalidated.Contains(subException.SourceItemValidator.TargetProperty + "|" + subException.SourceConstraint.GetType().Name))
{
ReasonsRowsInvalidated.Add(subException.SourceItemValidator.TargetProperty + "|" + subException.SourceConstraint.GetType().Name);
}
}
if (worstConsequences.Keys.Contains(subException.SourceItemValidator) == true)
{
//see if situation got worse
Consequence oldConsequence = worstConsequences[subException.SourceItemValidator];
Consequence newConsequence = subException.SourceConstraint.Consequence.Value;
if (newConsequence > oldConsequence)
{
worstConsequences[subException.SourceItemValidator] = newConsequence;
}
}
else
{
//new validation error for this column
worstConsequences.Add(subException.SourceItemValidator, (Consequence)subException.SourceConstraint.Consequence);
}
}
//now record the worst case event
if (worstConsequences.Values.Contains(Consequence.InvalidatesRow))
{
CountOfRowsInvalidated++;
}
foreach (var itemValidator in worstConsequences.Keys)
{
string columnName = itemValidator.TargetProperty;
//increment the most damaging consequence count for this cell
DictionaryOfFailure[columnName][worstConsequences[itemValidator]]++;
}
return(worstConsequences.Max(key => key.Value));
}
catch (Exception e)
{
throw new Exception("An error occurred when trying to process a ValidationException into Verbose results:" + e.Message, e);
}
}
/// <summary>
/// Gets the Impact score from severity and consequence
/// </summary>
/// <param name="severity">Severity as Constants.Severity</param>
/// <param name="consequence">Consequence as Constants.Consequence</param>
/// <returns>A string representing the impact score.</returns>
public static string getImpactScore(Severity? severity,
Consequence? consequence)
{
switch (consequence)
{
case Consequence.Certain:
case Consequence.Probable:
switch (severity)
{
case Severity.Major:
return "1";
case Severity.Moderate:
return "2";
case Severity.Minor:
return "3";
default:
return "";
}
case Consequence.Possible:
switch (severity)
{
case Severity.Major:
case Severity.Moderate:
return "4";
case Severity.Minor:
return "5";
default:
return "";
}
case Consequence.Unlikely:
return "5";
default:
return "";
}
}
