Exemple #1
0
        public static void StartListening()
        {
            client.Headers.Add("content-type", "application/json");//set your header here, you can add multiple headers
            sendEvent("lyokoconnect", "{\"user\":\"davcrox\"}");
            if (_listening)
            {
                return;
            }                                                      //dont do anything if we're already listening
            LyokoAPI.Events.LyokoLogger.Log("Test", "Subscribe");
            TowerActivationEvent.Subscribe(OnTowerActivation);     //Give the method name without '()'.
            XanaDefeatEvent.Subscribe(DoAThing);                   //the name of the method doesn't matter as long as the return value and parameters are the same

            TowerDeactivationEvent.Subscribe(onTowerdeactivation); //single statement lambda with one parameter

            XanaAwakenEvent.Subscribe(onXanaAwaken);               //single statement lambda with no parameters
            TowerHijackEvent.Subscribe(onHijack);

            /*TowerHijackEvent.Subscribe((tower, oldactivator, newactivator) => //multi statement lambda with 3 parameters
             * {
             *  //SoundPlayer.PlaySound(Sounds.Thief);
             *  Console.WriteLine("subscribe HIJACK");
             *  OnTowerActivation(tower); //you can re-use methods if you want, they're still methods.
             * });*/
            _listening = true;
        }
Exemple #2
0
 public static void Initialize()
 {
     XanaAwakenEvent.Subscribe(onXanaAwaken);
     XanaDefeatEvent.Subscribe(onXanaDefeat);
     TowerActivationEvent.Subscribe(onTowerActivation);
     TowerDeactivationEvent.Subscribe(onTowerDeactivation);
     TowerHijackEvent.Subscribe(onTowerHijacked);
 }
 public static void StopSuperscanner()
 {
     TowerActivationEvent.Unsubscribe(OnTowerActive);
     TowerDeactivationEvent.Unsubscribe(OnTowerDeactive);
     TowerHijackEvent.Unsubscribe(OnTowerHijack);
     XanaAwakenEvent.Unsubscribe(OnXANAWake);
     XanaDefeatEvent.Unsubscribe(onXANASleep);
 }
Exemple #4
0
 public void Hijack(APIActivator newActivator)
 {
     if (Activated && newActivator != APIActivator.NONE)
     {
         APIActivator oldActivator = Activator;
         Activator = newActivator;
         TowerHijackEvent.Call(this, oldActivator, newActivator);
     }
 }
Exemple #5
0
        public static void StopListening()
        {
            if (!_listening)
            {
                return;
            }

            TowerActivationEvent.Unsubscribe(OnTowerActivation);
            TowerDeactivationEvent.Unsubscribe(OnTowerDeactivation);
            TowerHijackEvent.Unsubscribe(OnTowerHijack);

            _listening = false;
        }
Exemple #6
0
        public static void StartListening()
        {
            if (_listening)
            {
                return;
            }

            TowerActivationEvent.Subscribe(OnTowerActivation);
            TowerDeactivationEvent.Subscribe(OnTowerDeactivation);
            TowerHijackEvent.Subscribe(OnTowerHijack);

            _listening = true;
        }
Exemple #7
0
        internal void Hijack(APIActivator newActivator)
        {
            if (!Activated)
            {
                return;
            }
            if (Activator.Equals(newActivator))
            {
                return;
            }
            APIActivator old = Activator; //the event doesn't change the activator for you

            Activator = newActivator;     //the ol' switcheroo
            TowerHijackEvent.Call(this, old, newActivator);
        }
Exemple #8
0
        public static void StopListening()
        {
            if (!_listening)
            {
                return;
            }                            //dont stop listening if we've already stopped (unregistering events that haven't been registered is harmless though)
            TowerActivationEvent.Unsubscribe(OnTowerActivation);
            XanaDefeatEvent.Unsubscribe(DoAThing);
            sendEvent("lyokodisconnect", "{\"user\":\"davcrox\"}");

            /*
             * these unregister the listeners by using the delegate returned by Subscribe()
             */
            TowerDeactivationEvent.Unsubscribe(onTowerdeactivation);
            XanaAwakenEvent.Unsubscribe(onXanaAwaken);
            TowerHijackEvent.Unsubscribe(onHijack);
        }
Exemple #9
0
        public void Hijack(string activator)
        {
            var newactivator = LyokoParser.ParseActivator(activator.ToUpper());

            if (!Activated)
            {
                Activate(activator);
            }
            else if (newactivator == APIActivator.NONE)
            {
                Deactivate();
            }
            else if (newactivator != Activator)
            {
                TowerHijackEvent.Call(new APITower(VirtualWorld.Name, Sector.Name, Number), newactivator, Activator);
                Activator = newactivator;
            }
        }
Exemple #10
0
        public Listener(ICollection <Command> commands, int port)
        {
            Commands = new List <Command>(commands);

            /*ServicePointManager.ServerCertificateValidationCallback +=
             *  (sender, certificate, chain, sslPolicyErrors) => true;*/
            connection = new HubConnectionBuilder().WithUrl($"http://localhost:{port}/MiniLyokoHub").Build();

            StartConnection();
            connection.Closed += async(error) =>
            {
                await Task.Delay(new Random().Next(0, 5) * 1000);

                await connection.StartAsync();
            };

            TowerActivationEvent.Subscribe(OnTowerActivation);
            TowerDeactivationEvent.Subscribe(OnTowerDeactivation);
            TowerHijackEvent.Subscribe(OnTowerHijack);
            CommandOutputEvent.Subscribe(OnCommandOutput);
            LyokoLogger.Subscribe(OnLogger);
            CommandInputEvent.Subscribe(OnCommand);
        }
Exemple #11
0
 private APISuperScan()
 {
     TowerActivationEvent.Subscribe(OnTowerActivation);
     TowerDeactivationEvent.Subscribe(OnTowerDeactivation);
     TowerHijackEvent.Subscribe(OnTowerHijack);
 }