public void updateSize(CCPoint touchLocation)
 {
     CCSize s = CCDirector.SharedDirector.WinSize;
     CCSize newSize = new CCSize(Math.Abs(touchLocation.X - s.Width / 2) * 2, Math.Abs(touchLocation.Y - s.Height / 2) * 2);
     CCLayerColor l = (CCLayerColor)GetChildByTag(kTagLayer);
     l.ContentSize = newSize;
 }

        public ParallaxScrollTest()
        {
            CCSize screen = CCDirector.SharedDirector.WinSize;
            parallax = new CCParallaxScrollNode();
            CCSprite land1 = new CCSprite("Images/land_green");
            CCSprite land2 = new CCSprite("Images/land_green");
            parallax.AddInfiniteScrollXWithZ(0, new CCPoint(0.5f, 0.2f), CCPoint.Zero, new CCSprite[] { land1, land2 });

            CCSprite land3 = new CCSprite("Images/land_grey");
            CCSprite land4 = new CCSprite("Images/land_grey");
            parallax.AddInfiniteScrollXWithZ(-2, new CCPoint(0.05f, 0.2f), new CCPoint(0f, 60f), new CCSprite[] { land3, land4 });

            CCSprite clouds1 = new CCSprite("Images/clouds");
            CCSprite clouds2 = new CCSprite("Images/clouds");
            parallax.AddInfiniteScrollXWithZ(1, new CCPoint(0.1f, 0.1f), new CCPoint(0f, screen.Height - clouds1.ContentSize.Height), new CCSprite[] { clouds1, clouds2 });

            for (int i = 0; i < 10; i++)
            {
                CCSprite mountain = new CCSprite("Images/mountain_grey");
                CCPoint pos = new CCPoint(CCMacros.CCRandomBetween0And1() * land1.ContentSize.Width * 2f, (0.1f + 0.24f * CCMacros.CCRandomBetween0And1()) * screen.Height);

                float speedMountainX = 0.15f + CCMacros.CCRandomBetween0And1() * 0.1f;
                parallax.AddChild(mountain, -1, new CCPoint(speedMountainX, .015f), pos, new CCPoint(land1.ContentSize.Width * 2f, 0));

                mountain.Scale = 0.6f + CCMacros.CCRandomBetween0And1() * 0.4f;
            }

            CCSprite sky = new CCSprite("Images/sky_evening");
            sky.AnchorPoint = CCPoint.AnchorLowerLeft;
            AddChild(parallax);
            AddChild(sky, -1);
        }

        public override void Update(float time)
        {
            int i, j;
            CCPoint c = m_positionInPixels;

            for (i = 0; i < (m_sGridSize.X + 1); ++i)
            {
                for (j = 0; j < (m_sGridSize.Y + 1); ++j)
                {
                    CCVertex3F v = OriginalVertex(new CCGridSize(i, j));

                    var avg = new CCPoint(i - (m_sGridSize.X / 2.0f), j - (m_sGridSize.Y / 2.0f));
                    var r = (float) Math.Sqrt((avg.X * avg.X + avg.Y * avg.Y));

                    float amp = 0.1f * m_fAmplitude * m_fAmplitudeRate;
                    float a = r * (float) Math.Cos((float) Math.PI / 2.0f + time * (float) Math.PI * m_nTwirls * 2) *
                              amp;

                    float dx = (float) Math.Sin(a) * (v.Y - c.Y) + (float) Math.Cos(a) * (v.X - c.X);
                    float dy = (float) Math.Cos(a) * (v.Y - c.Y) - (float) Math.Sin(a) * (v.X - c.X);

                    v.X = c.X + dx;
                    v.Y = c.Y + dy;

                    SetVertex(new CCGridSize(i, j), ref v);
                }
            }
        }

        public StackObject(b2World world, 
		                    CCPoint location,
		                    string spriteFileName,
		                    bool breaksOnGround,
		                    bool breaksFromNinja,
		                    bool hasAnimatedBreakFrames,
		                    bool damagesEnemy,
		                    float density,
		                    CreationMethod createHow,
		                    int angleChange,
		                    bool makeImmovable,
		                    int points,
		                    BreakEffect simpleScoreVisualFXType)
        {
            InitWithWorld(world,
                          location,
                          spriteFileName,
                          breaksOnGround,
                          breaksFromNinja,
                          hasAnimatedBreakFrames,
                          damagesEnemy,
                          density,
                          createHow,
                          angleChange,
                          makeImmovable,
                          points,
                          simpleScoreVisualFXType);
        }

        public void addNewSpriteWithCoords(CCPoint p)
        {
            CCSpriteBatchNode BatchNode = (CCSpriteBatchNode)GetChildByTag((int)kTags.kTagSpriteBatchNode);

            int idx = (int)(CCRandom.NextDouble() * 1400 / 100);
            int x = (idx % 5) * 85;
            int y = (idx / 5) * 121;


            CCSprite sprite = new CCSprite(BatchNode.Texture, new CCRect(x, y, 85, 121));
            BatchNode.AddChild(sprite);

            sprite.Position = (new CCPoint(p.X, p.Y));

            CCActionInterval action = null;
            float random = (float)CCRandom.NextDouble();

            if (random < 0.20)
                action = new CCScaleBy(3, 2);
            else if (random < 0.40)
                action = new CCRotateBy (3, 360);
            else if (random < 0.60)
                action = new CCBlink (1, 3);
            else if (random < 0.8)
                action = new CCTintBy (2, 0, -255, -255);
            else
                action = new CCFadeOut  (2);

            CCActionInterval action_back = (CCActionInterval)action.Reverse();
            CCActionInterval seq = (CCActionInterval)(new CCSequence(action, action_back));

            sprite.RunAction(new CCRepeatForever (seq));
        }

 public static CCPoint Transform(CCPoint point, CCAffineTransform t)
 {
     return new CCPoint(
         t.a * point.X + t.c * point.Y + t.tx,
         t.b * point.X + t.d * point.Y + t.ty
         );
 }

 public static void DrawPoints(CCPoint[] points, int numberOfPoints, float size, CCColor4B color)
 {
     for (int i = 0; i < numberOfPoints; i++)
     {
         DrawPoint(points[i], size, color);
     }
 }

		public GameMenu ()
		{
			var screenSize = CCDirector.SharedDirector.WinSize;
			
			voiceButtonName = "VoiceFX";
			voiceButtonNameDim = "VoiceFX";
			
			soundButtonName = "SoundFX";
			soundButtonNameDim = "SoundFX";
			
			ambientButtonName = "AmbientFX";
			ambientButtonNameDim = "AmbientFX";
			

			SoundFXMenuLocation = new CCPoint( 110, 55 );
			VoiceFXMenuLocation = new CCPoint( 230, 55 );
			AmbientFXMenuLocation = new CCPoint(355, 55 );
			

			TouchEnabled = true;
			

			IsSoundFXMenuItemActive = !GameData.SharedData.AreSoundFXMuted;

			IsVoiceFXMenuActive = !GameData.SharedData.AreVoiceFXMuted;

			IsAmbientFXMenuActive = !GameData.SharedData.AreAmbientFXMuted;

		}			

        public static void DrawLine(CCPoint origin, CCPoint destination, CCColor4B color)
        {
            var c = new Color(color.R, color.G, color.B, color.A);

            m_Batch.AddVertex(new Vector2(origin.X, origin.Y), c, PrimitiveType.LineList);
            m_Batch.AddVertex(new Vector2(destination.X, destination.Y), c, PrimitiveType.LineList);
        }

		bool enemyCantBeDamagedForShortInterval; // after damage occurs the enemy gets a moment of un-damage-abilty, which should play better ( I think)
		

		public Enemy (b2World world,
		              CCPoint location,
		              string spriteFileName,
		              bool isTheRotationFixed,
		              bool getsDamageFromGround,
		              bool doesGetDamageFromDamageEnabledStackObjects,
		              int breaksFromHowMuchContact,
		              bool hasDifferentSpritesForDamage,
		              int numberOfFramesToAnimateOnBreak,
		              float density,
		              CreationMethod createHow,
		              int points,
		              BreakEffect simpleScoreVisualFXType )
		{
			InitWithWorld( world,
			               location,
			               spriteFileName,
			               isTheRotationFixed,
			               getsDamageFromGround,
			               doesGetDamageFromDamageEnabledStackObjects,
			               breaksFromHowMuchContact,
			               hasDifferentSpritesForDamage,
			               numberOfFramesToAnimateOnBreak,
			               density,
			               createHow,
			               points,
			               simpleScoreVisualFXType );
		}

        public void addNewSpriteWithCoords(CCPoint p)
        {
            int idx = (int)(CCMacros.CCRandomBetween0And1() * 1400.0f / 100.0f);
            int x = (idx % 5) * 85;
            int y = (idx / 5) * 121;

            CCSprite sprite = new CCSprite("Images/grossini_dance_atlas", new CCRect(x, y, 85, 121));
            AddChild(sprite);

            sprite.Position = p;

            CCActionInterval action;
            float random = CCMacros.CCRandomBetween0And1();

            if (random < 0.20)
                action = new CCScaleBy(3, 2);
            else if (random < 0.40)
                action = new CCRotateBy (3, 360);
            else if (random < 0.60)
                action = new CCBlink (1, 3);
            else if (random < 0.8)
                action = new CCTintBy (2, 0, -255, -255);
            else
                action = new CCFadeOut  (2);
            object obj = action.Reverse();
            CCActionInterval action_back = (CCActionInterval)action.Reverse();
            CCActionInterval seq = (CCActionInterval)(new CCSequence(action, action_back));

            sprite.RunAction(new CCRepeatForever (seq));
        }

        public override void Update(float time)
        {
            if (m_pTarget != null)
            {
                float xa = 0;
                float xb = m_sConfig.ControlPoint1.X;
                float xc = m_sConfig.ControlPoint2.X;
                float xd = m_sConfig.EndPosition.X;

                float ya = 0;
                float yb = m_sConfig.ControlPoint1.Y;
                float yc = m_sConfig.ControlPoint2.Y;
                float yd = m_sConfig.EndPosition.Y;

                float x = CCSplineMath.CubicBezier(xa, xb, xc, xd, time);
                float y = CCSplineMath.CubicBezier(ya, yb, yc, yd, time);

                CCPoint currentPos = m_pTarget.Position;
                CCPoint diff = currentPos - m_previousPosition;
                m_startPosition = m_startPosition + diff;
        
                CCPoint newPos = m_startPosition + new CCPoint(x, y);
                m_pTarget.Position = newPos;

                m_previousPosition = newPos;
            }
        }

 /// <summary>
 /// Initializes a CCMenuItem with a target/selector
 /// </summary>
 /// <param name="selector"></param>
 /// <returns></returns>
 public bool InitWithTarget(SEL_MenuHandler selector)
 {
     AnchorPoint = new CCPoint(0.5f, 0.5f);
     m_pfnSelector = selector;
     m_bIsEnabled = true;
     m_bIsSelected = false;
     return true;
 }

        public void resetAndScoreBallForPlayer(int player)
        {
            m_ballStartingVelocity = new CCPoint(m_ballStartingVelocity.X * -1.1f, m_ballStartingVelocity.Y * -1.1f);
            m_ball.Velocity = m_ballStartingVelocity;
            m_ball.Position = new CCPoint(160.0f, 240.0f);

            // TODO -- scoring
        }

 /// <summary>
 /// Initializes a CCMenuItem with a target/selector
 /// </summary>
 /// <param name="selector"></param>
 /// <returns></returns>
 public bool InitWithTarget(Action<object> selector)
 {
     AnchorPoint = new CCPoint(0.5f, 0.5f);
     m_pfnSelector = selector;
     m_bIsEnabled = true;
     m_bIsSelected = false;
     return true;
 }

		private void InitWithWorld( b2World world, CCPoint location, string spriteFileName)
		{
			this.theWorld = world;
			this.initialLocation = location;
			this.spriteImageName = spriteFileName;
			
			CreateGround();
		}

 public CCLightningTrack(CCPoint start, CCPoint end)
 {
     _Start = start;
     _End = end;
     _Track = CreateBolt(start, end);
     CCPoint dir = end - start;
     _Length = dir.Normalize();
     _uDir = dir;
 }

        protected internal override void StartWithTarget(CCNode target)
        {
            base.StartWithTarget(target);

            m_fDeltaT = 1f / m_pPoints.Count;

            m_previousPosition = target.Position;
            m_accumulatedDiff = CCPoint.Zero;
        }

 /// <summary>
 /// Initializes a new <see cref="GestureSample"/>.
 /// </summary>
 /// <param name="gestureType"><see cref="GestureType"/></param>
 /// <param name="timestamp"></param>
 /// <param name="position"></param>
 /// <param name="position2"></param>
 /// <param name="delta"></param>
 /// <param name="delta2"></param>
 public CCGesture(GestureType gestureType, TimeSpan timestamp, CCPoint position, CCPoint position2, CCPoint delta, CCPoint delta2)
 {
     this._gestureType = gestureType;
     this._timestamp = timestamp;
     this._position = position;
     this._position2 = position2;
     this._delta = delta;
     this._delta2 = delta2;
 }

        public virtual bool CollidesWith(CCMaskedSprite target, out CCPoint pt)
        {
            pt = CCPoint.Zero;
            if (!BoundingBox.IntersectsRect(target.BoundingBox))
            {
                return (false);
            }
            // Based upon http://www.riemers.net/eng/Tutorials/XNA/Csharp/Series2D/Putting_CD_into_practice.php
            CCAffineTransform m1 = NodeToWorldTransform();
            CCAffineTransform m2 = target.NodeToWorldTransform();
            Matrix mat1 = m1.XnaMatrix;
            Matrix mat2 = m2.XnaMatrix;
            Matrix mat1to2 = mat1 * Matrix.Invert(mat2);
            int width2 = target.Texture.XNATexture.Width;
            int height2 = target.Texture.XNATexture.Height;
            int width1 = Texture.XNATexture.Width;
            int height1 = Texture.XNATexture.Height;
            byte[] maskA = CollisionMask;
            byte[] maskB = target.CollisionMask;
            for (int x1 = 0; x1 < width1; x1++)
            {
                for (int y1 = 0; y1 < height1; y1++)
                {
                    Vector2 pos1 = new Vector2(x1, y1);
                    Vector2 pos2 = Vector2.Transform(pos1, mat1to2);

                    int x2 = (int)pos2.X;
                    int y2 = (int)pos2.Y;
                    if ((x2 >= 0) && (x2 < width2))
                    {
                        if ((y2 >= 0) && (y2 < height2))
                        {
                            int iA = x1 + y1 * width1;
                            int iB = x2 + y2 * width2;
                            if (iA >= maskA.Length || iB >= maskB.Length)
                            {
                                continue;
                            }
                            byte ca = maskA[iA];
                            byte cb = maskB[iB];

                            if (maskA[iA] > 0)
                            {
                                if (maskB[iB] > 0)
                                {
                                    Vector2 screenPos = Vector2.Transform(pos1, mat1);
                                    pt = new CCPoint(screenPos);
                                    return (true);
                                }
                            }
                        }
                    }
                }
            }
            return (false);
        }