Ignore:
Timestamp:
Mar 18, 2008, 9:36:56 PM (12 years ago)
Author:
Sam Hocevar
Message:
  • Get rid of ugly tabs and trailing spaces everywhere.
File:
1 edited

Legend:

Unmodified
Added
Removed
  • abuse/trunk/src/level.cpp

    r123 r124  
    4141
    4242game_object *level::attacker(game_object *who)
    43 { 
     43{
    4444  int32_t d=0x7fffffff;
    4545  game_object *c=NULL;
     
    5252      if (tmp_d<d)
    5353      {
    54         d=tmp_d;
    55         c=f->focus;
     54    d=tmp_d;
     55    c=f->focus;
    5656      }
    5757    }
    5858  }
    5959  CONDITION(c,"no attacker found");
    60   return c; 
    61 } 
     60  return c;
     61}
    6262
    6363
    6464
    6565int level::is_attacker(game_object *who)
    66 { 
     66{
    6767  return who->controller()!=NULL;
    6868}
     
    108108}
    109109
    110 level::~level() 
    111 { 
     110level::~level()
     111{
    112112  load_fail();
    113113  if (attack_list) jfree(attack_list);
     
    130130      if (!strcmp(object_names[o->otype],"START"))
    131131      {
    132         if (!found) found=o;
    133         f->focus->x=o->x;
    134         f->focus->y=o->y;         
    135         f->focus->set_hp(get_ability(f->focus->otype,start_hp));
    136         f->focus->set_state(stopped);
    137         f=f->next;
     132    if (!found) found=o;
     133    f->focus->x=o->x;
     134    f->focus->y=o->y;
     135    f->focus->set_hp(get_ability(f->focus->otype,start_hp));
     136    f->focus->set_state(stopped);
     137    f=f->next;
    138138      }
    139139    }
     
    144144    {
    145145      f->focus->x=found->x;
    146       f->focus->y=found->y;         
     146      f->focus->y=found->y;
    147147      f->focus->set_hp(get_ability(f->focus->otype,start_hp));
    148       f->focus->set_state(stopped);     
     148      f->focus->set_state(stopped);
    149149    }
    150150    f=f->next;
     
    158158  for (i=0;i<total_objs;i++)
    159159    if (obj[i]==the_game->first_view->focus)
    160     {     
     160    {
    161161      int tries=total_objs;
    162162      do
    163163      {
    164         i++;
    165         if (i==total_objs)
    166           i=0;
    167         the_game->first_view->focus=obj[i];
    168       }  while ((!the_game->first_view->focus->is_playable() || 
    169                 the_game->first_view->focus->hp<=0) && tries--);
     164    i++;
     165    if (i==total_objs)
     166      i=0;
     167    the_game->first_view->focus=obj[i];
     168      }  while ((!the_game->first_view->focus->is_playable() ||
     169        the_game->first_view->focus->hp<=0) && tries--);
    170170      return ;
    171     }         */ 
     171    }            */
    172172}
    173173
     
    197197      if (other->can_block())              // if object can block other player, keep a list for fast testing
    198198      {
    199         add_block(other);
    200         add_all_block(other);
     199    add_block(other);
     200    add_all_block(other);
    201201      } else if (other->hurtable())
    202202        add_all_block(other);
     
    204204      t++;
    205205      last_active->next_active=other;
    206       last_active=other;       
     206      last_active=other;   
    207207      pull_actives(o,last_active,t);
    208208    }
     
    219219  game_object *o=first;
    220220  for (;o;o=o->next)
    221   {   
     221  {
    222222    if (!o->active)
    223223    {
     
    227227      if (o->x+xr>=x1 && o->x-xr<=x2 && o->y+yr>=y1 && o->y-yr<=y2)
    228228      {
    229        
    230         if (o->can_block())              // if object can block other player, keep a list for fast testing
    231         {
    232           add_block(o);
    233           add_all_block(o);
    234         } else if (o->hurtable())
     229   
     230    if (o->can_block())              // if object can block other player, keep a list for fast testing
     231    {
     232      add_block(o);
     233      add_all_block(o);
     234    } else if (o->hurtable())
    235235          add_all_block(o);
    236      
    237 
    238         o->active=1;
    239         t++;
    240         if (!first_active)     
    241           first_active=o;       
    242         else
     236
     237
     238    o->active=1;
     239    t++;
     240    if (!first_active)
     241      first_active=o;   
     242    else
    243243          last_active->next_active=o;
    244         last_active=o;
    245 
    246         pull_actives(o,last_active,t); 
    247       } 
    248     } 
     244    last_active=o;
     245
     246    pull_actives(o,last_active,t);   
     247      }
     248    }
    249249  }
    250250  if (last_active)
     
    265265  game_object *o=first;
    266266  for (;o;o=o->next)
    267   {   
     267  {
    268268    if (ft || !o->active)
    269269    {
     
    273273      if (o->x+xr>=x1 && o->x-xr<=x2 && o->y+yr>=y1 && o->y-yr<=y2)
    274274      {
    275         t++;
    276         if (!first_active)     
    277         first_active=o;
    278         else
    279         last_active->next_active=o;
    280         last_active=o;
    281         o->active=1;
     275    t++;
     276    if (!first_active)
     277    first_active=o;   
     278    else
     279    last_active->next_active=o;
     280    last_active=o;
     281    o->active=1;
    282282      } else if (ft) o->active=0;  // if this is the first pass, then mark objects not in this ranges as not active
    283283    }
     
    298298  game_object *o,*last_start=NULL;
    299299  int num=0;
    300  
     300
    301301  for (j=0,o=first;o && j<nplayers;o=o->next)
    302302  {
     
    310310    }
    311311  }
    312  
     312
    313313  // if we couldn't find enough starts then create the rest of the players at the original start
    314314  startable=j;  // if we haven't created anyone yet, it's because we can't
     
    323323      add_object_after(o,last_start);
    324324    }
    325     else 
    326     {
    327       f=new view(NULL,f,num); 
     325    else
     326    {
     327      f=new view(NULL,f,num);
    328328      num++;
    329329    }
     
    346346      if (xv!=sx1-o->x)                         // is the character in the wall?
    347347      {
    348         xv=-xv;
    349         o->try_move(o->x,o->y-1,xv,yv,1);       // see how far to the right we can push the character
    350         o->x+=xv;
     348    xv=-xv;
     349    o->try_move(o->x,o->y-1,xv,yv,1);       // see how far to the right we can push the character
     350    o->x+=xv;
    351351      } else
    352352      {
    353         xv=sx2-o->x;
    354         o->try_move(o->x,o->y-1,xv,yv,1);      // now check the right of the character for a wall
    355         if (xv!=sx2-o->x)
    356         {
    357           xv=-xv;
    358           o->try_move(o->x,o->y-1,xv,yv,1);
    359           o->x+=xv;
    360         }
    361       }           
     353    xv=sx2-o->x;
     354    o->try_move(o->x,o->y-1,xv,yv,1);      // now check the right of the character for a wall
     355    if (xv!=sx2-o->x)
     356    {
     357      xv=-xv;
     358      o->try_move(o->x,o->y-1,xv,yv,1);
     359      o->x+=xv;
     360    }
     361      }
    362362    }
    363363  }
     
    367367void level::try_pushback(game_object *subject,game_object *target)
    368368{
    369   if (subject->pushable() && target->pushable() && 
     369  if (subject->pushable() && target->pushable() &&
    370370      subject->state!=dead && target->state!=dead &&
    371371      subject->state!=dieing && target->state!=dieing)
     
    385385      yv=0;
    386386      target->try_move(target->x,target->y,xv2,yv,3);
    387       target->x+=xv2;     
     387      target->x+=xv2;
    388388    }
    389389  }
     
    399399  for (game_object *subject=first_active;subject;subject=subject->next_active)
    400400  {
    401     subject->picture_space(sx1,sy1,sx2,sy2);   
     401    subject->picture_space(sx1,sy1,sx2,sy2);
    402402    s_centerx=subject->x_center();
    403403
     
    408408      if (target!=subject)
    409409      {
    410         target->picture_space(tx1,ty1,tx2,ty2);
     410    target->picture_space(tx1,ty1,tx2,ty2);
    411411
    412412        if (!(sx2<tx1 || sx1>tx2 || sy1>ty2 || sy2<ty1))  // are they semi/overlapping?
    413         {   
    414           try_pushback(subject,target);
    415           if (subject->can_hurt(target))    // see if we can hurt him before calculating
    416           {        
    417             t_centerx=target->x_center();
    418             point_list *s_hit,*t_damage;
    419                          
    420             s_hit=subject->current_figure()->hit;        
    421             t_damage=target->current_figure()->damage;
    422 
    423             unsigned char *s_dat=s_hit->data,
    424             *t_dat;
    425             int i,j;
    426             for (i=(int)s_hit->tot-1;i>0 && !hit;i--)
    427             {
    428               for (t_dat=t_damage->data,j=(int)t_damage->tot-1;j>0 && !hit;j--)
    429               {
    430                 int32_t x1,y1,x2,y2,          // define the two line segments to check
    431                 xp1,yp1,xp2,yp2;
    432 
    433                 xp1=target->x+target->tx(*t_dat);  t_dat++;          
    434                 yp1=target->y+target->ty(*t_dat);  t_dat++;
    435                 xp2=target->x+target->tx(*t_dat);
    436                 yp2=target->y+target->ty(t_dat[1]);
    437 
    438                 x1=subject->x+subject->tx(s_dat[0]); 
    439                 y1=subject->y+subject->ty(s_dat[1]);
    440                 x2=subject->x+subject->tx(s_dat[2]);
    441                 y2=subject->y+subject->ty(s_dat[3]);
    442              
    443 
    444                 // ok, now we know which line segemnts to check for intersection
    445                 // now check to see if (x1,y1-x2,y2) intercest with (xp1,yp1-xp2,yp2)
    446                 int _x2=x2,_y2=y2;           
    447                 setback_intersect(x1, y1, x2, y2, xp1, yp1, xp2, yp2,0);
    448 
    449 
    450                 if (x2!=_x2 || _y2!=y2)
    451                 {
    452                   reciever=target;
    453                   hitx=((x1+x2)/2+(xp1+xp2)/2)/2;
    454                   hity=((y1+y1)/2+(yp1+yp2)/2)/2;
    455                 }
    456               }
    457               s_dat+=2;
    458             }      
    459           }
    460         }
    461       } 
    462     }   
     413        {
     414      try_pushback(subject,target);
     415      if (subject->can_hurt(target))    // see if we can hurt him before calculating
     416      {   
     417        t_centerx=target->x_center();
     418        point_list *s_hit,*t_damage;
     419                 
     420        s_hit=subject->current_figure()->hit;   
     421        t_damage=target->current_figure()->damage;
     422
     423        unsigned char *s_dat=s_hit->data,
     424        *t_dat;
     425        int i,j;
     426        for (i=(int)s_hit->tot-1;i>0 && !hit;i--)
     427        {
     428          for (t_dat=t_damage->data,j=(int)t_damage->tot-1;j>0 && !hit;j--)
     429          {
     430        int32_t x1,y1,x2,y2,          // define the two line segments to check
     431        xp1,yp1,xp2,yp2;
     432
     433        xp1=target->x+target->tx(*t_dat);  t_dat++;   
     434        yp1=target->y+target->ty(*t_dat);  t_dat++;
     435        xp2=target->x+target->tx(*t_dat);
     436        yp2=target->y+target->ty(t_dat[1]);
     437
     438        x1=subject->x+subject->tx(s_dat[0]);
     439        y1=subject->y+subject->ty(s_dat[1]);
     440        x2=subject->x+subject->tx(s_dat[2]);
     441        y2=subject->y+subject->ty(s_dat[3]);
     442   
     443
     444        // ok, now we know which line segemnts to check for intersection
     445        // now check to see if (x1,y1-x2,y2) intercest with (xp1,yp1-xp2,yp2)
     446        int _x2=x2,_y2=y2;   
     447        setback_intersect(x1, y1, x2, y2, xp1, yp1, xp2, yp2,0);
     448
     449
     450        if (x2!=_x2 || _y2!=y2)
     451        {
     452          reciever=target;
     453          hitx=((x1+x2)/2+(xp1+xp2)/2)/2;
     454          hity=((y1+y1)/2+(yp1+yp2)/2)/2;
     455        }
     456          }
     457          s_dat+=2;
     458        }   
     459      }
     460    }
     461      }
     462    }
    463463    if (reciever)
    464464    {
     
    479479  int t=block_total;
    480480  for (;t;t--,blist++)
    481   { 
     481  {
    482482    target=*blist;
    483483    if (target!=subject && (target->total_objects()==0 || target->get_object(0)!=subject))
     
    485485      target->picture_space(tx1,ty1,tx2,ty2);
    486486      if (!((x2<tx1 && x1<tx1) || (x1>tx2 && x2>tx2) ||
    487             (y1>ty2 && y2>ty2) || (y1<ty1 && y2<ty1)))  // are they semi/overlapping?
    488       {         
    489         t_centerx=target->x_center();
    490         boundary *t_damage;
    491         if (target->direction>0)
    492         t_damage=target->current_figure()->f_damage;
    493         else
    494         t_damage=target->current_figure()->b_damage;
    495         unsigned char *t_dat=t_damage->data,*ins=t_damage->inside;
    496         int iter=t_damage->tot-1;
    497         while(iter-->0)
    498         {
    499           int32_t xp1=target->x+target->tx(*t_dat);  t_dat++;        
    500           int32_t yp1=target->y+target->ty(*t_dat);  t_dat++;
    501           int32_t xp2=target->x+target->tx(*t_dat);
    502           int32_t yp2=target->y+target->ty(t_dat[1]);
    503 
    504           // now check to see if (x1,y1-x2,y2) intercest with (xp1,yp1-xp2,yp2)
    505           if (*ins)
    506           {              
    507             if (setback_intersect(x1,y1,x2,y2,xp1,yp1,xp2,yp2,1))
    508             l=target;
    509           }        
    510           else
    511           {
    512             if (setback_intersect(x1,y1,x2,y2,xp1,yp1,xp2,yp2,-1))
    513             l=target;
    514           }        
    515           ins++;
    516          
    517         }        
    518       }     
    519     }   
    520   }
    521   return l;       // return the last person we intersected 
     487        (y1>ty2 && y2>ty2) || (y1<ty1 && y2<ty1)))  // are they semi/overlapping?
     488      {
     489    t_centerx=target->x_center();
     490    boundary *t_damage;
     491    if (target->direction>0)
     492    t_damage=target->current_figure()->f_damage;
     493    else
     494    t_damage=target->current_figure()->b_damage;
     495    unsigned char *t_dat=t_damage->data,*ins=t_damage->inside;
     496    int iter=t_damage->tot-1;
     497    while(iter-->0)
     498    {
     499      int32_t xp1=target->x+target->tx(*t_dat);  t_dat++;   
     500      int32_t yp1=target->y+target->ty(*t_dat);  t_dat++;
     501      int32_t xp2=target->x+target->tx(*t_dat);
     502      int32_t yp2=target->y+target->ty(t_dat[1]);
     503
     504      // now check to see if (x1,y1-x2,y2) intercest with (xp1,yp1-xp2,yp2)
     505      if (*ins)
     506      {             
     507        if (setback_intersect(x1,y1,x2,y2,xp1,yp1,xp2,yp2,1))
     508        l=target;
     509      }   
     510      else
     511      {
     512        if (setback_intersect(x1,y1,x2,y2,xp1,yp1,xp2,yp2,-1))
     513        l=target;
     514      }   
     515      ins++;
     516   
     517    }   
     518      }
     519    }
     520  }
     521  return l;       // return the last person we intersected
    522522}
    523523
     
    531531  int t=all_block_total;
    532532  for (;t;t--,blist++)
    533   { 
     533  {
    534534    target=*blist;
    535535    if (target!=subject && (target->total_objects()==0 || target->get_object(0)!=subject))
     
    537537      target->picture_space(tx1,ty1,tx2,ty2);
    538538      if (!((x2<tx1 && x1<tx1) || (x1>tx2 && x2>tx2) ||
    539             (y1>ty2 && y2>ty2) || (y1<ty1 && y2<ty1)))  // are they semi/overlapping?
    540       {         
    541         t_centerx=target->x_center();
    542         boundary *t_damage;
    543         if (target->direction>0)
    544         t_damage=target->current_figure()->f_damage;
    545         else
    546         t_damage=target->current_figure()->b_damage;
    547         unsigned char *t_dat=t_damage->data,*ins=t_damage->inside;
    548         int iter=t_damage->tot-1;
    549         while(iter-->0)
    550         {
    551           int32_t xp1=target->x+target->tx(*t_dat);  t_dat++;        
    552           int32_t yp1=target->y+target->ty(*t_dat);  t_dat++;
    553           int32_t xp2=target->x+target->tx(*t_dat);
    554           int32_t yp2=target->y+target->ty(t_dat[1]);
    555 
    556           // now check to see if (x1,y1-x2,y2) intercest with (xp1,yp1-xp2,yp2)
    557           if (*ins)
    558           {              
    559             if (setback_intersect(x1,y1,x2,y2,xp1,yp1,xp2,yp2,1))
    560             l=target;
    561           }        
    562           else
    563           {
    564             if (setback_intersect(x1,y1,x2,y2,xp1,yp1,xp2,yp2,-1))
    565             l=target;
    566           }        
    567           ins++;         
    568         }        
    569       }     
    570     }   
    571   }
    572   return l;       // return the last person we intersected 
     539        (y1>ty2 && y2>ty2) || (y1<ty1 && y2<ty1)))  // are they semi/overlapping?
     540      {
     541    t_centerx=target->x_center();
     542    boundary *t_damage;
     543    if (target->direction>0)
     544    t_damage=target->current_figure()->f_damage;
     545    else
     546    t_damage=target->current_figure()->b_damage;
     547    unsigned char *t_dat=t_damage->data,*ins=t_damage->inside;
     548    int iter=t_damage->tot-1;
     549    while(iter-->0)
     550    {
     551      int32_t xp1=target->x+target->tx(*t_dat);  t_dat++;   
     552      int32_t yp1=target->y+target->ty(*t_dat);  t_dat++;
     553      int32_t xp2=target->x+target->tx(*t_dat);
     554      int32_t yp2=target->y+target->ty(t_dat[1]);
     555
     556      // now check to see if (x1,y1-x2,y2) intercest with (xp1,yp1-xp2,yp2)
     557      if (*ins)
     558      {             
     559        if (setback_intersect(x1,y1,x2,y2,xp1,yp1,xp2,yp2,1))
     560        l=target;
     561      }   
     562      else
     563      {
     564        if (setback_intersect(x1,y1,x2,y2,xp1,yp1,xp2,yp2,-1))
     565        l=target;
     566      }   
     567      ins++;   
     568    }   
     569      }
     570    }
     571  }
     572  return l;       // return the last person we intersected
    573573}
    574574
     
    580580  int32_t old_x,old_y;
    581581  current_view=v;
    582  
     582
    583583  game_object *o=first_active;
    584584  for (;o;o=o->next_active)
     
    624624  } else if (current_demo_mode()==DEMO_RECORD)
    625625  {
    626     if (!rcheck) 
     626    if (!rcheck)
    627627    {
    628628      rcheck=open_file("rcheck","wb");
     
    643643    }
    644644  }*/
    645  
     645
    646646  for (o=first_active;o;)
    647   {       
     647  {
    648648    o->last_x=o->x;
    649649    o->last_y=o->y;
     
    655655
    656656      if (c)
    657       {     
    658         area_controller *a,*smallest=NULL;
    659         int32_t smallest_size=0xffffffff;
    660         for (a=area_list;a;a=a->next)
    661           if (o->x>=a->x && o->y>=a->y && o->x<=a->x+a->w && o->y<=a->y+a->h)
    662           {
    663             int32_t size=a->w*a->h;
    664             if (size<smallest_size)
    665             {
    666               smallest=a;
    667               smallest_size=size;
    668             }
    669           }
    670 
    671         if (c->local_player())
    672         {
    673           if (!shutdown_lighting)       // should we initiate a lighting shutdown?
    674           {
    675             if (massive_frame_panic>30)
    676             {
    677               shutdown_lighting=100;
    678               shutdown_lighting_value=c->ambient;
    679             }
    680           } else if (massive_frame_panic)  // do we need brighten towards 63?
    681           {
    682             if (shutdown_lighting_value<63)
    683               shutdown_lighting_value++;
    684           } else if (shutdown_lighting>1)        // delay for some time before turning back on
    685             shutdown_lighting--;
    686           else if (shutdown_lighting_value!=c->ambient) // do we need to lower light toward real ambient?
    687           {
    688             if (abs(shutdown_lighting_value-c->ambient)<4)
    689               shutdown_lighting_value=c->ambient;
    690             else
    691               if (shutdown_lighting_value<c->ambient)
    692                 shutdown_lighting_value+=4;
    693             else if (shutdown_lighting_value>c->ambient)
    694               shutdown_lighting_value-=4;
    695           } else shutdown_lighting=0;                    // back to normal
    696         }
    697 
    698         if (smallest)
    699           c->configure_for_area(smallest);
    700 
    701 
    702         o->move(c->x_suggestion,c->y_suggestion,c->b1_suggestion|(c->b2_suggestion<<1)|
    703                 (c->b3_suggestion<<2));
    704 
    705         if (o->otype!=current_start_type)
    706         {
    707           int32_t fmp=o->fmp();     
    708           int reduce=figures[o->otype]->morph_power;
    709           if (reduce)
    710           {
    711             fmp-=reduce;
    712             o->add_power(fmp>>16);
    713             o->set_fmp(fmp&0xffff);
    714             if (o->mp()<=0)
    715             o->morph_into(current_start_type,NULL,-1,9);
    716           }
    717         }
    718 
    719         l=o;
    720         o=o->next_active;       
     657      {
     658    area_controller *a,*smallest=NULL;
     659    int32_t smallest_size=0xffffffff;
     660    for (a=area_list;a;a=a->next)
     661      if (o->x>=a->x && o->y>=a->y && o->x<=a->x+a->w && o->y<=a->y+a->h)
     662      {
     663        int32_t size=a->w*a->h;
     664        if (size<smallest_size)
     665        {
     666          smallest=a;
     667          smallest_size=size;
     668        }
     669      }
     670
     671    if (c->local_player())
     672    {
     673      if (!shutdown_lighting)       // should we initiate a lighting shutdown?
     674      {
     675        if (massive_frame_panic>30)
     676        {
     677          shutdown_lighting=100;
     678          shutdown_lighting_value=c->ambient;
     679        }
     680      } else if (massive_frame_panic)  // do we need brighten towards 63?
     681      {
     682        if (shutdown_lighting_value<63)
     683          shutdown_lighting_value++;
     684      } else if (shutdown_lighting>1)        // delay for some time before turning back on
     685        shutdown_lighting--;
     686      else if (shutdown_lighting_value!=c->ambient) // do we need to lower light toward real ambient?
     687      {
     688        if (abs(shutdown_lighting_value-c->ambient)<4)
     689          shutdown_lighting_value=c->ambient;
     690        else
     691          if (shutdown_lighting_value<c->ambient)
     692              shutdown_lighting_value+=4;
     693        else if (shutdown_lighting_value>c->ambient)
     694          shutdown_lighting_value-=4;
     695      } else shutdown_lighting=0;                    // back to normal
     696    }
     697
     698    if (smallest)
     699      c->configure_for_area(smallest);
     700
     701
     702    o->move(c->x_suggestion,c->y_suggestion,c->b1_suggestion|(c->b2_suggestion<<1)|
     703        (c->b3_suggestion<<2));
     704
     705    if (o->otype!=current_start_type)
     706    {
     707      int32_t fmp=o->fmp();
     708      int reduce=figures[o->otype]->morph_power;
     709      if (reduce)
     710      {
     711        fmp-=reduce;
     712        o->add_power(fmp>>16);
     713        o->set_fmp(fmp&0xffff);
     714        if (o->mp()<=0)
     715        o->morph_into(current_start_type,NULL,-1,9);
     716      }
     717    }
     718
     719    l=o;
     720    o=o->next_active;
    721721      }
    722722      else if (!o->decide())      // if object returns 0, delete it... I don't like 0's :)
    723723      {
    724         game_object *p=o;
    725         o=o->next_active;
    726         delete_object(p);
    727         cur=NULL;
    728       } else 
    729       {
    730         o=o->next_active;
    731         l=o;
     724    game_object *p=o;
     725    o=o->next_active;
     726    delete_object(p);
     727    cur=NULL;
     728      } else
     729      {
     730    o=o->next_active;
     731    l=o;
    732732      }
    733733    } else
    734734    {
    735735      o=o->next_active;
    736       l=o;     
     736      l=o;
    737737    }
    738738
     
    744744      if (p && p->tot)
    745745        add_attacker(cur);               // if so add him to attack list for later collision detect
    746      
     746
    747747      if (cur->hurtable())                    // add to target list if is hurtable
    748748        add_target(cur);
    749      
     749
    750750    }
    751751
     
    762762    sshot_fcount++;
    763763    if ((sshot_fcount%70)==0)
    764     {   
     764    {
    765765      char name[100];
    766766      sprintf(name,"shot%04d.pcx",screen_shot_on++);
     
    772772}
    773773
    774 void level::set_tick_counter(uint32_t x) 
    775 { 
    776   ctick=x; 
     774void level::set_tick_counter(uint32_t x)
     775{
     776  ctick=x;
    777777}
    778778
     
    788788      c1=morph_sel_frame_color;
    789789      c2=wm->bright_color();
    790     } else 
     790    } else
    791791    {
    792792      c2=morph_sel_frame_color;
    793793      c1=wm->bright_color();
    794794    }
    795    
     795
    796796    the_game->game_to_mouse(a->x,a->y,v,sx1,sy1);
    797797    the_game->game_to_mouse(a->x+a->w,a->y+a->h,v,sx2,sy2);
     
    817817
    818818  clear_tmp();
    819 } 
     819}
    820820
    821821void calc_bgsize(uint16_t fgw, uint16_t  fgh, uint16_t  &bgw, uint16_t  &bgh)
    822822{
    823823  bgw=fgw/ASPECT+8;
    824   bgh=fgh/ASPECT+8; 
    825 }
    826 
    827 
    828 void level::set_size(int w, int h) 
     824  bgh=fgh/ASPECT+8;
     825}
     826
     827
     828void level::set_size(int w, int h)
    829829{
    830830  if (w*h>200000)
    831831  {
    832832    the_game->show_help(symbol_str("too_big"));
    833     return ; 
     833    return ;
    834834  }
    835835
     
    839839
    840840  int x,y,miny=(h<fg_height)? h : fg_height,minx=(w<fg_width)? w : fg_width;
    841  
     841
    842842  uint16_t nbw,nbh;
    843843  calc_bgsize(w,h,nbw,nbh);
    844  
     844
    845845  new_bg=(uint16_t *)jmalloc((int)nbw*(int)nbh*sizeof(int16_t),"map bg : resized");
    846846  memset(new_bg,0,(int)nbw*(int)nbh*sizeof(int16_t));
     
    864864  fg_height=h;
    865865  bg_height=nbh;
    866   bg_width=nbw; 
     866  bg_width=nbw;
    867867
    868868  char msg[80];
     
    881881      return 0;
    882882    else return 1;
    883   } 
     883  }
    884884  return 0;
    885885}
     
    897897    fp->seek(se->offset,0);
    898898    /******************************* Read debug info ******************************/
    899     int16_t old_tot=fp->read_uint16(); 
    900     uint16_t *o_remap=(uint16_t *)jmalloc(old_tot*2,"obj remap array");   
    901     char old_name[150];     
     899    int16_t old_tot=fp->read_uint16();
     900    uint16_t *o_remap=(uint16_t *)jmalloc(old_tot*2,"obj remap array");
     901    char old_name[150];
    902902    for (i=0;i<old_tot;i++)
    903903    {
     
    905905      for (o_remap[i]=0xffff,j=0;j<total_objects;j++)  // check for matching current name
    906906      {
    907         if (!strcmp(old_name,object_names[j]))
     907    if (!strcmp(old_name,object_names[j]))
    908908          o_remap[i]=j;
    909909      }
     
    919919      s_remap[i]=stopped;           // non exsitant states get mapped into stopped state
    920920      for (j=0;j<MAX_STATE;j++)                  // see if old state exist now
    921         if (!strcmp(state_names[j],old_name))
     921    if (!strcmp(state_names[j],old_name))
    922922         s_remap[i]=j;
    923923    }
    924     total_objs=fp->read_uint32();   
     924    total_objs=fp->read_uint32();
    925925
    926926    se=sd->find("type");
     
    931931      if (fp->read_uint8()==RC_16)    //  read type array, this should be type RC_16
    932932      {
    933         for (i=0;i<total_objs;i++)
    934         {
    935           uint16_t t=fp->read_uint16();
    936           game_object *p=new game_object(o_remap[t],1);
    937           clear_tmp();
    938           if (!first) first=p; else last->next=p;
    939           last=p; p->next=NULL;           
    940         }
    941 
    942        
    943         se=sd->find("state");
    944         if (se)
    945         {
    946           fp->seek(se->offset,0);
    947           if (fp->read_uint8()==RC_16)    //  read state array, this should be type RC_16
    948           {
    949             game_object *l=first;
    950             for (i=0;i<total_objs;i++,l=l->next)
    951             {
    952               character_state s=(character_state)s_remap[fp->read_uint16()];
    953               if (l->otype!=0xffff)
    954               {
    955                 if (l->has_sequence((character_state)s))
    956                   l->state=s;
    957                 else l->state=stopped;
    958                 l->current_frame=0;
    959               }
    960             }
    961           }
    962         }
    963 
    964         int frame_var=0;
    965         int i=0;
    966         for (;i<TOTAL_OBJECT_VARS;i++)
    967           if (!strcmp(object_descriptions[i].name,"cur_frame"))
    968             frame_var=i;
    969            
    970         int j=0;
    971         for (;j<default_simple.total_vars();j++)
    972         {
    973           spec_entry *se=sd->find(object_descriptions[j].name);
    974           if (se)
    975           {
    976             fp->seek(se->offset,0);
    977             int t=object_descriptions[j].type;
    978             if (fp->read_uint8()!=t)
    979               dprintf("Warning : load level -> var '%s' size changed\n");
    980             else
    981             {
    982               game_object *f=first;
    983               for (;f;f=f->next)
    984               {       
    985                 switch (t)
    986                 {
    987                   case RC_8 : f->set_var(j,fp->read_uint8()); break;
    988                   case RC_16 : f->set_var(j,fp->read_uint16()); break;
    989                   case RC_32 : f->set_var(j,fp->read_uint32()); break;
    990                 }
    991 
    992                 // check to make sure the frame number is not out of bounds from the time
    993                 // it was last saved
    994                 if (j==frame_var)
    995                 {
    996                   if (f->otype!=0xffff && f->current_frame>=
    997                       figures[f->otype]->get_sequence(f->state)->length())
    998                     f->current_frame=0;
    999                 }
    1000               }
    1001             }       
    1002           } else dprintf("Warning : load level -> no previous var %s\n",default_simple.var_name(j));
    1003         }
    1004       }
    1005     }
     933    for (i=0;i<total_objs;i++)
     934    {
     935      uint16_t t=fp->read_uint16();
     936      game_object *p=new game_object(o_remap[t],1);
     937      clear_tmp();
     938      if (!first) first=p; else last->next=p;
     939      last=p; p->next=NULL;       
     940    }
     941
     942
     943    se=sd->find("state");
     944    if (se)
     945    {
     946      fp->seek(se->offset,0);
     947      if (fp->read_uint8()==RC_16)    //  read state array, this should be type RC_16
     948      {
     949        game_object *l=first;
     950        for (i=0;i<total_objs;i++,l=l->next)
     951        {
     952          character_state s=(character_state)s_remap[fp->read_uint16()];
     953          if (l->otype!=0xffff)
     954          {
     955        if (l->has_sequence((character_state)s))
     956          l->state=s;
     957        else l->state=stopped;
     958        l->current_frame=0;
     959          }
     960        }
     961      }
     962    }
     963
     964    int frame_var=0;
     965    int i=0;
     966    for (;i<TOTAL_OBJECT_VARS;i++)
     967      if (!strcmp(object_descriptions[i].name,"cur_frame"))
     968        frame_var=i;
    1006969   
    1007    
     970    int j=0;
     971    for (;j<default_simple.total_vars();j++)
     972    {
     973      spec_entry *se=sd->find(object_descriptions[j].name);
     974      if (se)
     975      {
     976        fp->seek(se->offset,0);
     977        int t=object_descriptions[j].type;
     978        if (fp->read_uint8()!=t)
     979          dprintf("Warning : load level -> var '%s' size changed\n");
     980        else
     981        {
     982          game_object *f=first;
     983          for (;f;f=f->next)
     984          {   
     985        switch (t)
     986        {
     987          case RC_8 : f->set_var(j,fp->read_uint8()); break;
     988          case RC_16 : f->set_var(j,fp->read_uint16()); break;
     989          case RC_32 : f->set_var(j,fp->read_uint32()); break;
     990        }
     991
     992        // check to make sure the frame number is not out of bounds from the time
     993        // it was last saved
     994        if (j==frame_var)
     995        {
     996          if (f->otype!=0xffff && f->current_frame>=
     997              figures[f->otype]->get_sequence(f->state)->length())
     998            f->current_frame=0;
     999        }
     1000          }
     1001        }   
     1002      } else dprintf("Warning : load level -> no previous var %s\n",default_simple.var_name(j));
     1003    }
     1004      }
     1005    }
     1006
     1007
    10081008
    10091009    jfree(o_remap);
    10101010    jfree(s_remap);
    1011   } 
    1012  
     1011  }
     1012
    10131013}
    10141014
     
    10171017void level::load_objects(spec_directory *sd, bFILE *fp)
    10181018{
    1019   spec_entry *se=sd->find("object_descripitions"); 
     1019  spec_entry *se=sd->find("object_descripitions");
    10201020  total_objs=0;
    10211021  first=last=first_active=NULL;
     
    10341034      return ;
    10351035
    1036     uint16_t *o_remap=(uint16_t *)jmalloc(old_tot*2,"obj remap array");   
    1037     uint16_t *o_backmap=(uint16_t *)jmalloc(total_objects*2,"obj remap array");   
     1036    uint16_t *o_remap=(uint16_t *)jmalloc(old_tot*2,"obj remap array");
     1037    uint16_t *o_backmap=(uint16_t *)jmalloc(total_objects*2,"obj remap array");
    10381038    memset(o_backmap,0xff,total_objects*2);
    1039     char old_name[150];     
     1039    char old_name[150];
    10401040    for (i=0;i<old_tot;i++)
    10411041    {
     
    10431043      for (o_remap[i]=0xffff,j=0;j<total_objects;j++)  // check for matching current name
    10441044      {
    1045         if (!strcmp(old_name,object_names[j]))
    1046         {
     1045    if (!strcmp(old_name,object_names[j]))
     1046    {
    10471047          o_remap[i]=j;
    1048           o_backmap[j]=i;
    1049         }
    1050       }
    1051     }   
     1048      o_backmap[j]=i;
     1049    }
     1050      }
     1051    }
    10521052
    10531053    se=sd->find("describe_states");
     
    10641064      {
    10651065        s_remap[i]=(int16_t *)jmalloc(t*sizeof(int16_t),"state remap");
    1066         int j=0;
    1067         for (;j<t;j++)
    1068           *(s_remap[i]+j)=stopped;    // if no remap found, then go to stopped state
     1066    int j=0;
     1067    for (;j<t;j++)
     1068      *(s_remap[i]+j)=stopped;    // if no remap found, then go to stopped state
    10691069      }
    10701070      else s_remap[i]=0;
     
    10731073      for (;j<t;j++)
    10741074      {
    1075         fp->read(old_name,fp->read_uint8());
    1076         int new_type=o_remap[i];       
    1077         if (new_type<total_objects)     // make sure old object still exsist
    1078         {
    1079           int k=0;
    1080           for (;k<figures[new_type]->ts;k++)
    1081           {
    1082             if (figures[new_type]->seq[k] &&
    1083                !strcmp(lstring_value(symbol_name(figures[new_type]->seq_syms[k])),old_name))
    1084             *(s_remap[i]+j)=k;
    1085           }
    1086         }
     1075    fp->read(old_name,fp->read_uint8());
     1076    int new_type=o_remap[i];   
     1077    if (new_type<total_objects)     // make sure old object still exsist
     1078    {
     1079      int k=0;
     1080      for (;k<figures[new_type]->ts;k++)
     1081      {
     1082        if (figures[new_type]->seq[k] &&
     1083           !strcmp(lstring_value(symbol_name(figures[new_type]->seq_syms[k])),old_name))
     1084        *(s_remap[i]+j)=k;
     1085      }
     1086    }
    10871087      }
    10881088    }
     
    11011101      for (;i<old_tot;i++)
    11021102      {
    1103         int16_t t=fp->read_uint16();
    1104         v_remap_totals[i]=t;
    1105         if (t)
    1106         {
    1107           v_remap[i]=(int16_t *)jmalloc(t*sizeof(int16_t),"var remap");
    1108           memset(v_remap[i],0xff,t*sizeof(int16_t));
    1109         } else { v_remap[i]=NULL; }
    1110         int j=0;
    1111         for (;j<t;j++)
    1112         {
    1113           fp->read(old_name,fp->read_uint8());
    1114           int new_type=o_remap[i];
    1115           if (new_type!=0xffff)        // make sure old object still exsist
    1116           {
    1117             int k=0;
    1118             for (;k<figures[new_type]->tiv;k++)
    1119             {
    1120               if (figures[new_type]->vars[k])
    1121               {
    1122                 if (!strcmp(lstring_value(symbol_name(figures[new_type]->vars[k])),old_name))
    1123                   *(v_remap[i]+j)=figures[new_type]->var_index[k];
    1124               }
    1125             }
    1126           }
    1127         }
     1103    int16_t t=fp->read_uint16();
     1104    v_remap_totals[i]=t;
     1105    if (t)
     1106    {
     1107      v_remap[i]=(int16_t *)jmalloc(t*sizeof(int16_t),"var remap");
     1108      memset(v_remap[i],0xff,t*sizeof(int16_t));
     1109    } else { v_remap[i]=NULL; }
     1110    int j=0;
     1111    for (;j<t;j++)
     1112    {
     1113      fp->read(old_name,fp->read_uint8());
     1114      int new_type=o_remap[i];
     1115      if (new_type!=0xffff)        // make sure old object still exsist
     1116      {
     1117        int k=0;
     1118        for (;k<figures[new_type]->tiv;k++)
     1119        {
     1120          if (figures[new_type]->vars[k])
     1121          {
     1122        if (!strcmp(lstring_value(symbol_name(figures[new_type]->vars[k])),old_name))
     1123          *(v_remap[i]+j)=figures[new_type]->var_index[k];
     1124          }
     1125        }
     1126      }
     1127    }
    11281128      }
    11291129      load_vars=1;
    11301130    }
    1131    
     1131
    11321132    se=sd->find("object_list");
    11331133    if (se)
    11341134    {
    1135       total_objs=fp->read_uint32();   
     1135      total_objs=fp->read_uint32();
    11361136
    11371137      se=sd->find("type");
    11381138      if (se)
    11391139      {
    1140         fp->seek(se->offset,0);
    1141         last=NULL;
    1142         if (fp->read_uint8()==RC_16)    //  read type array, this should be type RC_16
    1143         {
    1144           int i=0;
    1145           for (;i<total_objs;i++)
    1146           {
    1147             uint16_t t=fp->read_uint16();
    1148             game_object *p=new game_object(o_remap[t],1);
    1149             clear_tmp();
    1150             if (!first) first=p; else last->next=p;
    1151             last=p; p->next=NULL;                 
    1152           }
    1153        
    1154           se=sd->find("state");
    1155           if (se)
    1156           {
    1157             fp->seek(se->offset,0);
    1158             if (fp->read_uint8()==RC_16)    //  read state array, this should be type RC_16
    1159             {
    1160               game_object *l=first;
    1161               for (i=0;i<total_objs;i++,l=l->next)
    1162               {
    1163                 int st=fp->read_uint16();
    1164                 if (l->otype==0xffff)
    1165                   l->state=stopped;
    1166                 else
    1167                 {
    1168                   character_state s=(character_state)(*(s_remap[o_backmap[l->otype]]+st));
    1169                   if (l->has_sequence((character_state)s))
    1170                     l->state=s;
    1171                   else l->state=stopped;
    1172                   l->current_frame=0;
    1173                 }
    1174               }
    1175             }
    1176           }
    1177        
    1178           se=sd->find("lvars");
    1179           if (se && load_vars)
    1180           {
    1181             fp->seek(se->offset,0);
    1182             int abort=0;
    1183             game_object *o=first;
    1184             for (;o && !abort;o=o->next)
    1185             {
    1186               int16_t ot=fp->read_uint16();
    1187               int k=0;
    1188               for (;k<ot;k++)
    1189               {
    1190                 if (fp->read_uint8()!=RC_32) abort=1;
    1191                 else
    1192                 {
    1193                   int32_t v=fp->read_uint32();
    1194                   if (o->otype!=0xffff)     // non-exstant object
    1195                   {
    1196                     int remap=*(v_remap[o_backmap[o->otype]]+k);
    1197                     if (remap!=-1 && figures[o->otype]->tiv>=k)
    1198                     {
    1199                       o->lvars[remap]=v;       
    1200                     }
    1201                   }
    1202                 }
    1203               }
    1204             }
    1205           }
    1206 
    1207           int frame_var=0;
    1208           for (i=0;i<TOTAL_OBJECT_VARS;i++)
    1209             if (!strcmp(object_descriptions[i].name,"cur_frame"))
    1210               frame_var=i;
    1211            
    1212 
    1213           int j=0;
    1214           for (;j<default_simple.total_vars();j++)
    1215           {
    1216             spec_entry *se=sd->find(object_descriptions[j].name);
    1217             if (se)
    1218             {
    1219               fp->seek(se->offset,0);
    1220               int t=object_descriptions[j].type;
    1221               if (fp->read_uint8()!=t)
    1222                 dprintf("Warning : load level -> var '%s' size changed\n");
    1223               else
    1224               {
    1225                 game_object *f=first;
    1226                 for (;f;f=f->next)
    1227                 {             
    1228                   switch (t)
    1229                   {
    1230                     case RC_8 :
    1231                     { f->set_var(j,fp->read_uint8()); } break;
    1232                     case RC_16 :
    1233                     { f->set_var(j,fp->read_uint16()); } break;
    1234                     case RC_32 :
    1235                     { f->set_var(j,fp->read_uint32()); } break;
    1236                   }
    1237                  
    1238                   // check to make sure the frame number is not out of bounds from the time
    1239                   // it was last saved
    1240                   if (j==frame_var)
    1241                   {
    1242                     if (f->otype!=0xffff && f->current_frame>=
    1243                         figures[f->otype]->get_sequence(f->state)->length())
    1244                     f->current_frame=0;
    1245                   }
    1246                 }
    1247               }     
    1248             } else dprintf("Warning : load level -> no previous var %s\n",default_simple.var_name(j));
    1249           }
    1250         }
    1251       }
    1252     }
     1140    fp->seek(se->offset,0);
     1141    last=NULL;
     1142    if (fp->read_uint8()==RC_16)    //  read type array, this should be type RC_16
     1143    {
     1144      int i=0;
     1145      for (;i<total_objs;i++)
     1146      {
     1147        uint16_t t=fp->read_uint16();
     1148        game_object *p=new game_object(o_remap[t],1);
     1149        clear_tmp();
     1150        if (!first) first=p; else last->next=p;
     1151        last=p; p->next=NULL;       
     1152      }
     1153
     1154      se=sd->find("state");
     1155      if (se)
     1156      {
     1157        fp->seek(se->offset,0);
     1158        if (fp->read_uint8()==RC_16)    //  read state array, this should be type RC_16
     1159        {
     1160          game_object *l=first;
     1161          for (i=0;i<total_objs;i++,l=l->next)
     1162          {
     1163        int st=fp->read_uint16();
     1164        if (l->otype==0xffff)
     1165          l->state=stopped;
     1166        else
     1167        {
     1168          character_state s=(character_state)(*(s_remap[o_backmap[l->otype]]+st));
     1169          if (l->has_sequence((character_state)s))
     1170                l->state=s;
     1171          else l->state=stopped;
     1172          l->current_frame=0;
     1173        }
     1174          }
     1175        }
     1176      }
    12531177   
     1178      se=sd->find("lvars");
     1179      if (se && load_vars)
     1180      {
     1181        fp->seek(se->offset,0);
     1182        int abort=0;
     1183        game_object *o=first;
     1184        for (;o && !abort;o=o->next)
     1185        {
     1186          int16_t ot=fp->read_uint16();
     1187          int k=0;
     1188          for (;k<ot;k++)
     1189          {
     1190        if (fp->read_uint8()!=RC_32) abort=1;
     1191        else
     1192        {
     1193          int32_t v=fp->read_uint32();
     1194          if (o->otype!=0xffff)     // non-exstant object
     1195          {
     1196            int remap=*(v_remap[o_backmap[o->otype]]+k);
     1197            if (remap!=-1 && figures[o->otype]->tiv>=k)
     1198            {
     1199              o->lvars[remap]=v;
     1200            }
     1201          }
     1202        }
     1203          }
     1204        }
     1205      }
     1206
     1207      int frame_var=0;
     1208      for (i=0;i<TOTAL_OBJECT_VARS;i++)
     1209        if (!strcmp(object_descriptions[i].name,"cur_frame"))
     1210          frame_var=i;
     1211   
     1212
     1213      int j=0;
     1214      for (;j<default_simple.total_vars();j++)
     1215      {
     1216        spec_entry *se=sd->find(object_descriptions[j].name);
     1217        if (se)
     1218        {
     1219          fp->seek(se->offset,0);
     1220          int t=object_descriptions[j].type;
     1221          if (fp->read_uint8()!=t)
     1222            dprintf("Warning : load level -> var '%s' size changed\n");
     1223          else
     1224          {
     1225        game_object *f=first;
     1226        for (;f;f=f->next)
     1227        {   
     1228          switch (t)
     1229          {
     1230            case RC_8 :
     1231            { f->set_var(j,fp->read_uint8()); } break;
     1232            case RC_16 :
     1233            { f->set_var(j,fp->read_uint16()); } break;
     1234            case RC_32 :
     1235            { f->set_var(j,fp->read_uint32()); } break;
     1236          }
     1237       
     1238          // check to make sure the frame number is not out of bounds from the time
     1239          // it was last saved
     1240          if (j==frame_var)
     1241          {
     1242            if (f->otype!=0xffff && f->current_frame>=
     1243            figures[f->otype]->get_sequence(f->state)->length())
     1244            f->current_frame=0;
     1245          }
     1246        }
     1247          }   
     1248        } else dprintf("Warning : load level -> no previous var %s\n",default_simple.var_name(j));
     1249      }
     1250    }
     1251      }
     1252    }
     1253
    12541254    int k=0;
    12551255    for (;k<old_tot;k++)
     
    12711271    jfree(s_remap);
    12721272    jfree(v_remap);
    1273   } 
    1274  
     1273  }
     1274
    12751275}
    12761276
     
    13091309  } else
    13101310  {
    1311     first_name=(char *)jmalloc(strlen(Name)+1,"level first name");   
     1311    first_name=(char *)jmalloc(strlen(Name)+1,"level first name");
    13121312    strcpy(first_name,Name);
    13131313  }
     
    13171317
    13181318  if (e)
    1319   {   
     1319  {
    13201320    fp->seek(e->offset,0);
    13211321    fg_width=fp->read_uint32();
     
    13431343    int t=bg_width*bg_height;
    13441344    uint16_t *map=map_bg;
    1345     while (t) { *map=lstl(*map); map++; t--; } 
     1345    while (t) { *map=lstl(*map); map++; t--; }
    13461346  } else
    13471347  {
     
    13691369  /***************** Check map for non exsistant tiles **************************/
    13701370  int32_t i,w;
    1371   uint16_t *m; 
     1371  uint16_t *m;
    13721372  spec_entry *load_all=sd->find("player_info");
    13731373  for (i=0,w=fg_width*fg_height,m=map_fg;i<w;i++,m++)
     
    13761376      (*m)=(*m)&(~0x8000);    // clear the has-seen bit on the tile
    13771377
    1378     if (fgvalue(*m)>=nforetiles || foretiles[fgvalue(*m)]<0) 
    1379       *m=0; 
     1378    if (fgvalue(*m)>=nforetiles || foretiles[fgvalue(*m)]<0)
     1379      *m=0;
    13801380  }
    13811381
    13821382  for (i=0,w=bg_width*bg_height,m=map_bg;i<w;i++,m++)
    13831383  {
    1384     if ( (bgvalue(*m)>=nbacktiles) || backtiles[bgvalue(*m)]<0) 
    1385        *m=0; 
     1384    if ( (bgvalue(*m)>=nbacktiles) || backtiles[bgvalue(*m)]<0)
     1385       *m=0;
    13861386  }
    13871387
     
    13951395  object_node *players,*objs;
    13961396  players=make_player_onodes();
    1397   objs=make_not_list(players); 
     1397  objs=make_not_list(players);
    13981398
    13991399
     
    14191419    level *old=current_level;
    14201420    current_level=this;
    1421    
     1421
    14221422    object_node *list=NULL;
    14231423    list=make_not_list(list);     // create a list of the object list in case objects change positions
     
    14471447     ["object_states"]  2(total),<2=number,1,name>
    14481448
    1449      ["object_lvars"]   2(total),<1(type),1,name>   
     1449     ["object_lvars"]   2(total),<1(type),1,name>
    14501450   }
    14511451
    14521452  [object_list]
    1453    4 total_objects   
     1453   4 total_objects
    14541454   for(1..total_objects)
    14551455   {
     
    14691469  {
    14701470    *s2=*s1;
    1471     if (*s1=='.') dot=s2;   
     1471    if (*s1=='.') dot=s2;
    14721472  }
    14731473  if (dot) s2=dot+1;
    14741474
    1475   *(s2++)='c'; 
    1476   *(s2++)='p'; 
    1477   *(s2++)='f'; 
     1475  *(s2++)='c';
     1476  *(s2++)='p';
     1477  *(s2++)='f';
    14781478  *s2=0;
    14791479}
     
    15041504    }
    15051505  }
    1506  
     1506
    15071507/*  if (DEFINEDP(symbol_function(l_level_loaded)))
    15081508  {
     
    15211521
    15221522bFILE *level::create_dir(char *filename, int save_all,
    1523                         object_node *save_list, object_node *exclude_list)
     1523            object_node *save_list, object_node *exclude_list)
    15241524{
    15251525  spec_directory sd;
     
    15271527  if (first_name)
    15281528    sd.add_by_hand(new spec_entry(SPEC_DATA_ARRAY,"first name",NULL,strlen(first_name)+2,0));
    1529    
     1529
    15301530
    15311531
     
    15391539
    15401540  sd.add_by_hand(new spec_entry(SPEC_DATA_ARRAY,"area_list.v1",NULL,1+ta*(4*11)+4,0));
    1541  
     1541
    15421542  sd.add_by_hand(new spec_entry(SPEC_DATA_ARRAY,"tick_counter",NULL,1+4,0));
    15431543
     
    15551555
    15561556
    1557   size=0;                               
    1558   for (i=0;i<total_objects;i++) 
     1557  size=0;
     1558  for (i=0;i<total_objects;i++)
    15591559  {
    15601560    size+=2;  // total number of states
     
    15691569
    15701570  size=0;
    1571   for (i=0;i<total_objects;i++) 
     1571  for (i=0;i<total_objects;i++)
    15721572  {
    15731573    size+=2;  // total number of variables
     
    15791579  sd.add_by_hand(new spec_entry(SPEC_DATA_ARRAY,"describe_lvars",NULL,size,0));
    15801580
    1581  
     1581
    15821582
    15831583  // how many objects are we goint to save, use a int32_t to specify how many
    1584   sd.add_by_hand(new spec_entry(SPEC_DATA_ARRAY,"object_list",NULL,4,0)); 
    1585  
     1584  sd.add_by_hand(new spec_entry(SPEC_DATA_ARRAY,"object_list",NULL,4,0));
     1585
    15861586  int32_t t=0;
    15871587  object_node *o=save_list;
     
    16021602  for (i=0;i<TOTAL_OBJECT_VARS;i++)
    16031603    sd.add_by_hand(new spec_entry(SPEC_DATA_ARRAY,object_descriptions[i].name,NULL,1+
    1604                           RC_type_size(object_descriptions[i].type)*t,0));
     1604              RC_type_size(object_descriptions[i].type)*t,0));
    16051605
    16061606  add_light_spec(&sd,Name);
     
    16141614    t=0;
    16151615    view *v=player_list;
    1616     for (;v;v=v->next) t++; 
     1616    for (;v;v=v->next) t++;
    16171617    sd.add_by_hand(new spec_entry(SPEC_DATA_ARRAY,"player_info",NULL,t*4+4,0));
    16181618
     
    16521652  char buf[80];
    16531653
    1654   strftime(buf,80,"%T %A %B %d",localtime(&t)); 
     1654  strftime(buf,80,"%T %A %B %d",localtime(&t));
    16551655  wm->font()->put_string(i,80-strlen(buf)*wm->font()->width()/2,100+wm->font()->height(),buf);
    16561656
     
    16701670  int32_t t=0;
    16711671  view *v=player_list;
    1672   for (;v;v=v->next) t++; 
     1672  for (;v;v=v->next) t++;
    16731673  fp->write_uint32(t);
    16741674
     
    17221722
    17231723    for (v=player_list;v;v=v->next)
    1724       if (v->local_player()) 
     1724      if (v->local_player())
    17251725         my_player_number=v->player_number;
    17261726
     
    17321732        if (v->focus->controller())
    17331733         v->focus->set_controller(NULL);
    1734         delete v->focus;
     1734    delete v->focus;
    17351735      }
    17361736
     
    17421742    view *last=NULL;
    17431743    int i=0;
    1744     for (;i<total_players;i++)   
     1744    for (;i<total_players;i++)
    17451745    {
    17461746      game_object *o=number_to_object_in_list(fp->read_uint32(),save_list);
     
    17541754    if (set_first_view)
    17551755      the_game->first_view=player_list;
    1756    
     1756
    17571757    for (i=0;i<total_view_vars();i++)
    17581758    {
     
    17621762      if (se)
    17631763      {
    1764         fp->seek(se->offset,0);
    1765         if (fp->read_uint8()==RC_32)
    1766         {
    1767           for (v=player_list;v;v=v->next)
     1764    fp->seek(se->offset,0);
     1765    if (fp->read_uint8()==RC_32)
     1766    {
     1767      for (v=player_list;v;v=v->next)
    17681768            v->set_view_var_value(i,fp->read_uint32());
    1769         }
    1770       } else 
    1771       {
    1772         for (v=player_list;v;v=v->next)
    1773           v->set_view_var_value(i,0);
     1769    }
     1770      } else
     1771      {
     1772    for (v=player_list;v;v=v->next)
     1773        v->set_view_var_value(i,0);
    17741774      }
    17751775    }
     
    17891789      if (fp->read_uint8()==RC_32)
    17901790      {
    1791         int32_t m=fp->read_uint32();  // read how many weapons exsisted when last saved
    1792         int i;
    1793         for (v=player_list;v;v=v->next)  
    1794         {
    1795           for (i=0;i<m;i++)
    1796           {
    1797             int32_t x=fp->read_uint32();
    1798             if (i<total_weapons)
    1799             {
    1800               v->weapons[i]=x;
    1801               v->last_weapons[i]=x;
    1802             }
    1803           }
    1804         }
    1805       }
    1806     }  else 
    1807     { 
    1808       for (v=player_list;v;v=v->next)    
    1809       {
    1810         memset(v->last_weapons,0xff,total_weapons*sizeof(int32_t));
    1811         memset(v->weapons,0xff,total_weapons*sizeof(int32_t));
     1791    int32_t m=fp->read_uint32();  // read how many weapons exsisted when last saved
     1792    int i;
     1793    for (v=player_list;v;v=v->next)   
     1794    {
     1795      for (i=0;i<m;i++)
     1796      {
     1797        int32_t x=fp->read_uint32();
     1798        if (i<total_weapons)
     1799        {
     1800          v->weapons[i]=x;
     1801          v->last_weapons[i]=x;
     1802        }
     1803      }
     1804    }
     1805      }
     1806    }  else
     1807    {
     1808      for (v=player_list;v;v=v->next)   
     1809      {
     1810    memset(v->last_weapons,0xff,total_weapons*sizeof(int32_t));
     1811    memset(v->weapons,0xff,total_weapons*sizeof(int32_t));
    18121812      }
    18131813    }
     
    18171817    {
    18181818      fp->seek(se->offset,0);
    1819       for (v=player_list;v;v=v->next)    
    1820       {
    1821         uint8_t len=fp->read_uint8();
    1822         fp->read(v->name,len);
     1819      for (v=player_list;v;v=v->next)   
     1820      {
     1821    uint8_t len=fp->read_uint8();
     1822    fp->read(v->name,len);
    18231823      }
    18241824    }
     
    18261826    ret=1;
    18271827    recalc_local_view_space();
    1828    
    1829   } else 
     1828
     1829  } else
    18301830  {
    18311831    void *fun=make_find_symbol("set_player_defaults");
    18321832    if (DEFINEDP(symbol_function(fun)))
    1833     {     
     1833    {
    18341834      view *f;
    18351835      game_object *o=current_object;
    18361836      for (f=player_list;f;f=f->next)
    18371837      {
    1838         if (f->focus)
    1839         {
    1840           current_object=f->focus;
    1841           void *m=mark_heap(TMP_SPACE);
    1842           eval_function((lisp_symbol *)fun,NULL);
    1843           restore_heap(m,TMP_SPACE);
    1844         }
    1845       } 
     1838    if (f->focus)
     1839    {
     1840      current_object=f->focus;
     1841      void *m=mark_heap(TMP_SPACE);
     1842      eval_function((lisp_symbol *)fun,NULL);
     1843      restore_heap(m,TMP_SPACE);
     1844    }
     1845      }   
    18461846      current_object=o;
    18471847    }
     
    18551855    {
    18561856      vw->suggest.send_weapon_change=1;
    1857       vw->suggest.new_weapon=0;     
     1857      vw->suggest.new_weapon=0;
    18581858    }
    18591859  }
     
    18671867  // record information in the file about what the data structures look like
    18681868  // right now, so if they change later, they don't get get screwed up
    1869   fp->write_uint16(total_objects);   // mark how many objects we know about right now 
     1869  fp->write_uint16(total_objects);   // mark how many objects we know about right now
    18701870
    18711871  int i=0;
    18721872  for (;i<total_objects;i++)   // loop through all the object types we know of
    1873   {   
    1874     fp->write_uint8(strlen(object_names[i])+1);                    // sizeof name   
     1873  {
     1874    fp->write_uint8(strlen(object_names[i])+1);                    // sizeof name
    18751875    fp->write(object_names[i],strlen(object_names[i])+1);      // write object name
    18761876  }
    1877    
     1877
    18781878
    18791879  // write state numbers and names for each object
     
    18891889      if (figures[i]->seq[j])
    18901890      {
    1891         char *state_name=lstring_value(symbol_name(figures[i]->seq_syms[j]));
    1892         fp->write_uint8(strlen(state_name)+1);
    1893         fp->write(state_name,strlen(state_name)+1);
    1894       }
    1895   }
    1896 
    1897  
     1891    char *state_name=lstring_value(symbol_name(figures[i]->seq_syms[j]));
     1892    fp->write_uint8(strlen(state_name)+1);
     1893    fp->write(state_name,strlen(state_name)+1);
     1894      }
     1895  }
     1896
     1897
    18981898  // write object lvar names
    18991899  for (i=0;i<total_objects;i++)
     
    19011901    fp->write_uint16(figures[i]->tv);
    19021902    int j,x;
    1903    
     1903
    19041904    for (x=0;x<figures[i]->tv;x++)
    19051905    {
     
    19071907      {
    19081908        if (figures[i]->vars[j] && figures[i]->var_index[j]==x)
    1909         {
    1910           char *var_name=lstring_value(symbol_name(figures[i]->vars[j]));
    1911           fp->write_uint8(strlen(var_name)+1);
    1912           fp->write(var_name,strlen(var_name)+1);
    1913         }
    1914       }
    1915     }
    1916   }
    1917  
     1909    {
     1910      char *var_name=lstring_value(symbol_name(figures[i]->vars[j]));
     1911      fp->write_uint8(strlen(var_name)+1);
     1912      fp->write(var_name,strlen(var_name)+1);
     1913    }
     1914      }
     1915    }
     1916  }
     1917
    19181918  int32_t t=0;
    19191919  object_node *o=save_list;
     
    19231923
    19241924  fp->write_uint8(RC_16);                                    // save type info for each record
    1925   for (o=save_list;o;o=o->next) fp->write_uint16(o->me->type());   
     1925  for (o=save_list;o;o=o->next) fp->write_uint16(o->me->type());
    19261926
    19271927  fp->write_uint8(RC_16);                                    // save state info for each record
     
    19311931  {
    19321932    fp->write_uint16(figures[o->me->otype]->tv);
    1933     for (i=0;i<figures[o->me->otype]->tv;i++) 
     1933    for (i=0;i<figures[o->me->otype]->tv;i++)
    19341934    {
    19351935      fp->write_uint8(RC_32);                           // for now the only type allowed is int32_t
     
    19451945    {
    19461946      switch (t)
    1947       {        
    1948         case RC_8 :
    1949         { fp->write_uint8(o->me->get_var(i)); } break;
    1950         case RC_16 :
    1951         { fp->write_uint16(o->me->get_var(i)); } break;
    1952         case RC_32 :
    1953         { fp->write_uint32(o->me->get_var(i)); } break;
     1947      {    
     1948    case RC_8 :
     1949    { fp->write_uint8(o->me->get_var(i)); } break;
     1950    case RC_16 :
     1951    { fp->write_uint16(o->me->get_var(i)); } break;
     1952    case RC_32 :
     1953    { fp->write_uint32(o->me->get_var(i)); } break;
    19541954      }
    19551955    }
     
    19761976void level::write_links(bFILE *fp, object_node *save_list, object_node *exclude_list)
    19771977{
    1978   fp->write_uint8(RC_32); 
     1978  fp->write_uint8(RC_32);
    19791979  fp->write_uint32(total_object_links(save_list));
    19801980
     
    19881988    {
    19891989      fp->write_uint32(x);
    1990       int32_t x=object_to_number_in_list(o->me->get_object(i),save_list); 
     1990      int32_t x=object_to_number_in_list(o->me->get_object(i),save_list);
    19911991      if (x)
    19921992        fp->write_uint32(x);
     
    19961996  }
    19971997
    1998   fp->write_uint8(RC_32); 
     1998  fp->write_uint8(RC_32);
    19991999  fp->write_uint32(total_light_links(save_list));
    20002000
     
    20132013
    20142014
    2015 void level::load_links(bFILE *fp, spec_directory *sd, 
    2016                        object_node *save_list, object_node *exclude_list)
     2015void level::load_links(bFILE *fp, spec_directory *sd,
     2016               object_node *save_list, object_node *exclude_list)
    20172017{
    20182018  spec_entry *se=sd->find("object_links");
     
    20252025      while (t)
    20262026      {
    2027         int32_t x1=fp->read_uint32();
    2028         CONDITION(x1>=0,"expected x1 for object link to be > 0\n");
    2029         int32_t x2=fp->read_uint32();
    2030         game_object *p,*q=number_to_object_in_list(x1,save_list);
    2031         if (x2>0)
    2032           p=number_to_object_in_list(x2,save_list);
    2033         else p=number_to_object_in_list(-x2,exclude_list);
    2034         if (q)
    2035           q->add_object(p);
    2036         else dprintf("bad object link\n");
    2037 
    2038         t--;
    2039       } 
     2027    int32_t x1=fp->read_uint32();
     2028    CONDITION(x1>=0,"expected x1 for object link to be > 0\n");
     2029    int32_t x2=fp->read_uint32();
     2030    game_object *p,*q=number_to_object_in_list(x1,save_list);
     2031    if (x2>0)
     2032      p=number_to_object_in_list(x2,save_list);
     2033    else p=number_to_object_in_list(-x2,exclude_list);
     2034    if (q)
     2035      q->add_object(p);
     2036    else dprintf("bad object link\n");
     2037
     2038    t--;
     2039      }
    20402040    }
    20412041  }
     
    20502050      while (t)
    20512051      {
    2052         int32_t x1=fp->read_uint32();
    2053         int32_t x2=fp->read_uint32();
    2054         game_object *p=number_to_object_in_list(x1,save_list);
    2055         if (p)
    2056           p->add_light(number_to_light(x2));
    2057         else dprintf("bad object/light link\n");
    2058         t--;
    2059       } 
     2052    int32_t x1=fp->read_uint32();
     2053    int32_t x2=fp->read_uint32();
     2054    game_object *p=number_to_object_in_list(x1,save_list);
     2055    if (p)
     2056      p->add_light(number_to_light(x2));
     2057    else dprintf("bad object/light link\n");
     2058    t--;
     2059      }
    20602060    }
    20612061  }
     
    21252125      for (;i<ta;i++)
    21262126      {
    2127         int32_t x,y,w,h;
    2128         x=fp->read_uint32();
    2129         y=fp->read_uint32();
    2130         w=fp->read_uint32();
    2131         h=fp->read_uint32();   
    2132         p=new area_controller(x,y,w,h,NULL);
    2133         if (l) l->next=p;
    2134         else area_list=p;
    2135         l=p;
    2136         p->active=fp->read_uint32();
    2137         p->ambient=fp->read_uint32();
    2138         p->view_xoff=fp->read_uint32();
    2139         p->view_yoff=fp->read_uint32();
    2140         p->ambient_speed=fp->read_uint32();
    2141         p->view_xoff_speed=fp->read_uint32();
    2142         p->view_yoff_speed=fp->read_uint32();
     2127    int32_t x,y,w,h;
     2128    x=fp->read_uint32();
     2129    y=fp->read_uint32();
     2130    w=fp->read_uint32();
     2131    h=fp->read_uint32();   
     2132    p=new area_controller(x,y,w,h,NULL);
     2133    if (l) l->next=p;
     2134    else area_list=p;
     2135    l=p;
     2136    p->active=fp->read_uint32();
     2137    p->ambient=fp->read_uint32();
     2138    p->view_xoff=fp->read_uint32();
     2139    p->view_yoff=fp->read_uint32();
     2140    p->ambient_speed=fp->read_uint32();
     2141    p->view_xoff_speed=fp->read_uint32();
     2142    p->view_yoff_speed=fp->read_uint32();
    21432143      }
    21442144    }
     
    21492149  {
    21502150    fp->seek(se->offset,0);
    2151     if (fp->read_uint8()==RC_32)   
     2151    if (fp->read_uint8()==RC_32)
    21522152      set_tick_counter(fp->read_uint32());
    21532153    else set_tick_counter(0);
     
    22012201int level::save(char const *filename, int save_all)
    22022202{
    2203         char name[255], bkname[255];
    2204 
    2205         sprintf( name, "%s%s", get_save_filename_prefix(), filename );
    2206         sprintf( bkname, "%slevsave.bak", get_save_filename_prefix() );
    2207         if( !save_all && DEFINEDP( symbol_value( l_keep_backup ) ) &&
    2208                 symbol_value( l_keep_backup ) )   // make a backup
    2209         {
    2210                 bFILE *fp = open_file( name, "rb" );    // does file already exist?
    2211                 if( !fp->open_failure() )
    2212                 {
    2213                         unlink( bkname );
    2214                         bFILE *bk = open_file( bkname, "wb" );
    2215                         if( bk->open_failure() )
    2216                                 dprintf("unable to open backup file %s\n", bkname );
    2217                         else
    2218                         {
    2219                                 int32_t size = fp->file_size();
    2220                                 uint8_t *buf = (uint8_t *)jmalloc(0x1000,"copy buf");
    2221                                 int tr = 1;
    2222                                 while( size && tr )
    2223                                 {
    2224                                         int tr = fp->read(buf,0x1000);
    2225                                         if( tr )
    2226                                         tr = bk->write(buf,tr);
    2227                                         size -= tr;
    2228                                 }
    2229                                 jfree(buf);
    2230                         }
    2231                         delete bk;
     2203    char name[255], bkname[255];
     2204
     2205    sprintf( name, "%s%s", get_save_filename_prefix(), filename );
     2206    sprintf( bkname, "%slevsave.bak", get_save_filename_prefix() );
     2207    if( !save_all && DEFINEDP( symbol_value( l_keep_backup ) ) &&
     2208        symbol_value( l_keep_backup ) )   // make a backup
     2209    {
     2210        bFILE *fp = open_file( name, "rb" );    // does file already exist?
     2211        if( !fp->open_failure() )
     2212        {
     2213            unlink( bkname );
     2214            bFILE *bk = open_file( bkname, "wb" );
     2215            if( bk->open_failure() )
     2216                dprintf("unable to open backup file %s\n", bkname );
     2217            else
     2218            {
     2219                int32_t size = fp->file_size();
     2220                uint8_t *buf = (uint8_t *)jmalloc(0x1000,"copy buf");
     2221                int tr = 1;
     2222                while( size && tr )
     2223                {
     2224                    int tr = fp->read(buf,0x1000);
     2225                    if( tr )
     2226                    tr = bk->write(buf,tr);
     2227                    size -= tr;
     2228                }
     2229                jfree(buf);
     2230            }
     2231            delete bk;
    22322232#if (defined(__MACH__) || !defined(__APPLE__))
    2233                         chmod( bkname, S_IRWXU | S_IRWXG | S_IRWXO );
     2233            chmod( bkname, S_IRWXU | S_IRWXG | S_IRWXO );
    22342234#endif
    2235                 }
    2236                 delete fp;
    2237         }
    2238 
    2239         // if we are not doing a savegame then change the first_name to this name
    2240         if( !save_all )
    2241         {
    2242                 if( first_name )
    2243                         jfree(first_name);
    2244                 first_name = (char *)jmalloc( strlen( name ) + 1, "level first name" );
    2245                 strcpy( first_name, name );
    2246         }
    2247 
    2248         object_node *players, *objs;
    2249         if( save_all )
    2250                 players = NULL;
    2251         else
    2252                 players = make_player_onodes();
    2253 
    2254         objs = make_not_list(players);     // negate the above list
    2255 
    2256         bFILE *fp = create_dir( name, save_all, objs, players);
    2257         if( fp != NULL )
    2258         {
    2259                 if( !fp->open_failure() )
    2260                 {
    2261                         if( first_name )
    2262                         {
    2263                                 fp->write_uint8( strlen( first_name ) + 1 );
    2264                                 fp->write( first_name, strlen( first_name ) + 1 );
    2265                         }
    2266                         else
    2267                         {
    2268                                 fp->write_uint8( 1 );
    2269                                 fp->write_uint8( 0 );
    2270                         }
    2271 
    2272                         fp->write_uint32( fg_width );
    2273                         fp->write_uint32( fg_height );
    2274 
    2275                         int t  = fg_width * fg_height;
    2276                         uint16_t *rm = map_fg;
    2277                         for (;t;t--,rm++)
    2278                         {
    2279                                 uint16_t x = *rm;
    2280                                 x = lstl(x);            // convert to intel endianess
    2281                                 *rm = x;
    2282                         }
    2283 
    2284                         fp->write( (char *)map_fg, 2 * fg_width * fg_height );
    2285                         t = fg_width * fg_height;
    2286                         rm = map_fg;
    2287                         for (;t;t--,rm++)
    2288                         {
    2289                                 uint16_t x = *rm;
    2290                                 x = lstl( x );            // convert to intel endianess
    2291                                 *rm = x;
    2292                         }
    2293 
    2294                         fp->write_uint32( bg_width );
    2295                         fp->write_uint32( bg_height );
    2296                         t = bg_width * bg_height;
    2297                         rm = map_bg;
    2298 
    2299                         for (;t;t--,rm++)
    2300                         {
    2301                                 uint16_t x=*rm;
    2302                                 x = lstl( x );          // convert to intel endianess
    2303                                 *rm = x;
    2304                         }
    2305 
    2306                         fp->write( (char *)map_bg, 2 * bg_width * bg_height );
    2307                         rm = map_bg;
    2308                         t = bg_width*bg_height;
    2309 
    2310                         for (;t;t--,rm++)
    2311                         {
    2312                                 uint16_t x = *rm;
    2313                                 x = lstl( x );          // convert to intel endianess
    2314                                 *rm = x;
    2315                         }
    2316 
    2317                         write_options( fp );
    2318                         write_objects( fp, objs );
    2319                         write_lights( fp );
    2320                         write_links( fp, objs, players );
    2321                         if( save_all )
    2322                         {
    2323                                 write_player_info( fp, objs );
    2324                                 write_thumb_nail( fp,screen );
    2325                         }
    2326 
    2327                         delete fp;
     2235        }
     2236        delete fp;
     2237    }
     2238
     2239    // if we are not doing a savegame then change the first_name to this name
     2240    if( !save_all )
     2241    {
     2242        if( first_name )
     2243            jfree(first_name);
     2244        first_name = (char *)jmalloc( strlen( name ) + 1, "level first name" );
     2245        strcpy( first_name, name );
     2246    }
     2247
     2248    object_node *players, *objs;
     2249    if( save_all )
     2250        players = NULL;
     2251    else
     2252        players = make_player_onodes();
     2253
     2254    objs = make_not_list(players);     // negate the above list
     2255
     2256    bFILE *fp = create_dir( name, save_all, objs, players);
     2257    if( fp != NULL )
     2258    {
     2259        if( !fp->open_failure() )
     2260        {
     2261            if( first_name )
     2262            {
     2263                fp->write_uint8( strlen( first_name ) + 1 );
     2264                fp->write( first_name, strlen( first_name ) + 1 );
     2265            }
     2266            else
     2267            {
     2268                fp->write_uint8( 1 );
     2269                fp->write_uint8( 0 );
     2270            }
     2271
     2272            fp->write_uint32( fg_width );
     2273            fp->write_uint32( fg_height );
     2274
     2275            int t  = fg_width * fg_height;
     2276            uint16_t *rm = map_fg;
     2277            for (;t;t--,rm++)
     2278            {
     2279                uint16_t x = *rm;
     2280                x = lstl(x);            // convert to intel endianess
     2281                *rm = x;
     2282            }
     2283
     2284            fp->write( (char *)map_fg, 2 * fg_width * fg_height );
     2285            t = fg_width * fg_height;
     2286            rm = map_fg;
     2287            for (;t;t--,rm++)
     2288            {
     2289                uint16_t x = *rm;
     2290                x = lstl( x );            // convert to intel endianess
     2291                *rm = x;
     2292            }
     2293
     2294            fp->write_uint32( bg_width );
     2295            fp->write_uint32( bg_height );
     2296            t = bg_width * bg_height;
     2297            rm = map_bg;
     2298
     2299            for (;t;t--,rm++)
     2300            {
     2301                uint16_t x=*rm;
     2302                x = lstl( x );        // convert to intel endianess
     2303                *rm = x;
     2304            }
     2305
     2306            fp->write( (char *)map_bg, 2 * bg_width * bg_height );
     2307            rm = map_bg;
     2308            t = bg_width*bg_height;
     2309
     2310            for (;t;t--,rm++)
     2311            {
     2312                uint16_t x = *rm;
     2313                x = lstl( x );        // convert to intel endianess
     2314                *rm = x;
     2315            }
     2316
     2317            write_options( fp );
     2318            write_objects( fp, objs );
     2319            write_lights( fp );
     2320            write_links( fp, objs, players );
     2321            if( save_all )
     2322            {
     2323                write_player_info( fp, objs );
     2324                write_thumb_nail( fp,screen );
     2325            }
     2326
     2327            delete fp;
    23282328#if (defined(__MACH__) || !defined(__APPLE__))
    2329                         chmod( name, S_IRWXU | S_IRWXG | S_IRWXO );
     2329            chmod( name, S_IRWXU | S_IRWXG | S_IRWXO );
    23302330#endif
    2331                         write_cache_prof_info();
    2332                 }
    2333                 else
    2334                 {
    2335                         the_game->show_help( "Unable to open file for saving\n" );
    2336                         delete fp;
    2337                         return 0;
    2338                 }
    2339         }
    2340         else
    2341         {
    2342                 the_game->show_help( "Unable to open file for saving.\n" );
    2343                 printf( "\nFailed to save game.\n" );
    2344                 printf( "I was trying to save to: '%s'\n\tPath: '%s'\n\tFile: '%s'\n", name, get_save_filename_prefix(), filename );
    2345                 printf( "\nPlease send an email to:\n\ttrandor@labyrinth.net.au\nwith these details.\nThanks.\n" );
    2346                 return 0;
    2347         }
    2348 
    2349         delete_object_list(players);
    2350         delete_object_list(objs);
    2351 
    2352         return 1;
     2331            write_cache_prof_info();
     2332        }
     2333        else
     2334        {
     2335            the_game->show_help( "Unable to open file for saving\n" );
     2336            delete fp;
     2337            return 0;
     2338        }
     2339    }
     2340    else
     2341    {
     2342        the_game->show_help( "Unable to open file for saving.\n" );
     2343        printf( "\nFailed to save game.\n" );
     2344        printf( "I was trying to save to: '%s'\n\tPath: '%s'\n\tFile: '%s'\n", name, get_save_filename_prefix(), filename );
     2345        printf( "\nPlease send an email to:\n\ttrandor@labyrinth.net.au\nwith these details.\nThanks.\n" );
     2346        return 0;
     2347    }
     2348
     2349    delete_object_list(players);
     2350    delete_object_list(objs);
     2351
     2352    return 1;
    23532353}
    23542354
     
    23702370  all_block_list=NULL;
    23712371  all_block_list_size=all_block_total=0;
    2372  
     2372
    23732373  Name=NULL;
    23742374  first_name=NULL;
     
    23762376  set_name(name);
    23772377  first=first_active=NULL;
    2378  
     2378
    23792379  fg_width=width;
    23802380  fg_height=height;
    23812381  calc_bgsize(fg_width,fg_height,bg_width,bg_height);
    2382  
     2382
    23832383  map_bg=(uint16_t *)jmalloc(sizeof(int16_t)*bg_width*bg_height,"map bg");
    23842384  map_fg=(uint16_t *)jmalloc(sizeof(int16_t)*fg_width*fg_height,"map fg");
     
    23892389  memset(map_fg,0,sizeof(int16_t)*fg_width*fg_height);
    23902390
    2391   int i; 
     2391  int i;
    23922392  for (i=0;i<fg_width;i++)
    2393   {   
     2393  {
    23942394    map_fg[i]=1;
    23952395    map_fg[fg_width*(fg_height-1)+i]=1;
    23962396  }
    23972397  for (i=0;i<fg_height;i++)
    2398   {   
     2398  {
    23992399    map_fg[fg_width*i]=1;
    24002400    map_fg[fg_width*i+fg_width-1]=1;
    24012401  }
    2402  
    2403   total_objs=0; 
     2402
     2403  total_objs=0;
    24042404  insert_players();
    24052405}
     
    24592459      for (j=i;j<block_total;j++)
    24602460        block_list[j]=block_list[j+1];
    2461     } else o++;   
     2461    } else o++;
    24622462  }
    24632463}
     
    24772477      for (j=i;j<all_block_total;j++)
    24782478        all_block_list[j]=all_block_list[j+1];
    2479     } else o++;   
     2479    } else o++;
    24802480  }
    24812481}
     
    25052505
    25062506
    2507   if (first_active==who) 
     2507  if (first_active==who)
    25082508    first_active=who->next_active;
    25092509  else
     
    25242524      for (;i<t;i++)
    25252525        if (o->get_object(i)==who)
    2526         {
    2527           o->remove_object(who);
    2528           t=o->total_objects();
    2529         }
     2526    {
     2527      o->remove_object(who);
     2528      t=o->total_objects();
     2529    }
    25302530    }
    25312531  }
     
    25372537      remove_block(who);
    25382538      remove_all_block(who);
    2539     } else if (who->hurtable()) 
     2539    } else if (who->hurtable())
    25402540      remove_all_block(who);
    25412541  }
     
    25492549}
    25502550
    2551 void level::to_front(game_object *o)  // move to end of list, so we are drawn last, therefore top 
     2551void level::to_front(game_object *o)  // move to end of list, so we are drawn last, therefore top
    25522552{
    25532553  if (o==last) return ;
    25542554  first_active=NULL;     // make sure nothing goes screwy with the active list
    25552555
    2556   if (o==first) 
    2557     first=first->next; 
     2556  if (o==first)
     2557    first=first->next;
    25582558  else
    25592559  {
     
    25702570
    25712571void level::to_back(game_object *o)   // to make the character drawn in back, put at front of list
    2572 { 
     2572{
    25732573  if (o==first) return;
    2574   first_active=NULL;     // make sure nothing goes screwy with the active list 
    2575  
     2574  first_active=NULL;     // make sure nothing goes screwy with the active list
     2575
    25762576  game_object *w=first;
    25772577  for (;w && w->next!=o;w=w->next);
     
    25922592game_object *level::find_object(int32_t x, int32_t y)
    25932593{
    2594   int32_t x1,y1,x2,y2; 
     2594  int32_t x1,y1,x2,y2;
    25952595  game_object *o=first;
    25962596  for (;o;o=o->next)
    25972597  {
    2598     o->picture_space(x1,y1,x2,y2);   
     2598    o->picture_space(x1,y1,x2,y2);
    25992599    if (x<x2 && x>=x1 && y<y2 && y>=y1)
    26002600      return o;
    26012601  }
    2602   return NULL; 
     2602  return NULL;
    26032603}
    26042604
     
    26172617  int32_t tl=the_game->ftile_width(),th=the_game->ftile_height(),
    26182618    j,
    2619     xp1,yp1,xp2,yp2,    // starting and ending points of block line segment 
     2619    xp1,yp1,xp2,yp2,    // starting and ending points of block line segment
    26202620    swap;               // temp var
    26212621  int32_t blockx1,blocky1,blockx2,blocky2,block,bx,by;
     
    26362636
    26372637  if (blockx2>=foreground_width()) { x2=tl*foreground_width()-1; }
    2638   if (blocky2>=foreground_height()) { y2=th*foreground_height()-1; } 
     2638  if (blocky2>=foreground_height()) { y2=th*foreground_height()-1; }
    26392639  blockx1=max(blockx1,0);
    2640   blocky1=max(blocky1,0); 
     2640  blocky1=max(blocky1,0);
    26412641
    26422642  if ((blockx1>blockx2) || (blocky1>blocky2)) return ;
     
    26562656        bdat=block_list->data;
    26572657        unsigned char *ins=f->points->inside;
    2658         int32_t xo=bx*tl,yo=by*th;
     2658    int32_t xo=bx*tl,yo=by*th;
    26592659        for (j=0;j<total-1;j++,ins++)
    26602660        {
    26612661          // find the starting and ending points for this segment
    2662           xp1=xo+remapx(*bdat);
    2663           bdat++;
    2664 
    2665           yp1=yo+remapy(*bdat);
    2666           bdat++;
    2667 
    2668           xp2=xo+remapx(*bdat);
    2669           yp2=yo+remapy(bdat[1]);
    2670 
    2671 
    2672           int32_t ox2=x2,oy2=y2;
    2673           if (*ins)      
    2674             setback_intersect(x1,y1,x2,y2,xp1,yp1,xp2,yp2,1); 
     2662      xp1=xo+remapx(*bdat);
     2663      bdat++;
     2664
     2665      yp1=yo+remapy(*bdat);
     2666      bdat++;
     2667
     2668      xp2=xo+remapx(*bdat);
     2669      yp2=yo+remapy(bdat[1]);
     2670
     2671
     2672      int32_t ox2=x2,oy2=y2;
     2673          if (*ins)   
     2674            setback_intersect(x1,y1,x2,y2,xp1,yp1,xp2,yp2,1);
    26752675          else
    2676             setback_intersect(x1,y1,x2,y2,xp1,yp1,xp2,yp2,-1); 
    2677           if (ox2!=x2 || oy2!=y2)
    2678           {
    2679             last_tile_hit_x=bx;
    2680             last_tile_hit_y=by;
    2681           }
    2682 
    2683         }       
    2684       }
    2685     }
    2686   } 
     2676            setback_intersect(x1,y1,x2,y2,xp1,yp1,xp2,yp2,-1);
     2677      if (ox2!=x2 || oy2!=y2)
     2678      {
     2679        last_tile_hit_x=bx;
     2680        last_tile_hit_y=by;
     2681      }
     2682
     2683        }
     2684      }
     2685    }
     2686  }
    26872687}
    26882688
     
    27012701  {
    27022702    blocky1=y2/th;
    2703     blocky2=y1/th;   
     2703    blocky2=y1/th;
    27042704    y_addback=blocky2*f_hi;
    27052705  } else
     
    27462746
    27472747      int32_t oy2=y2;
    2748       if (*ins)  
    2749         setback_intersect(checkx,y1,checkx,y2,xp1,yp1,xp2,yp2,1); 
     2748      if (*ins)   
     2749        setback_intersect(checkx,y1,checkx,y2,xp1,yp1,xp2,yp2,1);
    27502750      else
    2751         setback_intersect(checkx,y1,checkx,y2,xp1,yp1,xp2,yp2,-1); 
     2751        setback_intersect(checkx,y1,checkx,y2,xp1,yp1,xp2,yp2,-1);
    27522752      if (oy2!=y2)
    27532753      {
    2754         last_tile_hit_x=bx;
    2755         last_tile_hit_y=by;
     2754    last_tile_hit_x=bx;
     2755    last_tile_hit_y=by;
    27562756      }
    27572757    }
     
    27682768    game_object *o=first_active;
    27692769    for (;o;o=o->next_active)
    2770       o->recieve_signal(signal); 
     2770      o->recieve_signal(signal);
    27712771  }
    27722772}
     
    27752775int level::crush(game_object *by_who, int xamount, int yamount)
    27762776{
    2777   int32_t xv,yv,crushed=0; 
     2777  int32_t xv,yv,crushed=0;
    27782778  game_object *o=first_active;
    27792779  for (;o;o=o->next_active)
    27802780  {
    27812781    if (o->hurtable() && o!=by_who)
    2782     {     
     2782    {
    27832783      xv=-xamount;
    2784       yv=-yamount;   
     2784      yv=-yamount;
    27852785      if (o->try_move(o->x,o->y,xv,yv,3)==by_who)
    2786       {     
    2787         xv=xamount;
    2788         yv=yamount;
    2789         o->try_move(o->x,o->y,xv,yv,3);
    2790         if (xv==0 && yv==0)
    2791         {
    2792           if (o->state!=dead && o->state!=dieing)
    2793             o->do_damage(by_who->current_figure()->hit_damage,by_who,o->x,o->y,0,0);
    2794 
    2795 /*        {          
    2796             if (o->has_sequence(dieing))
    2797               o->set_state(dieing);
    2798             else o->set_state(dead);
    2799               o->hp=0;     
    2800           }         */
    2801           crushed=1;     
    2802         }
    2803       }   
    2804     }   
    2805   }
    2806 
    2807   return crushed; 
     2786      {
     2787    xv=xamount;
     2788    yv=yamount;
     2789    o->try_move(o->x,o->y,xv,yv,3);
     2790    if (xv==0 && yv==0)
     2791    {
     2792      if (o->state!=dead && o->state!=dieing)
     2793        o->do_damage(by_who->current_figure()->hit_damage,by_who,o->x,o->y,0,0);
     2794
     2795/*      {   
     2796        if (o->has_sequence(dieing))
     2797          o->set_state(dieing);
     2798        else o->set_state(dead);
     2799          o->hp=0;   
     2800      }        */
     2801      crushed=1;   
     2802    }
     2803      }
     2804    }
     2805  }
     2806
     2807  return crushed;
    28082808}
    28092809
     
    28142814  int32_t xv,yv;
    28152815  game_object *o=first_active;
    2816   for (;o;o=o->next_active) 
    2817   {
    2818     if (o->is_playable() && o->state!=dieing && o->state!=dead) 
    2819     {     
    2820       // check to see if the platform is going up and will run into us.     
     2816  for (;o;o=o->next_active)
     2817  {
     2818    if (o->is_playable() && o->state!=dieing && o->state!=dead)
     2819    {
     2820      // check to see if the platform is going up and will run into us.
    28212821      int32_t tvx,tvy;
    28222822      if (yamount<0)
    28232823      {
    2824         tvx=-xamount;
    2825         tvy=-yamount;
    2826         if (o->try_move(o->x,o->y,tvx,tvy,1)==by_who)
    2827         {
    2828           o->x+=tvx;
    2829           o->y+=tvy;       
    2830         }
    2831       }
    2832 
    2833 /*      xv=xamount;   
     2824    tvx=-xamount;
     2825    tvy=-yamount;
     2826    if (o->try_move(o->x,o->y,tvx,tvy,1)==by_who)
     2827    {
     2828      o->x+=tvx;
     2829      o->y+=tvy;
     2830    }
     2831      }
     2832
     2833/*      xv=xamount;
    28342834      yv=yamount;
    28352835      tvx,tvy;
     
    28382838      if (o->try_move(o->x,o->y,tvx,tvy,1)==by_who)  // we the platform hit us?
    28392839      {
    2840         o->x+=tvx;
    2841         o->y+=tvy;       
     2840    o->x+=tvx;
     2841    o->y+=tvy;
    28422842      }*/
    28432843
    2844       xv=0;   
     2844      xv=0;
    28452845      yv=2;
    28462846      if (o->try_move(o->x,o->y,xv,yv,1)==by_who)  // are we standing on the platform?
    2847       {     
    2848         by_who->x=-by_who->x;
    2849         xv=xamount;
    2850         yv=yamount;
    2851         o->try_move(o->x,o->y,xv,yv,3);
    2852         if (xv!=xamount || yv!=yamount) failed=1;
    2853         o->x+=xv;
    2854         o->y+=yv;
    2855         by_who->x=-by_who->x;
    2856       }   
    2857     }   
     2847      {
     2848    by_who->x=-by_who->x;
     2849    xv=xamount;
     2850    yv=yamount;
     2851    o->try_move(o->x,o->y,xv,yv,3);
     2852    if (xv!=xamount || yv!=yamount) failed=1;
     2853    o->x+=xv;
     2854    o->y+=yv;
     2855    by_who->x=-by_who->x;
     2856      }
     2857    }
    28582858  }
    28592859  return !failed;
     
    28652865  int failed=0;
    28662866  game_object *o=first_active;
    2867   for (;o;o=o->next_active) 
    2868   {
    2869     if ((o->is_playable() || o->pushable()) && o->state!=dieing && o->state!=dead) 
    2870     {     
    2871       xv=-xamount;   
     2867  for (;o;o=o->next_active)
     2868  {
     2869    if ((o->is_playable() || o->pushable()) && o->state!=dieing && o->state!=dead)
     2870    {
     2871      xv=-xamount;
    28722872      yv=-yamount;
    28732873      int32_t tvx,tvy;
     
    28752875      if (yv>0) tvy=yv+1; else if (yv<0) tvx=yv-1; else tvy=0;
    28762876      if (o->try_move(o->x+xamount,o->y+yamount,tvx,tvy,3)==by_who)
    2877       {     
    2878         xv=(xamount-tvx);
    2879         yv=(yamount-tvy);
    2880         o->try_move(o->x,o->y,xv,yv,3);       
    2881         o->x+=xv;
    2882         o->y+=yv;
    2883         if (xv!=xamount-tvx || yv!=yamount-tvy)
    2884           failed=1;
    2885       }   
    2886     }   
     2877      {
     2878    xv=(xamount-tvx);
     2879    yv=(yamount-tvy);
     2880    o->try_move(o->x,o->y,xv,yv,3);
     2881    o->x+=xv;
     2882    o->y+=yv;
     2883    if (xv!=xamount-tvx || yv!=yamount-tvy)
     2884      failed=1;
     2885      }
     2886    }
    28872887  }
    28882888  return !failed;
     
    28942894  game_object *find=NULL;
    28952895  game_object *o=first_active;
    2896   for (;o;o=o->next_active) 
     2896  for (;o;o=o->next_active)
    28972897  {
    28982898    if (o->otype==type)
     
    29022902
    29032903      if (x_dist<xd  && y_dist<find_ydist)
    2904       {   
    2905         find_ydist=y_dist;
    2906         find=o;
     2904      {
     2905    find_ydist=y_dist;
     2906    find=o;
    29072907      }
    29082908    }
     
    29172917  game_object *find=NULL;
    29182918  game_object *o=first_active;
    2919   for (;o;o=o->next_active) 
     2919  for (;o;o=o->next_active)
    29202920  {
    29212921    if (o->otype==type && o!=who)
     
    29242924      if (x_dist<find_xdist)
    29252925      {
    2926         find_xdist=x_dist;
    2927         find_ydist=abs(y-o->y);
    2928         find=o;
     2926    find_xdist=x_dist;
     2927    find_ydist=abs(y-o->y);
     2928    find=o;
    29292929      }
    29302930      else if (x_dist==find_xdist)
    29312931      {
    2932         int y_dist=abs(y-o->y);
    2933         if (y_dist<find_ydist)
    2934         {
    2935           find_ydist=y_dist;
    2936           find=o;
    2937         }
     2932    int y_dist=abs(y-o->y);
     2933    if (y_dist<find_ydist)
     2934    {
     2935      find_ydist=y_dist;
     2936      find=o;
     2937    }
    29382938      }
    29392939    }
     
    29472947  game_object *find=NULL;
    29482948  game_object *o=first_active;
    2949   for (;o;o=o->next_active) 
     2949  for (;o;o=o->next_active)
    29502950  {
    29512951    if (o->otype==type && o!=who)
     
    29542954      if (d<find_dist)
    29552955      {
    2956         find=o;
    2957         find_dist=d;
     2956    find=o;
     2957    find_dist=d;
    29582958      }
    29592959    }
     
    29752975      for (;i<t;i++)
    29762976        if (o->get_light(i)==which)
    2977           o->remove_light(o->get_light(i));
     2977      o->remove_light(o->get_light(i));
    29782978    }
    29792979  }
     
    29912991    {
    29922992      if (!skip)
    2993         return o;     
     2993        return o;
    29942994      skip--;
    29952995      l=o;
     
    29992999}
    30003000
    3001 void level::hurt_radius(int32_t x, int32_t y,int32_t r, int32_t m, game_object *from, game_object *exclude, 
    3002                         int max_push)
     3001void level::hurt_radius(int32_t x, int32_t y,int32_t r, int32_t m, game_object *from, game_object *exclude,
     3002            int max_push)
    30033003{
    30043004  if (r<1) return ;   // avoid dev vy zero
     
    30253025      {
    30263026
    3027         int px=(r-cx)*max_push/r,py=(r-cy1)*max_push/r;
    3028         if (o->x<x)
     3027    int px=(r-cx)*max_push/r,py=(r-cy1)*max_push/r;
     3028    if (o->x<x)
    30293029          px=-px;
    3030         if (o->y<y)
     3030    if (o->y<y)
    30313031          py=-py;
    3032         o->do_damage((r-d1)*m/r,from,x,y1,px,py);
     3032    o->do_damage((r-d1)*m/r,from,x,y1,px,py);
    30333033      }
    30343034
     
    30573057    for (n=first;ctry && n;n=n->next)
    30583058    {
    3059       if (n->otype==start_position_type) 
    3060       {
    3061         o=n;
     3059      if (n->otype==start_position_type)
     3060      {
     3061    o=n;
    30623062        ctry--;
    30633063      }
     
    30673067    view *v=player_list;
    30683068    for (;v;v=v->next)
    3069     { 
     3069    {
    30703070      if (v!=exclude)
    30713071      {
    3072         int32_t cx=abs(v->x_center()-o->x),cy=abs(v->y_center()-o->y),d;
    3073         if (cx<cy)
     3072    int32_t cx=abs(v->x_center()-o->x),cy=abs(v->y_center()-o->y),d;
     3073    if (cx<cy)
    30743074          d=cx+cy-(cx>>1);
    3075         else d=cx+cy-(cy>>1);
    3076         if (d<min_player_dist) too_close=1;
     3075    else d=cx+cy-(cy>>1);
     3076    if (d<min_player_dist) too_close=1;
    30773077      }
    30783078    }
     
    30983098
    30993099  view *f=player_list;
    3100   for (;f;f=f->next) 
    3101   {
    3102     game_object *st=find_type(start,f->player_number); 
     3100  for (;f;f=f->next)
     3101  {
     3102    game_object *st=find_type(start,f->player_number);   
    31033103    if (st)
    31043104    {
     
    31183118    attack_list_size++;
    31193119    attack_list=(game_object **)jrealloc(attack_list,sizeof(game_object *)*attack_list_size,
    3120                                                       "attack_list");   
     3120                              "attack_list");
    31213121  }
    31223122  attack_list[attack_total]=who;
     
    31323132    target_list_size++;
    31333133    target_list=(game_object **)jrealloc(target_list,sizeof(game_object *)*target_list_size,
    3134                                                       "target_list");   
     3134                              "target_list");
    31353135  }
    31363136  target_list[target_total]=who;
     
    31463146    block_list_size++;
    31473147    block_list=(game_object **)jrealloc(block_list,sizeof(game_object *)*block_list_size,
    3148                                                       "block_list");   
     3148                              "block_list");
    31493149  }
    31503150  block_list[block_total]=who;
     
    31593159    all_block_list_size++;
    31603160    all_block_list=(game_object **)jrealloc(all_block_list,sizeof(game_object *)*all_block_list_size,
    3161                                                       "all_block_list");   
     3161                              "all_block_list");
    31623162  }
    31633163  all_block_list[all_block_total]=who;
     
    31673167
    31683168game_object *level::find_object_in_area(int32_t x, int32_t y, int32_t x1, int32_t y1, int32_t x2, int32_t y2,
    3169                                      Cell *list, game_object *exclude)
     3169                     Cell *list, game_object *exclude)
    31703170{
    31713171  game_object *closest=NULL;
     
    31853185      if (!NILP(v))
    31863186      {
    3187         xo=abs(o->x-x);
    3188         yo=abs(o->y-y);
    3189         distance=xo*xo+yo*yo;
    3190         if (distance<closest_distance)
    3191         {
    3192           closest_distance=distance;
    3193           closest=o;
    3194         }
     3187    xo=abs(o->x-x);
     3188    yo=abs(o->y-y);
     3189    distance=xo*xo+yo*yo;
     3190    if (distance<closest_distance)
     3191    {
     3192      closest_distance=distance;
     3193      closest=o;
     3194    }
    31953195      }
    31963196    }
     
    32033203
    32043204game_object *level::find_object_in_angle(int32_t x, int32_t y, int32_t start_angle, int32_t end_angle,
    3205                                     void *list, game_object *exclude)
     3205                    void *list, game_object *exclude)
    32063206{
    32073207  game_object *closest=NULL;
     
    32123212    int32_t angle=lisp_atan2(o->y-y,o->x-x);
    32133213    if (((start_angle<=end_angle && (angle>=start_angle && angle<=end_angle))
    3214         || (start_angle>end_angle && (angle>=start_angle || angle<=end_angle)))
    3215         && o!=exclude)
     3214    || (start_angle>end_angle && (angle>=start_angle || angle<=end_angle)))
     3215    && o!=exclude)
    32163216    {
    32173217      // check to see if the type is in the list
     
    32203220      if (!NILP(v))
    32213221      {
    3222         xo=abs(o->x-x);
    3223         yo=abs(o->y-y);
    3224         distance=xo*xo+yo*yo;
    3225         if (distance<closest_distance)
    3226         {
    3227           closest_distance=distance;
    3228           closest=o;
    3229         }
     3222    xo=abs(o->x-x);
     3223    yo=abs(o->y-y);
     3224    distance=xo*xo+yo*yo;
     3225    if (distance<closest_distance)
     3226    {
     3227      closest_distance=distance;
     3228      closest=o;
     3229    }
    32303230      }
    32313231    }
     
    32633263    {
    32643264      fprintf(fp,"%3d %s %4ld %4ld %4ld %4ld %04d\n",i++,object_names[o->otype],(long)o->x,(long)o->y,
    3265               (long)o->xvel(),(long)o->yvel(),o->current_frame);
     3265          (long)o->xvel(),(long)o->yvel(),o->current_frame);
    32663266    }
    32673267    fclose(fp);
     
    32713271
    32723272area_controller::area_controller(int32_t X, int32_t Y, int32_t W, int32_t H, area_controller *Next)
    3273 { 
    3274   x=X; y=Y; w=W; h=H; 
    3275   next=Next; active=0; 
     3273{
     3274  x=X; y=Y; w=W; h=H;
     3275  next=Next; active=0;
    32763276
    32773277  ambient=-1;
    32783278  view_xoff=-1;
    32793279  view_yoff=-1;
    3280   ambient_speed=2; 
     3280  ambient_speed=2;
    32813281  view_xoff_speed=4;
    32823282  view_yoff_speed=4;
Note: See TracChangeset for help on using the changeset viewer.