protected ChannelbarViewModelCommon(
     IUnityContainer contain, IRegionManager regman, IEventAggregator events, IChatModel cm,
     ICharacterManager lists)
     : base(contain, regman, events, cm, lists)
 {
     cm.SelectedChannelChanged += (s, e) => OnPropertyChanged("HasUsers");
 }
Esempio n. 2
0
        public ChannelbarViewModel(
            IChatModel cm, IUnityContainer contain, IRegionManager regman, IEventAggregator events,
            ICharacterManager manager)
            : base(contain, regman, events, cm, manager)
        {
            try
            {
                Events.GetEvent<ChatOnDisplayEvent>().Subscribe(RequestNavigate, ThreadOption.UIThread, true);

                // create the tabs
                Container.Resolve<ChannelsTabViewModel>();
                Container.Resolve<UsersTabViewModel>();
                Container.Resolve<NotificationsTabViewModel>();
                Container.Resolve<GlobalTabViewModel>();
                Container.Resolve<ManageListsTabView>();

                ChatModel.Notifications.CollectionChanged += (s, e) =>
                    {
                        if (!IsExpanded)
                        {
                            // removed checking logic, allow the notifications daemon to worry about that
                            HasUpdate = true;
                        }
                    };
            }
            catch (Exception ex)
            {
                ex.Source = "Channelbar ViewModel, init";
                Exceptions.HandleException(ex);
            }
        }
Esempio n. 3
0
        public GlobalTabViewModel(
            IChatModel cm, IUnityContainer contain, IRegionManager regman, IEventAggregator eventagg,
            ICharacterManager manager)
            : base(contain, regman, eventagg, cm, manager)
        {
            Container.RegisterType<object, GlobalTabView>(GlobalTabView);
            genderSettings = new GenderSettingsModel();

            SearchSettings.Updated += (s, e) =>
                {
                    OnPropertyChanged("SortedUsers");
                    OnPropertyChanged("SearchSettings");
                };

            GenderSettings.Updated += (s, e) =>
                {
                    OnPropertyChanged("GenderSettings");
                    OnPropertyChanged("SortedUsers");
                };

            Events.GetEvent<NewUpdateEvent>().Subscribe(
                args =>
                    {
                        var thisNotification = args as CharacterUpdateModel;
                        if (thisNotification == null)
                            return;

                        if (thisNotification.Arguments is CharacterUpdateModel.ListChangedEventArgs
                            || thisNotification.Arguments is CharacterUpdateModel.LoginStateChangedEventArgs)
                            OnPropertyChanged("SortedUsers");
                    });
        }
Esempio n. 4
0
 public HomeSettingsViewModel(IChatState chatState, IAutomateThings automationService, IconService iconService,
     ICharacterManager characterManager)
     : base(chatState)
 {
     automation = automationService;
     this.iconService = iconService;
     this.characterManager = characterManager;
 }
Esempio n. 5
0
 public ClientPacketHandler(
     ICharacterManager characterManager,
     IMapChannelManager mapChannelManager,
     IManifestationManager manifestationManager)
 {
     _characterManager     = characterManager;
     _mapChannelManager    = mapChannelManager;
     _manifestationManager = manifestationManager;
 }
Esempio n. 6
0
 public ToggleBlockCharacterCommand(ICharacterManager characterManager, IHttpContextReader httpContextReader,
                                    INotifier notifier, IHubManager <NotifierHub> hubManager, IMapper mapper)
 {
     this.characterManager  = characterManager;
     this.httpContextReader = httpContextReader;
     this.notifier          = notifier;
     this.hubManager        = hubManager;
     this.mapper            = mapper;
 }
Esempio n. 7
0
 public Script(IApiManager apiManager, IChatManager chatManager, IChannelManager channelManager, ICharacterManager characterManager, IEventManager eventManager, IMessageManager messageManager)
 {
     this.apiManager       = apiManager;
     this.chatManager      = chatManager;
     this.channelManager   = channelManager;
     this.characterManager = characterManager;
     this.eventManager     = eventManager;
     this.messageManager   = messageManager;
 }
Esempio n. 8
0
 public RogueAssassination2(IObjectManager objectManager, ICharacterManager characterManager, IHookManager hookManager, IPathfindingHandler pathhandler, DefaultMovementEngine movement)
 {
     ObjectManager      = objectManager;
     CharacterManager   = characterManager;
     HookManager        = hookManager;
     PathfindingHandler = pathhandler;
     MovementEngine     = movement;
     spells             = new RogueAssassinSpells(hookManager, objectManager);
 }
Esempio n. 9
0
 public WarriorFury(IObjectManager objectManager, ICharacterManager characterManager, IHookManager hookManager, IPathfindingHandler pathhandler, DefaultMovementEngine movement)
 {
     ObjectManager      = objectManager;
     CharacterManager   = characterManager;
     HookManager        = hookManager;
     PathfindingHandler = pathhandler;
     MovementEngine     = movement;
     spells             = new WarriorFurySpells(hookManager, objectManager);
 }
Esempio n. 10
0
 public PaladinProtection(IObjectManager objectManager, ICharacterManager characterManager, IHookManager hookManager, IPathfindingHandler pathhandler, DefaultMovementEngine movement)
 {
     ObjectManager      = objectManager;
     CharacterManager   = characterManager;
     HookManager        = hookManager;
     PathfindingHandler = pathhandler;
     MovementEngine     = movement;
     Jumped             = false;
     LastTargetCheck    = DateTime.Now;
 }
Esempio n. 11
0
        protected override void Awake()
        {
            base.Awake();
            this.AssertRequiredObjects(content);

            continueInput = Engine.GetService <IInputManager>().GetContinue();
            scriptPlayer  = Engine.GetService <IScriptPlayer>();

            CharacterManager = Engine.GetService <ICharacterManager>();
        }
Esempio n. 12
0
        protected override void Awake()
        {
            base.Awake();
            this.AssertRequiredObjects(messagesContainer, scrollRect, messagePrefab);

            inputManager        = Engine.GetService <IInputManager>();
            charManager         = Engine.GetService <ICharacterManager>();
            stateManager        = Engine.GetService <IStateManager>();
            localizationManager = Engine.GetService <ILocalizationManager>();
        }
Esempio n. 13
0
        public ChannelMemberViewModel(ICharacterManager characterManager, IChannelManager channelManager, Channel channel, Channel.Member member)
        {
            this.characterManager = characterManager;
            this.channel          = channel;
            Member    = member;
            Character = Mvx.GetSingleton <CharacterViewModels>().GetCharacterViewModel(member.Character);

            ChannelKickCommand     = new MvxCommand(() => channelManager.KickUser(channel, member.Character.Name));
            ChannelBanCommand      = new MvxCommand(() => channelManager.SetUserBanned(channel, member.Character.Name, true));
            ChannelToggleOpCommand = new MvxCommand(() => channelManager.SetUserOp(channel, member.Character.Name, Member.Rank == Channel.RankEnum.User));
        }
Esempio n. 14
0
        public Client(
            IGameUnitOfWorkFactory gameUnitOfWorkFactory,
            ICharacterManager characterManager,
            ClientPacketHandler handler)
        {
            _gameUnitOfWorkFactory = gameUnitOfWorkFactory;
            _characterManager      = characterManager;

            _handler = handler;
            _handler.RegisterClient(this);
        }
Esempio n. 15
0
 private void Awake()
 {
     UserControl._instance = this;
     this._character = GetComponent<CharacterManager>();
     //m_Character = Intercept.ThroughProxy<ICharacterManager>(
     //  character,
     //  new InterfaceInterceptor(),
     //    new IInterceptionBehavior [] {
     //      new ExceptionInterceptionBehavior()
     //  });
 }
Esempio n. 16
0
        public UtilityChannelViewModel(
            string name, IUnityContainer contain, IRegionManager regman, IEventAggregator events, IChatModel cm,
            ICharacterManager manager, IAutomationService automation)
            : base(contain, regman, events, cm, manager)
        {
            this.automation = automation;
            try
            {
                Model = Container.Resolve<GeneralChannelModel>(name);
                ConnectTime = 0;
                flavorText = new StringBuilder("Connecting");
                connectDotDot = new StringBuilder();

                Container.RegisterType<object, UtilityChannelView>(Model.Id, new InjectionConstructor(this));
                minuteOnlineCount = new CacheCount(OnlineCountPrime, 15, 1000*15);

                updateTimer.Enabled = true;
                updateTimer.Elapsed += (s, e) =>
                    {
                        OnPropertyChanged("RoughServerUpTime");
                        OnPropertyChanged("RoughClientUpTime");
                        OnPropertyChanged("LastMessageReceived");
                        OnPropertyChanged("IsConnecting");
                    };

                updateTimer.Elapsed += UpdateConnectText;

                Events.GetEvent<NewUpdateEvent>().Subscribe(
                    param =>
                        {
                            if (!(param is CharacterUpdateModel))
                                return;

                            var temp = param as CharacterUpdateModel;
                            if (!(temp.Arguments is CharacterUpdateModel.LoginStateChangedEventArgs))
                                return;

                            OnPropertyChanged("OnlineCount");
                            OnPropertyChanged("OnlineFriendsCount");
                            OnPropertyChanged("OnlineBookmarksCount");
                            OnPropertyChanged("OnlineCountChange");
                        });

                Events.GetEvent<LoginAuthenticatedEvent>().Subscribe(LoggedInEvent);
                Events.GetEvent<LoginFailedEvent>().Subscribe(LoginFailedEvent);
                Events.GetEvent<ReconnectingEvent>().Subscribe(LoginReconnectingEvent);
            }
            catch (Exception ex)
            {
                ex.Source = "Utility Channel ViewModel, init";
                Exceptions.HandleException(ex);
            }
        }
Esempio n. 17
0
        public ChannelsTabViewModel(
            IChatModel cm, IUnityContainer contain, IRegionManager reggman, IEventAggregator events,
            ICharacterManager manager)
            : base(contain, reggman, events, cm, manager)
        {
            Container.RegisterType<object, ChannelTabView>(ChannelsTabView);

            SearchSettings.Updated += (s, e) =>
                {
                    OnPropertyChanged("SearchSettings");
                    OnPropertyChanged("SortedChannels");
                };
        }
Esempio n. 18
0
        public ListsViewModel(ICharacterManager characterManager, CharacterViewModels cache, CharacterListProvider characterListProvider)
        {
            var lists = new ObservableList <List>();

            IObservableList <CharacterViewModel> Mapper(IObservableList <Character> l) => new MappingObservableList <Character, CharacterViewModel>(l, cache.GetCharacterViewModel);

            lists.Add(new List(Strings.CharacterLists_Bookmarks, Mapper(new FilteringObservableList <Character, bool>(characterManager.OnlineCharacters, x => x.IsBookmarked, x => x))));
            lists.Add(new List(Strings.CharacterLists_Friends, Mapper(new FilteringObservableList <Character, bool>(characterManager.OnlineCharacters, x => x.IsFriend, x => x))));
            lists.Add(new List(Strings.CharacterLists_ChatOps, Mapper(new FilteringObservableList <Character, bool>(characterManager.OnlineCharacters, x => x.IsChatOp, x => x))));
            lists.InsertRange(characterListProvider.CustomLists.Select(l => new List(l.Name,
                                                                                     Mapper(new FilteringObservableList <Character>(characterManager.OnlineCharacters, x => l.Characters.Contains(x.Name))))), lists.Count);
            Lists = lists;
        }
Esempio n. 19
0
        public EventManager(IChatManager chatManager, IMessageManager messageManager, ICharacterManager characterManager, IChannelManager channelManager)
        {
            this.characterManager  = characterManager;
            this.channelManager    = channelManager;
            chatManager.Connected += () => {
                characterManager.OnlineCharacters.CollectionChanged += (sender, args) => {
                    switch (args.Action)
                    {
                    case NotifyCollectionChangedAction.Add:
                        foreach (var character in args.NewItems.Cast <Character>())
                        {
                            AddEvent(new LoginEvent(character));
                        }
                        break;

                    case NotifyCollectionChangedAction.Remove:
                        foreach (var character in args.OldItems.Cast <Character>())
                        {
                            AddEvent(new LogoutEvent(character));
                        }
                        break;
                    }
                };
                chatManager.CommandReceived += OnCommandReceived;
            };
            messageManager.ChannelMessageReceived += (channel, message) => {
                if (message.Sender == characterManager.OwnCharacter)
                {
                    return;
                }
                OnChannelMessage(channel, message);
            };
            channelManager.JoinedChannels.CollectionChanged += (sender, args) => {
                switch (args.Action)
                {
                case NotifyCollectionChangedAction.Add:
                    foreach (var channel in args.NewItems.Cast <Channel>())
                    {
                        channel.Members.CollectionChanged += (_, memberArgs) => ChannelMembersChanged(channel, memberArgs);
                    }
                    break;

                case NotifyCollectionChangedAction.Remove:
                    foreach (var channel in args.OldItems.Cast <Channel>())
                    {
                        AddEvent(new ChannelLeaveEvent(channel, channel.Members[characterManager.OwnCharacter]));
                    }
                    break;
                }
            };
        }
Esempio n. 20
0
        public Client(
            IGameUnitOfWorkFactory gameUnitOfWorkFactory,
            ICharacterManager characterManager,
            ClientPacketHandler handler)
        {
            _gameUnitOfWorkFactory = gameUnitOfWorkFactory;
            _characterManager      = characterManager;

            inboundData        = BufferManager.RequestBuffer();
            inboundData.Length = 0;

            _handler = handler;
            _handler.RegisterClient(this);
        }
Esempio n. 21
0
        private bool requestIsSent; // used for determining Login UI state

        #endregion Fields

        #region Constructors

        public LoginViewModel(
            IUnityContainer contain, IRegionManager regman, IAccount acc, IEventAggregator events, IChatModel cm,
            ICharacterManager lists)
            : base(contain, regman, events, cm, lists)
        {
            try
            {
                model = acc.ThrowIfNull("acc");
            }
            catch (Exception ex)
            {
                ex.Source = "Login ViewModel, Init";
                Exceptions.HandleException(ex);
            }
        }
Esempio n. 22
0
        public AutomationService(IEventAggregator events, ICharacterManager manager, IChatModel cm)
        {
            this.events = events;
            this.manager = manager;
            this.cm = cm;

            idleTimer = new Timer(ApplicationSettings.AutoIdleTime*OneMinute);
            awayTimer = new Timer(ApplicationSettings.AutoAwayTime*OneMinute);

            idleTimer.Elapsed += IdleTimerOnElapsed;
            awayTimer.Elapsed += AwayTimerOnElapsed;
            fullscreenTimer.Elapsed += FullscreenTimerOnElapsed;

            events.GetEvent<UserCommandEvent>().Subscribe(OnUserCommandSent);
        }
Esempio n. 23
0
        public static bool MeetsFilters(
            this ICharacter character,
            GenderSettingsModel genders,
            GenericSearchSettingsModel search,
            ICharacterManager cm,
            GeneralChannelModel channel)
        {
            if (!character.NameContains(search.SearchString))
            {
                return(false);
            }

            return(genders.MeetsGenderFilter(character) &&
                   character.MeetsChatModelLists(search, cm, channel));
        }
Esempio n. 24
0
        public void ReadMonsterGroup(ICharacterManager characterManager, MonsterGroup monsterGroup, IDataReader dataReader)
        {
            dataReader.Position = 0;

            for (int r = 0; r < 3; ++r)
            {
                for (int c = 0; c < 6; ++c)
                {
                    uint monsterIndex = dataReader.ReadWord();

                    monsterGroup.Monsters[c, r] = monsterIndex == 0 ? null :
                                                  characterManager.GetMonster(monsterIndex);
                }
            }
        }
Esempio n. 25
0
 public void Init(DataManager db,
                  ICharacterManager characterManager,
                  DataCategory category,
                  int serverId,
                  Logger logger,
                  Action <int> action)
 {
     mDataCategory     = category;
     mServerId         = serverId;
     Logger            = logger;
     mDbManager        = db;
     mCharacterManager = characterManager;
     mServerAction     = action;
     RegisterTasks();
     CoroutineFactory.NewCoroutine(InitImpl).MoveNext();
 }
Esempio n. 26
0
        public static bool MeetsFilters(
            this IMessage message,
            GenderSettingsModel genders,
            GenericSearchSettingsModel search,
            ICharacterManager cm,
            GeneralChannelModel channel)
        {
            if (!message.Poster.NameContains(search.SearchString) &&
                !message.Message.ContainsOrdinal(search.SearchString))
            {
                return(false);
            }

            return(genders.MeetsGenderFilter(message.Poster) &&
                   message.Poster.MeetsChatModelLists(search, cm, channel));
        }
Esempio n. 27
0
 public ChatWrapperViewModel(
     IUnityContainer contain, IRegionManager regman, IEventAggregator events, IChatModel cm,
     ICharacterManager lists)
     : base(contain, regman, events, cm, lists)
 {
     try
     {
         Events.GetEvent<CharacterSelectedLoginEvent>()
             .Subscribe(HandleCurrentCharacter, ThreadOption.UIThread, true);
     }
     catch (Exception ex)
     {
         ex.Source = "Chat Wrapper ViewModel, init";
         Exceptions.HandleException(ex);
     }
 }
Esempio n. 28
0
        public FriendRequestService(IBrowseThings browser, IGetTickets ticketService,
                                    IAccount account, IEventAggregator events, ICharacterManager characterManager)
        {
            this.browser          = browser;
            this.ticketService    = ticketService;
            this.account          = account;
            this.events           = events;
            this.characterManager = characterManager;

            events.GetEvent <CharacterSelectedLoginEvent>().Subscribe(result =>
            {
                selectedCharacter = result;

                UpdateOutgoingRequests();
                UpdatePendingRequests();
            });
        }
Esempio n. 29
0
        public FriendRequestService(IBrowseThings browser, IGetTickets ticketService,
            IAccount account, IEventAggregator events, ICharacterManager characterManager)
        {
            this.browser = browser;
            this.ticketService = ticketService;
            this.account = account;
            this.events = events;
            this.characterManager = characterManager;

            events.GetEvent<CharacterSelectedLoginEvent>().Subscribe(result =>
            {
                selectedCharacter = result;

                UpdateOutgoingRequests();
                UpdatePendingRequests();
            });
        }
Esempio n. 30
0
 public ChatState(
     IUnityContainer container,
     IRegionManager regionManager,
     IEventAggregator eventAggregator,
     IChatModel chatModel,
     ICharacterManager characterManager,
     IHandleChatConnection connection,
     IAccount account)
 {
     Connection       = connection;
     Container        = container;
     RegionManager    = regionManager;
     EventAggregator  = eventAggregator;
     ChatModel        = chatModel;
     CharacterManager = characterManager;
     Account          = account;
 }
Esempio n. 31
0
        public NotificationsTabViewModel(
            IChatModel cm, IUnityContainer contain, IRegionManager regman, IEventAggregator eventagg,
            ICharacterManager manager)
            : base(contain, regman, eventagg, cm, manager)
        {
            Container.RegisterType<object, NotificationsTabView>(NotificationsTabView);

            notificationManager =
                new FilteredCollection<NotificationModel, IViewableObject>(
                    ChatModel.Notifications, MeetsFilter, true);

            notificationManager.Collection.CollectionChanged += (sender, args) =>
                {
                    OnPropertyChanged("HasNoNotifications");
                    OnPropertyChanged("NeedsAttention");
                };
        }
Esempio n. 32
0
        protected ChannelViewModelBase(
            IUnityContainer contain, IRegionManager regman, IEventAggregator events, IChatModel cm,
            ICharacterManager manager)
            : base(contain, regman, events, cm, manager)
        {
            Events.GetEvent<ErrorEvent>().Subscribe(UpdateError);

            PropertyChanged += OnThisPropertyChanged;

            if (errorRemoveTimer != null)
                return;

            errorRemoveTimer = new Timer(5000);
            errorRemoveTimer.Elapsed += (s, e) => { Error = null; };

            errorRemoveTimer.AutoReset = false;
        }
Esempio n. 33
0
    // The player number needs to be set from the player character, and not from the manager.
    // The reason is that in a network game, the character that is spawned by the other client will not be spawned here through the manager. However, it will go through the player character's Awake/Start function.
    protected void SetPlayerNumber()
    {
        ICharacterManager characterManager = GameManager.Instance.CharacterManager;

        if (GameRules.GamePlayerType == GamePlayerType.NetworkMultiplayer)
        {
            if (PhotonNetwork.IsMasterClient)
            {
                if (PhotonView.IsMine)
                {
                    PlayerNumber = PlayerNumber.Player1;
                }
                else
                {
                    PlayerNumber = PlayerNumber.Player2;
                }
            }
            else
            {
                if (PhotonView.IsMine)
                {
                    PlayerNumber = PlayerNumber.Player2;
                }
                else
                {
                    PlayerNumber = PlayerNumber.Player1;
                }
            }
        }
        else if (GameRules.GamePlayerType == GamePlayerType.SinglePlayer)
        {
            PlayerNumber = PlayerNumber.Player1;
        }
        else
        {
            if (characterManager.GetPlayerCount() == 0)
            {
                PlayerNumber = PlayerNumber.Player1;
            }
            else
            {
                PlayerNumber = PlayerNumber.Player2;
            }
        }
        Logger.Log(Logger.Initialisation, $"We set the player number to {PlayerNumber}");
    }
Esempio n. 34
0
        public ListManagerTests()
        {
            bookmarkCharacter = new CharacterModel {Name = "Character One"};
            friendCharacter = new CharacterModel {Name = "Character Two"};
            otherCharacter = new CharacterModel {Name = "Character Three"};
            interestedCharacter = new CharacterModel {Name = "Character Four"};

            bookmarks = new[] {bookmarkCharacter.Name};
            var allFriends = new Dictionary<string, IList<string>> {{friendCharacter.Name, new[] {currentCharacter}}};

            var account = Mock.Of<IAccount>(acc =>
                acc.AllFriends == allFriends
                && acc.Bookmarks == bookmarks
                && acc.Characters == new ObservableCollection<string> {currentCharacter});

            eventAggregator = new EventAggregator();
            manager = new GlobalCharacterManager(account, eventAggregator);
        }
Esempio n. 35
0
        public CharacterSelectViewModel(
            IUnityContainer contain, IRegionManager regman, IEventAggregator events, IAccount acc, IChatModel cm,
            ICharacterManager manager)
            : base(contain, regman, events, cm, manager)
        {
            try
            {
                model = acc.ThrowIfNull("acc");

                Events.GetEvent<LoginCompleteEvent>()
                    .Subscribe(HandleLoginComplete, ThreadOption.UIThread, true);
            }
            catch (Exception ex)
            {
                ex.Source = "Character Select ViewModel, init";
                Exceptions.HandleException(ex);
            }
        }
Esempio n. 36
0
 public MainViewModel(IChatManager chatManager, ICharacterManager characterManager, INavigationProvider navigationProvider, IMvxMessenger messenger) : base(navigationProvider)
 {
     this.chatManager        = chatManager;
     this.characterManager   = characterManager;
     this.messenger          = messenger;
     Character               = Mvx.GetSingleton <CharacterViewModels>().GetCharacterViewModel(characterManager.OwnCharacter);
     ViewConversationCommand = new MvxCommand <string>(ShowCharacterTab);
     ChangeStatusCommand     = new MvxCommand <Tuple <StatusEnum, string> >(tuple => chatManager.SetStatus(tuple.Item1, tuple.Item2));
     ViewHomeTabCommand      = new MvxCommand(() => {
         if (messenger.HasSubscriptionsFor <ChatViewModel.ShowTabMessage>())
         {
             messenger.Publish(new ChatViewModel.ShowTabMessage(this));
         }
         else
         {
             Navigator.Navigate <ChatViewModel>();
         }
     });
 }
Esempio n. 37
0
        public static string RelationshipToUser(this ICharacter character, ICharacterManager cm,
                                                GeneralChannelModel channel)
        {
            foreach (var pair in GeneralExtensions.ListKindSet.Where(pair => cm.IsOnList(character.Name, pair.Key)))
            {
                return(pair.Value);
            }

            if (channel != null && channel.CharacterManager.IsOnList(character.Name, ListKind.Moderator))
            {
                return("d");
            }

            string result;

            return(GeneralExtensions.SortDictionary.TryGetValue(character.Status, out result)
                ? result
                : "f");
        }
Esempio n. 38
0
        public UsersTabViewModel(
            IChatModel cm, IUnityContainer contain, IRegionManager regman, IEventAggregator eventagg,
            ICharacterManager manager)
            : base(contain, regman, eventagg, cm, manager)
        {
            Container.RegisterType<object, UsersTabView>(UsersTabView);
            genderSettings = new GenderSettingsModel();

            SearchSettings.Updated += (s, e) =>
                {
                    OnPropertyChanged("SortedUsers");
                    OnPropertyChanged("SearchSettings");
                };

            GenderSettings.Updated += (s, e) =>
                {
                    OnPropertyChanged("GenderSettings");
                    OnPropertyChanged("SortedUsers");
                };

            ChatModel.SelectedChannelChanged += (s, e) =>
                {
                    currentChan = null;
                    OnPropertyChanged("SortContentString");
                    OnPropertyChanged("SortedUsers");
                };

            Events.GetEvent<NewUpdateEvent>().Subscribe(
                args =>
                    {
                        var thisNotification = args as CharacterUpdateModel;
                        if (thisNotification == null)
                            return;

                        if (thisNotification.Arguments is CharacterUpdateModel.PromoteDemoteEventArgs)
                            OnPropertyChanged("HasPermissions");

                        else if (thisNotification.Arguments is CharacterUpdateModel.JoinLeaveEventArgs
                                 || thisNotification.Arguments is CharacterUpdateModel.ListChangedEventArgs)
                            OnPropertyChanged("SortedUsers");
                    });
        }
Esempio n. 39
0
        public TabbedPeopleViewModel(ICharacterManager characterManager)
        {
            var cache        = Mvx.GetSingleton <CharacterViewModels>();
            var nameComparer = Comparer <CharacterViewModel> .Create((x, y) => CultureInfo.CurrentUICulture.CompareInfo.Compare(x.Character.Name, y.Character.Name));

            var onlineCharacters = new MappingObservableList <Character, CharacterViewModel>(characterManager.OnlineCharacters, x => cache.GetCharacterViewModel(x));

            Tabs = new List <Tab> {
                new Tab(Strings.People_Friends, new UIThreadObservableList <CharacterViewModel>(new SortingObservableList <CharacterViewModel>(
                                                                                                    new FilteringObservableList <CharacterViewModel, bool>(onlineCharacters, x => x.Character.IsFriend, x => x), nameComparer))),
                new Tab(Strings.People_Bookmarks, new UIThreadObservableList <CharacterViewModel>(new SortingObservableList <CharacterViewModel>(
                                                                                                      new FilteringObservableList <CharacterViewModel, bool>(onlineCharacters, x => x.Character.IsBookmarked, x => x), nameComparer))),
                new Tab(Strings.People_All, new UIThreadObservableList <CharacterViewModel>(new SortingObservableList <CharacterViewModel>(onlineCharacters, nameComparer)))
            };
            SelectedTab        = Tabs[0];
            TabSelectedCommand = new MvxCommand <Tab>(tab => {
                SelectedTab       = tab;
                SelectedCharacter = null;
            });
        }
    public void SetupData()
    {
        ICharacterManager characterManager = DIContainer.GetModule <ICharacterManager>();

        if (characterManager == null)
        {
            return;
        }
        List <Character> list = characterManager.GetAllCharacter();
        int i = 0;

        for (; i < list.Count && i < characterList.Length; i++)
        {
            characterList[i].CHARACTER = list[i];
        }
        for (; i < characterList.Length; i++)
        {
            characterList[i].CHARACTER = null;
        }
    }
Esempio n. 41
0
        public ICharacterManager CreateCharacterManager(Type cmType, CharacterControllerBase owner, params CharacterStateBase[] states)
        {
            if (owner == null)
            {
                throw new GameFrameworkException("Invalid Owner to create CharacterManager");
            }

            if (states.Length < 1)
            {
                throw new GameFrameworkException("Must has at least One State to create a CharacterManager");
            }

            string tName = cmType.FullName;

            if (cmType.GetInterface("ICharacterManager") == null)
            {
                throw new GameFrameworkException(string.Format("Invalid Type {0} to create CharacterManager.", tName));
            }

            ICharacterManager ret = null;
            Dictionary <string, ICharacterManager> dict = null;

            if (m_CharacterInstancesDict.TryGetValue(tName, out dict))
            {
                string instName = string.Format("{0}.{1}", owner.name, cmType.Name);
                if (dict.ContainsKey(instName))
                {
                    Log.Warning("{0} already Exists, will be replaced", instName);
                }
                ret = (ICharacterManager)Activator.CreateInstance(cmType);
                ret.Initialize(GameFrameworkEntry.GetModule <IFsmManager>(), owner, states);
                dict [instName] = ret;
            }
            else
            {
                throw new GameFrameworkException(string.Format("Invalid Type {0} to create CharacterManager.", tName));
            }

            return(ret);
        }
Esempio n. 42
0
    public void CalculateScores()
    {
        Logger.Log(Logger.Score, "Finished counting score.");

        ICharacterManager characterManager = GameManager.Instance.CharacterManager;

        if (characterManager == null)
        {
            return;
        }

        if (characterManager.GetPlayers <MazePlayerCharacter>().Count == 1)
        {
            PlayerMazeScores.Add(PlayerNumber.Player1, new PlayerMazeScore());
        }
        else
        {
            PlayerMazeScores.Add(PlayerNumber.Player1, new PlayerMazeScore());
            PlayerMazeScores.Add(PlayerNumber.Player2, new PlayerMazeScore());
        }

        CountTileMarkerScores();
        CountEnemyEncountersScores();
        CountFirstFinishedBonus();

        Dictionary <PlayerNumber, PlayerMazeScore> tempPlayerScores = new Dictionary <PlayerNumber, PlayerMazeScore>();

        foreach (KeyValuePair <PlayerNumber, PlayerMazeScore> item in PlayerMazeScores)
        {
            int             mazeTotal       = item.Value.CountMazeTotal();
            PlayerMazeScore playerMazeScore = item.Value;
            playerMazeScore.MazeScore = mazeTotal;
            tempPlayerScores.Add(item.Key, playerMazeScore);

            PersistentGameManager.UpdatePlayerOveralScoresWithMazeScore(item.Key, playerMazeScore.MazeScore);
        }

        PlayerMazeScores = tempPlayerScores;
    }
Esempio n. 43
0
        public CommandService(
            IChatModel cm,
            IChatConnection conn,
            IChannelManager manager,
            IUnityContainer contain,
            IRegionManager regman,
            IEventAggregator eventagg,
            ICharacterManager characterManager,
            IAutomationService automation)
            : base(contain, regman, eventagg, cm, characterManager)
        {
            connection = conn;
            this.manager = manager;
            this.automation = automation;

            Events.GetEvent<CharacterSelectedLoginEvent>()
                .Subscribe(GetCharacter, ThreadOption.BackgroundThread, true);
            Events.GetEvent<ChatCommandEvent>().Subscribe(EnqueAction, ThreadOption.BackgroundThread, true);
            Events.GetEvent<ConnectionClosedEvent>().Subscribe(WipeState, ThreadOption.PublisherThread, true);

            ChatModel.CurrentAccount = connection.Account;
        }
Esempio n. 44
0
    void Start()
    {
        dialogueSystem = new DialogueSystem()
        {
            Elements = new DialogueSystemElements()
            {
                DefaultSpeechSettings = new SpeechSettings()
                {
                    DisplaySpeed = 5f,
                    FontSettings = new FontSettings()
                    {
                        FontAsset    = ResourceHelpers.LoadFontAsset("OpenSans SDF"),
                        FontMaterial = ResourceHelpers.LoadMaterial("Fonts", "OpenSans SDF Presset")
                    },
                    FontColor         = Color.cyan,
                    FontSize          = 45,
                    FontOnSpeakerName = false
                },
                DialoguePanel      = DialogueSetup.Instance.DialoguePanel,
                SpeakerNameDisplay = DialogueSetup.Instance.SpeakerNameDisplay,
                SpeechTextDisplay  = DialogueSetup.Instance.SpeechTextDisplay
            }
        };
        GlobalSetup.Instance.DialogueSystem = dialogueSystem;

        characterManager = new CharacterManager()
        {
            CharacterPanel = CharacterSetup.Instance.CharacterPanelRect
        };
        character = (SingleLayerCharacter)characterManager.AddCharacter <SingleLayerCharacter>("Miu", true);
        character.Initialize(false);
        character.Renderer.SetSprite(GetSprite("neutral"));//Transition(ResourceHelpers.LoadCharacterSingleSprite("Miu"), 1f, false);
        character.Enabled = true;

        scripter = new Scripter();
        scripter.CommandFactory = new CommandFactory();
        scripter.Initialize(new ScriptText());
    }
Esempio n. 45
0
        protected ViewModelBase(IUnityContainer contain, IRegionManager regman, IEventAggregator events, IChatModel cm,
            ICharacterManager manager)
        {
            try
            {
                Container = contain.ThrowIfNull("contain");
                RegionManager = regman.ThrowIfNull("regman");
                Events = events.ThrowIfNull("events");
                ChatModel = cm.ThrowIfNull("cm");
                CharacterManager = manager.ThrowIfNull("manager");

                RightClickMenuViewModel = new RightClickMenuViewModel(ChatModel.IsGlobalModerator, CharacterManager);
                CreateReportViewModel = new CreateReportViewModel(Events, ChatModel);
                ChatModel.SelectedChannelChanged += OnSelectedChannelChanged;

                Events.GetEvent<NewUpdateEvent>().Subscribe(UpdateRightClickMenu);
            }
            catch (Exception ex)
            {
                ex.Source = "Generic ViewModel, init";
                Exceptions.HandleException(ex);
            }
        }
Esempio n. 46
0
        public MessageManager(IChatManager chatManager, ICharacterManager characterManager, IChannelManager channelManager)
        {
            this.chatManager             = chatManager;
            this.characterManager        = characterManager;
            this.channelManager          = channelManager;
            chatManager.CommandReceived += HandleServerCommand;

            chatManager.Connected += () => {
                MaxChatBytes    = chatManager.ServerVars["chat_max"].ToObject <int>();
                MaxAdBytes      = chatManager.ServerVars["lfrp_max"].ToObject <int>();
                MaxPrivateBytes = chatManager.ServerVars["priv_max"].ToObject <int>();
                msgFlood        = this.chatManager.ServerVars["msg_flood"].ToObject <double>();
                var pinned = AppSettings.Instance.PinnedChannels;
                if (pinned != null)
                {
                    foreach (var channel in AppSettings.Instance.PinnedChannels)
                    {
                        chatManager.Send(Helpers.CreateClientCommand(ClientCommandType.JCH, new ClientJch {
                            channel = channel
                        }));
                    }
                }
            };
        }
        public CharacterViewModel(IChatManager chatManager, ICharacterManager characterManager, IApiManager apiManager, CharacterListProvider characterListProvider)
        {
            this.characterManager      = characterManager;
            this.apiManager            = apiManager;
            this.characterListProvider = characterListProvider;
            ToggleBookmarkCommand      = new MvxCommand(() => apiManager.QueryApi($"bookmark-{(Character.IsBookmarked ? "remove" : "add")}.php?name={Character.Name}"));
            ToggleIgnoreCommand        = new MvxCommand(() => characterManager.SetIgnored(Character, !Character.IsIgnored));
            ShowProfileCommand         = new MvxCommand(() => Navigator.Navigate(this));
            MessageCommand             = new MvxCommand(() => {
                Navigator.Navigate <ChatViewModel, ChatViewModel.InitArgs>(new ChatViewModel.InitArgs {
                    Character = Character.Name
                });
            });

            KickCommand = new MvxCommand(() => {
                chatManager.Send(Helpers.CreateClientCommand(ClientCommandType.KIK, new { character = Character.Name }));
            });
            BanCommand = new MvxCommand(() => {
                chatManager.Send(Helpers.CreateClientCommand(ClientCommandType.ACB, new { character = Character.Name }));
            });
            AddToListCommand      = new MvxCommand <CustomCharacterList>(list => characterListProvider.AddCharacter(list, Character.Name));
            RemoveFromListCommand = new MvxCommand <CustomCharacterList>(list => characterListProvider.RemoveCharacter(list, Character.Name));
            characterListProvider.CustomListsChanged += SetCharacterLists;
        }
Esempio n. 48
0
 public FindPartnersViewModel(IChatManager chatManager, IApiManager apiManager, ICharacterManager characterManager, IMessageManager messageManager)
 {
     this.chatManager      = chatManager;
     this.apiManager       = apiManager;
     this.characterManager = characterManager;
     this.messageManager   = messageManager;
     if (!searchFieldsInitialized)
     {
         GetSearchFields();
     }
     SearchCommand = new MvxCommand(() => {
         Pending = true;
         chatManager.CommandReceived += OnCommandReceived;
         chatManager.Send(Helpers.CreateClientCommand(ClientCommandType.FKS, new {
             kinks        = SelectedKinks.Select(x => x.Id),
             genders      = SelectedGenders,
             orientations = SelectedOrientations,
             positions    = SelectedPositions,
             roles        = SelectedRoles,
             languages    = SelectedLanguages
         }));
     });
     ViewProfileCommand = new MvxCommand <CharacterViewModel>(c => Navigator.Navigate <CharacterViewModel, string>(c.Character.Name));
 }
Esempio n. 49
0
 public PermissionService(IChatState chatState)
 {
     cm = chatState.ChatModel;
     characters = chatState.CharacterManager;
 }
Esempio n. 50
0
 public RightClickMenuViewModel(bool isModerator, ICharacterManager characters, IGetPermissions permissionService)
 {
     this.isModerator = isModerator;
     this.characters = characters;
     this.permissionService = permissionService;
 }
Esempio n. 51
0
        public MessageService(
            IRegionManager regman,
            IUnityContainer contain,
            IEventAggregator events,
            IChatModel model,
            IChatConnection connection,
            IListConnection api,
            ICharacterManager manager,
            ILoggingService logger,
            IAutomationService automation)
        {
            this.logger = logger;
            this.automation = automation;

            try
            {
                region = regman.ThrowIfNull("regman");
                container = contain.ThrowIfNull("contain");
                this.events = events.ThrowIfNull("events");
                this.model = model.ThrowIfNull("model");
                this.connection = connection.ThrowIfNull("connection");
                this.api = api.ThrowIfNull("api");
                characterManager = manager.ThrowIfNull("characterManager");

                this.model.SelectedChannelChanged += (s, e) => RequestNavigate(this.model.CurrentChannel.Id);

                this.events.GetEvent<ChatOnDisplayEvent>()
                    .Subscribe(BuildHomeChannel, ThreadOption.UIThread, true);
                this.events.GetEvent<RequestChangeTabEvent>()
                    .Subscribe(RequestNavigate, ThreadOption.UIThread, true);
                this.events.GetEvent<UserCommandEvent>().Subscribe(CommandRecieved, ThreadOption.UIThread, true);

                commands = new Dictionary<string, CommandHandler>
                    {
                        {"priv", OnPrivRequested},
                        {Commands.UserMessage, OnPriRequested},
                        {Commands.ChannelMessage, OnMsgRequested},
                        {Commands.ChannelAd, OnLrpRequested},
                        {Commands.UserStatus, OnStatusChangeRequested},
                        {"close", OnCloseRequested},
                        {"join", OnJoinRequested},
                        {Commands.UserIgnore, OnIgnoreRequested},
                        {"clear", OnClearRequested},
                        {"clearall", OnClearAllRequested},
                        {"_logger_open_log", OnOpenLogRequested},
                        {"_logger_open_folder", OnOpenLogFolderRequested},
                        {"code", OnChannelCodeRequested},
                        {"_snap_to_last_update", OnNotificationFocusRequested},
                        {Commands.UserInvite, OnInviteToChannelRequested},
                        {"who", OnWhoInformationRequested},
                        {"getdescription", OnChannelDescripionRequested},
                        {"interesting", OnMarkInterestedRequested},
                        {"notinteresting", OnMarkNotInterestedRequested},
                        {"ignoreUpdates", OnIgnoreUpdatesRequested},
                        {Commands.AdminAlert, OnReportRequested},
                        {"tempignore", OnTemporaryIgnoreRequested},
                        {"tempunignore", OnTemporaryIgnoreRequested},
                        {"tempinteresting", OnTemporaryInterestingRequested},
                        {"tempnotinteresting", OnTemporaryInterestingRequested},
                        {"handlelatest", OnHandleLatestReportRequested},
                        {"handlereport", OnHandleLatestReportByUserRequested}
                    };
            }
            catch (Exception ex)
            {
                ex.Source = "Message Daemon, init";
                Exceptions.HandleException(ex);
            }
        }
Esempio n. 52
0
        public GeneralChannelViewModel(
            string name, IUnityContainer contain, IRegionManager regman, IEventAggregator events, IChatModel cm,
            ICharacterManager manager)
            : base(contain, regman, events, cm, manager)
        {
            try
            {
                Model = ChatModel.CurrentChannels.FirstOrDefault(chan => chan.Id == name)
                        ?? ChatModel.AllChannels.First(chan => chan.Id == name);
                Model.ThrowIfNull("this.Model");

                var safeName = HelperConverter.EscapeSpaces(name);

                Container.RegisterType<object, GeneralChannelView>(safeName, new InjectionConstructor(this));

                isDisplayingChat = ShouldDisplayChat;

                ChannelManagementViewModel = new ChannelManagementViewModel(Events, Model as GeneralChannelModel);

                // instance our management vm
                Model.Messages.CollectionChanged += OnMessagesChanged;
                Model.Ads.CollectionChanged += OnAdsChanged;
                Model.PropertyChanged += OnModelPropertyChanged;

                searchSettings = new GenericSearchSettingsModel();
                genderSettings = new GenderSettingsModel();

                messageManager =
                    new FilteredMessageCollection(
                        isDisplayingChat
                            ? Model.Messages
                            : Model.Ads,
                        MeetsFilter,
                        ConstantFilter,
                        IsDisplayingAds);

                genderSettings.Updated += (s, e) => OnPropertyChanged("GenderSettings");

                SearchSettings.Updated += (s, e) => OnPropertyChanged("SearchSettings");

                messageFlood.Elapsed += (s, e) =>
                    {
                        isInCoolDownMessage = false;
                        messageFlood.Enabled = false;
                        OnPropertyChanged("CanPost");
                    };

                adFlood.Elapsed += (s, e) =>
                    {
                        isInCoolDownAd = false;
                        adFlood.Enabled = false;
                        OnPropertyChanged("CanPost");
                        OnPropertyChanged("CannotPost");
                        OnPropertyChanged("ShouldShowAutoPost");
                        if (autoPostAds)
                            SendAutoAd();
                    };

                update.Elapsed += (s, e) =>
                    {
                        if (!Model.IsSelected)
                            return;

                        if (CannotPost)
                            OnPropertyChanged("TimeLeft");

                        OnPropertyChanged("StatusString");
                    };

                ChannelManagementViewModel.PropertyChanged += (s, e) => OnPropertyChanged("ChannelManagementViewModel");

                update.Enabled = true;

                var newSettings = SettingsService.GetChannelSettings(
                    cm.CurrentCharacter.Name, Model.Title, Model.Id, Model.Type);
                Model.Settings = newSettings;

                ChannelSettings.Updated += (s, e) =>
                    {
                        OnPropertyChanged("ChannelSettings");
                        OnPropertyChanged("HasNotifyTerms");
                        if (!ChannelSettings.IsChangingSettings)
                        {
                            SettingsService.UpdateSettingsFile(
                                ChannelSettings, cm.CurrentCharacter.Name, Model.Title, Model.Id);
                        }
                    };

                PropertyChanged += OnPropertyChanged;

                Events.GetEvent<NewUpdateEvent>().Subscribe(UpdateChat);
            }
            catch (Exception ex)
            {
                ex.Source = "General Channel ViewModel, init";
                Exceptions.HandleException(ex);
            }
        }
Esempio n. 53
0
        /// <summary>
        ///     Initializes a new instance of the <see cref="NotificationService" /> class.
        /// </summary>
        /// <param name="eventagg">
        ///     The eventagg.
        /// </param>
        /// <param name="cm">
        ///     The cm.
        /// </param>
        /// <param name="manager"></param>
        public NotificationService(IEventAggregator eventagg, IChatModel cm, ICharacterManager manager)
        {
            events = eventagg;
            this.cm = cm;
            this.manager = manager;
            toast = new ToastNotificationsViewModel(events);

            events.GetEvent<NewMessageEvent>().Subscribe(HandleNewChannelMessage, true);
            events.GetEvent<NewPmEvent>().Subscribe(HandleNewMessage, true);
            events.GetEvent<NewUpdateEvent>().Subscribe(HandleNotification, true);

            events.GetEvent<CharacterSelectedLoginEvent>().Subscribe(
                args =>
                    {
                        Application.Current.MainWindow.Closing += (s, e) =>
                            {
                                e.Cancel = true;
                                HideWindow();
                            };

                        Application.Current.MainWindow.MouseLeave +=
                            (s, e) => events.GetEvent<ErrorEvent>().Publish(null);

                        this.cm.SelectedChannelChanged += (s, e) => events.GetEvent<ErrorEvent>().Publish(null);

                        icon.Icon = new Icon(Environment.CurrentDirectory + @"\icons\catIcon.ico");
                        icon.DoubleClick += (s, e) => ShowWindow();

                        icon.BalloonTipClicked += (s, e) =>
                            {
                                Settings.Default.ShowStillRunning = false;
                                Settings.Default.Save();
                            };

                        var iconMenu = new ContextMenu();

                        iconMenu.MenuItems.Add(
                            new MenuItem(
                                string.Format(
                                    "{0} {1} ({2}) - {3}",
                                    Constants.ClientId,
                                    Constants.ClientName,
                                    Constants.ClientVer,
                                    args))
                                {
                                    Enabled = false
                                });
                        iconMenu.MenuItems.Add(new MenuItem("-"));

                        iconMenu.MenuItems.Add(
                            new MenuItem("Sounds Enabled", ToggleSound)
                                {
                                    Checked =
                                        ApplicationSettings.Volume > 0.0,
                                });
                        iconMenu.MenuItems.Add(
                            new MenuItem("Toasts Enabled", ToggleToast)
                                {
                                    Checked =
                                        ApplicationSettings
                                            .ShowNotificationsGlobal
                                });
                        iconMenu.MenuItems.Add(new MenuItem("-"));

                        iconMenu.MenuItems.Add("Show", (s, e) => ShowWindow());
                        iconMenu.MenuItems.Add("Exit", (s, e) => ShutDown());

                        icon.Text = string.Format("{0} - {1}", Constants.ClientId, args);
                        icon.ContextMenu = iconMenu;
                        icon.Visible = true;
                    });
        }
Esempio n. 54
0
 public RightClickMenuViewModel(bool isModerator, ICharacterManager manager)
 {
     this.isModerator = isModerator;
     this.manager = manager;
 }
Esempio n. 55
0
 protected GenderColorConverterBase(IGetPermissions permissions, ICharacterManager characters)
 {
     Permissions = permissions;
     this.characters = characters;
 }
 public DictionaryController(ICharacterManager characterManager, IPhraseManager phraseManager, IIdiomManager idiomManager)
 {
     _characterManager = characterManager;
     _phraseManager = phraseManager;
     _idiomManager = idiomManager;
 }
Esempio n. 57
0
 private IEnumerable<ICharacter> GetList(ICharacterManager characters, ListKind listKind, bool onlineOnly = true)
     =>
         characters.GetCharacters(listKind, onlineOnly)
             .Where(MeetsFilter)
             .OrderBy(x => x.Name);
Esempio n. 58
0
 public PermissionService(IChatModel cm, ICharacterManager manager)
 {
     this.cm = cm;
     this.manager = manager;
 }
Esempio n. 59
0
        public static bool MeetsFilters(
            this IMessage message,
            GenderSettingsModel genders,
            GenericSearchSettingsModel search,
            ICharacterManager cm,
            GeneralChannelModel channel)
        {
            if (!message.Poster.NameContains(search.SearchString)
                && !message.Message.ContainsOrdinal(search.SearchString))
                return false;

            return genders.MeetsGenderFilter(message.Poster)
                   && message.Poster.MeetsChatModelLists(search, cm, channel);
        }
Esempio n. 60
0
 public void SetUp()
 {
     _characterManager = new CharacterManager();
     _smsManager = new SMSManager(_characterManager);
 }