public SessionInfo(Session oS) { if (oS.PathAndQuery.StartsWith("/state/", StringComparison.OrdinalIgnoreCase)) { Type = SessionType.State; string[] pathSegments = oS.PathAndQuery.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries); UserId = pathSegments[1]; TapeId = pathSegments[2]; StateAction = (StateAction) Enum.Parse(typeof(StateAction), pathSegments[3],true); return; } if (oS.PathAndQuery.StartsWith("/record/", StringComparison.OrdinalIgnoreCase)) { Type = SessionType.Record; } if (oS.PathAndQuery.StartsWith("/play/", StringComparison.OrdinalIgnoreCase)) { Type = SessionType.Playback; } if (oS.PathAndQuery.StartsWith("/export/", StringComparison.OrdinalIgnoreCase)) { Type = SessionType.Export; string[] pathSegments = oS.PathAndQuery.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries); UserId = pathSegments[1]; TapeId = pathSegments[2]; return; } if (Type != SessionType.None) { string path = oS.PathAndQuery; switch (path) { //#TODO: remove this case "/blank.html": //do nothing break; default: string[] pathSegments = path.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries); UserId = pathSegments[1]; TapeId = pathSegments[2]; Host = pathSegments[3]; PathAndQuery = "/" + string.Join("/", pathSegments, 4, pathSegments.Length - 4); break; } } }
/*public void addAction(string evt, StateAction action){ if (!actionMap_.ContainsKey (evt)) { actionMap_.Add (evt, action); } else { } }*/ public void addAction(string evt, StateAction action) { if (!actionMap_.ContainsKey (evt)) { actionMap_.Add (evt, action); } else { StateAction old = actionMap_[evt]; actionMap_[evt] = delegate(FSMEvent e) { string ret = null; ret = old(e); if(!string.IsNullOrEmpty(ret)){ return ret; } return action(e); }; } }
public ServerSideConnection(ITransport<StompFrame> transport, ServerData serverData) { _connectionNumber = Interlocked.Increment(ref _connectionCount); _logMessagePrefix = "#" + _connectionNumber + ": "; _transport = Verify.ArgumentNotNull(transport, "transport"); _serverData = Verify.ArgumentNotNull(serverData, "serverData"); _transport.ConnectedChanged += TransportConnectedChanged; _transport.FrameReady += TransportFrameReady; _transport.TransportException += TransportTransportException; _stateAction = ExpectingConnect; _incomingHeartBeatTimer = new Timer(HandleIncomingHeartBeatTimeout); _outgoingHeartBeatTimer = new Timer(HandleOutgoingHeartBeatTimeout); _connectTimer = new Timer(HandleConnectTimeout, null, (int) serverData.Config.ConnectFrameTimeout.TotalMilliseconds, Timeout.Infinite); Log.Debug(_logMessagePrefix + "Connect established"); }
public void movePlayer(BufferedGraphics buffer, Bitmap bm) { switch (action) { //Đi xuống case StateAction.Down: indexrow = 0; if (indexcomlumn >= 0 && indexcomlumn < 3) { indexcomlumn++; } else { indexcomlumn = 0; dx = 0; dy = 10; direction = StateAction.Down; } break; //đi trái case StateAction.Left: indexrow = 1; if (indexcomlumn >= 0 && indexcomlumn < 3) { indexcomlumn++; } else { indexcomlumn = 0; dx = -10; dy = 0; direction = StateAction.Left; } break; //Đi phải case StateAction.Right: indexrow = 2; if (indexcomlumn >= 0 && indexcomlumn < 3) { indexcomlumn++; } else { indexcomlumn = 0; dx = 10; dy = 0; direction = StateAction.Right; } break; //Đi lên case StateAction.Up: indexrow = 3; if (indexcomlumn >= 0 && indexcomlumn < 3) { indexcomlumn++; } else { indexcomlumn = 0; dx = 0; dy = -10; direction = StateAction.Up; } break; case StateAction.Standing: dx = 0; dy = 0; switch (direction) { case StateAction.Down: indexcomlumn = 0; indexrow = 0; break; case StateAction.Left: indexcomlumn = 0; indexrow = 1; break; case StateAction.Right: indexcomlumn = 0; indexrow = 2; break; case StateAction.Up: indexcomlumn = 0; indexrow = 3; break; default: break; } break; } drawPlayer(buffer, bm); }
public StateTransition(int nextState, BitValidator <T> validator, StateAction <T> action) { this.NextState = nextState; this.Validator = validator; this.Action = action; }
public void SetEffect(StateAction action) { m_Effect = CreateSummaryEffect(action); m_TimeToFinish = action.GetDurationInSeconds(); }
// ReSharper restore UnusedParameter.Local // ReSharper restore MemberCanBeMadeStatic.Local private void ExpectingConnect(StompFrame frame) { if (frame.Command != StompCommand.Connect && frame.Command != StompCommand.Stomp) { string message = "Expecting " + StompCommand.Connected + " or " + StompCommand.Stomp + " command, received " + frame.Command; Log.Error(_logMessagePrefix + message); var errorFrame = StompFrameUtils.CreateErrorFrame(message); _transport.SendFrame(errorFrame); DisconnectWithoutLocking(); return; } var login = frame.Headers[StompHeader.Login]; var passcode = frame.Headers[StompHeader.Passcode]; if (!Authenticate(login, passcode)) { string message = "Received " + frame.Command + " frame, Access denied"; Log.Warn(_logMessagePrefix + message); var errorFrame = StompFrameUtils.CreateErrorFrame(message); _transport.SendFrame(errorFrame); DisconnectWithoutLocking(); return; } Log.Debug(_logMessagePrefix + "Received " + frame.Command + " frame, authenticated OK"); var sessionId = frame.Headers[StompHeader.Session]; ServerSideSession session = null; if (sessionId != null) { session = _serverData.FindSession(sessionId); if (session == null) { Log.Warn(_logMessagePrefix + "Received " + frame.Command + " frame for non-existent session: " + sessionId); var message = ErrorMessages.SessionDoesNotExistPrefix + sessionId; var errorFrame = StompFrameUtils.CreateErrorFrame(message); _transport.SendFrame(errorFrame); DisconnectWithoutLocking(); return; } if (!session.AddConnection(this)) { var message = frame.Command + " frame requested a session already in use: " + sessionId; Log.Warn(_logMessagePrefix + message); var errorFrame = StompFrameUtils.CreateErrorFrame(message); _transport.SendFrame(errorFrame); DisconnectWithoutLocking(); return; } Log.Debug(_logMessagePrefix + "Reconnected to session " + sessionId); } if (session == null) { session = _serverData.CreateSession(); session.AddConnection(this); Log.Debug(_logMessagePrefix + "Created new session " + session.SessionId); } // helps with debugging if we give the session a more friendly name session.ClientId = frame.Headers[StompHeader.NonStandard.ClientId]; _session = session; var connectedFrame = new StompFrame { Command = StompCommand.Connected, Headers = { {StompHeader.Session, session.SessionId} } }; if (frame.Headers[StompHeader.HeartBeat] == null) { // no heart-beat header received, so we default to 0,0 _negotiatedHeartBeats = new HeartBeatValues(0, 0); } else { var otherHeartBeatValues = new HeartBeatValues(frame.Headers[StompHeader.HeartBeat]); var myHeartBeatValues = new HeartBeatValues(30000, 30000); _negotiatedHeartBeats = myHeartBeatValues.CombineWith(otherHeartBeatValues); connectedFrame.Headers[StompHeader.HeartBeat] = _negotiatedHeartBeats.ToString(); } _transport.SendFrame(connectedFrame); StopConnectTimer(); StartIncomingHeartBeatTimer(); StartOutgoingHeartBeatTimer(); _stateAction = Connected; Log.Debug(_logMessagePrefix + "Session " + session + " connected"); }
/// <summary> /// This function requests or changes the AutoDJ functionality's state. /// </summary> /// <param name="action"> /// The action can be either toggle or state. /// </param> public void RequestAutoDjState(StateAction action) { if (action == StateAction.Toggle) { if (!mbApiInterface.Player_GetAutoDjEnabled()) { mbApiInterface.Player_StartAutoDj(); } else { mbApiInterface.Player_EndAutoDj(); } } EventBus.FireEvent( new MessageEvent(EventType.ReplyAvailable, new SocketMessage(Constants.PlayerAutoDj, Constants.Reply, mbApiInterface.Player_GetAutoDjEnabled()).toJsonString())); }
private ActionValidationResult ValidateAction(StateAction stateAction) { InvalidContentActionReason reason; return(ValidateAction(stateAction, out reason)); }
public State(T name, StateAction action) { stateName = name; Action = action; }
private bool HasPermission(StateAction stateAction) { if (this.Node.Id == 0) { //for new content, creator needs to have AddNew permission for the parent if (!this.Node.Parent.Security.HasPermission(PermissionType.AddNew)) return false; //if this is a list type, the user must have a manage container permission for the parent if (!CheckManageListPermission(this.Node.NodeType, this.Node.Parent)) return false; } else { //otherwise the user needs to have Save permission for every action if (!this.Node.Security.HasPermission(PermissionType.Save)) return false; //if this is a list type, the user must have a manage container permission for the node if (!CheckManageListPermission(this.Node.NodeType, this.Node)) return false; } switch (stateAction) { case StateAction.Save: case StateAction.CheckOut: case StateAction.SaveAndCheckIn: case StateAction.CheckIn: return !IsCheckedOutByAnotherUser(this.Node); case StateAction.UndoCheckOut: //force and 'normal' undo operations return !IsCheckedOutByAnotherUser(this.Node) || HasForceUndoCheckOutRight(this.Node); case StateAction.Publish: return this.Node.Security.HasPermission(User.Current, PermissionType.Publish) && !IsCheckedOutByAnotherUser(this.Node); case StateAction.Approve: case StateAction.Reject: return this.Node.Security.HasPermission(User.Current, PermissionType.Approve); default: throw new NotImplementedException("Unknown StateAction: " + stateAction); } }
private ActionValidationResult ValidateAction(StateAction stateAction) { if (!HasPermission(stateAction)) return ActionValidationResult.Invalid; if (this.Node.Id == 0) { if (stateAction == StateAction.Save || stateAction == StateAction.SaveAndCheckIn) return ActionValidationResult.Valid; return ActionValidationResult.InvalidOnNewNode; } var action = 0; switch (stateAction) { case StateAction.Save: action = 0; break; case StateAction.CheckOut: action = 1; break; case StateAction.CheckIn: action = 2; break; case StateAction.UndoCheckOut: action = 3; break; case StateAction.Publish: action = 4; break; case StateAction.Approve: action = 5; break; case StateAction.Reject: action = 6; break; case StateAction.SaveAndCheckIn: action = 7; break; default: throw new NotImplementedException("Unknown StateAction: " + stateAction); } var status = 0; var versionStatus = this.Node.Locked ? VersionStatus.Locked : this.CurrentVersion.Status; switch (versionStatus) { case VersionStatus.Approved: status = 0; break; case VersionStatus.Locked: status = 1; break; case VersionStatus.Draft: status = 2; break; case VersionStatus.Rejected: status = 3; break; case VersionStatus.Pending: status = 4; break; default: throw new NotImplementedException("Unknown VersionStatus: " + this.CurrentVersion.Status); } var mode = 0; switch (this.VersioningMode) { case VersioningMode.None: mode = 0; break; case VersioningMode.Major: mode = 1; break; case VersioningMode.Full: mode = 2; break; default: throw new NotImplementedException("Unknown VersioningMode: " + this.VersioningMode); } var approving = this.HasApproving ? 1 : 0; if (!EnabledActions[15 * approving + 5 * mode + status][action]) return ActionValidationResult.Invalid; return ActionValidationResult.Valid; }
private void AssertValidAction(StateAction stateAction) { var result = ValidateAction(stateAction); if (result == ActionValidationResult.Invalid) throw new InvalidContentActionException(String.Concat( "Cannot execute the content action. Approving:", this.HasApproving, ", versioning mode:", this.VersioningMode, ", status:", this.CurrentVersion.Status, ", requested action:", stateAction, ", content id:", this.Node.Id, ", path:", this.Node.Path, ".")); if (result == ActionValidationResult.InvalidOnNewNode) throw new InvalidContentActionException(String.Concat( "Cannot execute the content action. The content is new. Requested action :", stateAction, ", path: ", this.Node.Path, ".")); }
public State(StateAction _enterHandler, StateAction _updateHandler, StateAction _exitHandler) { enterHandler = _enterHandler; updateHandler = _updateHandler; exitHandler = _exitHandler; }
private void DisconnectWithoutLocking() { if (_stateAction == ShuttingDown) { Log.Warn(_logMessagePrefix + "Ignoring duplicate Disconnect request"); } else { _transport.Shutdown(); _stateAction = ShuttingDown; StopAllTimers(); } }
public void ReduceTest() { var reducer = new PagePushReducer(); var state = new State(); state.SetValue <PageStack>(PageConst.StateStackKey, new PageStack()); state.SetValue <PageDefinition>(PageConst.StateDefinitionKey, new PageDefinition { PermanentScenes = new[] { "PermanentScene1" }, PageScenes = new[] { new PageScene { Name = "Page1", Scenes = new[] { "Scene1", "Scene2" }, }, new PageScene { Name = "Page2", Scenes = new[] { "Scene1", "Scene3" }, } } }); state.SetValue <IDictionary <string, bool> >(SceneConst.StateKey, new Dictionary <string, bool>() { { "Scene1", true }, { "Scene2", false }, { "Scene3", false }, { "Scene4", true }, { "PermanentScene1", true }, }); state.SetValue <PageStack>(PageConst.StateStackKey, new PageStack()); { var page = new Page { Name = "Page1", Data = null }; var action = new StateAction(reducer, "page", new Any(page)); state = reducer.Reduce(state, action); var stack = state.GetValue <PageStack>(PageConst.StateStackKey); Assert.That(stack.Count, Is.EqualTo(1)); Assert.That(stack.Peek().Name, Is.EqualTo("Page1")); var sceneMap = state.GetValue <IDictionary <string, bool> >(SceneConst.StateKey); Assert.That(sceneMap.Count, Is.EqualTo(5)); Assert.That(sceneMap["Scene1"], Is.True); Assert.That(sceneMap["Scene2"], Is.True); Assert.That(sceneMap["Scene3"], Is.False); Assert.That(sceneMap["Scene4"], Is.False); Assert.That(sceneMap["PermanentScene1"], Is.True); } { var page = new Page { Name = "Page2", Data = null }; var action = new StateAction(reducer, "page", new Any(page)); state = reducer.Reduce(state, action); var stack = state.GetValue <PageStack>(PageConst.StateStackKey); Assert.That(stack.Count, Is.EqualTo(2)); Assert.That(stack.Peek().Name, Is.EqualTo("Page2")); var sceneMap = state.GetValue <IDictionary <string, bool> >(SceneConst.StateKey); Assert.That(sceneMap.Count, Is.EqualTo(5)); Assert.That(sceneMap["Scene1"], Is.True); Assert.That(sceneMap["Scene2"], Is.False); Assert.That(sceneMap["Scene3"], Is.True); Assert.That(sceneMap["Scene4"], Is.False); Assert.That(sceneMap["PermanentScene1"], Is.True); } }
public void Add(T id, StateAction OnEnter, StateAction OnUpdate, StateAction OnExit) { var new_state = new State(id, OnEnter, OnUpdate, OnExit); states.Add(id, new_state); }
public void Reset() { activeStateAction = null; }
private bool HasPermission(StateAction stateAction, out InvalidContentActionReason reason) { // set this as permission error will be the most common reason reason = InvalidContentActionReason.NotEnoughPermissions; if (this.Node.Id == 0) { var parent = this.Node.Parent; // for new content, creator needs to have AddNew permission for the parent if (!parent.Security.HasPermission(PermissionType.AddNew)) { return(false); } // if this is a list type, the user must have a manage container permission for the parent if (!CheckManageListPermission(this.Node.NodeType, parent)) { return(false); } // do not call this.Node.Security.HasPermission method because the node has not exist yet. switch (stateAction) { case StateAction.Save: return(true); case StateAction.CheckOut: case StateAction.SaveAndCheckIn: case StateAction.CheckIn: case StateAction.UndoCheckOut: case StateAction.Publish: case StateAction.Approve: case StateAction.Reject: return(false); default: throw new SnNotSupportedException("Unknown StateAction: " + stateAction); } } else { // otherwise the user needs to have Save permission for every action if (!this.Node.Security.HasPermission(PermissionType.Save)) { return(false); } // if this is a list type, the user must have a manage container permission for the node if (!CheckManageListPermission(this.Node.NodeType, this.Node)) { return(false); } var checkedOutByAnotherUser = IsCheckedOutByAnotherUser(this.Node); if (checkedOutByAnotherUser) { reason = InvalidContentActionReason.CheckedOutToSomeoneElse; } switch (stateAction) { case StateAction.Save: case StateAction.CheckOut: case StateAction.SaveAndCheckIn: case StateAction.CheckIn: return(!checkedOutByAnotherUser); case StateAction.UndoCheckOut: // force and 'normal' undo operations return(!checkedOutByAnotherUser || HasForceUndoCheckOutRight(this.Node)); case StateAction.Publish: return(this.Node.Security.HasPermission(User.Current, PermissionType.Publish) && !checkedOutByAnotherUser); case StateAction.Approve: case StateAction.Reject: return(this.Node.Security.HasPermission(User.Current, PermissionType.Approve)); default: throw new SnNotSupportedException("Unknown StateAction: " + stateAction); } } }
public void CreateState(string name, StateAction action) { name = CreateState(name); m_States[name].AddStateAction(action); }
/// <summary> /// Sets N[s,a]'s value /// </summary> /// <param name="s">The state</param> /// <param name="a">The action</param> /// <param name="e">The value to be updated</param> protected virtual void __set_nsa_value(State s, Action a, NVal e) { var sig = new StateAction(s, a); if (!this.NSA.Contains(sig)) this.NSA.Add(sig, e); else this.NSA[sig] = e; }
public void addAction(string evt, StateAction action){ actionMap_.Add (evt, action); }
/// <summary> /// Changes the player shuffle state. If the StateAction is Toggle then the current state is switched with it's opposite, /// if it is State the current state is dispatched with an Event. /// </summary> /// <param name="action"></param> public void RequestShuffleState(StateAction action) { if (action == StateAction.Toggle) { mbApiInterface.Player_SetShuffle(!mbApiInterface.Player_GetShuffle()); } EventBus.FireEvent( new MessageEvent( EventType.ReplyAvailable, new SocketMessage(Constants.PlayerShuffle, Constants.Reply, mbApiInterface.Player_GetShuffle()).toJsonString())); }
public void ReduceTest() { var reducer = new PagePopReducer(); var state = new State(); state.SetValue <PageStack>(PageConst.StateStackKey, new PageStack()); state.SetValue <PageDefinition>(PageConst.StateDefinitionKey, new PageDefinition { PageScenes = new[] { new PageScene { Name = "Page1", Scenes = new[] { "Scene1", "Scene2" }, }, new PageScene { Name = "Page2", Scenes = new[] { "Scene1", "Scene3" }, } } }); state.SetValue <IDictionary <string, bool> >(SceneConst.StateKey, new Dictionary <string, bool>() { { "Scene1", true }, { "Scene2", false }, { "Scene3", false }, }); { var pageStack = new PageStack(); pageStack.Push(new Page { Name = "Page1", Data = null }); pageStack.Push(new Page { Name = "Page2", Data = null }); state.SetValue <PageStack>(PageConst.StateStackKey, pageStack); } // pop1 { var action = new StateAction(reducer, "page", new Any()); state = reducer.Reduce(state, action); var stack = state.GetValue <PageStack>(PageConst.StateStackKey); Assert.That(stack.Count, Is.EqualTo(1)); Assert.That(stack.Peek().Name, Is.EqualTo("Page1")); var sceneMap = state.GetValue <IDictionary <string, bool> >(SceneConst.StateKey); Assert.That(sceneMap.Count, Is.EqualTo(3)); Assert.That(sceneMap["Scene1"], Is.True); Assert.That(sceneMap["Scene2"], Is.True); Assert.That(sceneMap["Scene3"], Is.False); } // pop is failed if stack has only an element { var action = new StateAction(reducer, "page", new Any()); state = reducer.Reduce(state, action); var stack = state.GetValue <PageStack>(PageConst.StateStackKey); Assert.That(stack.Count, Is.EqualTo(1)); Assert.That(stack.Peek().Name, Is.EqualTo("Page1")); var sceneMap = state.GetValue <IDictionary <string, bool> >(SceneConst.StateKey); Assert.That(sceneMap.Count, Is.EqualTo(3)); Assert.That(sceneMap["Scene1"], Is.True); Assert.That(sceneMap["Scene2"], Is.True); Assert.That(sceneMap["Scene3"], Is.False); } }
public void UpdateAI() { if (grid == null) { grid = GameObject.FindObjectOfType <Grid>(); } if (myTurn && !didTurn) { didTurn = true; State boardState = GetBoardState(); Debug.Log("State visited counter: " + boardState.TimesVisited); if (brain == null) { brain = new StateAgent(boardState); } else { brain.SetState(boardState); } //get action from brain, execute. StateAction action = brain.GetChosenActionForCurrentState(); string[] moves = Regex.Split(action.ActionString, "to"); string[] from = Regex.Split(moves[0], "-"); string[] to = Regex.Split(moves[1], "-"); Debug.Log(action.ActionString + ", Quality: " + action.GetDeepEvaluation() + " (" + action.ActionEvaluation + ") --- " + brain.LearnedStates + "///" + brain.EvaluatedActions); if (action.GetDeepEvaluation() != action.ActionEvaluation) { Debug.Log("///////////////////////////////////////////////////////////////"); } foreach (Node n in grid.grid) { n.UnhighlightEat(); n.UnhighlightMove(); } Node fromNode = grid.GetNodeAt(int.Parse(from[1]), int.Parse(from[0])); Node toNode = grid.GetNodeAt(int.Parse(to[1]), int.Parse(to[0])); fromNode.HighlightMove(); toNode.HighlightEat(); piece = fromNode.Piece; piece.Pickup(); GameManager.Instance.GameState.Grab(); int reward = 0; Piece tPiece = toNode.Piece; if (tPiece == null) { if (piece.IsPossibleMove(toNode)) { if (Rules.IsCheckMove(this, piece, toNode, true)) { Debug.Log("Move checked, not allowed"); // do nothing brain.EvaluateLastAction(-10000); GameManager.Instance.GameState.Checkmate(); GameManager.Instance.GameOver(GameManager.Instance.PlayerOponent, GameOverType.CHECKMATE); } else { piece.MoveToXZ(toNode, Drop); GameManager.Instance.GameState.Place(); } } } else { if (piece.IsPossibleEat(toNode)) { if (Rules.IsCheckEat(this, piece, toNode, true)) { Debug.Log("Eat checked"); // do nothing brain.EvaluateLastAction(-10000); GameManager.Instance.GameState.Checkmate(); GameManager.Instance.GameOver(GameManager.Instance.PlayerOponent, GameOverType.CHECKMATE); } else { GCPlayer oppPlayer = GameManager.Instance.Opponent(this); oppPlayer.brain.EvaluateLastAction(-tPiece.GetPieceValue()); reward = tPiece.GetPieceValue(); oppPlayer.RemovePiece(tPiece); AddEatenPieces(tPiece); tPiece.ScaleOut(0.2f, 1.5f); piece.MoveToXZ(toNode, Drop); GameManager.Instance.GameState.Place(); } } } State newState = GetBoardState(); brain.PerformStateAction(action, newState); brain.EvaluateLastAction(reward); } }
public virtual void setStateAction(StateAction action) { throw new NotImplementedException(); }
public ClientStateAction StateKey(int ClientId, string Message, int StateActionStateId) { ClientStateAction clientStateAction = null; StateActionState stateActionState = db.StateActionState.FirstOrDefault(s => s.StateActionStateId == StateActionStateId); StateAction action = db.StateActions.FirstOrDefault(x => x.StateActionId == stateActionState.StateActionId); StateActionState NewStateActionState; if (action.Name == "Rechazado") { NewStateActionState = db.StateActionState.FirstOrDefault( s => s.ClientState.Name == "Rechazado" && s.StateAction.Name == "Rechazado"); clientStateAction = CreateClientStateAction(ClientId, Message, NewStateActionState.StateActionStateId); } switch (stateActionState.ClientState.Name) { case "Lead": if (action.Name == "Llamada") { NewStateActionState = db.StateActionState.FirstOrDefault( s => s.ClientState.Name == "Contacto" && s.StateAction.Name == "llamada"); clientStateAction = CreateClientStateAction(ClientId, Message, NewStateActionState.StateActionStateId); } break; case "Contacto": if (action.Name == "Cita") { NewStateActionState = db.StateActionState.FirstOrDefault( s => s.ClientState.Name == "Visita" && s.StateAction.Name == "Cita"); clientStateAction = CreateClientStateAction(ClientId, Message, NewStateActionState.StateActionStateId); } break; case "Visita": if (action.Name == "Venta realizada") { NewStateActionState = db.StateActionState.FirstOrDefault( s => s.ClientState.Name == "Venta" && s.StateAction.Name == "Venta realizada"); clientStateAction = CreateClientStateAction(ClientId, Message, NewStateActionState.StateActionStateId); } break; case "Venta": if (action.Name == "Cerrar") { NewStateActionState = db.StateActionState.FirstOrDefault( s => s.ClientState.Name == "Vendido" && s.StateAction.Name == "Venta realizada"); clientStateAction = CreateClientStateAction(ClientId, Message, NewStateActionState.StateActionStateId); } break; case "Rechazado": if (action.Name == "Recuperar cliente") { ClientStateAction clientStateActionToDelete = db.ClientStateAction.FirstOrDefault( c => c.ClientId == ClientId && c.StateActionState.ClientState.Name == "Rechazado"); db.ClientStateAction.Remove(clientStateActionToDelete); db.SaveChanges(); NewStateActionState = db.StateActionState.FirstOrDefault( s => s.ClientState.Name == "Contacto" && s.StateAction.Name == "Informacion"); clientStateAction = CreateClientStateAction(ClientId, Message, NewStateActionState.StateActionStateId); } break; default: clientStateAction = null; break; } return(clientStateAction); }
public override void setStateAction(StateAction action) { stateAction = action; }
/// <summary> /// A state transition which is only valid when the bit /// is equal to the <code>validBit</code>. /// </summary> /// <param name="validBit"></param> /// <param name="action"></param> public StateTransition(int nextState, T validBit, StateAction <T> action) { this.NextState = nextState; this.Validator = (bit) => bit.Equals(validBit); this.Action = action; }
public void Add(T _key, StateAction _act) { this.stateTable.Add(_key, new State(_act.Start, _act.Update, _act.End)); }
public UnitState(Point position, double time, StateAction stateAction) { this.position = position; this.Time = time; this._action = stateAction; }
public void addAction(string evt, StateAction action) { actionMap_.Add(evt, action); }
public Sprite(int x, int y, int dx, int dy, int width, int height, StateAction dir, StateAction act) { this.x = x; this.y = y; this.dx = dx; this.dy = dy; this.widthtActor = width; this.heightActor = height; direction = dir; action = act; realHeight = this.heightActor; realWidth = this.widthtActor; }
public StateEvent(TStateId state, StateAction action) { this.state = state; this.action = action; }
private void ResetActionList() { SerializedObject obj = new SerializedObject(state); SerializedProperty elements = obj.FindProperty("actions"); actionList = new ReorderableObjectList(obj, elements); actionList.drawHeaderCallback = delegate(Rect rect) { EditorGUI.LabelField(rect, "Actions"); }; actionList.onAddCallback = delegate(ReorderableObjectList list) { FsmGUIUtility.SubclassMenu <StateAction> (delegate(Type type){ StateAction action = (StateAction)ScriptableObject.CreateInstance(type); action.name = type.GetCategory() + "." + type.Name; action.hideFlags = HideFlags.HideInHierarchy; state.Actions = ArrayUtility.Add <StateAction> (state.Actions, action); if (EditorUtility.IsPersistent(state)) { AssetDatabase.AddObjectToAsset(action, state); AssetDatabase.SaveAssets(); } list.index = list.count; EditorUtility.SetDirty(state); }); }; actionList.drawElementCallback = delegate(int index, bool selected) { StateAction action = state.Actions [index]; bool enabled = action.IsEnabled; if (selected) { GUIStyle selectBackground = new GUIStyle("MeTransitionSelectHead") { stretchHeight = false, }; selectBackground.overflow = new RectOffset(-1, -2, -2, 2); GUILayout.BeginVertical(selectBackground); } action.IsOpen = GUIDrawer.ObjectTitlebar(action, action.IsOpen, ref enabled, FsmGUIUtility.ExecutableContextMenu(action, state)); if (selected) { GUILayout.EndVertical(); } action.IsEnabled = enabled; if (action.IsOpen) { GUIDrawer.OnGUI(action); } }; actionList.onRemoveCallback = delegate(ReorderableObjectList list) { StateAction action = state.Actions[list.index]; state.Actions = ArrayUtility.Remove <StateAction> (state.Actions, action); FsmEditorUtility.DestroyImmediate(action); list.index = list.index - 1; ErrorChecker.CheckForErrors(); EditorUtility.SetDirty(state); }; actionList.onContextClick = delegate(int index) { FsmGUIUtility.ExecutableContextMenu(state.Actions [index], state).ShowAsContext(); }; actionList.onHeaderContextClick = delegate() { GenericMenu menu = new GenericMenu(); if (state.Actions.Length > 0) { menu.AddItem(new GUIContent("Copy"), false, delegate { copy = new List <StateAction>(state.Actions); copyState = state; }); } else { menu.AddDisabledItem(new GUIContent("Copy")); } if (copy == null) { copy = new List <StateAction>(); } copy.RemoveAll(x => x == null); if (copy.Count > 0) { menu.AddItem(new GUIContent("Paste After"), false, delegate() { for (int i = 0; i < copy.Count; i++) { ExecutableNode dest = FsmUtility.Copy(copy[i]); state.Actions = ArrayUtility.Add <StateAction>(state.Actions, (StateAction)dest); FsmEditorUtility.ParentChilds(state); EditorUtility.SetDirty(state); // NodeInspector.Dirty(); ErrorChecker.CheckForErrors(); } }); menu.AddItem(new GUIContent("Paste Before"), false, delegate() { for (int i = 0; i < copy.Count; i++) { ExecutableNode dest = FsmUtility.Copy(copy[i]); state.Actions = ArrayUtility.Insert <StateAction>(state.Actions, (StateAction)dest, 0); FsmEditorUtility.ParentChilds(state); EditorUtility.SetDirty(state); // NodeInspector.Dirty(); ErrorChecker.CheckForErrors(); } }); if (copyState != state) { menu.AddItem(new GUIContent("Replace"), false, delegate() { for (int i = 0; i < state.Actions.Length; i++) { FsmEditorUtility.DestroyImmediate(state.Actions[i]); } state.Actions = new StateAction[0]; ResetActionList(); for (int i = 0; i < copy.Count; i++) { ExecutableNode dest = FsmUtility.Copy(copy[i]); state.Actions = ArrayUtility.Add <StateAction>(state.Actions, (StateAction)dest); FsmEditorUtility.ParentChilds(state); EditorUtility.SetDirty(state); // NodeInspector.Dirty(); ErrorChecker.CheckForErrors(); } }); } else { menu.AddDisabledItem(new GUIContent("Replace")); } } else { menu.AddDisabledItem(new GUIContent("Paste After")); menu.AddDisabledItem(new GUIContent("Paste Before")); menu.AddDisabledItem(new GUIContent("Replace")); } menu.ShowAsContext(); }; this.host.Repaint(); if (FsmEditor.instance != null) { FsmEditor.instance.Repaint(); } }
public override void ApplyDifferenceByAction(StatsDifference difference, StateAction action, float multiplier = 1) { Value += GetDifferenceValue(difference); }
private ActionValidationResult ValidateAction(StateAction stateAction, out InvalidContentActionReason reason) { if (!HasPermission(stateAction, out reason)) { return(ActionValidationResult.Invalid); } if (this.Node.SavingState != ContentSavingState.Finalized && (stateAction != StateAction.CheckIn && stateAction != StateAction.UndoCheckOut)) { reason = InvalidContentActionReason.MultistepSaveInProgress; return(ActionValidationResult.Invalid); } reason = InvalidContentActionReason.InvalidStateAction; if (this.Node.Id == 0) { if (stateAction == StateAction.Save || stateAction == StateAction.SaveAndCheckIn) { return(ActionValidationResult.Valid); } return(ActionValidationResult.InvalidOnNewNode); } var action = 0; switch (stateAction) { case StateAction.Save: action = 0; break; case StateAction.CheckOut: action = 1; break; case StateAction.CheckIn: action = 2; break; case StateAction.UndoCheckOut: action = 3; break; case StateAction.Publish: action = 4; break; case StateAction.Approve: action = 5; break; case StateAction.Reject: action = 6; break; case StateAction.SaveAndCheckIn: action = 7; break; default: throw new SnNotSupportedException("Unknown StateAction: " + stateAction); } var status = 0; var versionStatus = this.Node.Locked ? VersionStatus.Locked : this.CurrentVersion.Status; switch (versionStatus) { case VersionStatus.Approved: status = 0; break; case VersionStatus.Locked: status = 1; break; case VersionStatus.Draft: status = 2; break; case VersionStatus.Rejected: status = 3; break; case VersionStatus.Pending: status = 4; break; default: throw new SnNotSupportedException("Unknown VersionStatus: " + this.CurrentVersion.Status); } var mode = 0; switch (this.VersioningMode) { case VersioningMode.None: mode = 0; break; case VersioningMode.Major: mode = 1; break; case VersioningMode.Full: mode = 2; break; default: throw new SnNotSupportedException("Unknown VersioningMode: " + this.VersioningMode); } var approving = this.HasApproving ? 1 : 0; if (!EnabledActions[15 * approving + 5 * mode + status][action]) { return(ActionValidationResult.Invalid); } return(ActionValidationResult.Valid); }
public static void ClearStates() { var a = new StateAction(); a.clearing = true; actions.Enqueue(a); }
public void RunAction(string actionName) { StateAction action = _actions[actionName]; RunAction(action); }
/// <summary> /// Mark a [s,a] visited and the result will be [s'] /// </summary> /// <param name="s">The state</param> /// <param name="a">The action</param> /// <param name="sprim">The next state</param> protected void __visit(State s, Action a, State sprim) { var sig = new StateAction(s, a); if (!this.VisitedStateActions.Contains(sig)) this.VisitedStateActions.Add(sig, new List<State>() { sprim }); else (this.VisitedStateActions[sig] as List<State>).Add(sprim); }
private void UpdateBeforeAction(StateAction action) { UpdateStatsOneTime(action.GetEffectBefore(), action); }
/// <summary> /// Gets N[s,a]'s value if any exists or initializes it by 0. /// </summary> /// <param name="s">The state</param> /// <param name="a">The action</param> /// <returns>The value</returns> protected virtual NVal __get_nsa_value(State s, Action a) { var sig = new StateAction(s, a); if (!this.NSA.Contains(sig)) this.NSA.Add(sig, (NVal)0); return (NVal)this.NSA[sig]; }
private void UpdateAfterAction(StateAction action) { UpdateStatsOneTime(action.GetEffectAfter(), action); }
/// <summary> /// If the action equals toggle then it changes the repeat state, in any other case /// it just returns the current value of the repeat. /// </summary> /// <param name="action">toggle or state</param> /// <returns>Repeat state: None, All, One</returns> public void RequestRepeatState(StateAction action) { if (action == StateAction.Toggle) { switch (mbApiInterface.Player_GetRepeat()) { case RepeatMode.None: mbApiInterface.Player_SetRepeat(RepeatMode.All); break; case RepeatMode.All: mbApiInterface.Player_SetRepeat(RepeatMode.None); break; case RepeatMode.One: mbApiInterface.Player_SetRepeat(RepeatMode.None); break; } } EventBus.FireEvent( new MessageEvent(EventType.ReplyAvailable, new SocketMessage(Constants.PlayerRepeat, Constants.Reply, mbApiInterface.Player_GetRepeat()).toJsonString())); }
public void movePlayer(BufferedGraphics buffer, Bitmap bm) { switch (_action) { case StateAction.Down: _indexRow = 0; if (_indexColumn >= 0 && _indexColumn < _maxCols - 1) { _indexColumn++; } else { _indexColumn = 0; _dx = 0; _dy = 10; _direction = StateAction.Down; } break; case StateAction.Left: _indexRow = 1; if (_indexColumn >= 0 && _indexColumn < _maxCols - 1) { _indexColumn++; } else { _indexColumn = 0; _dx = -10; _dy = 0; _direction = StateAction.Left; } break; case StateAction.Right: _indexRow = 2; if (_indexColumn >= 0 && _indexColumn < _maxCols - 1) { _indexColumn++; } else { _indexColumn = 0; _dx = 10; _dy = 0; _direction = StateAction.Right; } break; case StateAction.Up: _indexRow = 3; if (_indexColumn >= 0 && _indexColumn < _maxCols - 1) { _indexColumn++; } else { _indexColumn = 0; _dx = 0; _dy = -10; _direction = StateAction.Up; } break; case StateAction.Standing: _dx = 0; _dy = 0; switch (_direction) { case StateAction.Down: _indexColumn = 0; _indexRow = 0; break; case StateAction.Left: _indexColumn = 0; _indexRow = 1; break; case StateAction.Right: _indexColumn = 0; _indexRow = 2; break; case StateAction.Up: _indexColumn = 0; _indexRow = 3; break; default: break; } break; //case StateAction.Standing }//switch (Action) drawPlayer(buffer, bm, _zoom); }
public WINTRUST_DATA(WINTRUST_FILE_INFO fileInfo) { cbStruct = (uint)Marshal.SizeOf(typeof(WINTRUST_DATA)); pInfoStruct = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(WINTRUST_FILE_INFO))); Marshal.StructureToPtr(fileInfo, pInfoStruct, false); dwUnionChoice = UnionChoice.File; pPolicyCallbackData = IntPtr.Zero; pSIPCallbackData = IntPtr.Zero; dwUIChoice = UiChoice.NoUI; fdwRevocationChecks = RevocationCheckFlags.None; dwStateAction = StateAction.Ignore; hWVTStateData = IntPtr.Zero; pwszURLReference = IntPtr.Zero; dwProvFlags = TrustProviderFlags.Safer; dwUIContext = UIContext.Execute; }
private void CambiarEstadoTicket(Ticket oTicket, StateAction oAccion, string cMensaje = "") { _robot.SaveTicketNextState(cMensaje == "" ? oTicket : _Funciones.MesaDeControl(oTicket, cMensaje), oAccion.Id); _Funciones.CerrarDriver(_driverGlobal); }