void checkIfOnBalloon()
    {
        float playerSize = this.renderer.bounds.size.y;
        Vector3 position1 = transform.position;
        Vector3 position2 = transform.position;
        position1.x = position1.x - playerSize;
        position1.y = position1.y;
        position2.x = position2.x + playerSize;
        position2.y = position2.y - 2 * playerSize;

        Collider2D[] hits = Physics2D.OverlapAreaAll(new Vector2(position1.x, position1.y), new Vector2(position2.x, position2.y));
        Notification collision = new Notification(NotificationType.OnBalloonPlayerCollision, "Balloon Collided!");

        int i = 0;
        bool temp = false;
        while (i < hits.Length)  {
            Collider2D hit = hits[i];
            if (hit != null) {
                if (hit.tag == "platform") {
                    NotificationCenter.defaultCenter.postNotification(collision);
                    temp = true;
                }
            }
            i++;
        }
        this.GetComponent<Jump>().setGrounded(check);
    }

        public override void Handle(Connection connection)
        {
            var account = connection.Session.Account;
            var notification = new Notification();

            notification.UserId = account.Id;
            notification.Regex = new Regex(RegexPattern);
            notification.DeviceToken = DeviceToken;

            if (Program.NotificationManager.Exists(DeviceToken))
            {
                notification.Save();
            }
            else
            {
                if (Program.NotificationManager.FindWithId(account.Id).Count() < 5)
                {
                    notification.Insert();
                }
                else
                {
                    connection.SendSysMessage("You may only have 5 devices registered for push notifications.");
                    return;
                }
            }

            Program.NotificationsDirty = true;

            var notificationSubscription = new NotificationSubscription();
            notificationSubscription.DeviceToken = DeviceToken;
            notificationSubscription.RegexPattern = RegexPattern;
            notificationSubscription.Registered = true;

            connection.Send(notificationSubscription);
        }

    void GameOver(Notification noti)
    {
        List<int> pointsList = stateGame.userLoged.getPoints ();

        if (pointsList.Count < 11 && pointsList.Count > 0) {

            if(pointsList.Count < 10 && !pointsList.Contains(points)) {
                stateGame.userLoged.addPoints (points);
            }else {
                if(!pointsList.Contains(points)) {
                    if (pointsList [0] < points) {
                        stateGame.userLoged.getPoints ()[0] = points;
                    }
                }
            }
            stateGame.userLoged.getPoints ().Sort ();

        } else {
            if(pointsList.Count == 0) {
                stateGame.userLoged.addPoints (points);
                stateGame.userLoged.getPoints ().Sort ();
            }
        }
        stateGame.Save (stateGame.userLoged);

        /*if (points > StateGame.stateGame.highScore) {
            StateGame.stateGame.highScore = points;
            StateGame.stateGame.usuario = user;
            StateGame.stateGame.Save();
        }*/
    }

 public void valid_should_return_valid_notification()
 {
     var notification = new Notification();
     notification
         .IsValid()
         .ShouldBeTrue();
 }

 private void DisplayData(Notification notification)
 {
     EnableAppBarStatus(true);
     // Navigate to the appropriate destination page, configuring the new page
     // by passing required information as a navigation parameter
     frmNotification.Navigate(typeof(NotificationDetailFrame), notification);
 }

        public void GetChildReturnsValidIfNoChild()
        {
            var notification = new Notification();
            var child = notification.GetChild("anything");

            child.IsValid().ShouldBeTrue();
        }

        public bool Deliver(Notification notification)
        {
            bool success = false;
            try
            {
                notification.Retry = false;
                notification.Status = "Processing";

                var configuration = FtpClientConfiguration.GetFtpConfigurationFromSettings(notification.UserData);

                FtpClient ftpClient = FtpClient.GetClientFromSettings(configuration);
                RenderedOutputFile outputFile = notification.Report.Render(configuration.FileFormat, String.Empty)[0];
                outputFile.Data.Position = 0;
                using (var stream = outputFile.Data)
                {
                    byte[] bytes = new byte[stream.Length];
                    stream.Read(bytes, 0, bytes.Length);
                    stream.Close();
                    ftpClient.UploadFile(bytes);
                }
                notification.Status = "Success";
                success = true;
            }
            catch (Exception ex)
            {
                notification.Status = String.Format("Error: {0}", ex.Message);
                success = false;
            }
            finally
            {
                notification.Save();
            }

            return success;
        }

 public void ReceiveNotification(Notification notification)
 {
     foreach (var n in notification.GetAllNotifications())
     {
         WebsiteMain.notifications.Add(n);
     }
 }

        public void Validate(object target, Notification notification)
        {
            var validatedType = _typeResolver.ResolveType(target);
            var context = ContextFor(target, notification);

            _graph.PlanFor(validatedType).Execute(context);
        }

 private void acabarTorre(Notification notification)
 {
     u.moverApunto(transform, "nodoTorreBase", velTorre, new Vector2(separacionRunner.x, separacionRunner.y - 500), "salimosDeTorre");
     cambiarZoom(zoomNormal, velZoomNormal, "");
     cambiarEscalaLimitadores("_limitadoresBalas", new Vector3(1f, 1f, 1f));
     NotificationCenter.DefaultCenter().PostNotification(this, "empezarParallax");
 }

        /// <summary>
        /// GM取得拍卖行数据
        /// </summary>
        /// <param name="note"></param>
        public static object GMAuctionList(Notification note)
        {
            string[] strs = GMBusiness.GetCommand(note);
            if (strs.Length < 3)
                return null;
            PlayerBusiness player = PlayersProxy.FindPlayerByName(strs[0].Trim());
            if (player == null)
                return null;
            int pageIndex = 0;

            if (!int.TryParse(strs[1].Trim(), out pageIndex))
                return null;
            int pageSize = 6;

            int total = 0;
            int curIndex = 0;
            List<Auction> auctionList = AuctionAccess.Instance.AuctionSellerList(player.ID, pageSize, pageIndex, out total, out curIndex);
            List<Variant> list = new List<Variant>();
            foreach (Auction model in auctionList)
            {
                Variant mv = model.Value;
                Variant v = new Variant();
                foreach (var item in mv)
                {
                    v.Add(item.Key, item.Value);
                }
                v.Add("ID", model.ID);
                v.Add("Name", model.Name);
                list.Add(v);
            }
            return new object[] { list, total, curIndex };
        }

 public RegisterNewCompanyCommand(ICompanyFactory factory, Notification notification,
                                  ICompanyRepository companies)
 {
     this.factory = factory;
     this.notification = notification;
     this.companies = companies;
 }

 public void Should_return_true_if_Messages_contains_only_messages_with_Info_Severity()
 {
     var notification = new Notification();
     var messageTest = new NotificationMessage(NotificationSeverity.Info, "");
     notification.Add(messageTest);
     Assert.IsTrue(notification.IsValid);
 }

    void OnCognitivLiftEvent(Notification notification)
    {
        if (canLift)
        {
            liftCounter++;

            timeUntilCanLiftNext = Time.time + timeBetweenLifts;
            canLift = false;

            if (liftCounter == 1)
            {
                StartCoroutine(explainMana());
            }
            else if (liftCounter == numberOfTimesToLift)
            {
                EventFactory.FireDisplayTextEvent(this, "Good job! You have learned LIFT!", 5.0f);

                NotificationCenter.DefaultCenter.PostNotification(this, "LiftCompleted");
            }
        }
        else
        {
            EventFactory.FireDisplayTextEvent(this, "Why don't you try lifting in " + (int) (timeUntilCanLiftNext - Time.time) + " seconds?", timeUntilCanLiftNext - Time.time);
        }
    }

        public static SmiResultCode PlayNotes(int handle,
            uint noteCount,
            HapticsNote[] notes,
            bool repeat,
            Notification callback)
        {
            CallbackItem item= new CallbackItem();
            c_Notification cN = new c_Notification(Haptics.NotificationCallbakHandler);

            item.callback   = callback;
            item.handle     = handle;
            item.notesArray = notes;
            item.c_callback = cN; // reserve callback until callback is done

            lock (_locker)
            {
                // protect the _list inside of critical section
                _list.Add(item);
            }

            SmiResultCode result = c_PlayNotes(handle,
                               noteCount,
                               notes,
                               repeat,
                               cN);

            //System.Console.WriteLine("@PlayNotes handle     = " + handle);
            //System.Console.WriteLine("@PlayNotes noteCount  = " + noteCount);
            //System.Console.WriteLine("@PlayNotes repeat     = " + repeat);
            //System.Console.WriteLine("@PlayNotes result  = " + result);

            return result;
        }

        public bool IsValid(Notification notification)
        {
            var isRemoteOpValid = _sequence.OfType<IOperateRemote>().All(x => x.IsValid(notification));
            var isCompositeSeqValid = _sequence.OfType<CompositeSequence>().All(x => x.IsValid(notification));

            return isRemoteOpValid && isCompositeSeqValid;
        }

 public Notification Validate(object target)
 {
     var validatedType = typeResolver.ResolveType(target);
     var notification = new Notification(validatedType);
     Validate(target, notification);
     return notification;
 }

 public void acabarShooter(Notification notification)
 {
     rigidbody2D.isKinematic = false;
     gen.estado = 1;
     gen.animator.SetInteger("Estado", gen.estado);
     run.saltar(1500, run.fuerzaSalto * 7);
 }

        // Constructor
        public MainPage()
        {
            
            InitializeComponent();
            ser = new NotificationClass();
            obj = new Notification(ser);

            //NotificationSwitch is set by user to start or stop push notifications.
            if (IsolatedStorageSettings.ApplicationSettings.Contains("notificationSwitch"))
            {
                //If notificationSwitch is ON(True) then only start notification service.
                if ((bool)IsolatedStorageSettings.ApplicationSettings["notificationSwitch"])
                {
                    //Start in-app Notification listening every time application starts.
                    obj.SetupNotification();
                }
            }
            else
            {
                //By Default Notifications are disabled.
                IsolatedStorageSettings.ApplicationSettings["notificationSwitch"] = false;
            }

            
        }

 public void Notify(Story story)
 {
     var frontpageItem = story.Item;
     var notification = new Notification(ApplicationName, NotificationTypeName, "ID", frontpageItem.Title, frontpageItem.Link);
     var callback = new CallbackContext(frontpageItem.Link);
     _growl.Notify(notification, callback);
 }