protected ChannelbarViewModelCommon( IUnityContainer contain, IRegionManager regman, IEventAggregator events, IChatModel cm, ICharacterManager lists) : base(contain, regman, events, cm, lists) { cm.SelectedChannelChanged += (s, e) => OnPropertyChanged("HasUsers"); }
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); } }
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"); }); }
public HomeSettingsViewModel(IChatState chatState, IAutomateThings automationService, IconService iconService, ICharacterManager characterManager) : base(chatState) { automation = automationService; this.iconService = iconService; this.characterManager = characterManager; }
public ClientPacketHandler( ICharacterManager characterManager, IMapChannelManager mapChannelManager, IManifestationManager manifestationManager) { _characterManager = characterManager; _mapChannelManager = mapChannelManager; _manifestationManager = manifestationManager; }
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; }
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; }
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); }
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); }
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; }
protected override void Awake() { base.Awake(); this.AssertRequiredObjects(content); continueInput = Engine.GetService <IInputManager>().GetContinue(); scriptPlayer = Engine.GetService <IScriptPlayer>(); CharacterManager = Engine.GetService <ICharacterManager>(); }
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>(); }
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)); }
public Client( IGameUnitOfWorkFactory gameUnitOfWorkFactory, ICharacterManager characterManager, ClientPacketHandler handler) { _gameUnitOfWorkFactory = gameUnitOfWorkFactory; _characterManager = characterManager; _handler = handler; _handler.RegisterClient(this); }
private void Awake() { UserControl._instance = this; this._character = GetComponent<CharacterManager>(); //m_Character = Intercept.ThroughProxy<ICharacterManager>( // character, // new InterfaceInterceptor(), // new IInterceptionBehavior [] { // new ExceptionInterceptionBehavior() // }); }
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); } }
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"); }; }
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; }
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; } }; }
public Client( IGameUnitOfWorkFactory gameUnitOfWorkFactory, ICharacterManager characterManager, ClientPacketHandler handler) { _gameUnitOfWorkFactory = gameUnitOfWorkFactory; _characterManager = characterManager; inboundData = BufferManager.RequestBuffer(); inboundData.Length = 0; _handler = handler; _handler.RegisterClient(this); }
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); } }
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); }
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)); }
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); } } }
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(); }
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)); }
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); } }
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(); }); }
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(); }); }
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; }
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"); }; }
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; }
// 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}"); }
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); }
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); } }
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>(); } }); }
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"); }
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"); }); }
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; } }
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); }
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; }
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; }
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()); }
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); } }
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; }
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)); }
public PermissionService(IChatState chatState) { cm = chatState.ChatModel; characters = chatState.CharacterManager; }
public RightClickMenuViewModel(bool isModerator, ICharacterManager characters, IGetPermissions permissionService) { this.isModerator = isModerator; this.characters = characters; this.permissionService = permissionService; }
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); } }
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); } }
/// <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; }); }
public RightClickMenuViewModel(bool isModerator, ICharacterManager manager) { this.isModerator = isModerator; this.manager = manager; }
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; }
private IEnumerable<ICharacter> GetList(ICharacterManager characters, ListKind listKind, bool onlineOnly = true) => characters.GetCharacters(listKind, onlineOnly) .Where(MeetsFilter) .OrderBy(x => x.Name);
public PermissionService(IChatModel cm, ICharacterManager manager) { this.cm = cm; this.manager = manager; }
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); }
public void SetUp() { _characterManager = new CharacterManager(); _smsManager = new SMSManager(_characterManager); }