public void MinAsync(string columnName, SqlCondition condition, BasicAction <TableKey> onMin) { SqlManager.PoolAsyncOperation(() => { var min = _database.Min <TableKey>(columnName, condition); onMin?.Invoke(min); }); }
public void ExistAsync(SqlCondition condition, BasicAction <bool> onExist, bool distinct) { SqlManager.PoolAsyncOperation(() => { var count = _database.Count <TableKey>(condition, distinct); onExist?.Invoke(count > 0); }); }
public void SumAsync(string columnName, SqlCondition condition, BasicAction <decimal> onSum) { SqlManager.PoolAsyncOperation(() => { var sum = _database.Sum <TableKey>(columnName, condition); onSum?.Invoke(sum); }); }
public void SelectAllAsync(SqlCondition condition, BasicAction <TableKey[]> onSelected, bool distinct, params string[] columnsToSelect) { SqlManager.PoolAsyncOperation(() => { var tables = _database.SelectAll <TableKey>(condition, distinct, columnsToSelect); onSelected?.Invoke(tables); }); }
public void CountAsync(string columnName, SqlCondition condition, BasicAction <long> onCounted, bool distinct) { SqlManager.PoolAsyncOperation(() => { var count = _database.Count <TableKey>(columnName, condition, distinct); onCounted?.Invoke(count); }); }
BasicAction GetSecondaryAction(InteractableRaw thisInteractable, InteractorRaw interactor) { BasicAction action = null; switch (secondary) { case SecondGrab.None: action = new NothingAction(thisInteractable, interactor); break; case SecondGrab.Switch: action = new SwitchAction(thisInteractable, interactor); break; case SecondGrab.Scale: break; case SecondGrab.LookAt: var updateType = followType == FollowType.Transform ? UpdateEvents.BeforeRender : UpdateEvents.FixedUpdate; action = new LookAtAction(thisInteractable, interactor, ((FollowAction)grab.grabbedObjects[0].action).offset, true, updateType); break; } return(action); }
/// <summary> /// action's effect on worldState. /// </summary> /// <returns>returns the estimated effect of action on worldState</returns> public WorldState CalculateEffectOnWorld(BasicAction action, WorldState worldState) { // get memory of other times, compare with current world state // WorldState estimatedEffect = action.memory.EstimateEffectOn(worldState); WorldState estimatedEffect = worldState; return estimatedEffect; }
public void NotifyGrab(InteractorRaw interactor) { if (!interactor) { return; } if (grabbedObjects.Count == 0) { } BasicAction grabTypeAction = null; //Utils.CleanInteractions.CleanInteracableTouching(interactor, ref parent.touch.touchedObjects); if (grabbedObjects.Count < 1) { grabTypeAction = parent.PrimaryActionEvent(parent, interactor); } else //bool canGrab if (grabbedObjects.Count == 1) { grabTypeAction = parent.SecondaryActionEvent(parent, interactor); } if (grabTypeAction != null) { grabbedObjects.Add(new GrabData(interactor, parent, grabTypeAction)); parent.Grabbed?.Invoke(interactor); GrabProccess(); } }
public void AverageAsync(string columnName, SqlCondition condition, BasicAction <long> onAverage) { SqlManager.PoolAsyncOperation(() => { var average = _database.Average <TableKey>(columnName, condition); onAverage?.Invoke(average); }); }
public void MaxAsync(string columnName, SqlCondition condition, BasicAction <TableKey> onMax) { SqlManager.PoolAsyncOperation(() => { var max = _database.Max <TableKey>(columnName, condition); onMax?.Invoke(max); }); }
public static double GetElapsedMilliseconds(BasicAction handler) { var clock = new Clock(); handler(); return(clock.GetElapsedMilliseconds()); }
public GrabData(InteractorRaw _hand, InteractableRaw _interactable, BasicAction _action) { interactor = _hand; interactable = _interactable; action = _action; kinematicOnRelease = interactable.mainRigidbody.isKinematic; gravityOnRelease = interactable.mainRigidbody.useGravity; }
public TrialRunner(string name, BasicAction action, TimeSpan maxTime, InvocationCompleteAction runCompleteAction, InvocationCompleteAction batchCompleteAction) { Name = name; Action = action; MaxTime = maxTime; RunCompleteAction = runCompleteAction; BatchCompleteAction = batchCompleteAction; }
internal NextFrameExecution(BasicAction action) { if (action != null) { _action = action; RuntimeManager.RtUpdate += Execute; } }
/// <summary> /// Create a new instance of <see cref="SqlCondition"/> and attach to the current instance of <see cref="QueryAccessor{TableKey}"/> /// </summary> /// <param name="onCondition"></param> /// <returns></returns> public QueryAccessor <TableKey> UseCondition(BasicAction <SqlCondition> onCondition) { if (_cd == null) { _cd = new SqlCondition(); } onCondition(_cd); return(this); }
public void DeleteAsync(SqlCondition condition, BasicAction onDeleted) { SqlManager.PoolAsyncOperation(() => { var deleted = _database.Delete <TableKey>(condition); if (deleted) { onDeleted?.Invoke(); } }); }
public void UpdateAllAsync(TableKey reference, BasicAction onUpdated, params string[] columnsToUpdate) { SqlManager.PoolAsyncOperation(() => { var updated = _database.UpdateAll(reference, columnsToUpdate); if (updated) { onUpdated?.Invoke(); } }); }
internal ExecuteScriptIn(float time, BasicAction <ExecuteScriptIn> action, bool permanent) { _action = action; _time = time; Permanent = permanent; RuntimeManager.RtUpdate += Update; IsRunning = true; }
internal static void OnReader(this MySqlCommand command, BasicAction <MySqlDataReader> readerCallback) { using (var reader = command.ExecuteReader()) { while (reader.Read()) { readerCallback(reader); } } }
public void DeleteAllAsync(BasicAction onDeleted) { SqlManager.PoolAsyncOperation(() => { var deleted = _database.DeleteAll <TableKey>(); if (deleted) { onDeleted?.Invoke(); } }); }
public IActionViewModel NewActionViewModel(BasicAction actionType) { try { return((IActionViewModel)Activator.CreateInstance(Type.GetType("EMM.Core.ViewModels." + Enum.GetName(typeof(BasicAction), actionType) + "ViewModel"), this.GetDependency <SimpleAutoMapper>(), this)); } catch { throw new NotImplementedException("Cannot create an instance of this viewmodel. Maybe it's not yet implemented"); } }
public static void SetTypeSerialization(Type type, BasicAction <BasicWriter, object> serialization) { if (!_typageDefinitions.ContainsKey(type)) { _typageDefinitions.Add(type, serialization); } else { _typageDefinitions[type] = serialization; } }
private static string UseBuilder(string baseStr, SqlCondition condition, BasicAction <StringBuilder> onBuilder) { var sb = new StringBuilder(baseStr); onBuilder?.Invoke(sb); if (condition != null) { sb.Append($" { condition.GetQuery() }"); } return(sb.ToString()); }
internal void ExecuteCommand(string query, BasicAction <MySqlCommand> onCommand, bool force = false) { if (IsInitialized || force) { using (var conn = CreateConnection()) { using (var cmd = new MySqlCommand(query, conn)) { onCommand(cmd); } } } }
public static void Execute(ICommand command, BasicAction onFailure = null) { try { command.Execute(); } catch (Exception exception) { DebugHelper.PrintCommandExceptionMessage(exception, command); if (onFailure != null) onFailure(); } }
internal void ExecuteCommand(BasicAction <MySqlCommand> onCommand, bool force = false) { if (IsInitialized || force) { using (var conn = CreateConnection()) { using (var cmd = new MySqlCommand()) { cmd.Connection = conn; onCommand(cmd); } } } }
public IActionScriptGenerator GetActionScriptGenerator(Emulator emulator, BasicAction basicAction) { if (!dict.ContainsKey(emulator)) { throw new NotImplementedException(emulator.ToString() + " is not implemented"); } var actionDict = dict[emulator]; if (!actionDict.ContainsKey(basicAction)) { throw new NotImplementedException(basicAction.ToString() + " is not implemented"); } return(actionDict[basicAction]); }
public IActionViewModel NewActionViewModel(BasicAction actionType) { try { var type = Type.GetType("EMM.Core.ViewModels." + Enum.GetName(typeof(BasicAction), actionType) + "ViewModel"); if (type == typeof(ActionGroupViewModel) || type == typeof(CustomActionViewModel)) { return((IActionViewModel)Activator.CreateInstance(type, this.GetDependency <SimpleAutoMapper>(), this, this.GetDependency <ViewModelClipboard>())); } return((IActionViewModel)Activator.CreateInstance(type, this.GetDependency <SimpleAutoMapper>(), this)); } catch { throw new NotImplementedException("Cannot create an instance of this viewmodel. Maybe it's not yet implemented"); } }
/// <summary> /// Tries to pass and verify passage of an agility obstacle /// </summary> /// <param name="passObstacle">method for passing the obstacle</param> /// <param name="verifyPassedObstacle">method for verifying passage of the obstacle</param> /// <returns></returns> protected bool TryPassObstacle(BasicAction passObstacle, BasicAction verifyPassedObstacle) { verifyPassedObstacle = verifyPassedObstacle ?? HasPassedObstacle; int remainingTries = MaxPassObstacleTries; while (remainingTries-- > 0) { if (passObstacle() && verifyPassedObstacle()) { return(true); } if (StopFlag) { return(false); } } return(false); }
/// <summary> /// Attempts to clear each of a list of obstacles. /// Stops trying after an obstacle is failed. /// </summary> /// <param name="obstacles">list of pass and verify methods for a series of obstacles</param> /// <returns>True if successful for all obstacles. False if we fail on any obstacle.</returns> protected bool TryPassObstacles(List <Tuple <BasicAction, BasicAction> > obstacles) { foreach (Tuple <BasicAction, BasicAction> obstacle in obstacles) { if (StopFlag) { return(false); } BasicAction tryPass = obstacle.Item1; BasicAction verifyPassed = obstacle.Item2; if (!TryPassObstacle(tryPass, verifyPassed)) { return(false); } } return(true); }
// this function returns the utility for this action, as specified by the different goals and the worldState argument public float CalculateUtilityFunction(BasicAction action, WorldState worldState, int steps = 1) { // calculate this many steps into the future while (steps > 0) { WorldState effect = CalculateEffectOnWorld(action, worldState); float sum = 0; foreach (var g in agentController.goals) { sum += g.Utility(effect); } // now we have the sum of utilities from each goal. this is the total utility score of this action on this world. // multiply by discount factor depending on the number of steps. the more steps, the less utility the action should have. steps--; } return 0; }
public void ActivateEndGameCredits(BasicAction callback) { List <CanvasRenderer> canvasList = new List <CanvasRenderer>(); ListCanvasRendererRecursive(this.gameObject, canvasList); foreach (CanvasRenderer cr in canvasList) { float alpha = cr.GetAlpha(); cr.SetAlpha(1); } aboutGroup.SetActive(true); Button bt = aboutGroup.transform.Find("ReturnButton").GetComponent <Button>(); bt.enabled = true; bt.onClick.RemoveAllListeners(); bt.onClick.AddListener(delegate(){ callback(); }); }
public void Add(string name, BasicAction action) { trialRunners.Enqueue(new TrialRunner(name, action, maxTime, a => { }, a => { })); }
public SeparateThreadTimer(BasicAction onTick, int interval) { _onTick = onTick; _interval = interval; }
public void RunAction(BasicAction action, BasicAction.DelegateMessage delegateMessage) { ActionManager.GetInstance().RunAction(this, action, delegateMessage); }
public void Run(string name, BasicAction action) { new TrialRunner(name, action, maxTime, result => { }, result => { }).Run(); }
public void Run(string name, BasicAction action, InvocationCompleteAction runCompleteAction, InvocationCompleteAction batchCompleteAction) { new TrialRunner(name, action, maxTime, runCompleteAction, batchCompleteAction).Run(); }
public void SumAsync(string columnName, BasicAction <decimal> onSum) { SumAsync(columnName, _cd, onSum); }
public void Add(string name, BasicAction action, InvocationCompleteAction runCompleteAction, InvocationCompleteAction batchCompleteAction) { trialRunners.Enqueue(new TrialRunner(name, action, maxTime, runCompleteAction, batchCompleteAction)); }
public InvocationResult Run(string name, BasicAction action, TimeSpan maxTime, InvocationCompleteAction runCompleteAction, InvocationCompleteAction batchCompleteAction) { return new TrialRunner(name, action, maxTime, runCompleteAction, batchCompleteAction).Run(); }
private static double InvokeAsBatch(BasicAction action) { var stopwatch = new Stopwatch(); long invocationCount = 0; stopwatch.Start(); while (stopwatch.Elapsed < MinimumBatchTime) { action.Invoke(); ++invocationCount; } stopwatch.Stop(); return stopwatch.Elapsed.TotalMilliseconds / invocationCount; }