void Behave()
{
//Sequence for going in an open door
DebugTask openDebug = new DebugTask("Going through open door sequence");
ConditionalIsTrue doorOpenCheck = new ConditionalIsTrue(door.isOpen);
ArriveToTarget goInRoom = new ArriveToTarget(arrive, roomNavTarget);
Task[] openDoorSystem = new Task[3];
openDoorSystem[0] = openDebug;
openDoorSystem[1] = doorOpenCheck;
openDoorSystem[2] = goInRoom;
Sequence doorOpenSequence = new Sequence(openDoorSystem);
//Sequence for going in closed door
DebugTask closedDebug = new DebugTask("Going through closed door sequence");
ArriveToTarget goToDoor = new ArriveToTarget(arrive, doorNavTarget);
ConditionalIsTrue tryOpeningDoor = new ConditionalIsTrue(door.TryOpening());
OpenDoor openTheDoorUp = new OpenDoor(door);
//As is, these arrives don't have timing so it will seem like just going into the room
ArriveToTarget advanceIntoRoom = new ArriveToTarget(arrive, roomNavTarget);
Task[] closedDoorSystem = new Task[5];
closedDoorSystem[0] = closedDebug;
closedDoorSystem[1] = goToDoor;
closedDoorSystem[2] = tryOpeningDoor;
closedDoorSystem[3] = openTheDoorUp;
closedDoorSystem[4] = advanceIntoRoom;
Sequence closedDoorSequence = new Sequence(closedDoorSystem);
//Sequence for going in locked door
//Can just reuse goToDoor!
DebugTask lockedDebug = new DebugTask("Going through locked door sequence");
ConditionalIsFalse tryOpeningDoorFalse = new ConditionalIsFalse(door.TryOpening());
BustDoor burstIn = new BustDoor(door);
//Can reuse advanceIntoRoom as well!
Task[] lockedDoorSystem = new Task[5];
lockedDoorSystem[0] = lockedDebug;
lockedDoorSystem[1] = goToDoor;
lockedDoorSystem[2] = tryOpeningDoorFalse;
lockedDoorSystem[3] = burstIn;
lockedDoorSystem[4] = advanceIntoRoom;
Sequence lockedDoorSequence = new Sequence(lockedDoorSystem);
//Make a selector to try to go in closed door before locked
Task[] closedDoorOptions = new Task[2];
closedDoorOptions[0] = closedDoorSequence;
closedDoorOptions[1] = lockedDoorSequence;
Selector closedProtocols = new Selector(closedDoorOptions);
//Make a selector to try to go in the open door before closed ones
Task[] overallDoorProtocols = new Task[2];
overallDoorProtocols[0] = doorOpenSequence;
overallDoorProtocols[1] = closedProtocols;
Selector overallDoorOptions = new Selector(overallDoorProtocols);
overallDoorOptions.run();
}
public override bool Execute()
{
var debug = string.Equals("true", DebugTask?.Trim(), StringComparison.OrdinalIgnoreCase);
var promptAuth = string.Equals("true", AlwaysPromptInteractiveAuth?.Trim(), StringComparison.OrdinalIgnoreCase);
Config.Log.Information = x => Log.LogWarning(x);
Config.Log.Error = (ex, m) => Log.LogError("Error while processing secrets from keyvault. " + Environment.NewLine + ex);
try
{
if (debug && !Debugger.IsAttached)
{
Debugger.Launch();
Debugger.Break();
}
if (promptAuth)
{
Log.LogWarning("KeyVaultBuildTask: Set to always prompting for auth information.");
}
var service = SecretServiceBuilder.Create()
.AlwaysPromptInteractiveAuth(promptAuth)
.WithDirectory(DirectoryId)
.WithServicePrincipal(ClientId, Secret);
if (!string.IsNullOrEmpty(VaultAliases))
{
foreach (var alias in VaultAliases?.Trim().Split(new [] { ';' }, StringSplitOptions.RemoveEmptyEntries))
{
var pair = alias.Split(new[] { ':' }, StringSplitOptions.RemoveEmptyEntries);
service.WithVaultAlias(pair.First(), pair.Last());
Log.LogWarning("Overriding vault '{0}' with '{1}'", pair.First(), pair.Last());
}
}
var transformKey = new TransformKeys(service.Build());
var files = ConfigFiles.Select(file => file.GetMetadata("Fullpath")).ToArray();
Parallel.ForEach(files, file =>
{
transformKey.SaveAsFile(file);
});
}
catch (Exception ex)
{
TokenCache.DefaultShared.Clear();
Config.Log.Error(ex, "Error occured processing secrets. ");
if (debug)
{
Debugger.Break();
}
return(false);
}
return(true);
}
public override bool Execute()
{
if (DebugMode)
{
TaskLogger.LogInfo(MessageImportance.Low, "DebugMode Detected");
if (_debugTask == null)
{
_debugTask = new DebugTask();
}
_debugTask.ExecWithInfo(this.NetSdkTaskName);
}
return(TaskLogger.TaskSucceededWithNoErrorsLogged);
}
private IUnityTask OnPing(Ping ping, IPEndPoint senderAddress)
{
if (_isConnected || _pendingConnection != null)
{
return(EmptyTask);
}
_pendingConnection = senderAddress;
var connectionMessage = new ConnectionRequest(_synchronizationData.myName);
var sendMessage = new Common.SendMessageTask(_connection, connectionMessage, senderAddress);
var debug = new DebugTask($"Started waiting for connection", _logger);
return(new BatchTask(debug, sendMessage));
}
private IUnityTask OnConnectionResponse(ConnectionResponse response, IPEndPoint senderAddress)
{
if (_isConnected || (_pendingConnection != null && !senderAddress.Equals(_pendingConnection)))
{
return(EmptyTask);
}
_isConnected = true;
_connectedTo = senderAddress;
_pendingConnection = null;
_connectionTimer = 0f;
_notificationTask.SetAddress(_connectedTo);
var debug = new DebugTask($"Connected to {_connectedTo}", _logger);
var connectedEvent = new FireEventTask(connected);
if (response.Opponent != null)
{
var updateOpponent = new UpdateOpponentData(_synchronizationData, response.Opponent);
return(new BatchTask(debug, connectedEvent, updateOpponent));
}
return(new BatchTask(debug, connectedEvent));
}
