示例#1
0
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="entry"></param>
 /// <param name="currentTransition"></param>
 /// <param name="nextTransitions"></param>
 protected BaseWorkFlowAction(EntryState entry, Transition currentTransition, IEnumerable <Transition> nextTransitions)
 {
     EntryState        = entry;
     CurrentTransition = currentTransition;
     NextTransitions   = nextTransitions;
     Executor          = IoC.Resolve <IWorkFlowExecutorService>();
 }
示例#2
0
 public Entry(int num, Date d, string t)
 {
     number = num;
     date   = d;
     text   = t;
     state  = EntryState.UNENCRYPTED;
 }
示例#3
0
            public void VisitTree(SyntaxNode root, EntryState state, SemanticModel?model, CancellationToken cancellationToken)
            {
                if (state == EntryState.Removed)
                {
                    // mark both syntax *and* transform nodes removed
                    _filterTable.RemoveEntries();
                    _transformTable.RemoveEntries();
                }
                else
                {
                    Debug.Assert(model is object);

                    // get the syntax nodes from cache, or a syntax walk using the filter
                    ImmutableArray <SyntaxNode> nodes;
                    if (state != EntryState.Cached || !_filterTable.TryUseCachedEntries(out nodes))
                    {
                        nodes = IncrementalGeneratorSyntaxWalker.GetFilteredNodes(root, _owner._filterFunc, cancellationToken);
                        _filterTable.AddEntries(nodes, EntryState.Added);
                    }

                    // now, using the obtained syntax nodes, run the transform
                    foreach (var node in nodes)
                    {
                        var value       = new GeneratorSyntaxContext(node, model);
                        var transformed = ImmutableArray.Create(_owner._transformFunc(value, cancellationToken));

                        if (state == EntryState.Added || !_transformTable.TryModifyEntries(transformed, _owner._comparer))
                        {
                            _transformTable.AddEntries(transformed, EntryState.Added);
                        }
                    }
                }
            }
示例#4
0
 public static void Assert(this EntryState state, EntryState correct)
 {
     if (state != correct)
     {
         throw Error.Internal("Interaction was in an invalid state");
     }
 }
        static void CreateAIController()
        {
            AIController controller = CreateAssetAtSelectionPath <AIController> ();

            EntryState entryState = ScriptableObject.CreateInstance <EntryState> ();

            entryState.position = new Vector2(0, 0);
            entryState.name     = "Entry";

            AnyState anyState = ScriptableObject.CreateInstance <AnyState> ();

            anyState.position = new Vector2(0, 200);
            anyState.name     = "Any";

            controller.entryState = entryState;
            controller.anyState   = anyState;

            #if SERIALIZER_DEBUG
            Debug.Log("Controller [" + controller.name + "] created.");
            #endif

            AddNewNodeToController(controller, entryState, false);
            AddNewNodeToController(controller, anyState, false);

            Save();
        }
示例#6
0
        private void EntryEditDone_Click(object sender, EventArgs e)
        {
            if (_savepass.Root[tbxEntryName.Text] != null && _selectedEntry.Name != tbxEntryName.Text)
            {
                MessageBox.Show("Entry with this name is already exists", Application.ProductName);
                return;
            }

            _selectedEntry.Name     = tbxEntryName.Text;
            _selectedEntry.Username = tbxUsername.Text;
            _selectedEntry.Password = tbxPassword.Text;
            _selectedEntry.Email    = tbxEmail.Text;
            _selectedEntry.Website  = tbxWebsite.Text;
            _selectedEntry.Notes    = tbxNotes.Text;

            EntryRefresh();

            panEntryInfo.Visible   = true;
            panEntryEdit.Visible   = false;
            panEntriesList.Enabled = true;
            menuStrip1.Enabled     = true;
            toolStrip1.Enabled     = true;
            _entryState            = EntryState.None;

            _isFileSaved = false;
            this.Text    = string.Format("{0} * Password Manager", _savepass.Root.Name);

            _savepass.Root.Sort();

            dgEntries_Refresh();
        }
示例#7
0
        /// <summary>
        /// Initializes a new instance of the <see cref="StateManager{T}"/> class.
        /// Sets active state with an initial state and sets basic configuration.
        /// </summary>
        /// <param name="algorithmConfiguration">The configuration of the algorithm.</param>
        /// <param name="container">Exchange service container.</param>
        /// <param name="initial">The initial state.</param>
        public StateManager(
            T algorithmConfiguration,
            ExchangeProvidersContainer container,
            EntryState <T> initial)
        {
            lock (_lock)
            {
                // Setup logging
                _configuration = algorithmConfiguration;
                _container     = container;
                _logger        = container.LoggerFactory.CreateLogger(GetType());

                // Setup observing
                _timerObserver = container.TimerProvider.Subscribe(
                    new ConfigurableObserver <long>(
                        () => { },
                        _ => { },
                        tick =>
                {
                    if (_activeState is null)
                    {
                        Activate(initial);
                    }

                    OnMarketConditionEval();
                    EvaluateStateTimer();
                }));

                _tradingObserver = container.TradingProvider.Subscribe(
                    new ConfigurableObserver <OrderUpdate>(
                        () => { },
                        _ => { },
                        OnOrderUpdateEval));
            }
        }
示例#8
0
 private void EntryAdd_Click(object sender, EventArgs e)
 {
     _selectedEntry = new Entry("New entry");
     _savepass.Root.Add(_selectedEntry);
     dgEntries_Refresh();
     EntryEdit_Click(sender, e);
     _entryState = EntryState.Add;
 }
示例#9
0
 public void UpdateStateChange(EntryState state, long timestamp)
 {
     if (!IsStateChanged || StateChange.TimeStamp < timestamp ||
         StateChange.TimeStamp == timestamp && state == EntryState.Undone)
     {
         StateChange = new Change <EntryState>(state, timestamp);
     }
 }
示例#10
0
 public History(Operations operation, long timestamp, int userId, EntryState state, string name)
 {
     this.operation = operation;
     this.timestamp = timestamp;
     this.userId    = userId;
     this.state     = state;
     this.name      = name;
 }
示例#11
0
 private void AddStateInfo(int entryId, int userId, long timestamp, EntryState state)
 {
     if (!entriesStatus.ContainsKey(entryId))
     {
         entriesStatus[entryId] = new SortedSet <ItemWithState>();
     }
     entriesStatus[entryId].Add(new ItemWithState(userId, timestamp, state));
 }
 public void VisitTree(
     Lazy <SyntaxNode> root,
     EntryState state,
     Lazy <SemanticModel>?model,
     CancellationToken cancellationToken)
 {
     // We always have no inputs steps into a SyntaxInputNode, but we track the difference between "no inputs" (empty collection) and "no step information" (default value)
     var noInputStepsStepInfo = _filterTable.TrackIncrementalSteps ? ImmutableArray <(IncrementalGeneratorRunStep, int)> .Empty : default;
        public async Task <Status> AddEntry(AddEntryDto addEntryDto, int userId)
        {
            var user = _mainDbContext.Users.FirstOrDefault(u => u.UserId == userId);

            if (user == null)
            {
                return(new Status(false, "User not exist"));
            }

            var passwordE = SymmetricEncryptor.EncryptString(addEntryDto.PasswordDecrypted, user.PasswordHash);
            //todo: add auto mapper
            var newEntry = new Entry
            {
                UserOwnerUsername = user.Username,
            };
            var newEntryState = new EntryState
            {
                Username    = addEntryDto.Username,
                PasswordE   = passwordE,
                Description = addEntryDto.Description,
                Email       = addEntryDto.Email,
                WebAddress  = addEntryDto.WebAddress,
                IsDeleted   = false
            };

            newEntry.CurrentEntryState = newEntryState;
            var newUserEntry = new UsersEntries
            {
                IsUserOwner = true,
                Entry       = newEntry,
                User        = user
            };
            var entryAction = CreateEntryAction(user, newEntryState, newEntry, ActionTypesEnum.Create);


            try
            {
                _mainDbContext.Update(user);
                _mainDbContext.Update(entryAction);
                _mainDbContext.Update(newUserEntry);
                await _mainDbContext.SaveChangesAsync();

                return(new Status
                {
                    Success = true,
                    Message = "Added new password"
                });
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                return(new Status
                {
                    Success = false,
                    Message = "Something went wrong"
                });
            }
        }
        public async Task <Status> DeleteEntry(int entryId, int userId)
        {
            var userEntry =
                await _mainDbContext.UsersEntries
                .Include(x => x.Entry.CurrentEntryState)
                .Include(x => x.User)
                .FirstOrDefaultAsync(ue =>
                                     ue.EntryId == entryId && ue.UserId == userId);

            if (userEntry == null)
            {
                return(new Status(false, $"Cannot find entry with id: {entryId}"));
            }

            if (!userEntry.IsUserOwner)
            {
                return(new Status(false, "You cannot delete shared for you entry. You have to be an owner for delete."));
            }

            var entry             = userEntry.Entry;
            var currentEntryState = entry.CurrentEntryState;

            var newEntryState = new EntryState
            {
                PasswordE   = currentEntryState.PasswordE,
                Username    = currentEntryState.Username,
                Description = currentEntryState.Description,
                Email       = currentEntryState.Email,
                WebAddress  = currentEntryState.WebAddress,
                IsDeleted   = true
            };

            entry.CurrentEntryState = newEntryState;

            var entryAction = CreateEntryAction(userEntry.User, newEntryState, entry, ActionTypesEnum.Delete);

            try
            {
                await _mainDbContext.AddAsync(entryAction);

                await _mainDbContext.SaveChangesAsync();

                return(new Status
                {
                    Success = true,
                    Message = $"Successfully removed entry with Id={entryId} from entries!"
                });
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                return(new Status
                {
                    Success = false,
                    Message = "Something went wrong"
                });
            }
        }
示例#15
0
        public Entry(Guid id, int projectNumber, TimePeriod timePeriod, string comment)
            : base(id)
        {
            this.ProjectNumber = projectNumber;
            this.Period        = timePeriod;
            this.Comment       = comment;

            _state = new EntryState();
        }
        private void on_Entry_KeyPress(object o, KeyPressEventArgs args)
        {
            Entry      widget = (Entry)o;
            EntryState state  = _entryStates.Find(m => m.EntryWidget == widget);

            if (state != null)
            {
                state.Text = widget.Text;
            }
        }
示例#17
0
        public virtual void Highlight()
        {
            Color  = ParentMenu.Highlighted;
            _state = EntryState.Highlight;
            var handler = OnHighlight;

            if (handler != null)
            {
                handler(this, EventArgs.Empty);
            }
        }
示例#18
0
        public virtual void Normal()
        {
            Color  = ParentMenu.Normal;
            _state = EntryState.Normal;
            var handler = OnNormal;

            if (handler != null)
            {
                handler(this, EventArgs.Empty);
            }
        }
示例#19
0
        /// <summary>
        /// Activates the state manager by feeding it the initial state.
        /// </summary>
        /// <param name="initial">The initial state.</param>
        private void Activate(EntryState <T> initial)
        {
            Guard.Argument(initial).NotNull();
            if (_activeState != null)
            {
                throw new InvalidOperationException("Cannot activate the state manager when it is already active.");
            }

            _activeState = initial;
            SwitchState(_activeState.Activate(_configuration, _container));
        }
        public async Task <Status> EditEntry(EditEntryDto editEntryDto, int userId)
        {
            var owner = await _mainDbContext.Users.FirstOrDefaultAsync(user => user.UserId == userId);

            if (owner == null)
            {
                return(new Status(false, "User owner not found"));
            }

            var userEntry =
                await _mainDbContext.UsersEntries.Include(p => p.Entry.CurrentEntryState).FirstOrDefaultAsync(x =>
                                                                                                              x.EntryId == editEntryDto.EntryId && x.UserId == userId);

            if (userEntry == null)
            {
                return(new Status(false, "Entry not found"));
            }

            if (!userEntry.IsUserOwner)
            {
                return(new Status(false, "You cannot edit shared for you entry. You have to be an owner for edit."));
            }

            try
            {
                var newEntryState = new EntryState
                {
                    PasswordE   = SymmetricEncryptor.EncryptString(editEntryDto.PasswordDecrypted, owner.PasswordHash),
                    Username    = editEntryDto.Username,
                    Description = editEntryDto.Description,
                    Email       = editEntryDto.Email,
                    WebAddress  = editEntryDto.WebAddress,
                    IsDeleted   = false
                };
                userEntry.Entry.CurrentEntryState = newEntryState;
                var entryAction = CreateEntryAction(owner, newEntryState, userEntry.Entry, ActionTypesEnum.Edit);

                await _mainDbContext.AddAsync(entryAction);

                await _mainDbContext.SaveChangesAsync();

                return(new Status(true, "Password has been successfully edited"));
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                return(new Status
                {
                    Success = false,
                    Message = "Something went wrong"
                });
            }
        }
        public void ExecutePipeline(IInvocationPipeline basePipeline, IInvocation invocation)
        {
            // Это нарушает solid, но позволяет не выставлять кучу классов наружу библиотеки.
            var pipeline = (InvocationPipeline)basePipeline;

            pipeline.Init(invocation);

            var entryState = new EntryState <InvocationPipeline>(
                pipeline.BoundaryAspects, pipeline.InterceptionAspect);

            InvocationStateMachine.Execute(pipeline, entryState);
        }
示例#22
0
 private void EntryEdit_Click(object sender, EventArgs e)
 {
     _selectedEntry = GetSelectedEntry();
     EntryRefresh();
     panEntryEdit.Visible   = true;
     panEntryInfo.Visible   = false;
     panEntriesList.Enabled = false;
     menuStrip1.Enabled     = false;
     toolStrip1.Enabled     = false;
     _entryState            = EntryState.Edit;
     tbxEntryName.Focus();
 }
示例#23
0
 private void decrypt()
 {
     string[] tokens = c.decrypt(hash, userKey).Split(' ');
     if (tokens.Length != 3)
     {
         throw new Exception("Decryption cannot be done");
     }
     text   = c.decrypt(tokens[0], KEY);
     date   = new Date(tokens[1]);
     number = Convert.ToInt32(tokens[2]);
     state  = EntryState.DECRYPTED;
 }
示例#24
0
        protected virtual void SaveOperationLog(string objectId, string detail, EntryState entryState)
        {
            var operation = new OperationLog
            {
                ObjectId      = objectId,
                ObjectType    = typeof(ApplicationUserExtended).Name,
                OperationType = entryState,
                Detail        = detail
            };

            _changeLogService.SaveChanges(operation);
        }
示例#25
0
 public void VisitTree(SyntaxNode root, EntryState state, SemanticModel?model, CancellationToken cancellationToken)
 {
     if (_walker is object && state != EntryState.Removed)
     {
         Debug.Assert(model is object);
         try
         {
             _walker.VisitWithModel(model, root);
         }
         catch (Exception e)
         {
             throw new UserFunctionException(e);
         }
     }
 }
        private EntryAction CreateEntryAction(User user, EntryState entryState, Entry entry,
                                              ActionTypesEnum actionTypesEnum)
        {
            var entryAction = new EntryAction
            {
                ActionType   = actionTypesEnum,
                Entry        = entry,
                EntryState   = entryState,
                User         = user,
                DateTime     = DateTime.Now,
                IsRestorable = true
            };

            return(entryAction);
        }
示例#27
0
        private void EntryEditCancel_Click(object sender, EventArgs e)
        {
            if (_entryState == EntryState.Add)
            {
                _savepass.Root.Remove(_selectedEntry);
            }
            panEntryInfo.Visible   = true;
            panEntryEdit.Visible   = false;
            panEntriesList.Enabled = true;
            menuStrip1.Enabled     = true;
            toolStrip1.Enabled     = true;
            _entryState            = EntryState.None;

            dgEntries_Refresh();
        }
示例#28
0
 protected Entry(Bundle.HTTPVerb method, IKey key, DateTimeOffset?when, Resource resource)
 {
     if (resource != null)
     {
         key.ApplyTo(resource);
     }
     else
     {
         this.Key = key;
     }
     this.Resource = resource;
     this.Method   = method;
     this.When     = when ?? DateTimeOffset.Now;
     this.State    = EntryState.Undefined;
 }
        /// <summary>
        /// Execute actions
        /// </summary>
        /// <param name="entry"></param>
        /// <param name="transition"></param>
        /// <param name="data"></param>
        /// <returns></returns>
        public virtual async Task ExecuteActionsAsync(EntryState entry, Transition transition, Dictionary <string, string> data)
        {
            var actions         = transition.TransitionActions.Select(x => x.Action).ToList();
            var nextTransitions = await GetNextTransitionsAsync(transition);

            _backgroundTaskQueue.PushBackgroundWorkItemInQueue(async token =>
            {
                foreach (var action in actions)
                {
                    try
                    {
                        Type type      = null;
                        var memoryType = WorkFlowActionsStorage.GetActionType(action.ClassName);
                        if (memoryType == null)
                        {
                            var findType = this.GetTypeFromAssembliesByClassName(action.ClassName);
                            if (findType != null)
                            {
                                type = findType;
                                WorkFlowActionsStorage.AppendActionType(action.ClassName, findType);
                            }
                        }
                        else
                        {
                            type = memoryType;
                        }

                        if (type == null)
                        {
                            _logger.LogError($"Action {action.Name} was not found");
                            return;
                        }

                        var activatedObject = (BaseWorkFlowAction)Activator.CreateInstance(type, entry, transition, nextTransitions);
                        if (activatedObject == null)
                        {
                            return;
                        }
                        await activatedObject.InvokeExecuteAsync(data);
                    }
                    catch (Exception e)
                    {
                        _logger.LogCritical(e, e.Message);
                    }
                }
            });
        }
示例#30
0
 private void UpdateUserStateChangeToEntry(int entryId, int userId, EntryState entryState, long timestamp)
 {
     if (IsNewUser(userId))
     {
         throw new Exception(string.Format("Can't update changes of not initialized user {}", userId));
     }
     if (!HasUserDoneAnyChangesToEntry(entryId, userId))
     {
         InitializeUserChangesToEntry(entryId, userId);
     }
     if (usersLastChangesToEntry[userId][entryId].IsStateChanged &&
         entriesChanges[entryId].StateChanges.ContainsChangeByUser(userId, usersLastChangesToEntry[userId][entryId].StateChange))     //BAD!!!
     {
         entriesChanges[entryId].StateChanges.ClearChange(userId, usersLastChangesToEntry[userId][entryId].StateChange);
     }
     usersLastChangesToEntry[userId][entryId].UpdateStateChange(entryState, timestamp);
 }
示例#31
0
    private IEnumerator FetchCoroutine()
    {
        HeaderWriter.ClearWriting();
        Writer.WriteTextInstant ("Fetching...");

        Task<ParseUser> fetchTask = ParseUser.CurrentUser.FetchIfNeededAsync ();

        DateTime startTime = DateTime.UtcNow;
        TimeSpan waitDuration = TimeSpan.FromSeconds(TimeUtils.TIMEOUT_DURATION);
        while (!fetchTask.IsCompleted)
        {
            if(DateTime.UtcNow - startTime >= waitDuration)
                break;

            yield return null;
        }

        if (!fetchTask.IsCompleted)
        {
            errorInfo = new ErrorInfo(ErrorType.Timeout);
            entryState = EntryState.Error;
        }
        else if(fetchTask.IsFaulted)
        {
            using (IEnumerator<System.Exception> enumerator = fetchTask.Exception.InnerExceptions.GetEnumerator())
            {
                if (enumerator.MoveNext())
                {
                    ParseException exception = (ParseException) enumerator.Current;
                    errorInfo = new ErrorInfo(ErrorType.ParseException, exception.Code);
                }
                else
                {
                    errorInfo = new ErrorInfo(ErrorType.ParseInternal);
                }
            }

            entryState = EntryState.Error;
        }

        // we're done, what did we get?
        if (entryState != EntryState.Error)
        {
            PromptLoggedIn();
        }
        else
        {
            Writer.WriteTextInstant(errorInfo.GetErrorStr() + "\n" +
                                    "[Tap] to refresh\n");
        }
    }
示例#32
0
 private void PromptLoggedIn()
 {
     entryState = EntryState.LoggedIn;
     HeaderWriter.WriteTextInstant(MessageBook.AppName);
     Writer.WriteTextInstant ("Logged in: " + ParseUser.CurrentUser.Username + "\n"+
                              "[Tap] to play\n" +
                              "[Hold] to logout");
 }
示例#33
0
 private void PromptNormal()
 {
     entryState = EntryState.Normal;
     HeaderWriter.WriteTextInstant(MessageBook.AppName);
     Writer.WriteTextInstant ("[Tap] to play offline\n" +
                              "[Hold] to login or signup");
 }
示例#34
0
		public OrderChangeEvent(EntryState state, CustomerOrder origOrder, CustomerOrder modifiedOrder)
		{
			ChangeState = state;
			OrigOrder = origOrder;
			ModifiedOrder = modifiedOrder;
		}
示例#35
0
 public virtual void Normal()
 {
     Color = ParentMenu.Normal;
     _state = EntryState.Normal;
     var handler = OnNormal;
     if (handler != null)
     {
         handler(this, EventArgs.Empty);
     }
 }
示例#36
0
 void SetState(EntryState s)
 {
     this.entryState = s;
     this.lastStateChangeTime = Time.time;
 }
示例#37
0
 void DoEntryMovement()
 {
     target = wave.nb.endPos;
     DoTargetMovement();
     if (AtTarget())
     {
         this.entryState = EntryState.Loitering;
     }
 }
        private bool TryChangeState(TrackingEntry trackingEntity, EntryState newState)
        {
            if (trackingEntity == null)
            {
                throw new ArgumentNullException("trackingEntity");
            }

            var error = String.Format("Unable to change entity state from {0} -> {1}", trackingEntity.EntryState, newState);
            bool throwError = false;
            if (newState == EntryState.Modified)
            {
                switch (trackingEntity.EntryState)
                {
                    case EntryState.Detached:
                    case EntryState.Unchanged:
                        trackingEntity.EntryState = EntryState.Modified;
                        break;
                    case EntryState.Added:
                    case EntryState.Deleted:
                    case EntryState.Modified:
                        break;
                    default:
                        throwError = true;
                        break;
                }
            }
            else if (newState == EntryState.Added)
            {
                switch (trackingEntity.EntryState)
                {
                    case EntryState.Detached:
                    case EntryState.Unchanged:
                        trackingEntity.EntryState = EntryState.Added;
                        break;
                    default:
                        throwError = true;
                        break;
                }
            }
            else if (newState == EntryState.Deleted)
            {
                switch (trackingEntity.EntryState)
                {
                    case EntryState.Unchanged:
                    case EntryState.Modified:
                        trackingEntity.EntryState = EntryState.Deleted;
                        break;
                    default:
                        throwError = true;
                        break;
                }
            }
            else if (newState == EntryState.Unchanged)
            {
                trackingEntity.EntryState = EntryState.Unchanged;
            }

            if (throwError)
            {
                Debug.WriteLine(error);
                //  throw new InvalidOperationException(error);
            }
            return !throwError;
        }
示例#39
0
 /// <summary>
 /// Sets the neighbor to another room on the specified side.
 /// </summary>
 /// <param name='otherRoom'>
 /// The neighbor room.
 /// </param>
 /// <param name='side'>
 /// The side to which the neighbor room should be attached.
 /// </param>
 /// <param name='connectionState'>
 /// Specifies whether the neighboring room should be open or closed for access.
 /// </param>
 public void SetNeighbor(MazeRoom otherRoom, Cube.Side side, EntryState connectionState)
 {
     this.neighbors[(int)side] = otherRoom;
     this.entryStates[(int)side] = (otherRoom==null)?EntryState.Closed:connectionState;
 }
		public MemberChangingEvent(EntryState state, Member member)
		{
			ChangeState = state;
            Member = member;
		}
示例#41
0
 public virtual void Highlight()
 {
     Color = ParentMenu.Highlighted;
     _state = EntryState.Highlight;
     var handler = OnHighlight;
     if (handler != null)
     {
         handler(this, EventArgs.Empty);
     }
 }
 private void Refresh()
 {
     var _entity = _party.Find(Id);
     if (_entity == null)
     {
         _entryState = EntryState.NotIn;
         _entryText.text = EntryInText;
         _entryButton.interactable = !_party.IsFull;
     }
     else
     {
         _entryState = EntryState.In;
         _entryText.text = EntryOutText;
         _entryButton.interactable = true;
     }
 }
示例#43
0
        public virtual void Select()
        {
            if (SubMenu != null)
            {
                _state = EntryState.Selected;
                Color = ParentMenu.Selected;
                SubMenu.ActivateScreen();
                ParentMenu.ScreenManager.AddScreen(SubMenu);
                ParentMenu.FreezeScreen();
                ParentMenu.HideMouse();
                SubMenu.EnableMouse(ParentMenu.MouseTexture);
            }

            var handler = Selected;
            if (handler != null)
            {
                _state = EntryState.Selected;
                Color = ParentMenu.Selected;
                Selected(this, EventArgs.Empty);
            }
        }
示例#44
0
 void OnSwitchState(EntryState newState, EntryState oldState)
 {
 }
示例#45
0
    /// <summary>
    /// Set up our initial state.
    /// </summary>
    void DoInitialSpawn()
    {
        //We don't have any other kinds of entry behavior.
        this.transform.position = wave.nb.startPos;

        //Meh. Hardcode it.
        this.entryState = EntryState.Entering;
        //Immediately do a loiter change when we switch into it.
        this.nextLoiterChange = 0;

        this.nextShot = Random.Range(0f, 1f) * wave.at.fireInterval + Time.time;
    }
示例#46
0
		public CartChangeEvent(EntryState state, ShoppingCart origCart, ShoppingCart modifiedCart)
		{
			ChangeState = state;
			OrigCart = origCart;
			ModifiedCart = modifiedCart;
		}
示例#47
0
 /** Temporary(?) Elite control. It tries to follow what's in the wave. */
 public void DoWave(SpawnTDS.Wave w)
 {
     this.wave = w;
     this.entryState = EntryState.Spawned;
 }
		public QuoteRequestChangeEvent(EntryState state, QuoteRequest origQuote, QuoteRequest modifiedQuote)
		{
			ChangeState = state;
			OrigQuote = origQuote;
			ModifiedQuote = modifiedQuote;
		}