fork download
copy 
  1. using System;
  2. using System.Collections.Generic;
  3. using Microsoft.Xna.Framework;
  4. using Microsoft.Xna.Framework.Audio;
  5. using Microsoft.Xna.Framework.Content;
  6. using Microsoft.Xna.Framework.GamerServices;
  7. using Microsoft.Xna.Framework.Graphics;
  8. using Microsoft.Xna.Framework.Input;
  9. using Microsoft.Xna.Framework.Media;
  10. using System.Runtime.InteropServices;
  11.  
  12. public class User32
  13. {
  14.   [DllImport("user32.dll")]
  15.   public static extern void SetWindowPos(uint hwnd, uint level, int x, int y, int w, int h, uint flags);
  16. }
  17. namespace trial2
  18. {
  19.   class Entity
  20.   {
  21.     public static Texture2D tex;
  22.     public float x, y; 
  23.     public float w, h;
  24.     public Color color = Color.White;
  25.  
  26.     public static Color baseColor = new Color( 1, 0, 0, 0.2f );
  27.  
  28.     public static void init( GraphicsDevice gpu, int width, int height )
  29.     {
  30.       Color[] blockColors = new Color[ width * height ];
  31.  
  32.       for( int i = 0 ; i < width * height ; i++ ) blockColors[ i ] = Color.AliceBlue;
  33.  
  34.       tex = new Texture2D( gpu, width, height );
  35.       tex.SetData<Color>( blockColors );
  36.     }
  37.  
  38.     public float Left
  39.     {
  40.       get { return x; }
  41.       set { x = value; }
  42.     }
  43.     public float Right
  44.     {
  45.       get { return x+w; }
  46.       set { x = value - w ; }
  47.     }
  48.     public float Top
  49.     {
  50.       get { return y ; }
  51.       set { y = value ; }
  52.     }
  53.     public float Bottom
  54.     {
  55.       get { return y + h; }
  56.       set { y = value - h ; }
  57.     }
  58.  
  59.     public Rectangle getRect()
  60.     {
  61.       return new Rectangle((int)x,(int)y,(int)w,(int)h);
  62.     }
  63.  
  64.     /// <summary>Its only intersecting if there is overlap in BOTH x and y.</summary>
  65.     public bool intersects( Entity o )
  66.     {
  67.       return ( ( this.hitsBottomOf(o) || this.hitsTopOf(o) ) && ( this.hitsLeftOf(o) || this.hitsRightOf(o) ) );
  68.     }
  69.  
  70.     // get overlap.
  71.     // -y = this ON o's TOP edge (needs to move -y: down)
  72.     // +y = this ON o's BOTTOM edge (needs to move +y: up)
  73.     // -x = this ON o's RIGHT (needs to move -x: to the left)
  74.     // +x = this ON o's LEFT (needs to move +x: to the right)
  75.  
  76.     public bool hitsTopOf( Entity o )
  77.     {
  78.       // +----------> +x
  79.       // | ______
  80.       // | |this|
  81.       // | |____|_
  82.       // | || o  |
  83.       // |  |    |
  84.       // |  |____|
  85.       // v
  86.       // +y
  87.       // 1. this hits o from the top
  88.       return ( this.Bottom <= o.Bottom && // this is above o and
  89.                this.Bottom > o.Top ) ;   // this's Bottom below o's Top
  90.     }
  91.  
  92.     public bool hitsBottomOf( Entity o )
  93.     {
  94.       // 2. this's head hit a ceiling tile o
  95.       // ______
  96.       // | o  |
  97.       // |____|_
  98.       // ||this|
  99.       //  |    |
  100.       //  |____|
  101.       return ( this.Top >= o.Top &&    // this is below o and
  102.                this.Top < o.Bottom ) ;// this's top has entered bottom of o
  103.     }
  104.  
  105.     public bool hitsLeftOf( Entity o )
  106.     {
  107.       // x
  108.       // 3.
  109.       //   ______
  110.       // __|_o_ |
  111.       // |this| |
  112.       // |    |_|
  113.       // |____|
  114.       return ( this.Left <= o.Left &&   // this approaches from left and
  115.                this.Right > o.Left ) ;  // this's right is stepping on o's left OR
  116.     }
  117.  
  118.     public bool hitsRightOf( Entity o )
  119.     {
  120.       // 4.
  121.       //   ______
  122.       // __|this|
  123.       // | o  | |
  124.       // |    |_|
  125.       // |____|
  126.       return ( this.Right >= o.Right && // this approaches from right and
  127.                this.Left < o.Right ) ;  // this's left is stepping into o's right
  128.     }
  129.  
  130.     public void pushOffX( Entity o )
  131.     {
  132.       // 3.
  133.       //   ______
  134.       // __|_o_ |
  135.       // |this| |
  136.       // |    |_|
  137.       // |____|
  138.       if( this.hitsLeftOf( o ) )
  139.         this.x -= ( this.Right - o.Left ) ;
  140.  
  141.       // 4.
  142.       //   ______
  143.       // __|this|
  144.       // | o  | |
  145.       // |    |_|
  146.       // |____|
  147.       else if( this.hitsRightOf( o ) )
  148.         this.x += o.Right - this.Left ;
  149.     }
  150.     public void pushOffY( Entity o )
  151.     {
  152.       // +----------> +x
  153.       // | ______
  154.       // | |this|
  155.       // | |____|_
  156.       // | || o  |
  157.       // |  |    |
  158.       // |  |____|
  159.       // v
  160.       // +y
  161.       // 1. this hits o from the top
  162.       if( this.hitsTopOf( o ) )    // 1. this hit floor o with his feet
  163.         this.y -= this.Bottom - o.Top ;  // -y value
  164.  
  165.       // 2. this's head hit a ceiling tile o
  166.       // ______
  167.       // | o  |
  168.       // |____|_
  169.       // ||this|
  170.       //  |    |
  171.       //  |____|
  172.       if( this.hitsBottomOf( o ) )
  173.         this.y += o.Bottom - this.Top ;
  174.     }
  175.  
  176.  
  177.     /// <summary>Mag px overlap, x</summary>
  178.     /// <param name="o"></param>
  179.     /// <returns></returns>
  180.     public float XOverlap( Entity o )
  181.     {
  182.       // for this to "count", 
  183.       // you must overlap in Y
  184.       if( this.hitsTopOf( o ) || this.hitsBottomOf( o ) )
  185.       {
  186.         // 3.
  187.         //   ______
  188.         // __|_o_ |
  189.         // |this| |
  190.         // |    |_|
  191.         // |____|
  192.         if( this.hitsLeftOf( o ) ) // 3. t1 is bumping into t2 to the right
  193.           //return o.Left - this.Right; // -x, b/c this needs move left
  194.           return this.Right - o.Left ; // abs(x)
  195.  
  196.         // 4.
  197.         //   ______
  198.         // __|this|
  199.         // | o  | |
  200.         // |    |_|
  201.         // |____|
  202.         else if( this.hitsRightOf( o ) ) // 4. t1 hitting t2 to the left
  203.           return o.Right - this.Left; // +x
  204.         else
  205.           return 0 ;
  206.       }
  207.       else
  208.         return 0;
  209.     }
  210.  
  211.  
  212.     /// <summary>Magnitude of pixel overlap in y</summary>
  213.     public float YOverlap( Entity o )
  214.     {
  215.       if( this.hitsLeftOf( o ) || this.hitsRightOf( o ) )
  216.       {
  217.         // +----------> +x
  218.         // | ______
  219.         // | |this|
  220.         // | |____|_
  221.         // | || o  |
  222.         // |  |    |
  223.         // |  |____|
  224.         // v
  225.         // +y
  226.         // 1. this hits o from the top
  227.         if( this.hitsTopOf( o ) )    // 1. this hit floor o with his feet
  228.           //return o.Top - this.Bottom ;  // -y value
  229.           return this.Bottom - o.Top ; // abs(y)
  230.  
  231.         // 2. this's head hit a ceiling tile o
  232.         // ______
  233.         // | o  |
  234.         // |____|_
  235.         // ||this|
  236.         //  |    |
  237.         //  |____|
  238.         else if( this.hitsBottomOf( o ) )  // 2. this's head hit a ceiling tile o
  239.           return o.Bottom - this.Top ; // player move down +y
  240.  
  241.         else
  242.           return 0 ;
  243.       }
  244.       else
  245.         return 0 ;
  246.     }
  247.  
  248.   }
  249.  
  250.  
  251.   class Player : Entity
  252.   {
  253.     public float sp = 5 ;
  254.     public float vx,vy;
  255.     public bool groundContact;
  256.  
  257.     public static double JUMP_JUICE = .3;
  258.     public double jumpJuiceRem = 0;
  259.  
  260.     double expFactor = 1.0; /// how strong gravity is.  make large for stronger gravity
  261.  
  262.     public Player( int width, int height )
  263.     {
  264.       w=width;  h=height;
  265.       x = y = w;
  266.       vx=vy=0;
  267.       color = new Color( 0, 1, 0, 0.2f );
  268.     }
  269.  
  270.     public void doJump()
  271.     {
  272.       if( groundContact ) // if on ground
  273.       {
  274.         jumpJuiceRem = Player.JUMP_JUICE;
  275.         groundContact = false;
  276.       }
  277.     }
  278.  
  279.     public void computeVel( GameTime gt )
  280.     {
  281.       vx=vy=0;
  282.  
  283.       // Set his velocity
  284.       if( jumpJuiceRem > 0 ) // jump juice left
  285.       {
  286.         // he's jumping
  287.         //                                   5     -     5 = 0 (at start)
  288.         //                                   5     -     0 = 5 (at end)
  289.         double jumpDist = 22.5 * Math.Exp( -expFactor * ( JUMP_JUICE - jumpJuiceRem ) );
  290.         vy -= ( float )jumpDist;
  291.  
  292.         // spend his jump juice by time
  293.         jumpJuiceRem -= gt.ElapsedGameTime.TotalSeconds;
  294.       }
  295.  
  296.       vy += sp ; // everything falls at a constant rate
  297.     }
  298.  
  299.  
  300.     public void move()
  301.     {
  302.       x+=vx;  y+=vy;
  303.     }
  304.  
  305.   }
  306.  
  307.   class Tile : Entity
  308.   {
  309.     public Tile( int width, int height )
  310.     {
  311.       w=width;  h=height;
  312.       color = baseColor;
  313.     }
  314.   }
  315.  
  316.   public class CollisionDemo2 : Microsoft.Xna.Framework.Game
  317.   {
  318.     GraphicsDevice gpu;
  319.     GraphicsDeviceManager graphics;
  320.     SpriteBatch sb;
  321.     //SpriteFont sf;
  322.  
  323.     Player p;
  324.     Tile movingTile;
  325.     List<Tile> tiles;
  326.  
  327.     public CollisionDemo2()
  328.     {
  329.       graphics = new GraphicsDeviceManager( this );
  330.       Content.RootDirectory = "Content";
  331.     }
  332.  
  333.     protected override void Initialize()
  334.     {
  335.       base.Initialize();
  336.     }
  337.  
  338.     private void wallTest()
  339.     {
  340.       //Console.WriteLine( "move" ) ;
  341.       p.move() ;
  342.  
  343.       p.groundContact = false ; 
  344.  
  345.       List<Tile> intns = new List<Tile>();
  346.  
  347.       foreach( Tile t in tiles )
  348.       {
  349.         t.color = Entity.baseColor; // reset
  350.  
  351.         if( p.intersects( t ) )
  352.         {
  353.           t.color = Color.Red ;
  354.           intns.Add( t ) ;
  355.         }
  356.       }
  357.  
  358.       // categorize intersections:
  359.       List<Tile> groundTiles = new List<Tile>() ;
  360.       List<Tile> ceilingTiles = new List<Tile>() ;
  361.       foreach( Tile t in intns )
  362.       {
  363.         if( p.hitsTopOf( t ) )
  364.         {
  365.           // does this count as grounding?
  366.           // define grounding as 1/4 tile width
  367.           if( p.XOverlap( t ) > t.w / 4 )
  368.           {
  369.             //Console.WriteLine( "p grounded" ) ;
  370.             p.groundContact =true ;
  371.             t.color = Color.Black ;
  372.             groundTiles.Add( t ) ;
  373.           }
  374.         }
  375.  
  376.         // Do the same thing for ceiling tiles
  377.         if( p.hitsBottomOf( t ) )
  378.         {
  379.           if( p.XOverlap( t ) > t.w / 4 )
  380.           {
  381.             //Console.WriteLine( "OW MY HEAD!" ) ;
  382.             t.color = Color.Plum ;
  383.             ceilingTiles.Add( t ) ;
  384.             p.jumpJuiceRem = 0 ; // kill jump
  385.           }
  386.         }
  387.       }
  388.  
  389.       // push off the ceiling and remove those tiles
  390.       // from the main collection
  391.       // 1 RESOLVE CEILING BUMPS (and remove these tiles from further consideration)
  392.       foreach( Tile t in ceilingTiles )
  393.       {
  394.         if( p.intersects( t ) ) // check this again since player will be moving between iterations
  395.           p.pushOffY( t ) ;
  396.  
  397.         intns.Remove( t ) ; // remove it from the main collection once we push off it
  398.       }
  399.  
  400.       // 2 RESOLVE MID-AIR WALL COLLISIONS
  401.       if( !p.groundContact ) // then push x off first
  402.       {
  403.         //sb.DrawString( sf, "Flying", new Vector2( 0, 20 ), Color.Red ) ;
  404.  
  405.         // now that's done, we can push off x
  406.         foreach( Tile t in intns )
  407.         {
  408.           if( p.intersects( t ) )
  409.           if( p.hitsLeftOf( t ) || p.hitsRightOf( t ) )
  410.           {
  411.             //Console.WriteLine( "Push t side " + p.XOverlap( t ) ); 
  412.             t.color = Color.Olive;
  413.             p.pushOffX( t );
  414.           }
  415.         }
  416.       }
  417.  
  418.       // 3 RESOLVE SINK-INTO-GROUND COLLISIONS
  419.       else
  420.       {
  421.         // push off y
  422.         foreach( Tile t in groundTiles )
  423.         {
  424.           if( p.intersects( t ) )
  425.           {
  426.             if( p.hitsTopOf( t ) )
  427.             {
  428.               //Console.WriteLine( "Push t bottom " + p.YOverlap( t ) ); 
  429.               p.pushOffY( t ) ;
  430.               intns.Remove( t ) ;
  431.             }
  432.           }
  433.         }
  434.       }
  435.  
  436.       // now for the rest of the tiles we intersected with
  437.       // that were neither ground nor ceiling tiles
  438.       // 4 RESOLVE ALL OTHER COLLISIONS (GROUNDED-WALL COLLISIONS)
  439.       foreach( Tile t in intns )
  440.       {
  441.         if( p.intersects( t ) )
  442.           if( p.hitsRightOf( t ) || p.hitsLeftOf( t ) )
  443.           {
  444.             //Console.WriteLine( "Push t side#2: " + p.XOverlap( t ) ); 
  445.             t.color = Color.Aqua ;
  446.             p.pushOffX( t ) ;
  447.           }
  448.       }
  449.     }
  450.  
  451.     protected override void LoadContent()
  452.     {
  453.       gpu = GraphicsDevice;
  454.       sb = new SpriteBatch( GraphicsDevice );
  455.       //sf = Content.Load<SpriteFont>( "SpriteFont1" ) ;
  456.  
  457.       //User32.SetWindowPos( (uint)Window.Handle, 0, 0, 0, 800, 600, 1 ) ;
  458.  
  459.       int s = 40;
  460.       Entity.init( gpu, s, s );
  461.  
  462.       p = new Player( s, s );
  463.  
  464.       // the world is an array of Tiles
  465.       int w = gpu.Viewport.Width;
  466.       int h = gpu.Viewport.Height;
  467.  
  468.       int tw = w / s;
  469.       int th = h / 2 / s;
  470.       tiles = new List<Tile>();
  471.       Tile t;
  472.       for( int row = 0 ; row < h / 2 ; row += s )
  473.       {
  474.         for( int col = 0 ; col < w ; col += s )
  475.         {
  476.           t = new Tile( s, s );
  477.  
  478.           t.Top = gpu.Viewport.Height - row;
  479.           t.Left = col;
  480.  
  481.           tiles.Add( t );
  482.         }
  483.       }
  484.  
  485.       // make a wall
  486.       for( int row = h / 2 ; row < gpu.Viewport.Height ; row += s )
  487.       {
  488.         t = new Tile( s, s );
  489.  
  490.         t.Top = gpu.Viewport.Height - row;
  491.         t.Left = 6 * s;
  492.  
  493.         tiles.Add( t );
  494.       }
  495.  
  496.       Random r = new Random();
  497.       // some random tiles
  498.       for( int i = 0 ; i < 10 ; i++ )
  499.       {
  500.         t = new Tile( s, s );
  501.  
  502.         t.Top = ( float )( s * th * r.NextDouble() );
  503.         t.Left = ( float )( s * tw * r.NextDouble() );
  504.  
  505.         tiles.Add( t );
  506.       }
  507.  
  508.       movingTile = new Tile( s, s );
  509.       movingTile.Left = 4 * s;
  510.       movingTile.Top = h / 2 - s;
  511.  
  512.       tiles.Add( movingTile );
  513.     }
  514.  
  515.     double a = 0.0f;
  516.     protected override void Update( GameTime gameTime )
  517.     {
  518.  
  519.       base.Update( gameTime );
  520.     }
  521.  
  522.     protected override void Draw( GameTime gameTime )
  523.     {
  524.       gpu.Clear( Color.Gray );
  525.  
  526.       sb.Begin( SpriteSortMode.BackToFront, BlendState.AlphaBlend );
  527.  
  528.  
  529.  
  530.  
  531.       #region computation:  needs move update
  532.       KeyboardState ks = Keyboard.GetState();
  533.       if( ks.IsKeyDown( Keys.Escape ) )
  534.         this.Exit();
  535.  
  536.  
  537.  
  538.       a += 0.01f;
  539.       if( a >= 2 * Math.PI )
  540.         a -= 2 * Math.PI;
  541.  
  542.       // Before moving the tile.. should see if the move's allowed
  543.       movingTile.y += ( float )Math.Sin( a );
  544.  
  545.       p.computeVel( gameTime );
  546.  
  547.  
  548.  
  549.       if( ks.IsKeyDown( Keys.Up ) )
  550.         p.doJump();
  551.  
  552.       if( ks.IsKeyDown( Keys.Left ) )
  553.         p.vx = -p.sp;
  554.       if( ks.IsKeyDown( Keys.Right ) )
  555.         p.vx = p.sp;
  556.  
  557.       if( !ks.IsKeyDown( Keys.Space ) )
  558.         wallTest();
  559.       #endregion
  560.  
  561.  
  562.  
  563.  
  564.       sb.Draw( Entity.tex, p.getRect(), Color.Blue );
  565.       foreach( Tile t in tiles )
  566.         sb.Draw( Entity.tex, t.getRect(), t.color );
  567.       sb.End();
  568.  
  569.       base.Draw( gameTime );
  570.     }
  571.   }
  572.  
  573.  
  574.   //launcher
  575.   static class Program
  576.   {
  577.     static void Main( string[] args )
  578.     {
  579.       using( CollisionDemo2 game = new CollisionDemo2() )
  580.       {
  581.         game.Run();
  582.       }
  583.     }
  584.   }
  585. }
Not running #stdin #stdout 0s 0KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
Standard output is empty
https://ideone.com/JDleh
language:
C# (gmcs 5.20.1)
created:
12 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!