Ejemplo n.º 1
0
        public void ModeTest()
        {
            var session = SingleJoinTest("spyguy", "spyguy", "#GSP!gmtest!MlNK4q4l1M");
            var request = new ModeRequest("MODE #GSP!gmtest!MlNK4q4l1M -i-p-s+m-n+t+l+e 2");
            var handler = new ModeHandler(session, request);

            handler.Handle();
        }
Ejemplo n.º 2
0
 // Start is called before the first frame update
 void Start()
 {
     tilemap            = GameObject.Find("Tilemap").GetComponent <Tilemap>();
     spawnBulletScript  = ScriptableObject.CreateInstance <SpawnBullet>();
     waitForStartScript = ScriptableObject.CreateInstance <WaitForStart>();
     checkModeScript    = ScriptableObject.CreateInstance <ModeHandler>();
     endGameScript      = ScriptableObject.CreateInstance <EndGame>();
     mouseUp            = false;
 }
Ejemplo n.º 3
0
 /// <summary>
 /// Initializes the handles with given values from map loaded
 /// </summary>
 private void InitHandlers()
 {
     _modeHandler   = new ModeHandler();
     _cameraHandler = new CameraHandler();
     _gridHandler   = new GridHandler(_cameraHandler);
     _tileHandler   = new TileHandler(_gridHandler);
     _tilesetLoader = new TilesetLoader();
     _mapLoader     = new MapLoader(_tileHandler, _gridHandler, _tilesetLoader, MapData);
     _drawHandler   = new DrawHandler(DrawCanvas, _gridHandler, _cameraHandler, _tilesetLoader, _tileHandler, _modeHandler);
     InputHandler   = new InputHandler(_gridHandler, _cameraHandler, _tileHandler, _modeHandler, DrawCanvas, Information, TileProperty);
 }
Ejemplo n.º 4
0
        internal static void Init()
        {
            SpellHandler.Init();

            MenuHandler.Init();

            DrawingHandler.Init();

            ModeHandler.Init();

            Chat.Print($"{ChampionName} Loaded!");
        }
 private void Awake()
 {
     audio.Play();
     if (modehandler == null)
     {
         modehandler = this;
     }
     if (MainMenu.is_loaded)
     {
         load();
     }
 }
Ejemplo n.º 6
0
        public void OrchestrateMode_WhenGivenRetrieveMode_ShouldCallHandlerRetrieveAllWordsToConsoleOnce()
        {
            var input = UserMode.RETRIEVE;

            var moqWordService = new Mock<IWordService>();
            var moqValidator = new Validator();
            var moqWordInverter = new WordInverter();

            var target = new ModeHandler(moqWordService.Object, moqValidator, moqWordInverter);

            moqWordService.Setup(m => m.RetrieveAllWordsToConsole(It.IsAny<string>()));

            target.OrchestrateMode(input, string.Empty);

            moqWordService.Verify(m => m.RetrieveAllWordsToConsole(It.IsAny<string>()), Times.Once);
        }
Ejemplo n.º 7
0
Archivo: Scene.cs Proyecto: XF9/Fenrir
        /// <summary>
        /// activates a specific mode of operation
        /// </summary>
        /// <param name="handler"></param>
        /// <param name="entity"></param>
        public void ActivateModeHandler(ModeHandler handler, Entity entity = null)
        {
            if (this.currentModeHandler != null)
            {
                this.DisposeCurrentModeHandler();
            }

            switch (handler)
            {
            case ModeHandler.Unit:
                this.currentModeHandler = this.unitHandler;
                this.unitHandler.Activate(entity);
                break;

            case ModeHandler.BuildTunnel:
                this.currentModeHandler = this.buildTunnelHandler;
                this.buildTunnelHandler.Activate(null);
                break;

            case ModeHandler.ClearTunnel:
                this.currentModeHandler = this.clearTunnelHandler;
                this.clearTunnelHandler.Activate(null);
                break;

            case ModeHandler.BuildCaveSmall:
                this.currentModeHandler = this.buildCaveHandler;
                this.buildCaveHandler.Activate(this.smallCave);
                break;

            case ModeHandler.BuildCaveMedium:
                this.currentModeHandler = this.buildCaveHandler;
                this.buildCaveHandler.Activate(this.mediumCave);
                break;

            case ModeHandler.BuildCaveLarge:
                this.currentModeHandler = this.buildCaveHandler;
                this.buildCaveHandler.Activate(this.largeCave);
                break;

            default:
                this.currentModeHandler = null;
                break;
            }
        }
Ejemplo n.º 8
0
        public void OrchestrateMode_WhenGivenInsertMode_ShouldCallValidatorIsValidOnceAndWordInverterGetInvertedWordOnce()
        {
            var input = UserMode.INSERT;

            var moqWordService = new Mock<IWordService>();
            var moqValidator = new Mock<IValidator>();
            var moqWordInverter = new Mock<IWordInverter>();

            var target = new ModeHandler(moqWordService.Object, moqValidator.Object, moqWordInverter.Object);

            moqValidator.Setup(m => m.IsValid(It.IsAny<string>())).Returns(true);
            moqWordInverter.Setup(m => m.GetInvertedWord(It.IsAny<string>())).Returns(It.IsAny<string>());
            moqWordService.Setup(m => m.AddWord(It.IsAny<string>(), It.IsAny<string>()));

            target.OrchestrateMode(input, string.Empty);

            moqValidator.Verify(m => m.IsValid(It.IsAny<string>()), Times.Once);
            moqWordInverter.Verify(m => m.GetInvertedWord(It.IsAny<string>()), Times.Once);
            moqWordService.Verify(m => m.AddWord(It.IsAny<string>(), It.IsAny<string>()), Times.Once);
        }
        public override void RegisterSpells(ModeHandler handler)
        {
            // Create the spells
            Q = new Spell.Skillshot(SpellSlot.Q, 925, SkillShotType.Linear, 250, 1800, 70)
            {
                MinimumHitChance = HitChance.High
            };
            W = new Spell.Active(SpellSlot.W, (uint)Player.Instance.GetAutoAttackRange());
            E = new Spell.Active(SpellSlot.E, (uint)Player.Instance.GetAutoAttackRange());
            R = new Spell.Active(SpellSlot.R, 600);

            // Enable spell range drawing
            SpellRangeDrawings.Add(Q);

            // Set modes which should respect mana usage
            handler.SetManaModes(Modes.Harass | Modes.LaneClear, 40);

            // Register always active spell usages
            handler.RegisterSpellUsage(R, Modes.None, DamageType.Magical, () => CheckKillsteal(R.Slot), customName: "Killsteal with R", checkTarget: false);

            // Q in Combo with the overriden hitchance high
            handler.RegisterSpellUsage(Q, Modes.Combo, DamageType.Magical, heroCondition: target => !target.HasBuffOfType(BuffType.SpellShield), hitChance: HitChance.High);
            // Q in JungleClear and Harass
            handler.RegisterSpellUsage(Q, Modes.JungleClear | Modes.Harass, DamageType.Magical, heroCondition: target => !target.HasBuffOfType(BuffType.SpellShield));
            // W in Flee
            handler.RegisterSpellUsage(W, Modes.Flee, checkTarget: false);
            // E in Combo, JungleClear and Harass, casting only when target is in auto attack range
            handler.RegisterSpellUsage(E,
                                       Modes.Combo | Modes.JungleClear | Modes.Harass,
                                       DamageType.Magical,
                                       heroCondition: target => Player.Instance.IsInAutoAttackRange(target));
            // R in Combo, casting only when target is killable
            handler.RegisterSpellUsage(R,
                                       Modes.Combo,
                                       DamageType.Magical,
                                       heroCondition: target => Player.Instance.GetSpellDamage(target, R.Slot) > target.TotalShieldHealth());

            // Finalize by automatically creating the sub menus with the registered modes
            handler.CreateModeMenus();
        }
Ejemplo n.º 10
0
        public void TestMode()
        {
            var modeHandler = new ModeHandler();
            var msg         = new MsgEventArgs {
                Command = "MODE", Data = new[] { "test", "+v", "tast" }, Meta = "a!b@c"
            };
            var visited = false;

            Caller.mode = new Action <ModeAction>(res =>
            {
                Assert.AreEqual("test", res.ChatNames.First());
                Assert.AreEqual("+v", res.Mode);
                Assert.AreEqual("tast", res.Message);
                var user = res.User;
                Assert.AreEqual("a", user.Nick);
                Assert.AreEqual("b", user.Name);
                Assert.AreEqual("c", user.Host);
                visited = true;
            });
            modeHandler.Msg(Talker, Caller, msg);
            Assert.IsTrue(visited);
        }
Ejemplo n.º 11
0
        public void TestOnlyTriggerOnMode()
        {
            var modeHandler = new ModeHandler();

            Assert.AreEqual("MODE", modeHandler.ForCommand());
        }
Ejemplo n.º 12
0
 // Start is called before the first frame update
 void Start()
 {
     checkModeScript = ScriptableObject.CreateInstance <ModeHandler>();
 }
Ejemplo n.º 13
0
 /// <summary>
 /// Initializises Commands, NavigationHandler and ModeHandler of Model
 /// </summary>
 /// <param name="handler">For navigation</param>
 public ModesPageVM()
 {
     _modeHandler        = ModeHandler.SingletonModeHandler;
     ActivateModeCommand = new Command <Mode>(ActivateMode);
     Modes = new ObservableCollection <Mode>();
 }
Ejemplo n.º 14
0
Archivo: Scene.cs Proyecto: XF9/Fenrir
        /// <summary>
        /// activates a specific mode of operation
        /// </summary>
        /// <param name="handler"></param>
        /// <param name="entity"></param>
        public void ActivateModeHandler(ModeHandler handler, Entity entity = null)
        {
            if(this.currentModeHandler != null)
                this.DisposeCurrentModeHandler();

            switch (handler)
            {
                case ModeHandler.Unit:
                    this.currentModeHandler = this.unitHandler;
                    this.unitHandler.Activate(entity);
                    break;
                case ModeHandler.BuildTunnel:
                    this.currentModeHandler = this.buildTunnelHandler;
                    this.buildTunnelHandler.Activate(null);
                    break;
                case ModeHandler.ClearTunnel:
                    this.currentModeHandler = this.clearTunnelHandler;
                    this.clearTunnelHandler.Activate(null);
                    break;
                case ModeHandler.BuildCaveSmall:
                    this.currentModeHandler = this.buildCaveHandler;
                    this.buildCaveHandler.Activate(this.smallCave);
                    break;
                case ModeHandler.BuildCaveMedium:
                    this.currentModeHandler = this.buildCaveHandler;
                    this.buildCaveHandler.Activate(this.mediumCave);
                    break;
                case ModeHandler.BuildCaveLarge:
                    this.currentModeHandler = this.buildCaveHandler;
                    this.buildCaveHandler.Activate(this.largeCave);
                    break;
                default:
                    this.currentModeHandler = null;
                    break;
            }
        }