C:\Users\weaver\Justin\Workspace\UAA_2011_A_Spring\CS470\Project\OrbitClash\OrbitClash\SolidEntity.cs

Transcription

1 1 #region Header Comments 2 3 /* $Id: SolidEntity.cs :53:42Z weaver $ 4 * 5 * Author: Justin Weaver 6 * Date: Mar * Description: Extendable abstract class to facilitate collision detection 8 * between particles. This class is extended by several classes in the game 9 * (e.g. Planet, Ship, and Bullet classes). 10 */ #endregion Header Comments using System; 15 using System.Collections.Generic; 16 using System.Drawing; 17 using SdlDotNet.Core; 18 using SdlDotNet.Graphics; 19 using SdlDotNet.Graphics.Sprites; 20 using SdlDotNet.Particles; namespace OrbitClash 23 { 24 // Notice that this class extends SDL.NET's ParticleSprite class. 25 internal abstract class SolidEntity : ParticleSprite 26 { 27 #region Properties /* Get/Set current particle position (top-left corner) in a nice tidy 30 * Point class. This is just a simple matter of float <--> int 31 * conversion. Use Truncate rather than Floor, Ceiling, or Round in 32 * order to avoid the remote possibility of breaching the boundaries of 33 * the sprite's surface image. 34 */ 35 public Point Position 36 { 37 get 38 { 39 int x = Convert.ToInt32(Math.Truncate(this.X)); 40 int y = Convert.ToInt32(Math.Truncate(this.Y)); 41 return new Point(x, y); 42 } 43 set 44 { 45 this.x = value.x; 46 this.y = value.y; 47 } 48 } // Get the current position of the center of the particle image. 51 public Point Center 52 { 53 get 54 { -1-

2 55 /* Locate the center using the position of the current particle 56 * image's top-left corner, and its Size. 57 */ // Start at the top-left corner of the image's rectangle. 60 Point center = this.position; // Get the image size. 63 Size size = this.sprite.size; // Find the approximate center. 66 center.x += size.width / 2; 67 center.y += size.height / 2; return center; 70 } 71 } // True if this particle is alive (exists); false otherwise. 74 public bool IsAlive 75 { 76 get 77 { 78 // Non-zero particle Life means: alive. 79 return (this.life!= 0); 80 } 81 } #endregion Properties #region Constructors public SolidEntity(Sprite sprite) 88 : base(sprite, 0, 0, new Vector(), 0) 89 { 90 } public SolidEntity(Sprite sprite, float x, float y, Vector vector, int life) 93 : base(sprite, x, y, vector, life) 94 { 95 } #endregion Constructors #region Collision Detection /* A Few Important Notes About Collision Detection 102 * 103 * CS-SDL (which is the C# wrapper for SDL) allows the programmer to 104 * set a target frame rate (fps). If the machine can't maintain the 105 * target rate, things just slow down. In other words, CS-SDL doesn t 106 * drop frames, rather it simply calls your Tick event handler as fast 107 * as it can manage. 108 * -2-

3 109 * I could have implemented frame rate independent movement, to 110 * accommodate slower machines, by moving particles according to the 111 * elapsed time since the last Tick() call. However, I did not, 112 * because it would require me to develop a predictive collision 113 * detection system to use in tandem with my after-the-fact collision 114 * detection system. Without the predictive system, entities could 115 * potentially pass through each other without the collision being 116 * detected. I might still do it, but time is a tough commodity to 117 * come by these days! Besides, predictive collision detection was 118 * never part of the plan I put forward in my presentation (or design 119 * document), but the phrase keep it simple appeared several times. 120 * 121 * On the positive side, the requirements for this game are pretty 122 * minimal. I believe it may be quite a challenge to find a Windows 123 * machine (with.net 4.0) that couldn't run this game without missing 124 * a beat (with no other crippling system loads, naturally). Heck, my 125 * buddy even tested this game in on a virtual machine running Windows 126 * 7 on his half-decade-old Mac laptop, and it looked great. 127 * 128 * To tie up the last loose end, I set a universal speed limit, which 129 * is enforced after all the other updates to solid entities during 130 * each Tick(). The speed limit ensures that no particle can ever 131 * travel further than the radius of the smallest entity in the game 132 * in one Tick(). Thus, the speed limit makes missed collisions, even 133 * on a slow machine, very unlikely. 134 */ public bool GetCollisionStatus(SolidEntity otherentity) 137 { 138 if (!this.isalive) 139 // Dead entities don't collide, because they don't exist. 140 return false; return SolidEntity.GetCollisionStatus(this, otherentity); 143 } /* Returns true if the two specified entities are colliding. This 146 * method has pixel-level accuracy. 147 */ 148 private static bool GetCollisionStatus(SolidEntity entity1, SolidEntity entity2) 149 { 150 /* Immediately grab a reference to each particle sprite image 151 * (Surface), so that any sprite animation will not trip us up by 152 * changing surfaces under us. 153 */ 154 Surface surface1 = entity1.sprite.surface; 155 Surface surface2 = entity2.sprite.surface; // Find the position of each particle image. 158 Point surface1position = new Point(Convert.ToInt32(Math.Truncate(entity1.X )), Convert.ToInt32(Math.Truncate(entity1.Y))); 159 Point surface2position = new Point(Convert.ToInt32(Math.Truncate(entity2.X )), Convert.ToInt32(Math.Truncate(entity2.Y)));

4 161 // Find the size of each particle image. 162 Size surface1size = new Size(Convert.ToInt32(Math.Truncate(entity1.Width)), Convert.ToInt32(Math.Truncate(entity1.Height))); 163 Size surface2size = new Size(Convert.ToInt32(Math.Truncate(entity2.Width)), Convert.ToInt32(Math.Truncate(entity2.Height))); // Put 'em together to make rectangles. 166 Rectangle surface1rec = new Rectangle(surface1Position, surface1size); 167 Rectangle surface2rec = new Rectangle(surface2Position, surface2size); if (!surface1rec.intersectswith(surface2rec)) 170 /* The two entity's bounding rectangles don't even intersect. 171 * They obviously aren't colliding. 172 */ 173 // False: entity1 and entity2 are not colliding. 174 return false; /* Their rectangles do intersect, so now we need to check each 177 * pixel in the overlapping area. 178 */ // Find the intersecting rectangle of the two entities. 181 Rectangle intersectingrectangle = new Rectangle(surface1Rec.Location, surface1rec.size); 182 intersectingrectangle.intersect(surface2rec); /* Lock the two entitiy's surfaces into memory to allow direct 185 * pixel manipulation with high performance. 186 */ 187 surface1.lock(); 188 surface2.lock(); // Check each overlapping pixel. 191 for (int x = 0; x < intersectingrectangle.width; x++) 192 for (int y = 0; y < intersectingrectangle.height; y++) 193 { 194 /* Get the position within each surface of the overlapping 195 * pixel. 196 */ 197 Point surface1pixelposition = new Point(intersectingRectangle.X - surface1rec.x + x, intersectingrectangle.y - surface1rec.y + y); 198 Point surface2pixelposition = new Point(intersectingRectangle.X - surface2rec.x + x, intersectingrectangle.y - surface2rec.y + y); /* Get the color from each surface at the overlapping 201 * pixel. Unlike the GetPixel and SetPixel operations of 202 * the.net Image class, the GetPixel and SetPixel 203 * operations of the C# SDL Surface class allow direct 204 * pixel manipulation, and do not create their own locks 205 * (hence the locks happen outside the loop). 206 */ 207 Color surface1pixelcolor = surface1.getpixel(surface1pixelposition); 208 Color surface2pixelcolor = surface2.getpixel(surface2pixelposition);

5 210 /* True if the pixel at the overlapping point in the 211 * associated surface is transparent. 212 */ 213 bool surface1pixelistransparent = surface1.transparent && surface1pixelcolor == surface1.transparentcolor; 214 bool surface2pixelistransparent = surface2.transparent && surface2pixelcolor == surface2.transparentcolor; /* If both pixels are non-transparent, then we have a 217 * collision! 218 */ 219 if (!surface1pixelistransparent &&!surface2pixelistransparent) 220 { 221 // Unlock the two surfaces before returning. 222 surface1.unlock(); 223 surface2.unlock(); // True: entity1 and entity2 are colliding. 226 return true; 227 } 228 } // Unlock the two surfaces before returning. 231 surface1.unlock(); 232 surface2.unlock(); // False: entity1 and entity2 are not colliding. 235 return false; 236 } #endregion Collision Detection #region Static Helper Operations /* Note: SDL.NET provides the Vector class, which is a vector in the 243 * mathematical sense (i.e. point, direction, magnitude), rather than 244 * the Vector array-object many Java folks will likely be familiar 245 * with. 246 * 247 * Vectors are used to specify particle velocity, but they also make 248 * handy shortcuts for a few generally useful tasks (see below). 249 */ /* Return the position that lies the specified distance (in pixels) 252 * from the specified position, at the specified angle (in degrees). 253 */ 254 public static Point GetPosition(Point startingposition, int angledeg, int distancepixels) 255 { 256 // Create a vector at the starting position. 257 Vector basevector = new Vector(startingPosition.X, startingposition.y, 0); // Create a vector with the specified angle and length. 260 Vector offsetvector = Vector.FromDirection(angleDeg, distancepixels); -5-

6 // Add the two vectors. 263 Vector resultvector = basevector + offsetvector; // Return the resulting position. 266 return resultvector.point; 267 } /* Given two SolidEntity objects, returns the distance (in pixels) 270 * between the centers of the two objects. 271 */ 272 public static double GetDistance(SolidEntity entity1, SolidEntity entity2) 273 { 274 // Create a vector between the two entities to find the distance. 275 Vector v = new Vector(entity1.Center, entity2.center); 276 return v.length; 277 } /* Given two SolidEntity objects, returns the degree of the angle 280 * between the centers of the two entities (with entity1's center as 281 * the origin). 282 */ 283 public static int GetDirectionDeg(SolidEntity entity1, SolidEntity entity2) 284 { 285 // Create a vector between the two entities to find the angle. 286 Vector v = new Vector(entity1.Center, entity2.center); 287 return Convert.ToInt32(Math.Truncate(v.DirectionDeg)); 288 } #endregion Static Helper Operations 291 } 292 } -6-