projects/openmelee: ai/steer.d comparison

comparison ai/steer.d @ 22:4fce5596d1f6

ai work

author	zzzzrrr <mason.green@gmail.com>
date	Thu, 26 Mar 2009 16:56:30 -0400
parents	cad384ad349e
children	e79347dd38a3

comparison

equal deleted inserted replaced

-:cad384ad349e
+:4fce5596d1f6
 // Constructor: initializes state
 this (Ship ship)
 {
 m_ship = ship;
 m_body = ship.rBody;
-m_radius = 0.0f;
-// Find radius of body
-for (bzShape s = m_body.shapeList; s; s = s.next) {
-if(s.sweepRadius > m_radius) {
-m_radius = s.sweepRadius;
-}
-}
 }
 	struct PathIntersection
 {
 bool intersect;
 m_position = m_ship.state.position;
 m_velocity = m_ship.state.velocity;
 m_speed = m_ship.state.speed;
 m_maxForce = m_ship.state.maxForce;
 m_forward = m_ship.state.forward;
+m_radius = m_ship.state.radius;
 }
 // -------------------------------------------------- steering behaviors
 bzVec2 steerForWander (float dt) {
 bzVec2 steerToAvoidObstacles (float minTimeToCollision, bzBody obstacles) {
 bzVec2 avoidance;
 PathIntersection nearest, next;
-float minDistanceToCollision = minTimeToCollision * m_speed;
+float minDistanceToCollision = 10; //minTimeToCollision * m_speed;
 next.intersect = false;
 nearest.intersect = false;
 // test all obstacles for intersection with my forward axis,
 for (bzBody o = obstacles; o; o = o.next) {
 if(o is m_body) continue;
 // This code which presumes the obstacle is spherical
-findNextIntersectionWithSphere(o, next, minDistanceToCollision);
+findNextIntersectionWithSphere(o, next);
 if (!nearest.intersect || (next.intersect && next.distance < nearest.distance)) {
 					nearest = next;
 }
 }
 // when a nearest intersection was found
 if (nearest.intersect && (nearest.distance < minDistanceToCollision)) {
-Stdout("Distance: ")(nearest.distance).newline;
 // compute avoidance steering force: take offset from obstacle to me,
 // take the component of that which is lateral (perpendicular to my
 // forward direction), set length to maxForce, add a bit of forward
 // component (in capture the flag, we never want to slow down)
 bzVec2 offset = m_position - nearest.obstacle.position;
 avoidance = perpendicularComponent(offset, m_forward);
 avoidance.normalize;
-//avoidance *= m_maxForce;
+avoidance = m_body.localPoint(avoidance);
+///avoidance *= m_maxForce;
 //avoidance += m_forward * m_maxForce * 0.75f;
 }
+auto state = cast(State) m_body.userData;
+state.avoid = avoidance;
 return avoidance;
 }
 bzVec2 avoid(float minTimeToCollision, bzBody obstacles) {
 bzVec2 movementNormal = m_velocity;
 movementNormal.normalize();
 bzVec2 characterToObstacle = o.position - m_position;
 real distanceSquared = bzDot(characterToObstacle, movementNormal);
-distanceSquared = characterToObstacle.length -
+distanceSquared = characterToObstacle.lengthSquared - distanceSquared*distanceSquared;
-distanceSquared*distanceSquared;
 // Check for collision
-// Find radius of obstacle
 float oRad = 0;
-for (bzShape shape = o.shapeList; shape; shape = shape.next) {
+for (bzShape s = o.shapeList; s; s = s.next) {
-if(shape.sweepRadius > oRad) {
+if(s.sweepRadius > oRad) {
-oRad = shape.sweepRadius;
+oRad = s.sweepRadius;
 }
 }
 real radius = oRad + avoidMargin;
 if (distanceSquared < radius*radius)
 // Make sure this isn't behind us and is closer than our lookahead.
 if (distanceToClosest > 0 && distanceToClosest < maxLookahead)
 {
 // Find the closest point
-bzVec2 closestPoint =
+bzVec2 closestPoint =  o.position + movementNormal * distanceToClosest;
-o.position + movementNormal*distanceToClosest;
 // Find the point of avoidance
-bzVec2 target =
+bzVec2 target = o.position + (closestPoint - o.position).length * radius;
-o.position +
-(closestPoint - o.position).length *
+auto state = cast(State) m_body.userData;
-(oRad + avoidMargin);
+state.avoid = target;
 return target;
 }
 }
 }
 		}
+auto state = cast(State) m_body.userData;
+state.avoid = bzVec2.zeroVect;
 return bzVec2.zeroVect;
 }
 		void findNextIntersectionWithSphere(bzBody obs,
-inout PathIntersection intersection, float mdc) {
+inout PathIntersection intersection) {
 			// This routine is based on the Paul Bourke's derivation in:
 			//   Intersection of a Line and a Sphere (or circle)
-			//   http://www.swin.edu.au/astronomy/pbourke/geometry/sphereline/
+			//   http://local.wasp.uwa.edu.au/~pbourke/geometry/sphereline/raysphere.c
 			float b, c, d, p, q, s;
 			bzVec2 lc;
 			// initialize pathIntersection object
 			intersection.intersect = false;
 			intersection.obstacle = obs;
-			// find "local center" (lc) of sphere in boid's coordinate space
+			// find "local center" (lc) of sphere in coordinate space
 			lc = m_body.localPoint(obs.position);
 			// computer line-sphere intersection parameters
 			b = 0;
 if(shape.sweepRadius > obsRadius) {
 obsRadius = shape.sweepRadius;
 }
 }
-			c = square(lc.x) + square(lc.y) - square(obsRadius + m_radius+mdc);
+			c = square(lc.x) + square(lc.y) - square(obsRadius + m_radius);
 			d = (b * b) - (4 * c);
 			// when the path does not intersect the sphere
 			if (d < 0) return;

Mercurial > projects > openmelee

comparison ai/steer.d @ 22:4fce5596d1f6