home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / ABUSESRC.ZIP / AbuseSrc / macabuse / src / chars.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-05-20  |  14.3 KB  |  573 lines
  1. #include "chars.hpp"
  2. #include "game.hpp"
  3. #include "intsect.hpp"
  4. #include "lisp.hpp"
  5. #include "jwindow.hpp"
  6. #include "input.hpp"
  7. #include "id.hpp"
  8. #include "clisp.hpp"
  9. #include "dprint.hpp"
  10. #include "lisp_gc.hpp"
  11.  
  12. #define FADING_FRAMES 26
  13. #define FADING_MAX 32
  14.  
  15. character_type **figures;
  16.  
  17.  
  18.  
  19. int total_weapons=0;
  20. int *weapon_types=NULL;    // maps 0..total_weapons into 'real' weapon type
  21.  
  22. char *state_names[MAX_STATE]= {
  23.                    "dead",
  24.                                "dieing",
  25.                    "stopped",
  26.                    "start_run_jump","run_jump","run_jump_fall","end_run_jump",
  27.                    "flinch_up","flinch_down",
  28.                    "morph_pose",
  29.                    "running" };
  30.  
  31. /*                   "start_still_jump","still_jump","still_jump_fall","end_still_jump",
  32.  
  33.                    "morph_pose",
  34.                    
  35.                    "walking",
  36.                    
  37.  
  38.                    "weapon_draw",
  39.                    "weapon_put_away",
  40.                    "weapon_fire",
  41.                    "weapon_end_fire",
  42.                    "weapon_fire_up",
  43.                    "weapon_end_fire_up",
  44.  
  45.                    "blocking",
  46.                    "block_recoil",
  47.  
  48.                    "turn_around",
  49.                    "flinch_up","flinch_down","flinch_back",
  50.                    "flinch_air","flinch_ground","flinch_getup","woze",
  51.                    "stance"
  52.                  } ; */
  53.  
  54.  
  55. char *cflag_names[TOTAL_CFLAGS]={"hurt_all","is_weapon","stoppable","can_block",
  56.                  "hurtable","pushable","unlistable",
  57.                      "add_front","cached_in","need_cache_in","unactive_shield"};
  58. char *ofun_names[TOTAL_OFUNS]={"ai_fun","move_fun","draw_fun","map_draw_fun","damage_fun",
  59.                    "next_state_fun","user_fun",
  60.                    "constructor","reload_fun","get_cache_list_fun",
  61.                    "type_change_fun"};
  62.  
  63. int character_type::add_state(void *symbol)             // returns index into seq to use
  64. {
  65.   if (item_type(symbol)!=L_SYMBOL)
  66.   {
  67.     lprint(symbol);
  68.     lbreak("is not a symbol (in def_char)");
  69.     exit(0);
  70.   }
  71.  
  72.   void *val=symbol_value(symbol);
  73.  
  74.   int num;
  75.   if (DEFINEDP(val))
  76.   {
  77.     if (item_type(val)!=L_NUMBER)
  78.     {
  79.       lprint(symbol);
  80.       dprintf("expecting symbol value to be a number, instead got : ");
  81.       lprint(val);
  82.       lbreak("");
  83.       exit(0);
  84.     }
  85.     num=lnumber_value(val);
  86.   } else 
  87.   {
  88.     num=ts;
  89.     if (num<MAX_STATE) num=MAX_STATE;
  90.     int sp=current_space;
  91.     current_space=PERM_SPACE;
  92.     set_symbol_number(symbol,num);
  93.     current_space=sp;
  94.   }
  95.  
  96.   if (num<ts && seq[num])
  97.   {
  98.     lprint(symbol);
  99.     lbreak("symbol has been assigned value %d, but value already in use by state %s\n"
  100.        "use a different symbol for this state\n",
  101.        lstring_value(symbol_name(seq_syms[num])));
  102.     exit(0);
  103.   } else if (num>=ts)
  104.   {
  105.     seq=(sequence **)jrealloc(seq,sizeof(sequence *)*(num+1),"state list");    
  106.     seq_syms=(void **)jrealloc(seq_syms,sizeof(void *)*(num+1),"state sym list");    
  107.  
  108.     memset(&seq[ts],0,sizeof(sequence *)*((num+1)-ts));
  109.     memset(&seq_syms[ts],0,sizeof(void *)*((num+1)-ts));
  110.  
  111.     ts=num+1;
  112.   }
  113.  
  114.   seq_syms[num]=symbol;
  115.   return num;
  116. }
  117.  
  118. int flinch_state(character_state state)
  119. {
  120.   if (state==flinch_up || state==flinch_down)
  121.     return 1;
  122.   else return 0;
  123. }
  124.  
  125. int character_type::cache_in()    // returns false if out of cache memory
  126. {
  127.   int i;
  128.   if (get_cflag(CFLAG_CACHED_IN))
  129.     return 1;
  130.   cflags|=1<<CFLAG_CACHED_IN;
  131.  
  132.   for (i=0;i<ts;i++)
  133.   {
  134.     if (seq[i])
  135.       seq[i]->cache_in();
  136.   }
  137.   return 1;
  138. }
  139.  
  140. void character_type::add_sequence(character_state which, sequence *new_seq)
  141. {
  142.   if (seq[which])
  143.     delete seq[which];
  144.   seq[which]=new_seq;  
  145. }  
  146.  
  147. void *l_obj_get(long number) // exten lisp function switches on number
  148. {
  149.   character_type *t=figures[current_object->otype];
  150.   if (t->tiv<=number || !t->vars[number])
  151.   {
  152.     lbreak("access : variable does not exsist for this class\n");
  153.     return 0;
  154.   }
  155.   return new_lisp_number(current_object->lvars[t->var_index[number]]);  
  156. }
  157.  
  158. void l_obj_set(long number, void *arg)  // exten lisp function switches on number
  159. {
  160.   character_type *t=figures[current_object->otype];
  161.   if (t->tiv<=number || !t->vars[number])
  162.   {
  163.     lbreak("set : variable does not exsist for this class\n");
  164.     return;
  165.   }
  166.   current_object->lvars[t->var_index[number]]=lnumber_value(arg);
  167. }
  168.  
  169. void l_obj_print(long number)  // exten lisp function switches on number
  170. {
  171.   character_type *t=figures[current_object->otype];
  172.   if (t->tiv<=number || !t->vars[number])
  173.   {
  174.     lbreak("access : variable does not exsist for this class\n");
  175.     return;
  176.   }
  177.   dprintf("%d",current_object->lvars[t->var_index[number]]);  
  178. }
  179.  
  180. void character_type::add_var(void *symbol, void *name)
  181. {
  182.   /* First see if the variable has been defined for another object
  183.      if so report a conflict if any occur */
  184.   lisp_symbol *s=(lisp_symbol *)symbol;
  185.   if (DEFINEDP(s->value) && (item_type(s->value)!=L_OBJECT_VAR))
  186.   {
  187.     lprint(symbol);
  188.     lbreak("symbol already has a value, cannot instantiate an object varible");
  189.     exit(0);
  190.   } else if (DEFINEDP(s->value))
  191.   {
  192.     int index=((lisp_object_var *)s->value)->number;
  193.     if (index<tiv)
  194.     {
  195.       if (vars[index])
  196.       {       
  197.     lbreak("While defining object %s :\n"
  198.            "  var '%s' was previously defined by another\n"
  199.            "  with index %d, but %s has a var listed '%s' with same index\n"
  200.            "  try moving definition of %s before previously declared object",
  201.            lstring_value(symbol_name(name)),
  202.            lstring_value(symbol_name(symbol)),
  203.            index,
  204.            lstring_value(symbol_name(name)),
  205.            lstring_value(symbol_name(vars[index])),
  206.            lstring_value(symbol_name(name))
  207.            );
  208.     exit(0);
  209.       } else 
  210.       {
  211.     var_index[index]=tv;
  212.     vars[index]=symbol;
  213.     tv++;
  214.       }
  215.     } else
  216.     {
  217.       int new_total=index+1;
  218.       vars=(void **)jrealloc(vars,sizeof(void *)*new_total,"variable name list");
  219.       var_index=(short *)jrealloc(var_index,sizeof(short)*new_total,"variable index");
  220.       memset(&vars[tiv],0,(new_total-tiv)*sizeof(void *));
  221.       memset(&var_index[tiv],0,(new_total-tiv)*sizeof(short));
  222.       tiv=new_total;
  223.  
  224.       var_index[index]=tv;
  225.       vars[index]=symbol;
  226.       tv++;
  227.     }    
  228.   } else  /** Nope, looks like we have to add the variable ourself and define the assesor funs */
  229.   {
  230.     /* locate a free index in the index list */
  231.     int free_index=tiv;
  232.     for (int i=0;i<tiv;i++)
  233.       if (!vars[i] && i<tiv) free_index=i;
  234.     if (free_index==tiv)
  235.     {
  236.       int new_total=free_index+1;
  237.       vars=(void **)jrealloc(vars,sizeof(void *)*new_total,"variable name list");
  238.       var_index=(short *)jrealloc(var_index,sizeof(short)*new_total,"variable index");
  239.       memset(&vars[tiv],0,(new_total-tiv)*sizeof(void *));
  240.       memset(&var_index[tiv],0,(new_total-tiv)*sizeof(short));
  241.       tiv=new_total;
  242.     }
  243.  
  244.     /* create the var and add to var list */
  245.     int sp=current_space;
  246.     current_space=PERM_SPACE;
  247.  
  248.     add_c_object(symbol,free_index);
  249.    
  250.     vars[free_index]=symbol;
  251.     var_index[free_index]=tv;
  252.     tv++;
  253.     current_space=sp;
  254.   }
  255. }
  256.  
  257.  
  258. long character_type::isa_var_name(char *name)
  259. {
  260.   int i=0;
  261.   for (;i<TOTAL_OBJECT_VARS;i++)
  262.   {
  263.     if (!strcmp(object_descriptions[i].name,name))
  264.       return 1;
  265.   }
  266.   for (i=0;i<tiv;i++)
  267.     if (!strcmp(lstring_value(symbol_name(vars[i])),name)) 
  268.       return 1;
  269.   return 0;
  270. }
  271.  
  272. character_type::character_type(void *args, void *name) 
  273. {
  274.   p_ref r2(args);
  275.   int i;
  276.   ts=tv=0;
  277.   seq=NULL;
  278.   seq_syms=NULL;
  279.   vars=NULL;
  280.   var_index=NULL;
  281.   tiv=0;
  282.  
  283.   void *l_abil=  make_find_symbol("abilities");
  284.   void *l_funs=  make_find_symbol("funs");
  285.   void *l_states=make_find_symbol("states");
  286.   void *l_flags= make_find_symbol("flags");
  287.   void *l_range= make_find_symbol("range");
  288.   void *l_draw_range= make_find_symbol("draw_range");
  289.   void *l_fields=make_find_symbol("fields");
  290.   void *l_logo=  make_find_symbol("logo");
  291.   void *l_vars=  make_find_symbol("vars");
  292.  
  293.   memset(fun_table,0,sizeof(fun_table));     // destory all hopes of fun
  294.   fields=NULL;
  295.   cflags=0;
  296.   morph_mask=-1;
  297.   morph_power=0;
  298.   total_fields=0;
  299.   logo=-1;
  300.   rangex=rangey=0;
  301.   draw_rangex=draw_rangey=0;
  302.  
  303.   for (i=0;i<TOTAL_ABILITIES;i++)
  304.     abil[i]=get_ability_default((ability)i);          
  305.   void *field=args;
  306.   p_ref r7(field);
  307.   for (;field;field=CDR(field))
  308.   {
  309.     void *f=CAR(CAR(field));
  310.     p_ref r1(f);
  311.     
  312.     if (f==l_abil)
  313.     {
  314.       void *l=CDR(CAR(field));
  315.       p_ref r4(l);
  316.       for (i=0;i<TOTAL_ABILITIES;i++)
  317.       {
  318.     Cell *ab=assoc(make_find_symbol(ability_names[i]),l);
  319.     p_ref r5(ab);
  320.     if (!NILP(ab))
  321.       abil[i]=lnumber_value(eval(lcar(lcdr(ab))));
  322.       }
  323.     } else if (f==l_funs)
  324.     {
  325.       void *l=CDR(CAR(field));
  326.       p_ref r4(l);
  327.       for (i=0;i<TOTAL_OFUNS;i++)
  328.       {
  329.     Cell *ab=assoc(make_find_symbol(ofun_names[i]),l);
  330.     p_ref r5(ab);
  331.     if (!NILP(ab) && lcar(lcdr(ab)))
  332.     fun_table[i]=lcar(lcdr(ab));
  333.       }
  334.     } else if (f==l_flags)
  335.     {
  336.       void *l=CDR(CAR(field));
  337.       p_ref r4(l);
  338.       for (i=0;i<TOTAL_CFLAGS;i++)
  339.       {
  340.     Cell *ab=assoc(make_find_symbol(cflag_names[i]),l);
  341.     p_ref r5(ab);
  342.     if (!NILP(ab) && eval(lcar(lcdr(ab))))
  343.     cflags|=(1<<i);
  344.       }
  345.       
  346.       if (get_cflag(CFLAG_IS_WEAPON))  // if this is a weapon add to weapon array
  347.       {
  348.     total_weapons++;
  349.     weapon_types=(int *)jrealloc(weapon_types,sizeof(int)*total_weapons,"weapon map");
  350.     weapon_types[total_weapons-1]=total_objects;
  351.       }
  352.     } else if (f==l_range)
  353.     {
  354.       rangex=lnumber_value(eval(lcar(lcdr(lcar(field)))));
  355.       rangey=lnumber_value(eval(lcar(lcdr(lcdr(lcar(field))))));
  356.     } else if (f==l_draw_range)
  357.     {
  358.       draw_rangex=lnumber_value(eval(lcar(lcdr(lcar(field)))));
  359.       draw_rangey=lnumber_value(eval(lcar(lcdr(lcdr(lcar(field))))));
  360.     } else if (f==l_states)
  361.     {
  362.       void *l=CDR(CAR(field));
  363.       p_ref r4(l);
  364.       char fn[100];
  365.       strcpy(fn,lstring_value(eval(CAR(l)))); l=CDR(l);
  366.       while (l)
  367.       {
  368.     seq[add_state(CAR((CAR(l))))]=new sequence(fn,eval(CAR(CDR(CAR(l)))),NULL);
  369.     l=CDR(l);
  370.       } 
  371.     } else if (f==l_fields)
  372.     {
  373.       void *mf=CDR(CAR(field));
  374.       p_ref r4(mf);
  375.       while (!NILP(mf))
  376.       {
  377.     char *real=lstring_value(eval(lcar(lcar(mf))));
  378.     char *fake=lstring_value(eval(lcar(lcdr(lcar(mf))))); 
  379.     if (!isa_var_name(real))
  380.     {
  381.       lprint(field);
  382.       lbreak("fields : no such var name \"%s\"\n",name);
  383.       exit(0);
  384.     } 
  385.     total_fields++;
  386.  
  387.     fields=(named_field **)jrealloc(fields,sizeof(named_field *)*total_fields,"named_fields");
  388.     fields[total_fields-1]=new named_field(real,fake);
  389.     mf=lcdr(mf);
  390.       }
  391.     } else if (f==l_logo)
  392.     {
  393.       char *fn=lstring_value(eval(CAR(CDR(CAR(field)))));
  394.       char *o=lstring_value(eval(CAR(CDR(CDR(CAR(field))))));
  395.       logo=cash.reg(fn,o,SPEC_IMAGE,1);
  396.     } else if (f==l_vars)
  397.     {
  398.       void *l=CDR(CAR(field));
  399.       p_ref r8(l);
  400.       while (l)
  401.       {
  402.     add_var(CAR(l),name);
  403.     l=CDR(l);
  404.       }       
  405.     }
  406.     else
  407.     {
  408.       lprint(lcar(field));
  409.       lbreak("Unknown field for character definiltion");
  410.       exit(0);
  411.     }    
  412.   }
  413.  
  414.   if (!seq[stopped])
  415.     lbreak("object (%s) has no stopped state, please define one!\n",
  416.        lstring_value(symbol_name(name)));
  417.  
  418. /*  char *fn=lstring_value(lcar(desc));
  419.   if (!fn)
  420.   {
  421.     dprintf("No filename given for def-character (%s)\n",name);
  422.     exit(0);
  423.   }
  424.   desc=lcdr(desc);  //  skip filename
  425.  
  426.  
  427.   Cell *mrph=assoc(l_morph,desc);     // check for morph info
  428.   morph_power=0;
  429.   if (!NILP(mrph))
  430.   {
  431.     mrph=lcdr(mrph);
  432.     morph_mask=cash.reg_object(fn,lcar(mrph),SPEC_IMAGE,1);
  433.     morph_power=lnumber_value(lcar(lcdr(mrph)));
  434.   } else morph_mask=-1;
  435.  
  436.   Cell *sa=assoc(l_state_art,desc);
  437.   if (NILP(sa))
  438.   {
  439.     dprintf("missing state state art in def-character (%s)\n",name);
  440.     exit(0);
  441.   } 
  442.   
  443.   sa=lcdr(sa);   // list of state sequences
  444.   while (!NILP(sa))
  445.   {
  446.     int num=lnumber_value(lcar(lcar(sa)));
  447.     if (seq[num])    
  448.       dprintf("Warning : state '%s' defined multiply for object %s\n"
  449.          "          using first definition\n",state_names[num],name);
  450.     else    
  451.       seq[lnumber_value(lcar(lcar(sa)))]=new sequence(fn,lcar(lcdr(lcar(sa))),lcar(lcdr(lcdr(lcar(sa)))));
  452.     sa=lcdr(sa);    
  453.   }
  454.  
  455.   Cell *range=assoc(l_range,desc);
  456.   if (!NILP(range))
  457.   {
  458.     rangex=lnumber_value(lcar(lcdr(range)));
  459.     rangey=lnumber_value(lcar(lcdr(lcdr(range)))); 
  460.   } else 
  461.   {
  462.     rangex=100;
  463.     rangey=50;
  464.   }
  465.  
  466.  
  467.  
  468.  
  469.   Cell *mf=assoc(l_fields,desc);
  470.   if (!NILP(mf))
  471.   {
  472.     mf=lcdr(mf);
  473.     total_fields=0;
  474.     while (!NILP(mf))
  475.     {
  476.       char *name=lstring_value(lcar(lcar(mf)));
  477.       int t=default_simple.total_vars(),find=-1;
  478.       for (int i=0;find<0 && i<t;i++)
  479.         if (!strcmp(default_simple.var_name(i),name))
  480.       find=i;
  481.       if (find<0)
  482.       {
  483.     lprint(assoc(l_fields,desc));
  484.     dprintf("fields : no such var name \"%s\"\n",name);
  485.     dprintf("current possiblities are : \n");
  486.     for (int i=0;i<t;i++) dprintf("\"%s\" ",default_simple.var_name(i));
  487.     dprintf("\n");
  488.     exit(0);
  489.       } 
  490.       char *new_name=lstring_value(lcar(lcdr(lcar(mf))));
  491.       total_fields++;
  492.  
  493.       fields=(named_field **)jrealloc(fields,sizeof(named_field *)*total_fields,"named_fields");
  494.       fields[total_fields-1]=new named_field(find,new_name);
  495.       mf=lcdr(mf);
  496.     }
  497.   } else total_fields=0;
  498.  
  499.  
  500.   Cell *lg=assoc(l_logo,desc);
  501.   if (NILP(lg)) 
  502.   {
  503.     if (get_cflag(CFLAG_IS_WEAPON))
  504.     {
  505.       lprint(desc);
  506.       lbreak("object must have a logo defined if it is a weapon\n"
  507.          "example '(logo . (""art/misc.spe"" . ""big waepon""))\n");
  508.     }
  509.     logo=-1;
  510.   }
  511.   else 
  512.     logo=cash.reg_object(fn,lcdr(lg),SPEC_IMAGE,1);  
  513.     */
  514. }
  515.  
  516.  
  517. sequence *character_type::get_sequence(character_state s)
  518. {
  519.   if (seq[s])
  520.     return seq[s];
  521.   else return seq[stopped];
  522. }
  523.  
  524.  
  525. character_type::~character_type()
  526. {
  527.   for (int i=0;i<ts;i++)  
  528.     if (seq[i]) 
  529.       delete seq[i];
  530.   if (ts) jfree(seq);
  531.  
  532.   if (total_fields)
  533.   {
  534.     for (int i=0;i<total_fields;i++)
  535.       delete fields[i];
  536.     jfree(fields);
  537.   }
  538.  
  539.   if (ts)
  540.     jfree(seq_syms);
  541.  
  542.   if (tiv)
  543.   {
  544.     jfree(vars);
  545.     jfree(var_index);
  546.   }
  547.  
  548.  
  549. }
  550.  
  551. extern long small_ptr_size(void *ptr);
  552.  
  553.  
  554. void chk_sizes()
  555. {
  556.   for (int i=0;i<total_objects;i++)
  557.   {
  558.     figures[i]->check_sizes();
  559.   }
  560. }
  561.  
  562.  
  563. void character_type::check_sizes()
  564. {
  565.   for (int i=0;i<ts;i++)
  566.     if (seq[i] && small_ptr_size(seq[i])!=8)
  567.       dprintf("bad size for state %d\n",i);
  568. }
  569.  
  570.  
  571.  
  572.  
  573.