xlib_playground

object.c (7187B)

---

 #include <stdio.h>
 #include <stdlib.h>
 #include <stdint.h>
 
 #include "list.h"
 #include "object.h"
 
 /*
  * Pair of two objects with their distance.
  * Used by lhandle_collision();
  */
 typedef struct LLD {
 	Object *o0;
 	Object *o1;
 	float dist;
 } LLD;
 
 static int test_collision_rr(Object *, Object *);
 static void rect_next_tick(Object *, long);
 static void rect_handle_collision_mf(Object *, Object *);
 static LLD *create_lld(void);
 static void lldfree(LLD *);
 
 static int obj_count = 0;
 static int lld_count = 0;
 
 
 Object *
 create_object(enum object_type t, uint32_t color,
               float px, float py, float vx, float vy, float ax, float ay,
               int w, int h, int m,
 			  void (*next_tick)(Object *, long))
 {
 	obj_count++;
 
 	Object *o;
 	o = (Object *)malloc(sizeof(Object));
 	o->type = t;
 	o->color = color;
 	o->shape = SRECTANGLE;
 	o->pp.x = o->p.x = px;
 	o->pp.y = o->p.y = py;
 	o->v.x = vx;
 	o->v.y = vy;
 	o->a.x = ax;
 	o->a.y = ay;
 	o->body.rectangle.w = w;
 	o->body.rectangle.h = h;
 	o->m = m;
 	o->on_floor = 0;
 	if (next_tick == NULL)
 		next_tick = *o_next_tick;
 	o->next_tick = next_tick;
 	return o;
 }
 
 void
 free_object(Object *o)
 {
 	obj_count--;
 	free(o);
 }
 
 int
 get_obj_count(void)
 {
 	return obj_count;
 }
 
 /*
  * 1 if collide, 0 if not
  */
 int
 test_collision(Object *o1, Object *o2)
 {
 	if (o1->shape == SRECTANGLE && o2->shape == SRECTANGLE)
 		return test_collision_rr(o1, o2);
 	else {
 		fprintf(stderr, "test_collision for other shapes is not implemented yet\n");
 		return -1;
 	}
 }
 
 static int
 test_collision_rr(Object *o1, Object *o2)
 {
 	if (o1->shape != SRECTANGLE || o2->shape != SRECTANGLE) {
 		fprintf(stderr, "test_collision_rr: invalid objects\n");
 		return -1;
 	}
 	return o1->p.x < o2->p.x + o2->body.rectangle.w &&
 		   o2->p.x < o1->p.x + o1->body.rectangle.w &&
 	       o2->p.y < o1->p.y + o1->body.rectangle.h &&
 		   o1->p.y < o2->p.y + o2->body.rectangle.h;
 }
 
 void
 o_next_tick(Object *o, long ndt)
 {
 	switch (o->shape) {
 	case SRECTANGLE:
 		rect_next_tick(o, ndt);
 		break;
 	default:
 		fprintf(stderr, "next_tick: not implemented for other shapes\n");
 		break;
 	}
 }
 
 static void
 rect_next_tick(Object *o, long ndt)
 {
 	if (o->shape != SRECTANGLE) {
 		fprintf(stderr, "rect_next_tick: invalid object shape\n");
 		return;
 	}
 	o->pp.x = o->p.x;
     o->pp.y = o->p.y;
     o->v.x += o->a.x * ndt / 1e9;
     o->v.y += o->a.y * ndt / 1e9;
     o->p.x += o->v.x * ndt / 1e9;
     o->p.y += o->v.y * ndt / 1e9;
 }
 
 void
 handle_collision_mf(Object *om, Object *of)
 {
 	// TODO: too many testing?
 	if (!test_collision(om, of))
 		return;
 	if (om->shape == SRECTANGLE && of->shape == SRECTANGLE)
 		rect_handle_collision_mf(om, of);
 	else {
 		fprintf(stderr, "handle_collision_mf: not implemented for other shapes\n");
 		return;
 	}
 }
 
 /*
  * Handle collision of a moving rect against fixed rect
  */
 static void
 rect_handle_collision_mf(Object *om, Object *of)
 {
 	// TODO: too many testing?
     if (!test_collision(om, of))
         return;
     if (om->pp.x + om->body.rectangle.w <= of->pp.x &&
         of->p.x < om->p.x + om->body.rectangle.w) {
         // collisioin from left to right
         om->p.x = of->p.x - om->body.rectangle.w;
         om->v.x = 0;
     }
     if (of->pp.x + of->body.rectangle.w <= om->pp.x &&
         om->p.x < of->p.x + of->body.rectangle.w) {
         // collision from right to left
         om->p.x = of->p.x + of->body.rectangle.w;
         om->v.x = 0;
     }
 
     if (om->pp.y + om->body.rectangle.h <= of->pp.y &&
         of->p.y < om->p.y + om->body.rectangle.h) {
         // collision from up to down
         om->p.y = of->p.y - om->body.rectangle.h;
         om->v.y = 0;
     }
     if (of->pp.y + of->body.rectangle.h <= om->pp.y &&
         om->p.y < of->p.y + of->body.rectangle.h) {
         // collision from down to up
         om->p.y = of->p.y + of->body.rectangle.h;
         om->v.y = 0;
     }
 
 }
 
 int
 object_dist(Object *o1, Object *o2)
 {
     return (o1->p.x - o2->p.x) * (o1->p.x - o2->p.x) +
            (o1->p.y - o2->p.y) * (o1->p.y - o2->p.y);
 }
 
 int
 is_on_floor(Object *p, Object *f)
 {
 	if (p->p.x + p->body.rectangle.w < f->p.x ||
 		f->p.x + f->body.rectangle.w < p->p.x)
 		return 0;
 	return p->p.y + p->body.rectangle.h == f->p.y;
 }
 
 int
 is_on_floor_before(Object *p, Object *f)
 {
 	if (p->pp.x + p->body.rectangle.w < f->pp.x ||
 		f->pp.x + f->body.rectangle.w < p->pp.x)
 		return 0;
 	return p->pp.y + p->body.rectangle.h == f->pp.y;
 }
 
 void
 ohandle_collision(Object *o0, Object *o1)
 {
 	if (col_func[o0->type][o1->type] == NULL)
 		return;
 	(* col_func[o0->type][o1->type])(o0, o1);
 }
 
 void
 oprint(Object *o)
 {
 	printf("[%d: (%4.0f, %4.0f)]", o->type, o->p.x, o->p.y);
 }
 
 /*
  * Compare object's x coordinate.
  */
 int
 olcmpx(Object *p, Object *q)
 {
 	if(p->p.x < q->p.x)
 		return -1;
 	else if(p->p.x == q->p.x)
 		return 0;
 	else
 		return 1;
 }
 
 /*
  * sort list of object according to the objects x coordinate.
  * TODO: change name to better one.
  */
 void
 olqsortx(List *p)
 {
 	lqsort(p, (int (*)(void *, void *))&olcmpx);
 }
 
 static int
 lldcmpdst(LLD *p, LLD *q)
 {
 	if (p->dist < q->dist)
 		return -1;
 	else if (p->dist == q->dist)
 		return 0;
 	else
 		return 1;
 }
 
 static void
 lldprint(LLD *p)
 {
 	printf("{");
 	oprint(p->o0);
 	printf(", ");
 	oprint(p->o1);
 	printf(", %2.0f}", p->dist);
 }
 
 static LLD *
 create_lld(void)
 {
 	LLD *p = NULL;
 	p = (LLD *)malloc(sizeof(LLD));
 
 	lld_count++;
 	return p;
 }
 
 static void
 lldfree(LLD *p)
 {
 	lld_count--;
 	free(p);
 }
 
 int
 get_lld_count(void)
 {
 	return lld_count;
 }
 
 /*
  * The order of list p will be changed.
  */
 void
 lhandle_collision(List *p)
 {
 	olqsortx(p);
 	List *stack, *tmp;
 	stack = NULL;
 	for (; p != NULL; p = p->next) {
 		// If p doesn't have intersection in x coodinate
 		// with an item in the stack
 		if (stack != NULL &&
 			((Object *)stack->item)->p.x +
 			((Object *)stack->item)->body.rectangle.w <=
 			((Object *)p->item)->p.x) {
 			// Handle collision among the items in the stack.
 			// LLD: {Object *o0, Object *o1, float dist}
 			// Sort LLD according to dist.
 			List *lld, *tmplld;
 			List *s, *t;
 			lld = NULL;
 			for (s = stack; s != NULL && s->next != NULL; s = s->next) {
 				for (t = s->next; t != NULL; t = t->next) {
 					LLD *l = NULL;
 					if((l = create_lld()) == NULL) {
 						fprintf(stderr, "lhandle_collision: Error. creating"
 							"lld.\n");
 						exit(1);
 					}
 					l->o0 = (Object *)s->item;
 					l->o1 = (Object *)t->item;
 					l->dist = object_dist((Object *)s->item,
 							(Object *)t->item);
 					if((tmplld = laddfront(lld, l)) == NULL){
 						fprintf(stderr, "lhandle_collision: Error. Could not"
 							"add item to lld\n");
 						exit(1);
 					}
 					lld = tmplld;
 				}
 			}
 			lqsort(lld, (int (*)(void *, void *))&lldcmpdst);
 			for (tmplld = lld; tmplld != NULL; tmplld = tmplld->next) {
 				if (test_collision(((LLD *)tmplld->item)->o0,
 					((LLD *)tmplld->item)->o1)) {
 					ohandle_collision(((LLD *)tmplld->item)->o0,
 						((LLD *)tmplld->item)->o1);
 				}
 			}
 			lfreei(lld, (void (*)(void *))&lldfree);
 			lfree(stack);
 			stack = NULL;
 		}
 		if ((tmp = laddfront(stack, p->item)) == NULL) {
 			fprintf(stderr, "lhandle_collision: Error. add item to stack\n");
 			exit(1);
 		}
 		stack = tmp;
 	}
 	lfree(stack);
 	return;
 }