Return to event.c CVS log

Up to [Research Unix] / researchv9 / jtools / src / demo / asteroids

Annotation of researchv9/jtools/src/demo/asteroids/event.c, revision 1.1.1.1

1.1       root        1: #include "event.h"
                      2: Event  *event, *efree;
                      3: #define        NEVENT  32
                      4: Event  eventpool[NEVENT];      /* for allocation */
                      5: 
                      6: /*
                      7:  * Advance the clock
                      8:  */
                      9: tick()
                     10: {
                     11:        register Event *e=event;
                     12:        if(e==0)
                     13:                return;
                     14:        --e->dt;
                     15:        while(e->dt==0){
                     16:                event=e->next;
                     17:                if((*e->fn)(e->type))
                     18:                        (void)addevent(e, e->time, e->fn, e->type);     /* it's gotta work! */
                     19:                else{
                     20:                        e->next=efree;
                     21:                        efree=e;
                     22:                }
                     23:                e=event;
                     24:        }
                     25: }
                     26: /*
                     27:  * Add an event at time t from now
                     28:  */
                     29: addevent(e, t, fn, type)
                     30:        register Event *e;
                     31:        register t;
                     32:        int      (*fn)();
                     33: {
                     34:        register Event *ep, *last=0;
                     35:        if(e==0)
                     36:                return 0;
                     37:        e->fn=fn;
                     38:        e->next=0;
                     39:        e->type=type;
                     40:        e->time=t;
                     41:        for(ep=event; ep; ep=ep->next){
                     42:                if(ep->dt < t)
                     43:                        t -= ep->dt;
                     44:                else{   /* gotta insert it here */
                     45:                        if(last)
                     46:                                last->next = e;
                     47:                        ep->dt-=t;
                     48:                        e->next=ep;
                     49:                        break;
                     50:                }
                     51:                last=ep;
                     52:        }
                     53:        if(last==0)
                     54:                event=e;
                     55:        else if(last->next==0)
                     56:                last->next=e;
                     57:        e->dt=t;
                     58:        return 1;
                     59: }
                     60: /*
                     61:  * Initially link all the events together
                     62:  */
                     63: initevent()
                     64: {
                     65:        register Event *e;
                     66:        for(e=eventpool; e<&eventpool[NEVENT-1]; e++)
                     67:                e->next=e+1;
                     68:        e->next=0;
                     69:        efree=eventpool;
                     70:        event=0;
                     71: }
                     72: /*
                     73:  * Allocate a new guy out of the array
                     74:  */
                     75: Event *
                     76: newevent()
                     77: {
                     78:        register Event *e;
                     79:        if(e=efree)     /* assignment = */
                     80:                efree=efree->next;
                     81:        return e;
                     82: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.