Changeset 642


Ignore:
Timestamp:
May 13, 2011, 9:13:48 AM (9 years ago)
Author:
Sam Hocevar
Message:

lisp: some refactoring in chars.cpp.

Location:
abuse/trunk/src
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • abuse/trunk/src/chars.cpp

    r638 r642  
    2929#define FADING_MAX 32
    3030
    31 character_type **figures;
    32 
    33 
    34 
    35 int total_weapons=0;
    36 int *weapon_types=NULL;    // maps 0..total_weapons into 'real' weapon type
     31CharacterType **figures;
     32
     33int total_weapons = 0;
     34int *weapon_types = NULL; // maps 0..total_weapons into 'real' weapon type
    3735
    3836char const *state_names[MAX_STATE] =
    … …  
    4543    "morph_pose",
    4644    "running"
     45#if 0
     46    "start_still_jump", "still_jump", "still_jump_fall", "end_still_jump",
     47
     48    "morph_pose",
     49
     50    "walking",
     51
     52    "weapon_draw",
     53    "weapon_put_away",
     54    "weapon_fire",
     55    "weapon_end_fire",
     56    "weapon_fire_up",
     57    "weapon_end_fire_up",
     58
     59    "blocking",
     60    "block_recoil",
     61
     62    "turn_around",
     63    "flinch_up", "flinch_down", "flinch_back",
     64    "flinch_air", "flinch_ground", "flinch_getup", "woze",
     65    "stance"
     66#endif
    4767};
    48 
    49 /*                   "start_still_jump","still_jump","still_jump_fall","end_still_jump",
    50 
    51                    "morph_pose",
    52 
    53                    "walking",
    54 
    55 
    56                    "weapon_draw",
    57                    "weapon_put_away",
    58                    "weapon_fire",
    59                    "weapon_end_fire",
    60                    "weapon_fire_up",
    61                    "weapon_end_fire_up",
    62 
    63                    "blocking",
    64                    "block_recoil",
    65 
    66                    "turn_around",
    67                    "flinch_up","flinch_down","flinch_back",
    68                    "flinch_air","flinch_ground","flinch_getup","woze",
    69                    "stance"
    70                  } ; */
    71 
    7268
    7369char const *cflag_names[TOTAL_CFLAGS] =
    … …  
    8682};
    8783
    88 int character_type::add_state(void *symbol) // returns index into seq to use
    89 {
    90   if (item_type(symbol)!=L_SYMBOL)
    91   {
    92     ((LObject *)symbol)->Print();
    93     lbreak("is not a symbol (in def_char)");
    94     exit(0);
    95   }
    96 
    97   void *val=symbol_value(symbol);
    98 
    99   int num;
    100   if (DEFINEDP(val))
    101   {
    102     if (item_type(val)!=L_NUMBER)
    103     {
    104       ((LObject *)symbol)->Print();
    105       dprintf("expecting symbol value to be a number, instead got : ");
    106       ((LObject *)val)->Print();
    107       lbreak("");
    108       exit(0);
    109     }
    110     num=lnumber_value(val);
    111   } else
    112   {
    113     num=ts;
    114     if (num<MAX_STATE) num=MAX_STATE;
    115     LSpace *sp = LSpace::Current;
    116     LSpace::Current = &LSpace::Perm;
    117     ((LSymbol *)symbol)->SetNumber(num);
    118     LSpace::Current=sp;
    119   }
    120 
    121   if (num<ts && seq[num])
    122   {
    123     ((LObject *)symbol)->Print();
    124     lbreak("symbol has been assigned value %d, but value already in use by state %s\n"
    125        "use a different symbol for this state\n",
    126        lstring_value(((LSymbol *)seq_syms[num])->GetName()));
    127     exit(0);
    128   } else if (num>=ts)
    129   {
    130     seq=(sequence **)realloc(seq,sizeof(sequence *)*(num+1));
    131     seq_syms=(void **)realloc(seq_syms,sizeof(void *)*(num+1));
    132 
    133     memset(&seq[ts],0,sizeof(sequence *)*((num+1)-ts));
    134     memset(&seq_syms[ts],0,sizeof(void *)*((num+1)-ts));
    135 
    136     ts=num+1;
    137   }
    138 
    139   seq_syms[num]=symbol;
    140   return num;
     84int CharacterType::add_state(LObject *symbol) // returns index into seq to use
     85{
     86    if (item_type(symbol) != L_SYMBOL)
     87    {
     88        symbol->Print();
     89        lbreak("is not a symbol (in def_char)");
     90        exit(0);
     91    }
     92
     93    LObject *val = symbol_value((LSymbol *)symbol);
     94
     95    int num;
     96    if (DEFINEDP(val))
     97    {
     98        if (item_type(val) != L_NUMBER)
     99        {
     100            symbol->Print();
     101            dprintf("expecting symbol value to be a number, instead got: ");
     102            val->Print();
     103            lbreak("");
     104            exit(0);
     105        }
     106        num = lnumber_value(val);
     107    }
     108    else
     109    {
     110        num = Max(ts, MAX_STATE);
     111        LSpace *sp = LSpace::Current;
     112        LSpace::Current = &LSpace::Perm;
     113        ((LSymbol *)symbol)->SetNumber(num);
     114        LSpace::Current = sp;
     115    }
     116
     117    if (num < ts && seq[num])
     118    {
     119        symbol->Print();
     120        lbreak("symbol has been assigned value %d, but value already in use "
     121               "by state %s\n" "use a different symbol for this state\n",
     122               lnumber_value(seq_syms[num]->GetValue()),
     123               lstring_value(seq_syms[num]->GetName()));
     124        exit(0);
     125    }
     126    else if (num >= ts)
     127    {
     128        seq = (sequence **)realloc(seq, sizeof(sequence *) * (num + 1));
     129        seq_syms = (LSymbol **)realloc(seq_syms, sizeof(LSymbol *) * (num + 1));
     130
     131        memset(&seq[ts], 0, sizeof(sequence *) * ((num + 1) - ts));
     132        memset(&seq_syms[ts], 0, sizeof(LSymbol *) * ((num + 1) - ts));
     133
     134        ts = num + 1;
     135    }
     136
     137    seq_syms[num] = (LSymbol *)symbol;
     138    return num;
    141139}
    142140
    143141int flinch_state(character_state state)
    144142{
    145   if (state==flinch_up || state==flinch_down)
     143    if (state == flinch_up || state == flinch_down)
     144        return 1;
     145    return 0;
     146}
     147
     148int CharacterType::cache_in()    // returns false if out of cache memory
     149{
     150    if (get_cflag(CFLAG_CACHED_IN))
     151        return 1;
     152    cflags |= 1 << CFLAG_CACHED_IN;
     153
     154    for (int i = 0; i < ts; i++)
     155        if (seq[i])
     156            seq[i]->cache_in();
     157
    146158    return 1;
    147   else return 0;
    148 }
    149 
    150 int character_type::cache_in()    // returns false if out of cache memory
    151 {
    152   int i;
    153   if (get_cflag(CFLAG_CACHED_IN))
    154     return 1;
    155   cflags|=1<<CFLAG_CACHED_IN;
    156 
    157   for (i=0; i<ts; i++)
    158   {
    159     if (seq[i])
    160       seq[i]->cache_in();
    161   }
    162   return 1;
    163 }
    164 
    165 void character_type::add_sequence(character_state which, sequence *new_seq)
    166 {
    167   if (seq[which])
     159}
     160
     161void CharacterType::add_sequence(character_state which, sequence *new_seq)
     162{
    168163    delete seq[which];
    169   seq[which]=new_seq;
     164    seq[which] = new_seq;
    170165}
    171166
    172167void *l_obj_get(long number) // exten lisp function switches on number
    173168{
    174   character_type *t=figures[current_object->otype];
    175   if (t->tiv<=number || !t->vars[number])
    176   {
    177     lbreak("access : variable does not exsist for this class\n");
    178     return 0;
    179   }
    180   return LNumber::Create(current_object->lvars[t->var_index[number]]);
     169    CharacterType *t = figures[current_object->otype];
     170    if (t->tiv <= number || !t->vars[number])
     171    {
     172        lbreak("access : variable does not exsist for this class\n");
     173        return 0;
     174    }
     175    return LNumber::Create(current_object->lvars[t->var_index[number]]);
    181176}
    182177
    183178void l_obj_set(long number, void *arg)  // exten lisp function switches on number
    184179{
    185   character_type *t=figures[current_object->otype];
     180  CharacterType *t=figures[current_object->otype];
    186181  if (t->tiv<=number || !t->vars[number])
    187182  {
    … …  
    194189void l_obj_print(long number)  // exten lisp function switches on number
    195190{
    196   character_type *t=figures[current_object->otype];
     191  CharacterType *t=figures[current_object->otype];
    197192  if (t->tiv<=number || !t->vars[number])
    198193  {
    … …  
    203198}
    204199
    205 void character_type::add_var(void *symbol, void *name)
     200void CharacterType::add_var(void *symbol, void *name)
    206201{
    207202  /* First see if the variable has been defined for another object
    … …  
    235230      {
    236231    var_index[index]=tv;
    237     vars[index]=symbol;
     232    vars[index]=(LSymbol *)symbol;
    238233    tv++;
    239234      }
    … …  
    241236    {
    242237      int new_total=index+1;
    243       vars=(void **)realloc(vars,sizeof(void *)*new_total);
     238      vars=(LSymbol **)realloc(vars,sizeof(LSymbol *)*new_total);
    244239      var_index=(short *)realloc(var_index,sizeof(short)*new_total);
    245       memset(&vars[tiv],0,(new_total-tiv)*sizeof(void *));
     240      memset(&vars[tiv],0,(new_total-tiv)*sizeof(LSymbol *));
    246241      memset(&var_index[tiv],0,(new_total-tiv)*sizeof(short));
    247242      tiv=new_total;
    248243
    249244      var_index[index]=tv;
    250       vars[index]=symbol;
     245      vars[index]=(LSymbol *)symbol;
    251246      tv++;
    252247    }
    … …  
    260255    {
    261256      int new_total=free_index+1;
    262       vars=(void **)realloc(vars,sizeof(void *)*new_total);
     257      vars=(LSymbol **)realloc(vars,sizeof(LSymbol *)*new_total);
    263258      var_index=(short *)realloc(var_index,sizeof(short)*new_total);
    264       memset(&vars[tiv],0,(new_total-tiv)*sizeof(void *));
     259      memset(&vars[tiv],0,(new_total-tiv)*sizeof(LSymbol *));
    265260      memset(&var_index[tiv],0,(new_total-tiv)*sizeof(short));
    266261      tiv=new_total;
    … …  
    273268    add_c_object(symbol,free_index);
    274269
    275     vars[free_index]=symbol;
     270    vars[free_index]=(LSymbol *)symbol;
    276271    var_index[free_index]=tv;
    277272    tv++;
    … …  
    281276
    282277
    283 long character_type::isa_var_name(char *name)
    284 {
    285   int i=0;
    286   for (; i<TOTAL_OBJECT_VARS; i++)
    287   {
     278long CharacterType::isa_var_name(char *name)
     279{
     280  for (int i=0; i<TOTAL_OBJECT_VARS; i++)
    288281    if (!strcmp(object_descriptions[i].name,name))
    289282      return 1;
    290   }
    291   for (i=0; i<tiv; i++)
     283  for (int i=0; i<tiv; i++)
    292284    if (!strcmp(lstring_value(((LSymbol *)vars[i])->GetName()),name))
    293285      return 1;
    … …  
    295287}
    296288
    297 character_type::character_type(void *args, void *name)
    298 {
    299   PtrRef r2(args);
    300   int i;
    301   ts=tv=0;
    302   seq=NULL;
    303   seq_syms=NULL;
    304   vars=NULL;
    305   var_index=NULL;
    306   tiv=0;
    307 
    308   LSymbol *l_abil =   LSymbol::FindOrCreate("abilities");
    309   LSymbol *l_funs =   LSymbol::FindOrCreate("funs");
    310   LSymbol *l_states = LSymbol::FindOrCreate("states");
    311   LSymbol *l_flags =  LSymbol::FindOrCreate("flags");
    312   LSymbol *l_range =  LSymbol::FindOrCreate("range");
    313   LSymbol *l_draw_range = LSymbol::FindOrCreate("draw_range");
    314   LSymbol *l_fields = LSymbol::FindOrCreate("fields");
    315   LSymbol *l_logo =   LSymbol::FindOrCreate("logo");
    316   LSymbol *l_vars =   LSymbol::FindOrCreate("vars");
    317 
    318   memset(fun_table,0,sizeof(fun_table));     // destory all hopes of fun
    319   fields=NULL;
    320   cflags=0;
    321   morph_mask=-1;
    322   morph_power=0;
    323   total_fields=0;
    324   logo=-1;
    325   rangex=rangey=0;
    326   draw_rangex=draw_rangey=0;
    327 
    328   for (i=0; i<TOTAL_ABILITIES; i++)
    329     abil[i]=get_ability_default((ability)i);
    330   void *field=args;
    331   PtrRef r7(field);
    332   for (; field; field=CDR(field))
    333   {
    334     void *f=CAR(CAR(field));
    335     PtrRef r1(f);
    336 
    337     if (f==l_abil)
    338     {
    339       LList *l = (LList *)CDR(CAR(field));
    340       PtrRef r4(l);
    341       for (i=0; i<TOTAL_ABILITIES; i++)
    342       {
    343     Cell *ab = l->Assoc(LSymbol::FindOrCreate(ability_names[i]));
    344     PtrRef r5(ab);
    345     if (!NILP(ab))
    346       abil[i]=lnumber_value(lcar(lcdr(ab))->Eval());
    347       }
    348     } else if (f==l_funs)
    349     {
    350       LList *l = (LList *)CDR(CAR(field));
    351       PtrRef r4(l);
    352       for (i=0; i<TOTAL_OFUNS; i++)
    353       {
    354     Cell *ab = l->Assoc(LSymbol::FindOrCreate(ofun_names[i]));
    355     PtrRef r5(ab);
    356     if (!NILP(ab) && lcar(lcdr(ab)))
    357     fun_table[i]=lcar(lcdr(ab));
    358       }
    359     } else if (f==l_flags)
    360     {
    361       LList *l = (LList *)CDR(CAR(field));
    362       PtrRef r4(l);
    363       for (i=0; i<TOTAL_CFLAGS; i++)
    364       {
    365 
    366     Cell *ab = l->Assoc(LSymbol::FindOrCreate(cflag_names[i]));
    367     PtrRef r5(ab);
    368     if (!NILP(ab) && lcar(lcdr(ab))->Eval())
    369     cflags|=(1<<i);
    370       }
    371 
    372       if (get_cflag(CFLAG_IS_WEAPON))  // if this is a weapon add to weapon array
    373       {
    374     total_weapons++;
    375     weapon_types=(int *)realloc(weapon_types,sizeof(int)*total_weapons);
    376     weapon_types[total_weapons-1]=total_objects;
    377       }
    378     } else if (f==l_range)
    379     {
    380       rangex=lnumber_value(lcar(lcdr(lcar(field)))->Eval());
    381       rangey=lnumber_value(lcar(lcdr(lcdr(lcar(field))))->Eval());
    382     } else if (f==l_draw_range)
    383     {
    384       draw_rangex=lnumber_value(lcar(lcdr(lcar(field)))->Eval());
    385       draw_rangey=lnumber_value(lcar(lcdr(lcdr(lcar(field))))->Eval());
    386     } else if (f==l_states)
    387     {
    388       void *l=CDR(CAR(field));
    389       PtrRef r4(l);
    390       char fn[100];
    391       strcpy(fn,lstring_value(CAR(l)->Eval())); l=CDR(l);
    392       while (l)
    393       {
    394       int index;
    395       void *e;
    396       sequence *mem;
    397       index = add_state(CAR((CAR(l))));
    398       e = CAR(CDR(CAR(l)))->Eval();
    399       mem = new sequence(fn,e,NULL);
    400     seq[index]=mem;
    401     l=CDR(l);
    402       }
    403     } else if (f==l_fields)
    404     {
    405       void *mf=CDR(CAR(field));
    406       PtrRef r4(mf);
    407       while (!NILP(mf))
    408       {
    409     char *real=lstring_value(lcar(lcar(mf))->Eval());
    410     char *fake=lstring_value(lcar(lcdr(lcar(mf)))->Eval());
    411     if (!isa_var_name(real))
    412     {
    413       ((LObject *)field)->Print();
    414       lbreak("fields : no such var name \"%s\"\n",name);
    415       exit(0);
    416     }
    417     total_fields++;
    418 
    419     fields=(named_field **)realloc(fields,sizeof(named_field *)*total_fields);
    420     fields[total_fields-1]=new named_field(real,fake);
    421     mf=lcdr(mf);
    422       }
    423     } else if (f==l_logo)
    424     {
    425       char *fn=lstring_value(CAR(CDR(CAR(field)))->Eval());
    426       char *o=lstring_value(CAR(CDR(CDR(CAR(field))))->Eval());
    427       logo=cache.reg(fn,o,SPEC_IMAGE,1);
    428     } else if (f==l_vars)
    429     {
    430       void *l=CDR(CAR(field));
    431       PtrRef r8(l);
    432       while (l)
    433       {
    434     add_var(CAR(l),name);
    435     l=CDR(l);
    436       }
    437     }
    438     else
    439     {
    440       ((LObject *)lcar(field))->Print();
    441       lbreak("Unknown field for character definition");
    442       exit(0);
    443     }
    444   }
    445 
    446   if (!seq[stopped])
    447     lbreak("object (%s) has no stopped state, please define one!\n",
    448        lstring_value(((LSymbol *)name)->GetName()));
     289CharacterType::CharacterType(LList *args, LSymbol *name)
     290{
     291    PtrRef r2(args);
     292    ts=tv=0;
     293    seq=NULL;
     294    seq_syms=NULL;
     295    vars=NULL;
     296    var_index=NULL;
     297    tiv=0;
     298
     299    LSymbol *l_abil =   LSymbol::FindOrCreate("abilities");
     300    LSymbol *l_funs =   LSymbol::FindOrCreate("funs");
     301    LSymbol *l_states = LSymbol::FindOrCreate("states");
     302    LSymbol *l_flags =  LSymbol::FindOrCreate("flags");
     303    LSymbol *l_range =  LSymbol::FindOrCreate("range");
     304    LSymbol *l_draw_range = LSymbol::FindOrCreate("draw_range");
     305    LSymbol *l_fields = LSymbol::FindOrCreate("fields");
     306    LSymbol *l_logo =   LSymbol::FindOrCreate("logo");
     307    LSymbol *l_vars =   LSymbol::FindOrCreate("vars");
     308
     309    memset(fun_table,0,sizeof(fun_table));     // destory all hopes of fun
     310    fields=NULL;
     311    cflags=0;
     312    morph_mask=-1;
     313    morph_power=0;
     314    total_fields=0;
     315    logo=-1;
     316    rangex=rangey=0;
     317    draw_rangex=draw_rangey=0;
     318
     319    for (int i=0; i<TOTAL_ABILITIES; i++)
     320        abil[i]=get_ability_default((ability)i);
     321    LObject *field = args;
     322    PtrRef r7(field);
     323    for (; field; field=CDR(field))
     324    {
     325        LObject *f=CAR(CAR(field));
     326        PtrRef r1(f);
     327
     328        if (f==l_abil)
     329        {
     330            LList *l = (LList *)CDR(CAR(field));
     331            PtrRef r4(l);
     332            for (int i=0; i<TOTAL_ABILITIES; i++)
     333            {
     334                Cell *ab = l->Assoc(LSymbol::FindOrCreate(ability_names[i]));
     335                PtrRef r5(ab);
     336                if (!NILP(ab))
     337                    abil[i]=lnumber_value(lcar(lcdr(ab))->Eval());
     338            }
     339        } else if (f==l_funs)
     340        {
     341            LList *l = (LList *)CDR(CAR(field));
     342            PtrRef r4(l);
     343            for (int i=0; i<TOTAL_OFUNS; i++)
     344            {
     345                Cell *ab = l->Assoc(LSymbol::FindOrCreate(ofun_names[i]));
     346                PtrRef r5(ab);
     347                if (!NILP(ab) && lcar(lcdr(ab)))
     348                    fun_table[i]=lcar(lcdr(ab));
     349            }
     350        } else if (f==l_flags)
     351        {
     352            LList *l = (LList *)CDR(CAR(field));
     353            PtrRef r4(l);
     354            for (int i=0; i<TOTAL_CFLAGS; i++)
     355            {
     356
     357                Cell *ab = l->Assoc(LSymbol::FindOrCreate(cflag_names[i]));
     358                PtrRef r5(ab);
     359                if (!NILP(ab) && lcar(lcdr(ab))->Eval())
     360                    cflags|=(1<<i);
     361            }
     362
     363            if (get_cflag(CFLAG_IS_WEAPON))  // if this is a weapon add to weapon array
     364            {
     365                total_weapons++;
     366                weapon_types=(int *)realloc(weapon_types,sizeof(int)*total_weapons);
     367                weapon_types[total_weapons-1]=total_objects;
     368            }
     369        } else if (f==l_range)
     370        {
     371            rangex=lnumber_value(lcar(lcdr(lcar(field)))->Eval());
     372            rangey=lnumber_value(lcar(lcdr(lcdr(lcar(field))))->Eval());
     373        } else if (f==l_draw_range)
     374        {
     375            draw_rangex=lnumber_value(lcar(lcdr(lcar(field)))->Eval());
     376            draw_rangey=lnumber_value(lcar(lcdr(lcdr(lcar(field))))->Eval());
     377        } else if (f==l_states)
     378        {
     379            LObject *l=CDR(CAR(field));
     380            PtrRef r4(l);
     381            char fn[100];
     382            strcpy(fn,lstring_value(CAR(l)->Eval())); l=CDR(l);
     383            while (l)
     384            {
     385                int index;
     386                void *e;
     387                sequence *mem;
     388                index = add_state(CAR((CAR(l))));
     389                e = CAR(CDR(CAR(l)))->Eval();
     390                mem = new sequence(fn,e,NULL);
     391                seq[index]=mem;
     392                l=CDR(l);
     393            }
     394        } else if (f==l_fields)
     395        {
     396            void *mf=CDR(CAR(field));
     397            PtrRef r4(mf);
     398            while (!NILP(mf))
     399            {
     400                char *real=lstring_value(lcar(lcar(mf))->Eval());
     401                char *fake=lstring_value(lcar(lcdr(lcar(mf)))->Eval());
     402                if (!isa_var_name(real))
     403                {
     404                    ((LObject *)field)->Print();
     405                    lbreak("fields : no such var name \"%s\"\n",name);
     406                    exit(0);
     407                }
     408                total_fields++;
     409
     410                fields=(named_field **)realloc(fields,sizeof(named_field *)*total_fields);
     411                fields[total_fields-1]=new named_field(real,fake);
     412                mf=lcdr(mf);
     413            }
     414        } else if (f==l_logo)
     415        {
     416            char *fn=lstring_value(CAR(CDR(CAR(field)))->Eval());
     417            char *o=lstring_value(CAR(CDR(CDR(CAR(field))))->Eval());
     418            logo=cache.reg(fn,o,SPEC_IMAGE,1);
     419        } else if (f==l_vars)
     420        {
     421            void *l=CDR(CAR(field));
     422            PtrRef r8(l);
     423            while (l)
     424            {
     425                add_var(CAR(l),name);
     426                l=CDR(l);
     427            }
     428        }
     429        else
     430        {
     431            lcar(field)->Print();
     432            lbreak("Unknown field for character definition");
     433            exit(0);
     434        }
     435    }
     436
     437    if (!seq[stopped])
     438        lbreak("object (%s) has no stopped state, please define one!\n",
     439             lstring_value(name->GetName()));
    449440
    450441/*  char *fn=lstring_value(lcar(desc));
    … …  
    547538
    548539
    549 sequence *character_type::get_sequence(character_state s)
    550 {
    551   if (seq[s])
     540sequence *CharacterType::get_sequence(character_state s)
     541{
     542    if (!seq[s])
     543        return seq[stopped];
     544
    552545    return seq[s];
    553   else return seq[stopped];
    554 }
    555 
    556 
    557 character_type::~character_type()
    558 {
    559   for (int i=0; i<ts; i++)
    560     if (seq[i])
    561       delete seq[i];
    562   if (ts) free(seq);
    563 
    564   if (total_fields)
    565   {
    566     for (int i=0; i<total_fields; i++)
    567       delete fields[i];
    568     free(fields);
    569   }
    570 
    571   if (ts)
    572     free(seq_syms);
    573 
    574   if (tiv)
    575   {
    576     free(vars);
    577     free(var_index);
    578   }
    579 
    580 
    581 }
    582 
     546}
     547
     548CharacterType::~CharacterType()
     549{
     550    for (int i = 0; i < ts; i++)
     551        delete seq[i];
     552
     553    if (ts)
     554        free(seq);
     555
     556    if (total_fields)
     557    {
     558        for (int i = 0; i < total_fields; i++)
     559            delete fields[i];
     560        free(fields);
     561    }
     562
     563    if (ts)
     564        free(seq_syms);
     565
     566    if (tiv)
     567    {
     568        free(vars);
     569        free(var_index);
     570    }
     571}
     572

  • abuse/trunk/src/chars.h

    r555 r642  
    8484
    8585
    86 class character_type
     86class CharacterType
    8787{
    88 public :
     88public:
     89    CharacterType(LList *args, LSymbol *name); // lisp object describes object
     90    ~CharacterType();
     91
    8992  uint16_t ts,tiv,tv; // total states, total index vars, total local vars
    9093  sequence **seq;   // [0..ts-1]
    91   void **seq_syms;  // symbol describing what this state is [0..ts-1]
     94  LSymbol **seq_syms;  // symbol describing what this state is [0..ts-1]
    9295
    93   void **vars;  // symbol describing variable names    [0..tiv-1]
     96  LSymbol **vars;  // symbol describing variable names    [0..tiv-1]
    9497  short *var_index; // index into local var                [0..tiv-1]
    9598
    9699  void add_var(void *symbol, void *name);
    97   int add_state(void *symbol);              // returns index into seq to use
     100  int add_state(LObject *symbol);           // returns index into seq to use
    98101  int abil[TOTAL_ABILITIES];
    99102  void *fun_table[TOTAL_OFUNS];             // pointers to lisp function for this object
    … …  
    107110  int total_fields;                         // used by game editor to replace field names
    108111  named_field **fields;
    109   character_type(void *args, void *name);   // lisp object describes object
    110112
    111113  sequence *get_sequence(character_state s);
    … …  
    115117  void check_sizes();
    116118  long isa_var_name(char *name);
    117 
    118   ~character_type();
    119119} ;
    120120
    121 extern character_type **figures;
     121extern CharacterType **figures;
    122122int flinch_state(character_state state);
    123123

  • abuse/trunk/src/clisp.cpp

    r635 r642  
    777777      {
    778778        object_names=(char **)malloc(sizeof(char *)*(total_objects+1));
    779     figures=(character_type **)malloc(sizeof(character_type *)*(total_objects+1));
     779    figures=(CharacterType **)malloc(sizeof(CharacterType *)*(total_objects+1));
    780780      }
    781781      else
    782782      {
    783783        object_names=(char **)realloc(object_names,sizeof(char *)*(total_objects+1));
    784     figures=(character_type **)realloc(figures,sizeof(character_type *)*(total_objects+1));
     784    figures=(CharacterType **)realloc(figures,sizeof(CharacterType *)*(total_objects+1));
    785785      }
    786786
    787787      object_names[total_objects] = strdup(lstring_value(sym->GetName()));
    788       figures[total_objects]=new character_type(CDR(args),sym);
     788      figures[total_objects]=new CharacterType((LList *)CDR(args),sym);
    789789      total_objects++;
    790790      return LNumber::Create(total_objects-1);

  • abuse/trunk/src/lisp/lisp.h

    r639 r642  
    304304
    305305// FIXME: get rid of this later
    306 static inline void *symbol_value(void *sym) { return ((LSymbol *)sym)->GetValue(); }
     306static inline LObject *symbol_value(void *sym) { return ((LSymbol *)sym)->GetValue(); }
    307307static inline char *lstring_value(void *str) { return ((LString *)str)->GetString(); }
    308308

  • abuse/trunk/src/morpher.cpp

    r555 r642  
    3838{
    3939  mor=NULL;
    40   character_type *t1=figures[who->otype],*t2=figures[to_type];
     40  CharacterType *t1=figures[who->otype],*t2=figures[to_type];
    4141  if (!t1->has_sequence(morph_pose) || t1->morph_mask<0 ||
    4242      !t2->has_sequence(morph_pose) || t2->morph_mask<0)

  • abuse/trunk/src/objects.cpp

    r636 r642  
    106106      return lvars[figures[otype]->var_index[i]];
    107107/*      LObjectVar *cobj=(LObjectVar *)symbol_value(figures[otype]->vars[i]);
    108       character_type *t=figures[otype];
     108      CharacterType *t=figures[otype];
    109109      int number=cobj->number;
    110110      if (t->tiv<=number || !t->vars[number])
Note: See TracChangeset for help on using the changeset viewer.