private void SetupEvents()
{
// called when the target object stays in the container
container.OnGoalStay = () => {
if (brain != NoTargetBrain)
{
// check if not holding object anymore
if (!robotArm.IsHoldingObject())
{
AddReward(4f);
Debug.Log("Drop Success with: " + GetCumulativeReward());
// for debugging (counts successes)
ResultLogger.AddSuccess();
ResultLogger.LogRatio();
// invoke callback for success
if (OnTargetDroppedSuccessfully != null)
{
OnTargetDroppedSuccessfully.Invoke(target);
}
container.OnGoalStay = null;
target = null;
if (DoneOnDrop)
{
Done();
}
}
}
};
}
public static void addArraylistToString(StringBuilder builder, ArrayList result)
{
IEnumerator enumerator = result.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
object obj = enumerator.Current;
if (obj is Hashtable)
{
ResultLogger.addHashtableToString(builder, (Hashtable)obj);
}
else if (obj is ArrayList)
{
ResultLogger.addArraylistToString(builder, (ArrayList)obj);
}
builder.Append("\n--------------------\n");
}
}
finally
{
IDisposable disposable;
if ((disposable = (enumerator as IDisposable)) != null)
{
disposable.Dispose();
}
}
Debug.Log(builder.ToString());
}
public static void logArraylist(ArrayList result)
{
StringBuilder stringBuilder = new StringBuilder();
IEnumerator enumerator = result.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
object obj = enumerator.Current;
Hashtable item = (Hashtable)obj;
ResultLogger.addHashtableToString(stringBuilder, item);
stringBuilder.Append("\n--------------------\n");
}
}
finally
{
IDisposable disposable;
if ((disposable = (enumerator as IDisposable)) != null)
{
disposable.Dispose();
}
}
Debug.Log(stringBuilder.ToString());
}
public static void addHashtableToString(StringBuilder builder, Hashtable item)
{
IDictionaryEnumerator enumerator = item.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
object obj = enumerator.Current;
DictionaryEntry dictionaryEntry = (DictionaryEntry)obj;
if (dictionaryEntry.Value is Hashtable)
{
builder.AppendFormat("{0}: ", dictionaryEntry.Key);
ResultLogger.addHashtableToString(builder, (Hashtable)dictionaryEntry.Value);
}
else if (dictionaryEntry.Value is ArrayList)
{
builder.AppendFormat("{0}: ", dictionaryEntry.Key);
ResultLogger.addArraylistToString(builder, (ArrayList)dictionaryEntry.Value);
}
else
{
builder.AppendFormat("{0}: {1}\n", dictionaryEntry.Key, dictionaryEntry.Value);
}
}
}
finally
{
IDisposable disposable;
if ((disposable = (enumerator as IDisposable)) != null)
{
disposable.Dispose();
}
}
}
public static void logHashtable(Hashtable result)
{
StringBuilder stringBuilder = new StringBuilder();
ResultLogger.addHashtableToString(stringBuilder, result);
Debug.Log(stringBuilder.ToString());
}
void Start()
{
bt = GameObject.FindWithTag("Player1").GetComponent <BehaviourTree>();
resource = resourceGameObject.GetComponent <Resource>();
ResultLogger.assignLoggerVariables();
ResultLogger.tryCreateFile();
p1GoldCount = 0;
p2GoldCount = 0;
playerGoldCounts = new int[numberOfPlayers];
for (int i = 0; i < playerGoldCounts.Length; i++)
{
playerGoldCounts[i] = 0;
}
displayGoldCount();
InvokeRepeating("addGold", 0.001f, goldTimer);
if (Resources.Count <= 0)
{
spawnResource();
//Debug.Log("Resources count: " + Resources.Count);
}
if (Troops == null)
{
//Debug.Log("Troops list is null");
}
}
protected override ReturnCode ExecuteInternal(Interpreter interpreter, IClientData clientData, ArgumentList arguments, ref Result result)
{
InternalLogger.Info("Executing Infotag command.");
InternalLogger.Debug($"Parameters: {string.Join(", ", arguments.Select(a => $"{a.Name}: {a.Value}"))}");
if (arguments.Count < 2)
{
result = Utility.WrongNumberOfArguments(this, 2, arguments, string.Empty);
ResultLogger.Error($"Incorrect number of arguments: {arguments.Count} for command infotag.");
return(ReturnCode.Error);
}
var subCommand = arguments[0];
if (subCommand == _infotagGet.Name)
{
return(_infotagGet.Execute(interpreter, clientData, arguments, ref result));
}
if (subCommand == _infotagSet.Name)
{
return(_infotagSet.Execute(interpreter, clientData, arguments, ref result));
}
ErrorLogger.Error($"Incorrect subcommand argument: {subCommand}");
result = $"Incorrect subcommand argument: {subCommand}";
return(ReturnCode.Error);
}
private void OnTriggerEnter(Collider other)
{
if (other.gameObject.CompareTag("Target"))
{
// if (!robotArmAgent.HasTarget()) {
// robotArmAgent.SetTarget(other.transform);
// }
if (area.IsTrainingArea())
{
if (academy.resetParameters["staycount"] == 0f)
{
AddReward(5f);
AddReward(-1f * Mathf.Abs(wheelVehicle.Speed));
Debug.Log("SUCCESS");
ResultLogger.AddSuccess();
ResultLogger.LogRatio();
Done();
}
else
{
AddReward(1f);
}
}
if (OnTargetEnter != null)
{
OnTargetEnter.Invoke(other.transform);
}
}
}
public override void AgentReset()
{
ResultLogger.AddTry();
if (area != null)
{
area.Reset();
}
}
public static void logArraylist(ArrayList result)
{
StringBuilder stringBuilder = new StringBuilder();
foreach (Hashtable item in result)
{
ResultLogger.addHashtableToString(stringBuilder, item);
stringBuilder.Append("\n--------------------\n");
}
Debug.Log(stringBuilder.ToString());
}
public void ResetForTraining()
{
agentParameters.maxStep = 1200;
HeldAlready = false;
robotArm.Reset();
robotArm.RandomRotation();
SetupEvents();
vehicle.transform.localPosition = new Vector3(0, 0.15f, 0);
vehicle.transform.localEulerAngles = new Vector3(0, 0, 0);
brainConfig = 1;
ResultLogger.AddTry();
}
public static void logArraylist(ArrayList result)
{
StringBuilder builder = new StringBuilder();
// we start off with an ArrayList of Hashtables
foreach (Hashtable item in result)
{
ResultLogger.addHashtableToString(builder, item);
builder.Append("\n--------------------\n");
}
Debug.Log(builder.ToString());
}
private ReturnCode ExecuteDefine(Interpreter interpreter, ArgumentList arguments,
ref Result result)
{
var fsmArray = arguments[2];
var initialState = arguments[3];
InternalLogger.Info($"Defining FSM with array {fsmArray} to initial state {initialState}");
if (!TclUtils.ArrayExists(interpreter, fsmArray))
{
var fsmTransArrayError = $"Array of fsm states with name: {fsmArray} does not exist (is not defined).";
ErrorLogger.Error(fsmTransArrayError);
result = fsmTransArrayError;
return(ReturnCode.Error);
}
InternalLogger.Debug($"Retrieving all FSM transitions from {fsmArray} FSM array.");
IReadOnlyList <FsmTransition> fsmTransitions;
if (!FsmUtils.TryGetFsmTransitions(interpreter, fsmArray, out fsmTransitions))
{
var transitionsFailed = $"Failed to retrieve FSM transition from {fsmArray} array.";
ErrorLogger.Error(transitionsFailed);
result = transitionsFailed;
return(ReturnCode.Error);
}
InternalLogger.Info($"Assigning all {fsmTransitions.Count} into internal transitions set.");
_transitions.Clear();
foreach (var fsmTransition in fsmTransitions)
{
InternalLogger.Debug($"Adding FSM transition: {fsmTransition}");
_transitions.Add(fsmTransition);
}
InternalLogger.Info($"Checking whether {initialState} state is defined in transition set.");
if (!ContainsState(initialState))
{
var stateNotFound = $"State {initialState} was not found in defined transitions. Known states are:\n{string.Join(",", DumpStates())}";
ErrorLogger.Error(stateNotFound);
result = stateNotFound;
return(ReturnCode.Error);
}
CurrentState = initialState;
ResultLogger.Info($"FSM successfully defined to initial state: {initialState}");
return(ReturnCode.Ok);
}
public static void logObject(object result)
{
if (result.GetType() == typeof(ArrayList))
{
ResultLogger.logArraylist((ArrayList)result);
}
else if (result.GetType() == typeof(Hashtable))
{
ResultLogger.logHashtable((Hashtable)result);
}
else
{
Debug.Log("result is not a hashtable or arraylist");
}
}
// Token: 0x06001BA0 RID: 7072 RVA: 0x0008E124 File Offset: 0x0008C324
public static void addArraylistToString(StringBuilder builder, ArrayList result)
{
foreach (object obj in result)
{
if (obj is Hashtable)
{
ResultLogger.addHashtableToString(builder, (Hashtable)obj);
}
else if (obj is ArrayList)
{
ResultLogger.addArraylistToString(builder, (ArrayList)obj);
}
builder.Append("\n--------------------\n");
}
}
public static void addArraylistToString(StringBuilder builder, ArrayList result)
{
foreach (object current in result)
{
if (current is Hashtable)
{
ResultLogger.addHashtableToString(builder, (Hashtable)current);
}
else if (current is ArrayList)
{
ResultLogger.addArraylistToString(builder, (ArrayList)current);
}
builder.Append("\n--------------------\n");
}
Debug.Log(builder.ToString());
}
public static void addArraylistToString(StringBuilder builder, ArrayList result)
{
// we start off with an ArrayList of Hashtables
foreach (object item in result)
{
if (item is Hashtable)
{
ResultLogger.addHashtableToString(builder, (Hashtable)item);
}
else if (item is ArrayList)
{
ResultLogger.addArraylistToString(builder, (ArrayList)item);
}
builder.Append("\n--------------------\n");
}
Debug.Log(builder.ToString());
}
// Token: 0x06001B9C RID: 7068 RVA: 0x0008DF24 File Offset: 0x0008C124
public static void logObject(object result)
{
if (result == null)
{
Debug.Log("attempting to log a null object");
return;
}
if (result.GetType() == typeof(ArrayList))
{
ResultLogger.logArraylist((ArrayList)result);
}
else if (result.GetType() == typeof(Hashtable))
{
ResultLogger.logHashtable((Hashtable)result);
}
else
{
Debug.Log("result is not a hashtable or arraylist");
}
}
private ReturnCode ExecuteSetState(ArgumentList arguments, ref Result result)
{
var fsmState = arguments[2];
InternalLogger.Info($"Executing FSM setstate with next state to be {fsmState}");
if (!ContainsState(fsmState))
{
var stateNotFound = $"State {fsmState} was not found in defined transitions. Known states are:\n{string.Join(",", DumpStates())}";
ErrorLogger.Error(stateNotFound);
result = stateNotFound;
return(ReturnCode.Error);
}
_overriddenNextState = fsmState;
ResultLogger.Info($"Next FSM state successfully set to be {fsmState}.");
return(ReturnCode.Ok);
}
[Test]//, Ignore("integration")]
public void UptimeMonitor_Runs()
{
var successWait = TimeSpan.FromSeconds(1);
var pinger = new Pinger("8.8.8.8");
var logWriter = new MultipleOutputWriter(
new ConsolOutputWriter(),
new FileOutputWriter("D:\\Projects\\InternetMonitor\\InternetMonitor\\InternetMonitor.Tests\\bin\\Debug\\log.txt")
);
var failWriter = new FileOutputWriter("D:\\Projects\\InternetMonitor\\InternetMonitor\\InternetMonitor.Tests\\bin\\Debug\\failures.txt");
var resultLogger = new ResultLogger(logWriter, failWriter);
var monitor = new UptimeMonitor(successWait, pinger, resultLogger);
var task = monitor.Run();
Thread.Sleep(TimeSpan.FromSeconds(60));
monitor.Stop();
task.Wait();
}
public static void addHashtableToString(StringBuilder builder, Hashtable item)
{
foreach (DictionaryEntry dictionaryEntry in item)
{
if (dictionaryEntry.Value is Hashtable)
{
builder.AppendFormat("{0}: ", dictionaryEntry.Key);
ResultLogger.addHashtableToString(builder, (Hashtable)dictionaryEntry.Value);
}
else if (dictionaryEntry.Value is ArrayList)
{
builder.AppendFormat("{0}: ", dictionaryEntry.Key);
ResultLogger.addArraylistToString(builder, (ArrayList)dictionaryEntry.Value);
}
else
{
builder.AppendFormat("{0}: {1}\n", dictionaryEntry.Key, dictionaryEntry.Value);
}
}
}
public void ResultLoggerTests()
{
var logWriter = MockRepository.GenerateStrictMock <IOutputWriter>();
var failWriter = MockRepository.GenerateStrictMock <IOutputWriter>();
logWriter.Expect(l => l.WriteLine(Arg <string> .Matches(p => p.EndsWith("No Failure."))));
logWriter.Expect(l => l.WriteLine(Arg <string> .Matches(p => p.EndsWith("Failure begin."))));
logWriter.Expect(l => l.WriteLine(Arg <string> .Matches(p => p.EndsWith("Failure continuing."))));
logWriter.Expect(l => l.WriteLine(Arg <string> .Matches(p => p.Contains("Connection restored. Outage Duration: "))));
logWriter.Expect(l => l.WriteLine(Arg <string> .Matches(p => p.EndsWith("No Failure."))));
failWriter.Expect(l => l.WriteLine(Arg <string> .Matches(p => p.Contains("Connection Restored. Begin: "))));
var resultLogger = new ResultLogger(logWriter, failWriter);
resultLogger.Log(DateTime.Now, true);
resultLogger.Log(DateTime.Now, false);
resultLogger.Log(DateTime.Now, false);
resultLogger.Log(DateTime.Now, true);
resultLogger.Log(DateTime.Now, true);
}
public void checkAlive()
{
if (health <= 0)
{
Destroy(gameObject);
if (thisteamNumber == TeamNumber.t1)
{
ResultLogger.setPlayerWinnerNumber(TeamNumber.t2);
}
if (thisteamNumber == TeamNumber.t2)
{
ResultLogger.setPlayerWinnerNumber(TeamNumber.t1);
}
Debug.Log("Result Loggggeeedd");
ResultLogger.logGameTime(scene.gameLength);
ResultLogger.logAllDataToFile();
SceneManager.LoadScene(SceneManager.GetActiveScene().name);
}
}
private void OnTriggerStay(Collider other)
{
if (other.gameObject.CompareTag("Target"))
{
// just test stay if training
if (area.IsTrainingArea())
{
if (academy.resetParameters["staycount"] != 0f)
{
staycounter++;
if (staycounter > academy.resetParameters["staycount"])
{
staycounter = -5000;
AddReward(5f);
AddReward(-1f * Mathf.Abs(wheelVehicle.Speed));
Debug.Log("SUCCESS");
ResultLogger.AddSuccess();
ResultLogger.LogRatio();
Done();
}
}
}
}
}
private ReturnCode ExecuteRaiseEvent(Interpreter interpreter, ArgumentList arguments, ref Result result)
{
var raisedEvent = arguments[2];
InternalLogger.Info($"Executing {raisedEvent} event.");
if (!CiscoTclEvents.All.Contains(raisedEvent.String))
{
var unknownEvent = $"Event {raisedEvent} is not valid Cisco TCL event.\nValid CiscoTcl events are: [{string.Join(", ", CiscoTclEvents.All)}]";
ErrorLogger.Error(unknownEvent);
result = unknownEvent;
return(ReturnCode.Error);
}
var transition = DetermineCurrentTransition(raisedEvent);
if (transition == null)
{
var transitionNotDefined = $"Transition for event {raisedEvent} is not defined in FSM.";
ErrorLogger.Warn(transitionNotDefined);
result = transitionNotDefined;
//transition is not defined, but it's not an error, just don't perform any transitions
return(ReturnCode.Ok);
}
InternalLogger.Info($"Found transition for event {raisedEvent} is {transition}.");
if (!TclUtils.ProcedureExists(interpreter, transition.Procedure))
{
var procedureNotExists = $"Procedure {transition.Procedure} which is defined in transition {transition} does not exist.";
ErrorLogger.Error(procedureNotExists);
result = procedureNotExists;
return(ReturnCode.Error);
}
var code = interpreter.EvaluateScript($"{transition.Procedure}", ref result);
if (code != ReturnCode.Ok)
{
var error = $"Error occured while executing procedure {transition.Procedure}. Error: {result.String}";
ErrorLogger.Error(error);
result = error;
return(ReturnCode.Error);
}
var nextStateToSet = DetermineNextState(transition);
if (!ContainsState(nextStateToSet))
{
var notDefinedState = $"Target state {nextStateToSet} defined in transition is not defined in FSM transitions.";
ErrorLogger.Error(notDefinedState);
result = notDefinedState;
return(ReturnCode.Error);
}
CurrentState = nextStateToSet;
//unset overridden state no matter if it was or was not used
_overriddenNextState = string.Empty;
ResultLogger.Info($"Successfully raised {raisedEvent} and set FSM to state {nextStateToSet}");
return(ReturnCode.Ok);
}
/// <summary>
/// Logs push message result.
/// </summary>
protected void Log(MessageSendResult result)
{
ResultLogger.Log(DisplayName, result);
}
/// <summary>
/// Logs push message error.
/// </summary>
protected void Log(MessageSendException exception)
{
ResultLogger.Log(DisplayName, exception);
}
