[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Stratagus-CVS] stratagus/src/unit ccl_unit.c ccl_unittype.c de...
|
From: |
Jimmy Salmon |
|
Subject: |
[Stratagus-CVS] stratagus/src/unit ccl_unit.c ccl_unittype.c de... |
|
Date: |
Thu, 02 Oct 2003 12:15:07 -0400 |
CVSROOT: /cvsroot/stratagus
Module name: stratagus
Branch:
Changes by: Jimmy Salmon <address@hidden> 03/10/02 12:15:07
Modified files:
src/unit : ccl_unit.c ccl_unittype.c depend.c
Log message:
Cleanup
Patches:
Index: stratagus/src/unit/ccl_unit.c
diff -u stratagus/src/unit/ccl_unit.c:1.67 stratagus/src/unit/ccl_unit.c:1.68
--- stratagus/src/unit/ccl_unit.c:1.67 Thu Sep 18 07:59:21 2003
+++ stratagus/src/unit/ccl_unit.c Thu Oct 2 12:15:05 2003
@@ -26,7 +26,7 @@
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
// 02111-1307, USA.
//
-// $Id: ccl_unit.c,v 1.67 2003/09/18 11:59:21 mr-russ Exp $
+// $Id: ccl_unit.c,v 1.68 2003/10/02 16:15:05 jsalmon3 Exp $
//@{
@@ -172,132 +172,132 @@
//
// Parse the list: (still everything could be changed!)
//
- while( !gh_null_p(list) ) {
- value=gh_car(list);
- list=gh_cdr(list);
- if( gh_eq_p(value,gh_symbol2scm("action-none")) ) {
- order->Action=UnitActionNone;
- } else if( gh_eq_p(value,gh_symbol2scm("action-still")) ) {
- order->Action=UnitActionStill;
- } else if( gh_eq_p(value,gh_symbol2scm("action-stand-ground")) ) {
- order->Action=UnitActionStandGround;
- } else if( gh_eq_p(value,gh_symbol2scm("action-follow")) ) {
- order->Action=UnitActionFollow;
- } else if( gh_eq_p(value,gh_symbol2scm("action-move")) ) {
- order->Action=UnitActionMove;
- } else if( gh_eq_p(value,gh_symbol2scm("action-attack")) ) {
- order->Action=UnitActionAttack;
- } else if( gh_eq_p(value,gh_symbol2scm("action-attack-ground")) ) {
- order->Action=UnitActionAttackGround;
- } else if( gh_eq_p(value,gh_symbol2scm("action-die")) ) {
- order->Action=UnitActionDie;
- } else if( gh_eq_p(value,gh_symbol2scm("action-spell-cast")) ) {
- order->Action=UnitActionSpellCast;
- } else if( gh_eq_p(value,gh_symbol2scm("action-train")) ) {
- order->Action=UnitActionTrain;
- } else if( gh_eq_p(value,gh_symbol2scm("action-upgrade-to")) ) {
- order->Action=UnitActionUpgradeTo;
- } else if( gh_eq_p(value,gh_symbol2scm("action-research")) ) {
- order->Action=UnitActionResearch;
- } else if( gh_eq_p(value,gh_symbol2scm("action-builded")) ) {
- order->Action=UnitActionBuilded;
- } else if( gh_eq_p(value,gh_symbol2scm("action-board")) ) {
- order->Action=UnitActionBoard;
- } else if( gh_eq_p(value,gh_symbol2scm("action-unload")) ) {
- order->Action=UnitActionUnload;
- } else if( gh_eq_p(value,gh_symbol2scm("action-patrol")) ) {
- order->Action=UnitActionPatrol;
- } else if( gh_eq_p(value,gh_symbol2scm("action-build")) ) {
- order->Action=UnitActionBuild;
- } else if( gh_eq_p(value,gh_symbol2scm("action-repair")) ) {
- order->Action=UnitActionRepair;
- } else if( gh_eq_p(value,gh_symbol2scm("action-resource")) ) {
- order->Action=UnitActionResource;
- } else if( gh_eq_p(value,gh_symbol2scm("action-return-goods")) ) {
- order->Action=UnitActionReturnGoods;
- } else if( gh_eq_p(value,gh_symbol2scm("action-demolish")) ) {
- order->Action=UnitActionDemolish;
-
- } else if( gh_eq_p(value,gh_symbol2scm("flags")) ) {
- value=gh_car(list);
- list=gh_cdr(list);
- order->Flags=gh_scm2int(value);
-
- } else if( gh_eq_p(value,gh_symbol2scm("range")) ) {
- sublist=gh_car(list);
- list=gh_cdr(list);
- order->RangeX=gh_scm2int(gh_car(sublist));
- order->RangeY=gh_scm2int(gh_cadr(sublist));
+ while (!gh_null_p(list)) {
+ value = gh_car(list);
+ list = gh_cdr(list);
+ if (gh_eq_p(value, gh_symbol2scm("action-none"))) {
+ order->Action = UnitActionNone;
+ } else if (gh_eq_p(value, gh_symbol2scm("action-still"))) {
+ order->Action = UnitActionStill;
+ } else if (gh_eq_p(value, gh_symbol2scm("action-stand-ground"))) {
+ order->Action = UnitActionStandGround;
+ } else if (gh_eq_p(value, gh_symbol2scm("action-follow"))) {
+ order->Action = UnitActionFollow;
+ } else if (gh_eq_p(value, gh_symbol2scm("action-move"))) {
+ order->Action = UnitActionMove;
+ } else if (gh_eq_p(value, gh_symbol2scm("action-attack"))) {
+ order->Action = UnitActionAttack;
+ } else if (gh_eq_p(value, gh_symbol2scm("action-attack-ground"))) {
+ order->Action = UnitActionAttackGround;
+ } else if (gh_eq_p(value, gh_symbol2scm("action-die"))) {
+ order->Action = UnitActionDie;
+ } else if (gh_eq_p(value, gh_symbol2scm("action-spell-cast"))) {
+ order->Action = UnitActionSpellCast;
+ } else if (gh_eq_p(value, gh_symbol2scm("action-train"))) {
+ order->Action = UnitActionTrain;
+ } else if (gh_eq_p(value, gh_symbol2scm("action-upgrade-to"))) {
+ order->Action = UnitActionUpgradeTo;
+ } else if (gh_eq_p(value, gh_symbol2scm("action-research"))) {
+ order->Action = UnitActionResearch;
+ } else if (gh_eq_p(value, gh_symbol2scm("action-builded"))) {
+ order->Action = UnitActionBuilded;
+ } else if (gh_eq_p(value, gh_symbol2scm("action-board"))) {
+ order->Action = UnitActionBoard;
+ } else if (gh_eq_p(value, gh_symbol2scm("action-unload"))) {
+ order->Action = UnitActionUnload;
+ } else if (gh_eq_p(value, gh_symbol2scm("action-patrol"))) {
+ order->Action = UnitActionPatrol;
+ } else if (gh_eq_p(value, gh_symbol2scm("action-build"))) {
+ order->Action = UnitActionBuild;
+ } else if (gh_eq_p(value, gh_symbol2scm("action-repair"))) {
+ order->Action = UnitActionRepair;
+ } else if (gh_eq_p(value, gh_symbol2scm("action-resource"))) {
+ order->Action = UnitActionResource;
+ } else if (gh_eq_p(value, gh_symbol2scm("action-return-goods"))) {
+ order->Action = UnitActionReturnGoods;
+ } else if (gh_eq_p(value, gh_symbol2scm("action-demolish"))) {
+ order->Action = UnitActionDemolish;
- } else if( gh_eq_p(value,gh_symbol2scm("goal")) ) {
+ } else if (gh_eq_p(value, gh_symbol2scm("flags"))) {
+ value = gh_car(list);
+ list = gh_cdr(list);
+ order->Flags = gh_scm2int(value);
+
+ } else if (gh_eq_p(value, gh_symbol2scm("range"))) {
+ sublist = gh_car(list);
+ list = gh_cdr(list);
+ order->RangeX = gh_scm2int(gh_car(sublist));
+ order->RangeY = gh_scm2int(gh_cadr(sublist));
+
+ } else if (gh_eq_p(value, gh_symbol2scm("goal"))) {
char* str;
int slot;
- value=gh_car(list);
- list=gh_cdr(list);
- str=gh_scm2newstr(value,NULL);
-
- slot=strtol(str+1,NULL,16);
- order->Goal=UnitSlots[slot];
- if( !UnitSlots[slot] ) {
+ value = gh_car(list);
+ list = gh_cdr(list);
+ str = gh_scm2newstr(value,NULL);
+
+ slot = strtol(str + 1, NULL, 16);
+ order->Goal = UnitSlots[slot];
+ if (!UnitSlots[slot]) {
DebugLevel0Fn("FIXME: Forward reference not supported\n");
}
++UnitSlots[slot]->Refs;
free(str);
- } else if( gh_eq_p(value,gh_symbol2scm("tile")) ) {
- sublist=gh_car(list);
- list=gh_cdr(list);
- order->X=gh_scm2int(gh_car(sublist));
- order->Y=gh_scm2int(gh_cadr(sublist));
+ } else if (gh_eq_p(value, gh_symbol2scm("tile"))) {
+ sublist = gh_car(list);
+ list = gh_cdr(list);
+ order->X = gh_scm2int(gh_car(sublist));
+ order->Y = gh_scm2int(gh_cadr(sublist));
- } else if( gh_eq_p(value,gh_symbol2scm("type")) ) {
+ } else if (gh_eq_p(value, gh_symbol2scm("type"))) {
char* str;
- value=gh_car(list);
- list=gh_cdr(list);
- str=gh_scm2newstr(value,NULL);
- order->Type=UnitTypeByIdent(str);
+ value = gh_car(list);
+ list = gh_cdr(list);
+ str = gh_scm2newstr(value,NULL);
+ order->Type = UnitTypeByIdent(str);
free(str);
- } else if( gh_eq_p(value,gh_symbol2scm("patrol")) ) {
- sublist=gh_car(list);
- list=gh_cdr(list);
- order->Arg1=(void*)((gh_scm2int(gh_car(sublist))<<16)|
- gh_scm2int(gh_cadr(sublist)));
+ } else if (gh_eq_p(value, gh_symbol2scm("patrol"))) {
+ sublist = gh_car(list);
+ list = gh_cdr(list);
+ order->Arg1 = (void*)((gh_scm2int(gh_car(sublist)) << 16) |
+ gh_scm2int(gh_cadr(sublist)));
- } else if( gh_eq_p(value,gh_symbol2scm("spell")) ) {
+ } else if (gh_eq_p(value, gh_symbol2scm("spell"))) {
char* str;
- value=gh_car(list);
- list=gh_cdr(list);
- str=gh_scm2newstr(value,NULL);
- order->Arg1=SpellTypeByIdent(str);
+ value = gh_car(list);
+ list = gh_cdr(list);
+ str = gh_scm2newstr(value, NULL);
+ order->Arg1 = SpellTypeByIdent(str);
free(str);
- } else if( gh_eq_p(value,gh_symbol2scm("upgrade")) ) {
+ } else if (gh_eq_p(value, gh_symbol2scm("upgrade"))) {
char* str;
- value=gh_car(list);
- list=gh_cdr(list);
- str=gh_scm2newstr(value,NULL);
- order->Arg1=UpgradeByIdent(str);
+ value = gh_car(list);
+ list = gh_cdr(list);
+ str = gh_scm2newstr(value, NULL);
+ order->Arg1 = UpgradeByIdent(str);
free(str);
- } else if( gh_eq_p(value,gh_symbol2scm("mine")) ) {
- sublist=gh_car(list);
- list=gh_cdr(list);
- order->Arg1=(void*)((gh_scm2int(gh_car(sublist))<<16)|
- gh_scm2int(gh_cadr(sublist)));
-
- } else if( gh_eq_p(value,gh_symbol2scm("arg1")) ) {
- value=gh_car(list);
- list=gh_cdr(list);
- order->Arg1 = (void * )gh_scm2int(value);
+ } else if (gh_eq_p(value, gh_symbol2scm("mine"))) {
+ sublist = gh_car(list);
+ list = gh_cdr(list);
+ order->Arg1 = (void*)((gh_scm2int(gh_car(sublist)) << 16) |
+ gh_scm2int(gh_cadr(sublist)));
+
+ } else if (gh_eq_p(value, gh_symbol2scm("arg1"))) {
+ value = gh_car(list);
+ list = gh_cdr(list);
+ order->Arg1 = (void*)gh_scm2int(value);
} else {
// FIXME: this leaves a half initialized unit
- errl("Unsupported tag",value);
+ errl("Unsupported tag", value);
}
}
}
@@ -308,15 +308,15 @@
** @param unit Unit pointer which should get the orders.
** @param vector All options of the order.
*/
-local void CclParseOrders(Unit* unit,SCM vector)
+local void CclParseOrders(Unit* unit, SCM vector)
{
int i;
int n;
n=gh_vector_length(vector);
- DebugCheck( n!=MAX_ORDERS );
- for( i=0; i<n; ++i ) {
- CclParseOrder(gh_vector_ref(vector,gh_int2scm(i)),&unit->Orders[i]);
+ DebugCheck(n != MAX_ORDERS);
+ for (i = 0; i < n; ++i) {
+ CclParseOrder(gh_vector_ref(vector, gh_int2scm(i)), &unit->Orders[i]);
}
}
@@ -340,7 +340,7 @@
value = gh_car(list);
str = gh_scm2newstr(value, NULL);
slot = strtol(str + 1, NULL, 16);
- DebugCheck( !UnitSlots[slot] );
+ DebugCheck(!UnitSlots[slot]);
unit->Data.Builded.Worker = UnitSlots[slot];
++UnitSlots[slot]->Refs;
free(str);
@@ -356,7 +356,7 @@
frame = gh_scm2int(gh_car(list));
cframe = unit->Type->Construction->Frames;
- while( frame-- ) {
+ while (frame--) {
cframe = cframe->Next;
}
unit->Data.Builded.Frame = cframe;
@@ -445,23 +445,23 @@
SCM sublist;
int i;
- while ( !gh_null_p(list) ) {
+ while (!gh_null_p(list)) {
value = gh_car(list);
list = gh_cdr(list);
- if (gh_eq_p(value, gh_symbol2scm("ticks")) ) {
+ if (gh_eq_p(value, gh_symbol2scm("ticks"))) {
value = gh_car(list);
list = gh_cdr(list);
unit->Data.Train.Ticks = gh_scm2int(value);
- } else if (gh_eq_p(value, gh_symbol2scm("count")) ) {
+ } else if (gh_eq_p(value, gh_symbol2scm("count"))) {
value = gh_car(list);
list = gh_cdr(list);
unit->Data.Train.Count = gh_scm2int(value);
- } else if (gh_eq_p(value, gh_symbol2scm("queue")) ) {
- sublist=gh_car(list);
- list=gh_cdr(list);
- for (i=0; i<MAX_UNIT_TRAIN; ++i) {
+ } else if (gh_eq_p(value, gh_symbol2scm("queue"))) {
+ sublist = gh_car(list);
+ list = gh_cdr(list);
+ for (i = 0; i < MAX_UNIT_TRAIN; ++i) {
value = gh_vector_ref(sublist, gh_int2scm(i));
- if ( gh_eq_p(value, gh_symbol2scm("unit-none")) ) {
+ if (gh_eq_p(value, gh_symbol2scm("unit-none"))) {
unit->Data.Train.What[i] = NULL;
} else {
char *ident;
@@ -486,19 +486,19 @@
SCM sublist;
int i;
- while ( !gh_null_p(list) ) {
+ while (!gh_null_p(list)) {
value = gh_car(list);
list = gh_cdr(list);
- if (gh_eq_p(value, gh_symbol2scm("fast")) ) {
+ if (gh_eq_p(value, gh_symbol2scm("fast"))) {
unit->Data.Move.Fast = 1;
- } else if (gh_eq_p(value, gh_symbol2scm("path")) ) {
+ } else if (gh_eq_p(value, gh_symbol2scm("path"))) {
int len;
- sublist=gh_car(list);
+ sublist = gh_car(list);
list = gh_cdr(list);
len = gh_length(sublist);
- for( i=0; i<len; ++i ) {
+ for (i = 0; i < len; ++i) {
value = gh_vector_ref(sublist, gh_int2scm(i));
- unit->Data.Move.Path[i]=gh_scm2int(value);
+ unit->Data.Move.Path[i] = gh_scm2int(value);
}
unit->Data.Move.Length = len;
}
@@ -520,42 +520,43 @@
Player* player;
int slot;
int i;
- int insidecount=-1;
+ int insidecount;
char* str;
char* s;
- slot=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
+ insidecount = -1;
+ slot = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
DebugLevel3Fn("parsing unit #%d\n" _C_ slot);
- unit=NULL;
- type=NULL;
- seentype=NULL;
- player=NULL;
- i=0;
+ unit = NULL;
+ type = NULL;
+ seentype = NULL;
+ player = NULL;
+ i = 0;
//
// Parse the list: (still everything could be changed!)
//
- while( !gh_null_p(list) ) {
+ while (!gh_null_p(list)) {
- value=gh_car(list);
- list=gh_cdr(list);
+ value = gh_car(list);
+ list = gh_cdr(list);
- if( gh_eq_p(value,gh_symbol2scm("type")) ) {
- type=UnitTypeByIdent(str=gh_scm2newstr(gh_car(list),NULL));
+ if (gh_eq_p(value, gh_symbol2scm("type"))) {
+ type=UnitTypeByIdent(str = gh_scm2newstr(gh_car(list),NULL));
free(str);
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("seen-type")) ) {
- seentype=UnitTypeByIdent(str=gh_scm2newstr(gh_car(list),NULL));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("seen-type"))) {
+ seentype=UnitTypeByIdent(str = gh_scm2newstr(gh_car(list),NULL));
free(str);
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("name")) ) {
- unit->Name=gh_scm2newstr(gh_car(list),NULL);
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("player")) ) {
- player=&Players[gh_scm2int(gh_car(list))];
- list=gh_cdr(list);
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("name"))) {
+ unit->Name = gh_scm2newstr(gh_car(list),NULL);
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("player"))) {
+ player = &Players[gh_scm2int(gh_car(list))];
+ list = gh_cdr(list);
// During a unit's death animation (when action is "die" but the
// unit still has its original type, i.e. it's still not a corpse)
@@ -567,275 +568,275 @@
// characterized by unit->HP==0 and by
// unit->Orders[0].Action==UnitActionDie so we have to wait
// until we parsed at least Unit::Orders[].
- DebugCheck( !type );
+ DebugCheck(!type);
unit = UnitSlots[slot];
InitUnit(unit, type);
- unit->SeenType=seentype;
- unit->Active=0;
- unit->Removed=0;
- unit->Reset=0; // JOHNS ????
- DebugCheck( unit->Slot!=slot );
- } else if( gh_eq_p(value,gh_symbol2scm("next")) ) {
- unit->Next=UnitSlots[gh_scm2int(gh_car(list))];
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("current-sight-range")) ) {
- unit->CurrentSightRange=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("host-info")) ) {
- value=gh_car(list);
- list=gh_cdr(list);
-
MapMarkSight(player,gh_scm2int(gh_car(value)),gh_scm2int(gh_cadr(value)),
- gh_scm2int(gh_cadr(gh_cdr(value))),
- gh_scm2int(gh_cadr(gh_cdr(gh_cdr(value)))),
- unit->CurrentSightRange);
- } else if( gh_eq_p(value,gh_symbol2scm("tile")) ) {
- value=gh_car(list);
- list=gh_cdr(list);
- unit->X=gh_scm2int(gh_car(value));
- unit->Y=gh_scm2int(gh_cadr(value));
- } else if( gh_eq_p(value,gh_symbol2scm("stats")) ) {
- unit->Stats=&type->Stats[gh_scm2int(gh_car(list))];
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("pixel")) ) {
- value=gh_car(list);
- list=gh_cdr(list);
- unit->IX=gh_scm2int(gh_car(value));
- unit->IY=gh_scm2int(gh_cadr(value));
- } else if( gh_eq_p(value,gh_symbol2scm("seen-pixel")) ) {
- value=gh_car(list);
- list=gh_cdr(list);
- unit->SeenIX=gh_scm2int(gh_car(value));
- unit->SeenIY=gh_scm2int(gh_cadr(value));
- } else if( gh_eq_p(value,gh_symbol2scm("frame")) ) {
- unit->Frame=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("flipped-frame")) ) {
- unit->Frame=-gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("seen")) ) {
- unit->SeenFrame=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("flipped-seen")) ) {
- unit->SeenFrame=-gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("not-seen")) ) {
- unit->SeenFrame=UnitNotSeen;
- } else if( gh_eq_p(value,gh_symbol2scm("direction")) ) {
- unit->Direction=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("attacked")) ) {
- unit->Attacked=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("burning")) ) {
- unit->Burning=1;
- } else if( gh_eq_p(value,gh_symbol2scm("destroyed")) ) {
- unit->Destroyed=1;
- } else if( gh_eq_p(value,gh_symbol2scm("seen-destroyed")) ) {
- unit->SeenDestroyed=1;
- } else if( gh_eq_p(value,gh_symbol2scm("removed")) ) {
- unit->Removed=1;
- } else if( gh_eq_p(value,gh_symbol2scm("selected")) ) {
- unit->Selected=1;
- } else if( gh_eq_p(value,gh_symbol2scm("rescued-from")) ) {
- unit->RescuedFrom=&Players[gh_scm2int(gh_car(list))];
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("visible")) ) {
- str=s=gh_scm2newstr(gh_car(list),NULL);
- list=gh_cdr(list);
- for( i=0; i<PlayerMax && *s; ++i,++s ) {
- if( *s=='-' || *s=='_' || *s==' ' ) {
- unit->Visible&=~(1<<i);
+ unit->SeenType = seentype;
+ unit->Active = 0;
+ unit->Removed = 0;
+ unit->Reset = 0; // JOHNS ????
+ DebugCheck(unit->Slot != slot);
+ } else if (gh_eq_p(value, gh_symbol2scm("next"))) {
+ unit->Next = UnitSlots[gh_scm2int(gh_car(list))];
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("current-sight-range"))) {
+ unit->CurrentSightRange = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("host-info"))) {
+ value = gh_car(list);
+ list = gh_cdr(list);
+ MapMarkSight(player, gh_scm2int(gh_car(value)),
gh_scm2int(gh_cadr(value)),
+ gh_scm2int(gh_cadr(gh_cdr(value))),
+ gh_scm2int(gh_cadr(gh_cdr(gh_cdr(value)))),
+ unit->CurrentSightRange);
+ } else if (gh_eq_p(value, gh_symbol2scm("tile"))) {
+ value = gh_car(list);
+ list = gh_cdr(list);
+ unit->X = gh_scm2int(gh_car(value));
+ unit->Y = gh_scm2int(gh_cadr(value));
+ } else if (gh_eq_p(value, gh_symbol2scm("stats"))) {
+ unit->Stats = &type->Stats[gh_scm2int(gh_car(list))];
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("pixel"))) {
+ value = gh_car(list);
+ list = gh_cdr(list);
+ unit->IX = gh_scm2int(gh_car(value));
+ unit->IY = gh_scm2int(gh_cadr(value));
+ } else if (gh_eq_p(value, gh_symbol2scm("seen-pixel"))) {
+ value = gh_car(list);
+ list = gh_cdr(list);
+ unit->SeenIX = gh_scm2int(gh_car(value));
+ unit->SeenIY = gh_scm2int(gh_cadr(value));
+ } else if (gh_eq_p(value, gh_symbol2scm("frame"))) {
+ unit->Frame = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("flipped-frame"))) {
+ unit->Frame = -gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("seen"))) {
+ unit->SeenFrame = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("flipped-seen"))) {
+ unit->SeenFrame = -gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("not-seen"))) {
+ unit->SeenFrame = UnitNotSeen;
+ } else if (gh_eq_p(value, gh_symbol2scm("direction"))) {
+ unit->Direction = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("attacked"))) {
+ unit->Attacked = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("burning"))) {
+ unit->Burning = 1;
+ } else if (gh_eq_p(value, gh_symbol2scm("destroyed"))) {
+ unit->Destroyed = 1;
+ } else if (gh_eq_p(value, gh_symbol2scm("seen-destroyed"))) {
+ unit->SeenDestroyed = 1;
+ } else if (gh_eq_p(value, gh_symbol2scm("removed"))) {
+ unit->Removed = 1;
+ } else if (gh_eq_p(value, gh_symbol2scm("selected"))) {
+ unit->Selected = 1;
+ } else if (gh_eq_p(value, gh_symbol2scm("rescued-from"))) {
+ unit->RescuedFrom = &Players[gh_scm2int(gh_car(list))];
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("visible"))) {
+ str=s = gh_scm2newstr(gh_car(list), NULL);
+ list = gh_cdr(list);
+ for (i = 0; i < PlayerMax && *s; ++i, ++s) {
+ if (*s == '-' || *s == '_' || *s == ' ') {
+ unit->Visible &= ~(1 << i);
} else {
- unit->Visible|=(1<<i);
+ unit->Visible |= (1 << i);
}
}
free(str);
- } else if( gh_eq_p(value,gh_symbol2scm("constructed")) ) {
- unit->Constructed=1;
- } else if( gh_eq_p(value,gh_symbol2scm("seen-constructed")) ) {
- unit->SeenConstructed=1;
- } else if( gh_eq_p(value,gh_symbol2scm("seen-state")) ) {
- unit->SeenState=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("active")) ) {
- unit->Active=1;
- } else if( gh_eq_p(value,gh_symbol2scm("resource-active")) ) {
- unit->Data.Resource.Active=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("mana")) ) {
- unit->Mana=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("hp")) ) {
- unit->HP=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("xp")) ) {
- unit->XP=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("kills")) ) {
- unit->Kills=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("ttl")) ) {
- unit->TTL=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("bloodlust")) ) {
- unit->Bloodlust=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("haste")) ) {
- unit->Haste=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("slow")) ) {
- unit->Slow=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("invisible")) ) {
- unit->Invisible=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("flame-shield")) ) {
- unit->FlameShield=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("unholy-armor")) ) {
- unit->UnholyArmor=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("group-id")) ) {
- unit->GroupId=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("last-group")) ) {
- unit->LastGroup=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("value")) ) {
- unit->Value=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("current-resource")) ) {
- unit->CurrentResource=CclGetResourceByName(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("sub-action")) ) {
- unit->SubAction=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("wait")) ) {
- unit->Wait=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("state")) ) {
- unit->State=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("reset")) ) {
- unit->Reset=1;
- } else if( gh_eq_p(value,gh_symbol2scm("blink")) ) {
- unit->Blink=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("moving")) ) {
- unit->Moving=1;
- } else if( gh_eq_p(value,gh_symbol2scm("rs")) ) {
- unit->Rs=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("units-contained-count")) ) {
- insidecount=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("units-contained")) ) {
- sublist=gh_car(list);
- list=gh_cdr(list);
- for (i=0;i<insidecount;i++) {
- value=gh_vector_ref(sublist,gh_int2scm(i));
- if( !gh_null_p(value) ) {
- str=gh_scm2newstr(value,NULL);
- slot=strtol(str+1,NULL,16);
- AddUnitInContainer(UnitSlots[slot],unit);
- DebugCheck( !UnitSlots[slot] );
+ } else if (gh_eq_p(value, gh_symbol2scm("constructed"))) {
+ unit->Constructed = 1;
+ } else if (gh_eq_p(value, gh_symbol2scm("seen-constructed"))) {
+ unit->SeenConstructed = 1;
+ } else if (gh_eq_p(value, gh_symbol2scm("seen-state"))) {
+ unit->SeenState = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("active"))) {
+ unit->Active = 1;
+ } else if (gh_eq_p(value, gh_symbol2scm("resource-active"))) {
+ unit->Data.Resource.Active = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("mana"))) {
+ unit->Mana = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("hp"))) {
+ unit->HP = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("xp"))) {
+ unit->XP = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("kills"))) {
+ unit->Kills = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("ttl"))) {
+ unit->TTL = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("bloodlust"))) {
+ unit->Bloodlust = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("haste"))) {
+ unit->Haste = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("slow"))) {
+ unit->Slow = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("invisible"))) {
+ unit->Invisible = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("flame-shield"))) {
+ unit->FlameShield = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("unholy-armor"))) {
+ unit->UnholyArmor = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("group-id"))) {
+ unit->GroupId = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("last-group"))) {
+ unit->LastGroup = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("value"))) {
+ unit->Value = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("current-resource"))) {
+ unit->CurrentResource = CclGetResourceByName(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("sub-action"))) {
+ unit->SubAction = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("wait"))) {
+ unit->Wait = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("state"))) {
+ unit->State = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("reset"))) {
+ unit->Reset = 1;
+ } else if (gh_eq_p(value, gh_symbol2scm("blink"))) {
+ unit->Blink = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("moving"))) {
+ unit->Moving = 1;
+ } else if (gh_eq_p(value, gh_symbol2scm("rs"))) {
+ unit->Rs = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("units-contained-count"))) {
+ insidecount = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("units-contained"))) {
+ sublist = gh_car(list);
+ list = gh_cdr(list);
+ for (i = 0; i < insidecount; ++i) {
+ value = gh_vector_ref(sublist, gh_int2scm(i));
+ if (!gh_null_p(value)) {
+ str = gh_scm2newstr(value, NULL);
+ slot = strtol(str + 1, NULL, 16);
+ AddUnitInContainer(UnitSlots[slot], unit);
+ DebugCheck(!UnitSlots[slot]);
++UnitSlots[slot]->Refs;
free(str);
}
}
- } else if( gh_eq_p(value,gh_symbol2scm("order-count")) ) {
- unit->OrderCount=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("order-flush")) ) {
- unit->OrderFlush=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("orders")) ) {
+ } else if (gh_eq_p(value, gh_symbol2scm("order-count"))) {
+ unit->OrderCount = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("order-flush"))) {
+ unit->OrderFlush = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("orders"))) {
int hp;
- sublist=gh_car(list);
- list=gh_cdr(list);
+ sublist = gh_car(list);
+ list = gh_cdr(list);
CclParseOrders(unit,sublist);
// now we know unit's action so we can assign it to a player
hp = unit->HP;
AssignUnitToPlayer (unit, player);
unit->HP = hp;
- if( unit->Orders[0].Action==UnitActionBuilded ) {
+ if (unit->Orders[0].Action == UnitActionBuilded) {
// HACK: the building is not ready yet
unit->Player->UnitTypesCount[type->Type]--;
}
// FIXME: (mr-russ) Does not load CorpseList Properly
- if( unit->Type->Building &&
- ( unit->Orders[0].Action==UnitActionDie || unit->Destroyed )) {
+ if (unit->Type->Building &&
+ (unit->Orders[0].Action == UnitActionDie ||
unit->Destroyed)) {
DeadBuildingCacheInsert(unit);
- } else if( unit->Orders[0].Action==UnitActionDie ) {
+ } else if (unit->Orders[0].Action == UnitActionDie) {
CorpseCacheInsert(unit);
}
#if 0
- if( unit->Orders[0].Action==UnitActionDie &&
- unit->Type->CorpseScript ) {
+ if (unit->Orders[0].Action == UnitActionDie &&
+ unit->Type->CorpseScript) {
MapMarkUnitSight(unit);
}
#endif
- } else if( gh_eq_p(value,gh_symbol2scm("saved-order")) ) {
- value=gh_car(list);
- list=gh_cdr(list);
- CclParseOrder(value,&unit->SavedOrder);
- } else if( gh_eq_p(value,gh_symbol2scm("new-order")) ) {
- value=gh_car(list);
- list=gh_cdr(list);
- CclParseOrder(value,&unit->NewOrder);
- } else if( gh_eq_p(value,gh_symbol2scm("data-builded")) ) {
- sublist=gh_car(list);
- list=gh_cdr(list);
- CclParseBuilded(unit,sublist);
- } else if( gh_eq_p(value,gh_symbol2scm("data-res-worker")) ) {
- sublist=gh_car(list);
- list=gh_cdr(list);
- CclParseResWorker(unit,sublist);
- } else if( gh_eq_p(value,gh_symbol2scm("data-research")) ) {
- sublist=gh_car(list);
- list=gh_cdr(list);
- CclParseResearch(unit,sublist);
- } else if( gh_eq_p(value,gh_symbol2scm("data-upgrade-to")) ) {
- sublist=gh_car(list);
- list=gh_cdr(list);
- CclParseUpgradeTo(unit,sublist);
- } else if( gh_eq_p(value,gh_symbol2scm("data-train")) ) {
- sublist=gh_car(list);
- list=gh_cdr(list);
- CclParseTrain(unit,sublist);
- } else if( gh_eq_p(value,gh_symbol2scm("data-move")) ) {
- sublist=gh_car(list);
- list=gh_cdr(list);
- CclParseMove(unit,sublist);
- } else if( gh_eq_p(value,gh_symbol2scm("goal")) ) {
+ } else if (gh_eq_p(value, gh_symbol2scm("saved-order"))) {
+ value = gh_car(list);
+ list = gh_cdr(list);
+ CclParseOrder(value, &unit->SavedOrder);
+ } else if (gh_eq_p(value, gh_symbol2scm("new-order"))) {
+ value = gh_car(list);
+ list = gh_cdr(list);
+ CclParseOrder(value, &unit->NewOrder);
+ } else if (gh_eq_p(value, gh_symbol2scm("data-builded"))) {
+ sublist = gh_car(list);
+ list = gh_cdr(list);
+ CclParseBuilded(unit, sublist);
+ } else if (gh_eq_p(value, gh_symbol2scm("data-res-worker"))) {
+ sublist = gh_car(list);
+ list = gh_cdr(list);
+ CclParseResWorker(unit, sublist);
+ } else if (gh_eq_p(value, gh_symbol2scm("data-research"))) {
+ sublist = gh_car(list);
+ list = gh_cdr(list);
+ CclParseResearch(unit, sublist);
+ } else if (gh_eq_p(value, gh_symbol2scm("data-upgrade-to"))) {
+ sublist = gh_car(list);
+ list = gh_cdr(list);
+ CclParseUpgradeTo(unit, sublist);
+ } else if (gh_eq_p(value, gh_symbol2scm("data-train"))) {
+ sublist = gh_car(list);
+ list = gh_cdr(list);
+ CclParseTrain(unit, sublist);
+ } else if (gh_eq_p(value, gh_symbol2scm("data-move"))) {
+ sublist = gh_car(list);
+ list = gh_cdr(list);
+ CclParseMove(unit, sublist);
+ } else if (gh_eq_p(value, gh_symbol2scm("goal"))) {
unit->Goal=UnitSlots[gh_scm2int(gh_car(list))];
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("auto-cast")) ) {
- str=gh_scm2newstr(gh_car(list),NULL);
- unit->AutoCastSpell=SpellTypeByIdent(str);
- list=gh_cdr(list);
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("auto-cast"))) {
+ str = gh_scm2newstr(gh_car(list),NULL);
+ unit->AutoCastSpell = SpellTypeByIdent(str);
+ list = gh_cdr(list);
free(str);
} else {
// FIXME: this leaves a half initialized unit
- errl("Unsupported tag",value);
+ errl("Unsupported tag", value);
}
}
if (!unit->Player) {
AssignUnitToPlayer (unit, player);
- UpdateForNewUnit(unit,0);
+ UpdateForNewUnit(unit, 0);
unit->HP = unit->Type->_HitPoints;
}
// Revealers are units that can see while removed
- if ( unit->Removed && unit->Type->Revealer ) {
+ if (unit->Removed && unit->Type->Revealer) {
MapMarkUnitSight(unit);
}
// Place on map
- if( !unit->Removed && !unit->Destroyed && !unit->Type->Vanishes ) {
- unit->Removed=1;
- PlaceUnit(unit,unit->X,unit->Y);
+ if (!unit->Removed && !unit->Destroyed && !unit->Type->Vanishes) {
+ unit->Removed = 1;
+ PlaceUnit(unit, unit->X, unit->Y);
}
// FIXME: johns: works only for debug code.
@@ -844,7 +845,7 @@
}
// Fix Colors for rescued units.
if (unit->RescuedFrom) {
- unit->Colors=&unit->RescuedFrom->UnitColors;
+ unit->Colors = &unit->RescuedFrom->UnitColors;
}
DebugLevel3Fn("unit #%d parsed\n" _C_ slot);
@@ -859,13 +860,13 @@
**
** @return Returns the slot number of the made unit.
*/
-local SCM CclMakeUnit(SCM type,SCM player)
+local SCM CclMakeUnit(SCM type, SCM player)
{
UnitType* unittype;
Unit* unit;
- unittype=CclGetUnitType(type);
- unit=MakeUnit(unittype,&Players[gh_scm2int(player)]);
+ unittype = CclGetUnitType(type);
+ unit = MakeUnit(unittype, &Players[gh_scm2int(player)]);
return gh_int2scm(unit->Slot);
}
@@ -879,9 +880,9 @@
**
** @return Returns the slot number of the made placed.
*/
-local SCM CclPlaceUnit(SCM unit,SCM x,SCM y)
+local SCM CclPlaceUnit(SCM unit, SCM x, SCM y)
{
- PlaceUnit(CclGetUnit(unit),gh_scm2int(x),gh_scm2int(y));
+ PlaceUnit(CclGetUnit(unit), gh_scm2int(x), gh_scm2int(y));
return unit;
}
@@ -895,7 +896,7 @@
**
** @return Returns the slot number of the made unit.
*/
-local SCM CclCreateUnit(SCM type,SCM player,SCM x,SCM y)
+local SCM CclCreateUnit(SCM type, SCM player, SCM x, SCM y)
{
UnitType* unittype;
Unit* unit;
@@ -904,20 +905,20 @@
int ix;
int iy;
- unittype=CclGetUnitType(type);
- ix=gh_scm2int(x);
- iy=gh_scm2int(y);
-
- heading=SyncRand()%256;
- unit=MakeUnit(unittype,&Players[gh_scm2int(player)]);
- mask=UnitMovementMask(unit);
- if( CheckedCanMoveToMask(ix,iy,mask) ) {
- unit->Wait=1;
- PlaceUnit(unit,ix,iy);
+ unittype = CclGetUnitType(type);
+ ix = gh_scm2int(x);
+ iy = gh_scm2int(y);
+
+ heading = SyncRand() % 256;
+ unit = MakeUnit(unittype, &Players[gh_scm2int(player)]);
+ mask = UnitMovementMask(unit);
+ if (CheckedCanMoveToMask(ix, iy, mask)) {
+ unit->Wait = 1;
+ PlaceUnit(unit, ix, iy);
} else {
- unit->X=ix;
- unit->Y=iy;
- DropOutOnSide(unit,heading,unittype->TileWidth,unittype->TileHeight);
+ unit->X = ix;
+ unit->Y = iy;
+ DropOutOnSide(unit, heading, unittype->TileWidth, unittype->TileHeight);
}
return gh_int2scm(unit->Slot);
@@ -947,45 +948,45 @@
char* order;
plynr=TriggerGetPlayer(gh_car(list));
- list=gh_cdr(list);
- unittype=TriggerGetUnitType(gh_car(list));
- list=gh_cdr(list);
- x1=gh_scm2int(gh_car(gh_car(list)));
- y1=gh_scm2int(gh_car(gh_cdr(gh_car(list))));
- x2=gh_scm2int(gh_car(gh_cdr(gh_cdr(gh_car(list)))));
- y2=gh_scm2int(gh_car(gh_cdr(gh_cdr(gh_cdr(gh_car(list))))));
- list=gh_cdr(list);
- dx1=gh_scm2int(gh_car(gh_car(list)));
- dy1=gh_scm2int(gh_car(gh_cdr(gh_car(list))));
- if( !gh_null_p(gh_cdr(gh_cdr(gh_car(list)))) ) {
- dx2=gh_scm2int(gh_car(gh_cdr(gh_cdr(gh_car(list)))));
- dy2=gh_scm2int(gh_car(gh_cdr(gh_cdr(gh_cdr(gh_car(list))))));
+ list = gh_cdr(list);
+ unittype = TriggerGetUnitType(gh_car(list));
+ list = gh_cdr(list);
+ x1 = gh_scm2int(gh_car(gh_car(list)));
+ y1 = gh_scm2int(gh_car(gh_cdr(gh_car(list))));
+ x2 = gh_scm2int(gh_car(gh_cdr(gh_cdr(gh_car(list)))));
+ y2 = gh_scm2int(gh_car(gh_cdr(gh_cdr(gh_cdr(gh_car(list))))));
+ list = gh_cdr(list);
+ dx1 = gh_scm2int(gh_car(gh_car(list)));
+ dy1 = gh_scm2int(gh_car(gh_cdr(gh_car(list))));
+ if (!gh_null_p(gh_cdr(gh_cdr(gh_car(list))))) {
+ dx2 = gh_scm2int(gh_car(gh_cdr(gh_cdr(gh_car(list)))));
+ dy2 = gh_scm2int(gh_car(gh_cdr(gh_cdr(gh_cdr(gh_car(list))))));
} else {
- dx2=dx1;
- dy2=dy1;
+ dx2 = dx1;
+ dy2 = dy1;
}
- list=gh_cdr(list);
- order=gh_scm2newstr(gh_car(list),NULL);
+ list = gh_cdr(list);
+ order = gh_scm2newstr(gh_car(list),NULL);
- an=SelectUnits(x1,y1,x2+1,y2+1,table);
- for( j=0; j<an; ++j ) {
- unit=table[j];
- if( unittype==ANY_UNIT
- || (unittype==ALL_FOODUNITS && !unit->Type->Building)
- || (unittype==ALL_BUILDINGS && unit->Type->Building)
- || unittype==unit->Type ) {
- if( plynr==-1 || plynr==unit->Player->Player ) {
- if( !strcmp(order,"move") ) {
- CommandMove(unit,(dx1+dx2)/2,(dy1+dy2)/2,1);
- } else if( !strcmp(order,"attack") ) {
+ an = SelectUnits(x1, y1, x2 + 1, y2 + 1, table);
+ for (j = 0; j < an; ++j) {
+ unit = table[j];
+ if (unittype == ANY_UNIT ||
+ (unittype == ALL_FOODUNITS && !unit->Type->Building) ||
+ (unittype == ALL_BUILDINGS && unit->Type->Building) ||
+ unittype == unit->Type) {
+ if (plynr == -1 || plynr == unit->Player->Player) {
+ if (!strcmp(order,"move")) {
+ CommandMove(unit, (dx1 + dx2) / 2, (dy1 + dy2) / 2, 1);
+ } else if (!strcmp(order, "attack")) {
Unit* attack;
- attack=TargetOnMap(unit,dx1,dy1,dx2,dy2);
- CommandAttack(unit,(dx1+dx2)/2,(dy1+dy2)/2,attack,1);
- } else if( !strcmp(order,"patrol") ) {
- CommandPatrolUnit(unit,(dx1+dx2)/2,(dy1+dy2)/2,1);
+ attack=TargetOnMap(unit, dx1, dy1, dx2, dy2);
+ CommandAttack(unit, (dx1 + dx2) / 2, (dy1 + dy2) / 2,
attack, 1);
+ } else if (!strcmp(order,"patrol")) {
+ CommandPatrolUnit(unit, (dx1 + dx2) / 2, (dy1 + dy2) / 2,
1);
} else {
- errl("Unsupported order",gh_car(list));
+ errl("Unsupported order", gh_car(list));
}
}
}
@@ -1003,7 +1004,7 @@
**
** @return Returns true if a unit was killed.
*/
-local SCM CclKillUnit(SCM type,SCM player)
+local SCM CclKillUnit(SCM type, SCM player)
{
int j;
int plynr;
@@ -1011,22 +1012,22 @@
Unit* unit;
Unit** table;
- unittype=TriggerGetUnitType(type);
- plynr=TriggerGetPlayer(player);
- if( plynr==-1 ) {
- table=Units;
- j=NumUnits-1;
+ unittype = TriggerGetUnitType(type);
+ plynr = TriggerGetPlayer(player);
+ if (plynr == -1) {
+ table = Units;
+ j = NumUnits - 1;
} else {
- table=Players[plynr].Units;
- j=Players[plynr].TotalNumUnits-1;
+ table = Players[plynr].Units;
+ j = Players[plynr].TotalNumUnits - 1;
}
- for( ; j>=0; --j ) {
- unit=table[j];
- if( unittype==ANY_UNIT
- || (unittype==ALL_FOODUNITS && !unit->Type->Building)
- || (unittype==ALL_BUILDINGS && unit->Type->Building)
- || unittype==unit->Type ) {
+ for (; j >= 0; --j) {
+ unit = table[j];
+ if (unittype == ANY_UNIT ||
+ (unittype == ALL_FOODUNITS && !unit->Type->Building) ||
+ (unittype == ALL_BUILDINGS && unit->Type->Building) ||
+ unittype == unit->Type) {
LetUnitDie(unit);
return SCM_BOOL_T;
}
@@ -1045,7 +1046,7 @@
**
** @return Returns the number of units killed.
*/
-local SCM CclKillUnitAt(SCM type,SCM player,SCM quantity,SCM loc)
+local SCM CclKillUnitAt(SCM type, SCM player, SCM quantity, SCM loc)
{
int plynr;
int q;
@@ -1061,21 +1062,21 @@
int s;
plynr=TriggerGetPlayer(player);
- q=gh_scm2int(quantity);
- unittype=TriggerGetUnitType(type);
- x1=gh_scm2int(gh_car(loc));
- y1=gh_scm2int(gh_car(gh_cdr(loc)));
- x2=gh_scm2int(gh_car(gh_cdr(gh_cdr(loc))));
- y2=gh_scm2int(gh_car(gh_cdr(gh_cdr(gh_cdr(loc)))));
-
- an=SelectUnits(x1,y1,x2+1,y2+1,table);
- for( j=s=0; j<an && s<q; ++j ) {
- unit=table[j];
- if( unittype==ANY_UNIT
- || (unittype==ALL_FOODUNITS && !unit->Type->Building)
- || (unittype==ALL_BUILDINGS && unit->Type->Building)
- || unittype==unit->Type ) {
- if( plynr==-1 || plynr==unit->Player->Player ) {
+ q = gh_scm2int(quantity);
+ unittype = TriggerGetUnitType(type);
+ x1 = gh_scm2int(gh_car(loc));
+ y1 = gh_scm2int(gh_car(gh_cdr(loc)));
+ x2 = gh_scm2int(gh_car(gh_cdr(gh_cdr(loc))));
+ y2 = gh_scm2int(gh_car(gh_cdr(gh_cdr(gh_cdr(loc)))));
+
+ an=SelectUnits(x1, y1, x2 + 1, y2 + 1, table);
+ for (j = s = 0; j < an && s < q; ++j) {
+ unit = table[j];
+ if (unittype == ANY_UNIT ||
+ (unittype == ALL_FOODUNITS && !unit->Type->Building) ||
+ (unittype == ALL_BUILDINGS && unit->Type->Building) ||
+ unittype==unit->Type) {
+ if (plynr == -1 || plynr == unit->Player->Player) {
LetUnitDie(unit);
++s;
}
@@ -1097,8 +1098,8 @@
const Unit* unit;
SCM value;
- unit=CclGetUnit(ptr);
- value=gh_int2scm(unit->UnholyArmor);
+ unit = CclGetUnit(ptr);
+ value = gh_int2scm(unit->UnholyArmor);
return value;
}
@@ -1110,19 +1111,19 @@
**
** @return The value of the unit.
*/
-local SCM CclSetUnitUnholyArmor(SCM ptr,SCM value)
+local SCM CclSetUnitUnholyArmor(SCM ptr, SCM value)
{
Unit* unit;
- unit=CclGetUnit(ptr);
- unit->UnholyArmor=gh_scm2int(value);
+ unit = CclGetUnit(ptr);
+ unit->UnholyArmor = gh_scm2int(value);
return value;
}
-local SCM CclSlotUsage (SCM list)
+local SCM CclSlotUsage(SCM list)
{
-#define SLOT_LEN MAX_UNIT_SLOTS/8 + 1
+#define SLOT_LEN MAX_UNIT_SLOTS / 8 + 1
unsigned char SlotUsage[SLOT_LEN];
int i;
int prev;
@@ -1130,7 +1131,7 @@
memset(SlotUsage, 0, SLOT_LEN);
prev = -1;
- while ( !gh_null_p(list) ) {
+ while (!gh_null_p(list)) {
value = gh_car(list);
list = gh_cdr(list);
if (gh_eq_p(value, gh_symbol2scm("-"))) {
@@ -1138,24 +1139,26 @@
value = gh_car(list);
list = gh_cdr(list);
range_end = gh_scm2int(value);
- for (i=prev; i<=range_end; i++)
- SlotUsage[i/8] |= 1 << (i%8);
+ for (i = prev; i <= range_end; ++i) {
+ SlotUsage[i / 8] |= 1 << (i % 8);
+ }
prev = -1;
} else {
- if (prev >= 0)
- SlotUsage[prev/8] |= 1 << (prev%8);
+ if (prev >= 0) {
+ SlotUsage[prev / 8] |= 1 << (prev % 8);
+ }
prev = gh_scm2int(value);
}
}
if (prev >= 0) {
- SlotUsage[prev/8] |= 1 << (prev%8);
+ SlotUsage[prev / 8] |= 1 << (prev % 8);
}
/* now walk through the bitfield and create the needed unit slots */
- for (i=0; i<SLOT_LEN*8; i++) {
- if ( SlotUsage[i/8] & (1 << i%8) ) {
- Unit *new_unit = (Unit * )calloc(1, sizeof (Unit));
- UnitSlotFree = (void *)UnitSlots[i];
+ for (i = 0; i < SLOT_LEN * 8; ++i) {
+ if (SlotUsage[i / 8] & (1 << i % 8)) {
+ Unit* new_unit = (Unit*)calloc(1, sizeof(Unit));
+ UnitSlotFree = (void*)UnitSlots[i];
UnitSlots[i] = new_unit;
new_unit->Slot = i;
}
@@ -1172,24 +1175,24 @@
global void UnitCclRegister(void)
{
gh_new_procedure1_0("set-hitpoint-regeneration!",
- CclSetHitPointRegeneration);
- gh_new_procedure1_0("set-xp-damage!",CclSetXpDamage);
- gh_new_procedure1_0("set-training-queue!",CclSetTrainingQueue);
- gh_new_procedure1_0("set-building-capture!",CclSetBuildingCapture);
- gh_new_procedure1_0("set-reveal-attacker!",CclSetRevealAttacker);
-
- gh_new_procedureN("unit",CclUnit);
-
- gh_new_procedure2_0("make-unit",CclMakeUnit);
- gh_new_procedure3_0("place-unit",CclPlaceUnit);
- gh_new_procedure4_0("create-unit",CclCreateUnit);
- gh_new_procedureN("order-unit",CclOrderUnit);
- gh_new_procedure2_0("kill-unit",CclKillUnit);
- gh_new_procedure4_0("kill-unit-at",CclKillUnitAt);
+ CclSetHitPointRegeneration);
+ gh_new_procedure1_0("set-xp-damage!", CclSetXpDamage);
+ gh_new_procedure1_0("set-training-queue!", CclSetTrainingQueue);
+ gh_new_procedure1_0("set-building-capture!", CclSetBuildingCapture);
+ gh_new_procedure1_0("set-reveal-attacker!", CclSetRevealAttacker);
+
+ gh_new_procedureN("unit", CclUnit);
+
+ gh_new_procedure2_0("make-unit", CclMakeUnit);
+ gh_new_procedure3_0("place-unit", CclPlaceUnit);
+ gh_new_procedure4_0("create-unit", CclCreateUnit);
+ gh_new_procedureN("order-unit", CclOrderUnit);
+ gh_new_procedure2_0("kill-unit", CclKillUnit);
+ gh_new_procedure4_0("kill-unit-at", CclKillUnitAt);
// unit member access functions
- gh_new_procedure1_0("get-unit-unholy-armor",CclGetUnitUnholyArmor);
- gh_new_procedure2_0("set-unit-unholy-armor!",CclSetUnitUnholyArmor);
+ gh_new_procedure1_0("get-unit-unholy-armor", CclGetUnitUnholyArmor);
+ gh_new_procedure2_0("set-unit-unholy-armor!", CclSetUnitUnholyArmor);
gh_new_procedure1_0 ("slot-usage", CclSlotUsage);
}
Index: stratagus/src/unit/ccl_unittype.c
diff -u stratagus/src/unit/ccl_unittype.c:1.90
stratagus/src/unit/ccl_unittype.c:1.91
--- stratagus/src/unit/ccl_unittype.c:1.90 Fri Sep 26 05:15:22 2003
+++ stratagus/src/unit/ccl_unittype.c Thu Oct 2 12:15:06 2003
@@ -26,7 +26,7 @@
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
// 02111-1307, USA.
//
-// $Id: ccl_unittype.c,v 1.90 2003/09/26 09:15:22 mr-russ Exp $
+// $Id: ccl_unittype.c,v 1.91 2003/10/02 16:15:06 jsalmon3 Exp $
//@{
@@ -54,9 +54,9 @@
-- Variables
----------------------------------------------------------------------------*/
-IfDebug(
+#ifdef DEBUG
extern int NoWarningUnitType; /// quiet ident lookup.
-);
+#endif
global _AnimationsHash AnimationsHash; /// Animations hash table
@@ -75,12 +75,13 @@
global unsigned CclGetResourceByName(SCM value)
{
int i;
- for( i=0; i<MaxCosts; ++i ) {
- if( gh_eq_p(value,gh_symbol2scm(DefaultResourceNames[i])) ) {
+
+ for (i = 0; i < MaxCosts; ++i) {
+ if (gh_eq_p(value, gh_symbol2scm(DefaultResourceNames[i]))) {
return i;
}
}
- errl("Unsupported resource tag",value);
+ errl("Unsupported resource tag", value);
return 0xABCDEF;
}
@@ -104,513 +105,518 @@
// Slot identifier
- str=gh_scm2newstr(gh_car(list),NULL);
- list=gh_cdr(list);
+ str = gh_scm2newstr(gh_car(list), NULL);
+ list = gh_cdr(list);
- IfDebug( i=NoWarningUnitType; NoWarningUnitType=1; );
- type=UnitTypeByIdent(str);
- IfDebug( NoWarningUnitType=i; );
- if( type ) {
+#ifdef DEBUG
+ i = NoWarningUnitType;
+ NoWarningUnitType = 1;
+#endif
+ type = UnitTypeByIdent(str);
+#ifdef DEBUG
+ NoWarningUnitType = i;
+#endif
+ if (type) {
DebugLevel3Fn("Redefining unit-type `%s'\n" _C_ str);
free(str);
redefine = 1;
} else {
DebugLevel3Fn("Defining unit-type `%s'\n" _C_ str);
- type=NewUnitTypeSlot(str);
+ type = NewUnitTypeSlot(str);
redefine = 0;
//Set some default values
- type->_RegenerationRate=0;
+ type->_RegenerationRate = 0;
}
- type->NumDirections=8;
+ type->NumDirections = 8;
#ifdef NEW_UI
type->AddButtonsHook = NIL;
-
#endif
+
//
// Parse the list: (still everything could be changed!)
//
- while( !gh_null_p(list) ) {
+ while (!gh_null_p(list)) {
- value=gh_car(list);
- list=gh_cdr(list);
+ value = gh_car(list);
+ list = gh_cdr(list);
- if( gh_eq_p(value,gh_symbol2scm("name")) ) {
- if( redefine ) {
+ if (gh_eq_p(value, gh_symbol2scm("name"))) {
+ if (redefine) {
free(type->Name);
}
- type->Name=gh_scm2newstr(gh_car(list),NULL);
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("use")) ) {
- if( redefine ) {
+ type->Name = gh_scm2newstr(gh_car(list), NULL);
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("use"))) {
+ if (redefine) {
free(type->SameSprite);
}
- type->SameSprite=gh_scm2newstr(gh_car(list),NULL);
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("files")) ) {
- sublist=gh_car(list);
- list=gh_cdr(list);
- while( !gh_null_p(sublist) ) {
+ type->SameSprite = gh_scm2newstr(gh_car(list), NULL);
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("files"))) {
+ sublist = gh_car(list);
+ list = gh_cdr(list);
+ while (!gh_null_p(sublist)) {
char* str;
- value=gh_car(sublist);
- sublist=gh_cdr(sublist);
+ value = gh_car(sublist);
+ sublist = gh_cdr(sublist);
// FIXME: use a general get tileset function here!
- str=gh_scm2newstr(value,NULL);
- i=0;
- if( strcmp(str,"default") ) {
- for( ; i<TilesetMax; ++i ) {
- if( !strcmp(str,Tilesets[i]->Ident) ||
- !strcmp(str,Tilesets[i]->Class) ) {
+ str = gh_scm2newstr(value, NULL);
+ i = 0;
+ if (strcmp(str, "default")) {
+ for (; i < TilesetMax; ++i) {
+ if (!strcmp(str,Tilesets[i]->Ident) ||
+ !strcmp(str,Tilesets[i]->Class)) {
break;
}
}
- if( i==TilesetMax ) {
+ if (i == TilesetMax) {
// FIXME: this leaves half initialized unit-type
- errl("Unsupported tileset tag",value);
+ errl("Unsupported tileset tag", value);
}
}
free(str);
- if( redefine ) {
+ if (redefine) {
free(type->File[i]);
}
- type->File[i]=gh_scm2newstr(gh_car(sublist),NULL);
- sublist=gh_cdr(sublist);
+ type->File[i] = gh_scm2newstr(gh_car(sublist), NULL);
+ sublist = gh_cdr(sublist);
}
- } else if( gh_eq_p(value,gh_symbol2scm("shadow")) ) {
- sublist=gh_car(list);
- list=gh_cdr(list);
- while( !gh_null_p(sublist) ) {
- value=gh_car(sublist);
- sublist=gh_cdr(sublist);
+ } else if (gh_eq_p(value, gh_symbol2scm("shadow"))) {
+ sublist = gh_car(list);
+ list = gh_cdr(list);
+ while (!gh_null_p(sublist)) {
+ value = gh_car(sublist);
+ sublist = gh_cdr(sublist);
- if( gh_eq_p(value,gh_symbol2scm("file")) ) {
- if( redefine ) {
+ if (gh_eq_p(value, gh_symbol2scm("file"))) {
+ if (redefine) {
free(type->ShadowFile);
}
- type->ShadowFile=gh_scm2newstr(gh_car(sublist),NULL);
- } else if( gh_eq_p(value,gh_symbol2scm("width")) ) {
- type->ShadowWidth=gh_scm2int(gh_car(sublist));
- } else if( gh_eq_p(value,gh_symbol2scm("height")) ) {
- type->ShadowHeight=gh_scm2int(gh_car(sublist));
- } else if( gh_eq_p(value,gh_symbol2scm("offset")) ) {
- type->ShadowOffset=gh_scm2int(gh_car(sublist));
+ type->ShadowFile = gh_scm2newstr(gh_car(sublist), NULL);
+ } else if (gh_eq_p(value, gh_symbol2scm("width"))) {
+ type->ShadowWidth = gh_scm2int(gh_car(sublist));
+ } else if (gh_eq_p(value, gh_symbol2scm("height"))) {
+ type->ShadowHeight = gh_scm2int(gh_car(sublist));
+ } else if (gh_eq_p(value, gh_symbol2scm("offset"))) {
+ type->ShadowOffset = gh_scm2int(gh_car(sublist));
} else {
- errl("Unsupported shadow tag",value);
+ errl("Unsupported shadow tag", value);
}
- sublist=gh_cdr(sublist);
+ sublist = gh_cdr(sublist);
}
- } else if( gh_eq_p(value,gh_symbol2scm("size")) ) {
- sublist=gh_car(list);
- list=gh_cdr(list);
- type->Width=gh_scm2int(gh_car(sublist));
- type->Height=gh_scm2int(gh_cadr(sublist));
- } else if( gh_eq_p(value,gh_symbol2scm("animations")) ) {
- type->Animations=
- AnimationsByIdent(str=gh_scm2newstr(gh_car(list),NULL));
+ } else if (gh_eq_p(value, gh_symbol2scm("size"))) {
+ sublist = gh_car(list);
+ list = gh_cdr(list);
+ type->Width = gh_scm2int(gh_car(sublist));
+ type->Height = gh_scm2int(gh_cadr(sublist));
+ } else if (gh_eq_p(value, gh_symbol2scm("animations"))) {
+ type->Animations =
+ AnimationsByIdent(str = gh_scm2newstr(gh_car(list), NULL));
free(str);
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("icon")) ) {
- if( redefine ) {
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("icon"))) {
+ if (redefine) {
free(type->Icon.Name);
}
- type->Icon.Name=gh_scm2newstr(gh_car(list),NULL);
- type->Icon.Icon=NULL;
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("costs")) ) {
- sublist=gh_car(list);
- list=gh_cdr(list);
- while( !gh_null_p(sublist) ) {
- value=gh_car(sublist);
- sublist=gh_cdr(sublist);
-
type->_Costs[CclGetResourceByName(value)]=gh_scm2int(gh_car(sublist));
- sublist=gh_cdr(sublist);
- }
- } else if( gh_eq_p(value,gh_symbol2scm("improve-production")) ) {
- sublist=gh_car(list);
- list=gh_cdr(list);
- while( !gh_null_p(sublist) ) {
- value=gh_car(sublist);
- sublist=gh_cdr(sublist);
- type->ImproveIncomes[CclGetResourceByName(value)]=
-
DefaultIncomes[CclGetResourceByName(value)]+gh_scm2int(gh_car(sublist));
- sublist=gh_cdr(sublist);
+ type->Icon.Name = gh_scm2newstr(gh_car(list), NULL);
+ type->Icon.Icon = NULL;
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("costs"))) {
+ sublist = gh_car(list);
+ list = gh_cdr(list);
+ while (!gh_null_p(sublist)) {
+ value = gh_car(sublist);
+ sublist = gh_cdr(sublist);
+ type->_Costs[CclGetResourceByName(value)] =
gh_scm2int(gh_car(sublist));
+ sublist = gh_cdr(sublist);
+ }
+ } else if (gh_eq_p(value, gh_symbol2scm("improve-production"))) {
+ sublist = gh_car(list);
+ list = gh_cdr(list);
+ while (!gh_null_p(sublist)) {
+ value = gh_car(sublist);
+ sublist = gh_cdr(sublist);
+ type->ImproveIncomes[CclGetResourceByName(value)] =
+ DefaultIncomes[CclGetResourceByName(value)] +
gh_scm2int(gh_car(sublist));
+ sublist = gh_cdr(sublist);
}
- } else if( gh_eq_p(value,gh_symbol2scm("construction")) ) {
+ } else if (gh_eq_p(value, gh_symbol2scm("construction"))) {
// FIXME: What if constructions arn't yet loaded?
- str=gh_scm2newstr(gh_car(list),NULL);
- type->Construction=ConstructionByIdent(str);
- list=gh_cdr(list);
+ str = gh_scm2newstr(gh_car(list), NULL);
+ type->Construction = ConstructionByIdent(str);
+ list = gh_cdr(list);
free(str);
- } else if( gh_eq_p(value,gh_symbol2scm("speed")) ) {
- type->_Speed=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("draw-level")) ) {
- type->DrawLevel=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("max-on-board")) ) {
- type->MaxOnBoard=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("hit-points")) ) {
- type->_HitPoints=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("regeneration-rate")) ) {
- type->_RegenerationRate=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("max-mana")) ) {
- type->_MaxMana=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("magic")) ) {
- type->Magic=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("tile-size")) ) {
- sublist=gh_car(list);
- list=gh_cdr(list);
- type->TileWidth=gh_scm2int(gh_car(sublist));
- type->TileHeight=gh_scm2int(gh_cadr(sublist));
- } else if( gh_eq_p(value,gh_symbol2scm("must-build-on-top")) ){
- str=gh_scm2newstr(gh_car(list),NULL);
- auxtype=UnitTypeByIdent(str);
+ } else if (gh_eq_p(value, gh_symbol2scm("speed"))) {
+ type->_Speed = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("draw-level"))) {
+ type->DrawLevel = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("max-on-board"))) {
+ type->MaxOnBoard = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("hit-points"))) {
+ type->_HitPoints = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("regeneration-rate"))) {
+ type->_RegenerationRate = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("max-mana"))) {
+ type->_MaxMana = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("magic"))) {
+ type->Magic = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("tile-size"))) {
+ sublist = gh_car(list);
+ list = gh_cdr(list);
+ type->TileWidth = gh_scm2int(gh_car(sublist));
+ type->TileHeight = gh_scm2int(gh_cadr(sublist));
+ } else if (gh_eq_p(value, gh_symbol2scm("must-build-on-top"))) {
+ str = gh_scm2newstr(gh_car(list), NULL);
+ auxtype = UnitTypeByIdent(str);
if (!auxtype) {
DebugLevel0("Build on top of undefined unit \"%s\".\n" _C_ str);
DebugCheck(1);
}
- type->MustBuildOnTop=auxtype;
+ type->MustBuildOnTop = auxtype;
free(str);
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("box-size")) ) {
- sublist=gh_car(list);
- list=gh_cdr(list);
- type->BoxWidth=gh_scm2int(gh_car(sublist));
- type->BoxHeight=gh_scm2int(gh_cadr(sublist));
- } else if( gh_eq_p(value,gh_symbol2scm("num-directions")) ) {
- type->NumDirections=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("revealer")) ) {
- type->Revealer=1;
- } else if( gh_eq_p(value,gh_symbol2scm("sight-range")) ) {
- type->_SightRange=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("computer-reaction-range")) ) {
- type->ReactRangeComputer=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("person-reaction-range")) ) {
- type->ReactRangePerson=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("armor")) ) {
- type->_Armor=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("basic-damage")) ) {
- type->_BasicDamage=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("piercing-damage")) ) {
- type->_PiercingDamage=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("missile")) ) {
- type->Missile.Name=gh_scm2newstr(gh_car(list),NULL);
- type->Missile.Missile=NULL;
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("min-attack-range")) ) {
- type->MinAttackRange=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("max-attack-range")) ) {
- type->_AttackRange=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("weapons-upgradable")) ) {
- type->WeaponsUpgradable=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("armor-upgradable")) ) {
- type->ArmorUpgradable=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("priority")) ) {
- type->Priority=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("annoy-computer-factor")) ) {
- type->AnnoyComputerFactor=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("decay-rate")) ) {
- type->DecayRate=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("points")) ) {
- type->Points=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("demand")) ) {
- type->Demand=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("supply")) ) {
- type->Supply=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("corpse")) ) {
- sublist=gh_car(list);
- list=gh_cdr(list);
- if( redefine ) {
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("box-size"))) {
+ sublist = gh_car(list);
+ list = gh_cdr(list);
+ type->BoxWidth = gh_scm2int(gh_car(sublist));
+ type->BoxHeight = gh_scm2int(gh_cadr(sublist));
+ } else if (gh_eq_p(value, gh_symbol2scm("num-directions"))) {
+ type->NumDirections = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("revealer"))) {
+ type->Revealer = 1;
+ } else if (gh_eq_p(value, gh_symbol2scm("sight-range"))) {
+ type->_SightRange = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("computer-reaction-range"))) {
+ type->ReactRangeComputer = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("person-reaction-range"))) {
+ type->ReactRangePerson = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("armor"))) {
+ type->_Armor = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("basic-damage"))) {
+ type->_BasicDamage = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("piercing-damage"))) {
+ type->_PiercingDamage = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("missile"))) {
+ type->Missile.Name = gh_scm2newstr(gh_car(list), NULL);
+ type->Missile.Missile = NULL;
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("min-attack-range"))) {
+ type->MinAttackRange = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("max-attack-range"))) {
+ type->_AttackRange = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("weapons-upgradable"))) {
+ type->WeaponsUpgradable = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("armor-upgradable"))) {
+ type->ArmorUpgradable = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("priority"))) {
+ type->Priority = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("annoy-computer-factor"))) {
+ type->AnnoyComputerFactor = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("decay-rate"))) {
+ type->DecayRate = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("points"))) {
+ type->Points = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("demand"))) {
+ type->Demand = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("supply"))) {
+ type->Supply = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("corpse"))) {
+ sublist = gh_car(list);
+ list = gh_cdr(list);
+ if (redefine) {
free(type->CorpseName);
}
- type->CorpseName=gh_scm2newstr(gh_car(sublist),NULL);
- type->CorpseType=NULL;
- type->CorpseScript=gh_scm2int(gh_cadr(sublist));
- } else if( gh_eq_p(value,gh_symbol2scm("explode-when-killed")) ) {
- type->ExplodeWhenKilled=1;
- type->Explosion.Name=gh_scm2newstr(gh_car(list),NULL);
- type->Explosion.Missile=NULL;
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("type-land")) ) {
- type->UnitType=UnitTypeLand;
- } else if( gh_eq_p(value,gh_symbol2scm("type-fly")) ) {
- type->UnitType=UnitTypeFly;
- } else if( gh_eq_p(value,gh_symbol2scm("type-naval")) ) {
- type->UnitType=UnitTypeNaval;
-
- } else if( gh_eq_p(value,gh_symbol2scm("right-none")) ) {
- type->MouseAction=MouseActionNone;
- } else if( gh_eq_p(value,gh_symbol2scm("right-attack")) ) {
- type->MouseAction=MouseActionAttack;
- } else if( gh_eq_p(value,gh_symbol2scm("right-move")) ) {
- type->MouseAction=MouseActionMove;
- } else if( gh_eq_p(value,gh_symbol2scm("right-harvest")) ) {
- type->MouseAction=MouseActionHarvest;
- } else if( gh_eq_p(value,gh_symbol2scm("right-demolish")) ) {
- type->MouseAction=MouseActionDemolish;
- } else if( gh_eq_p(value,gh_symbol2scm("right-sail")) ) {
- type->MouseAction=MouseActionSail;
-
- } else if( gh_eq_p(value,gh_symbol2scm("can-ground-attack")) ) {
- type->GroundAttack=1;
- } else if( gh_eq_p(value,gh_symbol2scm("can-attack")) ) {
- type->CanAttack=1;
- } else if( gh_eq_p(value,gh_symbol2scm("demolish-range"))){
- type->DemolishRange=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("demolish-damage"))){
- type->DemolishDamage=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("repair-range")) ) {
- type->RepairRange=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("repair-hp")) ) {
- type->RepairHP=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("repair-costs")) ) {
- sublist=gh_car(list);
- list=gh_cdr(list);
- while( !gh_null_p(sublist) ) {
- value=gh_car(sublist);
- sublist=gh_cdr(sublist);
-
type->RepairCosts[CclGetResourceByName(value)]=gh_scm2int(gh_car(sublist));
- sublist=gh_cdr(sublist);
- }
- } else if( gh_eq_p(value,gh_symbol2scm("can-target-land")) ) {
- type->CanTarget|=CanTargetLand;
- } else if( gh_eq_p(value,gh_symbol2scm("can-target-sea")) ) {
- type->CanTarget|=CanTargetSea;
- } else if( gh_eq_p(value,gh_symbol2scm("can-target-air")) ) {
- type->CanTarget|=CanTargetAir;
-
- } else if( gh_eq_p(value,gh_symbol2scm("building")) ) {
- type->Building=1;
- } else if( gh_eq_p(value,gh_symbol2scm("wall")) ) {
- type->Wall=1;
- } else if( gh_eq_p(value,gh_symbol2scm("builder-outside")) ) {
- type->BuilderOutside=1;
- } else if( gh_eq_p(value,gh_symbol2scm("builder-lost")) ) {
- type->BuilderLost=1;
- } else if( gh_eq_p(value,gh_symbol2scm("auto-build-rate")) ) {
- type->AutoBuildRate=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("shore-building")) ) {
- type->ShoreBuilding=1;
- } else if( gh_eq_p(value,gh_symbol2scm("land-unit")) ) {
- type->LandUnit=1;
- } else if( gh_eq_p(value,gh_symbol2scm("air-unit")) ) {
- type->AirUnit=1;
- } else if( gh_eq_p(value,gh_symbol2scm("sea-unit")) ) {
- type->SeaUnit=1;
- } else if( gh_eq_p(value,gh_symbol2scm("random-movement-probability"))
) {
- type->RandomMovementProbability=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("clicks-to-explode")) ) {
- type->ClicksToExplode=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("sniper")) ) {
- type->Sniper=1;
- } else if( gh_eq_p(value,gh_symbol2scm("permanent-cloak")) ) {
- type->PermanentCloak=1;
- } else if( gh_eq_p(value,gh_symbol2scm("detect-cloak")) ) {
- type->DetectCloak=1;
- } else if( gh_eq_p(value,gh_symbol2scm("transporter")) ) {
- type->Transporter=1;
- } else if( gh_eq_p(value,gh_symbol2scm("coward")) ) {
- type->Coward=1;
- } else if( gh_eq_p(value,gh_symbol2scm("can-gather-resource")) ) {
- sublist=gh_car(list);
- list=gh_cdr(list);
- res=(ResourceInfo*)malloc(sizeof(ResourceInfo));
- memset(res,0,sizeof(ResourceInfo));
- while( !gh_null_p(sublist) ) {
- value=gh_car(sublist);
- sublist=gh_cdr(sublist);
- if (gh_eq_p(value,gh_symbol2scm("resource-id")) ) {
- res->ResourceId=CclGetResourceByName(gh_car(sublist));
- type->ResInfo[res->ResourceId]=res;
- sublist=gh_cdr(sublist);
- } else if( gh_eq_p(value,gh_symbol2scm("resource-step")) ) {
- res->ResourceStep=gh_scm2int(gh_car(sublist));
- sublist=gh_cdr(sublist);
- } else if( gh_eq_p(value,gh_symbol2scm("final-resource")) ) {
- res->FinalResource=CclGetResourceByName(gh_car(sublist));
- sublist=gh_cdr(sublist);
- } else if( gh_eq_p(value,gh_symbol2scm("wait-at-resource")) ) {
- res->WaitAtResource=gh_scm2int(gh_car(sublist));
- sublist=gh_cdr(sublist);
- } else if( gh_eq_p(value,gh_symbol2scm("wait-at-depot")) ) {
- res->WaitAtDepot=gh_scm2int(gh_car(sublist));
- sublist=gh_cdr(sublist);
- } else if( gh_eq_p(value,gh_symbol2scm("resource-capacity")) ) {
- res->ResourceCapacity=gh_scm2int(gh_car(sublist));
- sublist=gh_cdr(sublist);
- } else if( gh_eq_p(value,gh_symbol2scm("terrain-harvester")) ) {
- res->TerrainHarvester=1;
- } else if( gh_eq_p(value,gh_symbol2scm("lose-resources")) ) {
- res->LoseResources=1;
- } else if( gh_eq_p(value,gh_symbol2scm("harvest-from-outside"))
) {
- res->HarvestFromOutside=1;
- } else if( gh_eq_p(value,gh_symbol2scm("file-when-empty")) ) {
- res->FileWhenLoaded=gh_scm2newstr(gh_car(sublist),0);
- sublist=gh_cdr(sublist);
- } else if( gh_eq_p(value,gh_symbol2scm("file-when-loaded")) ) {
- res->FileWhenLoaded=gh_scm2newstr(gh_car(sublist),0);
- sublist=gh_cdr(sublist);
+ type->CorpseName = gh_scm2newstr(gh_car(sublist), NULL);
+ type->CorpseType = NULL;
+ type->CorpseScript = gh_scm2int(gh_cadr(sublist));
+ } else if (gh_eq_p(value, gh_symbol2scm("explode-when-killed"))) {
+ type->ExplodeWhenKilled = 1;
+ type->Explosion.Name = gh_scm2newstr(gh_car(list), NULL);
+ type->Explosion.Missile = NULL;
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("type-land"))) {
+ type->UnitType = UnitTypeLand;
+ } else if (gh_eq_p(value, gh_symbol2scm("type-fly"))) {
+ type->UnitType = UnitTypeFly;
+ } else if (gh_eq_p(value, gh_symbol2scm("type-naval"))) {
+ type->UnitType = UnitTypeNaval;
+
+ } else if (gh_eq_p(value, gh_symbol2scm("right-none"))) {
+ type->MouseAction = MouseActionNone;
+ } else if (gh_eq_p(value, gh_symbol2scm("right-attack"))) {
+ type->MouseAction = MouseActionAttack;
+ } else if (gh_eq_p(value, gh_symbol2scm("right-move"))) {
+ type->MouseAction = MouseActionMove;
+ } else if (gh_eq_p(value, gh_symbol2scm("right-harvest"))) {
+ type->MouseAction = MouseActionHarvest;
+ } else if (gh_eq_p(value, gh_symbol2scm("right-demolish"))) {
+ type->MouseAction = MouseActionDemolish;
+ } else if (gh_eq_p(value, gh_symbol2scm("right-sail"))) {
+ type->MouseAction = MouseActionSail;
+
+ } else if (gh_eq_p(value, gh_symbol2scm("can-ground-attack"))) {
+ type->GroundAttack = 1;
+ } else if (gh_eq_p(value, gh_symbol2scm("can-attack"))) {
+ type->CanAttack = 1;
+ } else if (gh_eq_p(value, gh_symbol2scm("demolish-range"))){
+ type->DemolishRange = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("demolish-damage"))){
+ type->DemolishDamage = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("repair-range"))) {
+ type->RepairRange = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("repair-hp"))) {
+ type->RepairHP = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("repair-costs"))) {
+ sublist = gh_car(list);
+ list = gh_cdr(list);
+ while (!gh_null_p(sublist)) {
+ value = gh_car(sublist);
+ sublist = gh_cdr(sublist);
+ type->RepairCosts[CclGetResourceByName(value)] =
gh_scm2int(gh_car(sublist));
+ sublist = gh_cdr(sublist);
+ }
+ } else if (gh_eq_p(value, gh_symbol2scm("can-target-land"))) {
+ type->CanTarget |= CanTargetLand;
+ } else if (gh_eq_p(value, gh_symbol2scm("can-target-sea"))) {
+ type->CanTarget |= CanTargetSea;
+ } else if (gh_eq_p(value, gh_symbol2scm("can-target-air"))) {
+ type->CanTarget |= CanTargetAir;
+
+ } else if (gh_eq_p(value, gh_symbol2scm("building"))) {
+ type->Building = 1;
+ } else if (gh_eq_p(value, gh_symbol2scm("wall"))) {
+ type->Wall = 1;
+ } else if (gh_eq_p(value, gh_symbol2scm("builder-outside"))) {
+ type->BuilderOutside = 1;
+ } else if (gh_eq_p(value, gh_symbol2scm("builder-lost"))) {
+ type->BuilderLost = 1;
+ } else if (gh_eq_p(value, gh_symbol2scm("auto-build-rate"))) {
+ type->AutoBuildRate = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("shore-building"))) {
+ type->ShoreBuilding = 1;
+ } else if (gh_eq_p(value, gh_symbol2scm("land-unit"))) {
+ type->LandUnit = 1;
+ } else if (gh_eq_p(value, gh_symbol2scm("air-unit"))) {
+ type->AirUnit = 1;
+ } else if (gh_eq_p(value, gh_symbol2scm("sea-unit"))) {
+ type->SeaUnit = 1;
+ } else if (gh_eq_p(value,
gh_symbol2scm("random-movement-probability"))) {
+ type->RandomMovementProbability = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("clicks-to-explode"))) {
+ type->ClicksToExplode = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("sniper"))) {
+ type->Sniper = 1;
+ } else if (gh_eq_p(value, gh_symbol2scm("permanent-cloak"))) {
+ type->PermanentCloak = 1;
+ } else if (gh_eq_p(value, gh_symbol2scm("detect-cloak"))) {
+ type->DetectCloak = 1;
+ } else if (gh_eq_p(value, gh_symbol2scm("transporter"))) {
+ type->Transporter = 1;
+ } else if (gh_eq_p(value, gh_symbol2scm("coward"))) {
+ type->Coward = 1;
+ } else if (gh_eq_p(value, gh_symbol2scm("can-gather-resource"))) {
+ sublist = gh_car(list);
+ list = gh_cdr(list);
+ res = (ResourceInfo*)malloc(sizeof(ResourceInfo));
+ memset(res, 0, sizeof(ResourceInfo));
+ while (!gh_null_p(sublist)) {
+ value = gh_car(sublist);
+ sublist = gh_cdr(sublist);
+ if (gh_eq_p(value, gh_symbol2scm("resource-id"))) {
+ res->ResourceId = CclGetResourceByName(gh_car(sublist));
+ type->ResInfo[res->ResourceId] = res;
+ sublist = gh_cdr(sublist);
+ } else if (gh_eq_p(value, gh_symbol2scm("resource-step"))) {
+ res->ResourceStep = gh_scm2int(gh_car(sublist));
+ sublist = gh_cdr(sublist);
+ } else if (gh_eq_p(value, gh_symbol2scm("final-resource"))) {
+ res->FinalResource = CclGetResourceByName(gh_car(sublist));
+ sublist = gh_cdr(sublist);
+ } else if (gh_eq_p(value, gh_symbol2scm("wait-at-resource"))) {
+ res->WaitAtResource = gh_scm2int(gh_car(sublist));
+ sublist = gh_cdr(sublist);
+ } else if (gh_eq_p(value, gh_symbol2scm("wait-at-depot"))) {
+ res->WaitAtDepot = gh_scm2int(gh_car(sublist));
+ sublist = gh_cdr(sublist);
+ } else if (gh_eq_p(value, gh_symbol2scm("resource-capacity"))) {
+ res->ResourceCapacity = gh_scm2int(gh_car(sublist));
+ sublist = gh_cdr(sublist);
+ } else if (gh_eq_p(value, gh_symbol2scm("terrain-harvester"))) {
+ res->TerrainHarvester = 1;
+ } else if (gh_eq_p(value, gh_symbol2scm("lose-resources"))) {
+ res->LoseResources = 1;
+ } else if (gh_eq_p(value,
gh_symbol2scm("harvest-from-outside"))) {
+ res->HarvestFromOutside = 1;
+ } else if (gh_eq_p(value, gh_symbol2scm("file-when-empty"))) {
+ res->FileWhenLoaded = gh_scm2newstr(gh_car(sublist),0);
+ sublist = gh_cdr(sublist);
+ } else if (gh_eq_p(value, gh_symbol2scm("file-when-loaded"))) {
+ res->FileWhenLoaded = gh_scm2newstr(gh_car(sublist),0);
+ sublist = gh_cdr(sublist);
} else {
printf("\n%s\n",type->Name);
- errl("Unsupported tag",value);
- DebugCheck( 1 );
+ errl("Unsupported tag", value);
+ DebugCheck(1);
}
}
- type->Harvester=1;
+ type->Harvester = 1;
if (!res->FinalResource) {
- res->FinalResource=res->ResourceId;
+ res->FinalResource = res->ResourceId;
}
DebugCheck(!res->ResourceId);
- } else if( gh_eq_p(value,gh_symbol2scm("gives-resource")) ) {
- type->GivesResource=CclGetResourceByName(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("max-workers")) ) {
- type->MaxWorkers=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("can-harvest")) ) {
- type->CanHarvest=1;
- } else if( gh_eq_p(value,gh_symbol2scm("can-store")) ) {
- sublist=gh_car(list);
- list=gh_cdr(list);
- while( !gh_null_p(sublist) ) {
- type->CanStore[CclGetResourceByName(gh_car(sublist))]=1;
- sublist=gh_cdr(sublist);
- }
- } else if( gh_eq_p(value,gh_symbol2scm("vanishes")) ) {
- type->Vanishes=1;
- } else if( gh_eq_p(value,gh_symbol2scm("hero")) ) {
- type->Hero=1;
- } else if( gh_eq_p(value,gh_symbol2scm("volatile")) ) {
- type->Volatile=1;
- } else if( gh_eq_p(value,gh_symbol2scm("isundead")) ) {
- type->IsUndead=1;
- } else if( gh_eq_p(value,gh_symbol2scm("can-cast-spell")) ) {
+ } else if (gh_eq_p(value, gh_symbol2scm("gives-resource"))) {
+ type->GivesResource = CclGetResourceByName(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("max-workers"))) {
+ type->MaxWorkers = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("can-harvest"))) {
+ type->CanHarvest = 1;
+ } else if (gh_eq_p(value, gh_symbol2scm("can-store"))) {
+ sublist = gh_car(list);
+ list = gh_cdr(list);
+ while (!gh_null_p(sublist)) {
+ type->CanStore[CclGetResourceByName(gh_car(sublist))] = 1;
+ sublist = gh_cdr(sublist);
+ }
+ } else if (gh_eq_p(value, gh_symbol2scm("vanishes"))) {
+ type->Vanishes = 1;
+ } else if (gh_eq_p(value, gh_symbol2scm("hero"))) {
+ type->Hero = 1;
+ } else if (gh_eq_p(value, gh_symbol2scm("volatile"))) {
+ type->Volatile = 1;
+ } else if (gh_eq_p(value, gh_symbol2scm("isundead"))) {
+ type->IsUndead = 1;
+ } else if (gh_eq_p(value, gh_symbol2scm("can-cast-spell"))) {
//
// Warning: can-cast-spell should only be used AFTER all spells
// have been defined. FIXME: MaxSpellType=500 or something?
//
if (!type->CanCastSpell) {
- type->CanCastSpell=malloc(SpellTypeCount);
- memset(type->CanCastSpell,0,SpellTypeCount);
+ type->CanCastSpell = malloc(SpellTypeCount);
+ memset(type->CanCastSpell, 0, SpellTypeCount);
}
- sublist=gh_car(list);
- list=gh_cdr(list);
- while( !gh_null_p(sublist) ) {
+ sublist = gh_car(list);
+ list = gh_cdr(list);
+ while (!gh_null_p(sublist)) {
DebugLevel3Fn("%d \n" _C_ CclGetSpellByIdent(gh_car(sublist)));
- type->CanCastSpell[CclGetSpellByIdent(gh_car(sublist))]=1;
- sublist=gh_cdr(sublist);
+ type->CanCastSpell[CclGetSpellByIdent(gh_car(sublist))] = 1;
+ sublist = gh_cdr(sublist);
}
- } else if( gh_eq_p(value,gh_symbol2scm("organic")) ) {
- type->Organic=1;
- } else if( gh_eq_p(value,gh_symbol2scm("selectable-by-rectangle")) ) {
- type->SelectableByRectangle=1;
- } else if( gh_eq_p(value,gh_symbol2scm("teleporter")) ) {
- type->Teleporter=1;
- } else if( gh_eq_p(value,gh_symbol2scm("sounds")) ) {
- sublist=gh_car(list);
- list=gh_cdr(list);
- while( !gh_null_p(sublist) ) {
+ } else if (gh_eq_p(value, gh_symbol2scm("organic"))) {
+ type->Organic = 1;
+ } else if (gh_eq_p(value, gh_symbol2scm("selectable-by-rectangle"))) {
+ type->SelectableByRectangle = 1;
+ } else if (gh_eq_p(value, gh_symbol2scm("teleporter"))) {
+ type->Teleporter = 1;
+ } else if (gh_eq_p(value, gh_symbol2scm("sounds"))) {
+ sublist = gh_car(list);
+ list = gh_cdr(list);
+ while (!gh_null_p(sublist)) {
- value=gh_car(sublist);
- sublist=gh_cdr(sublist);
+ value = gh_car(sublist);
+ sublist = gh_cdr(sublist);
- if( gh_eq_p(value,gh_symbol2scm("selected")) ) {
- if( redefine ) {
+ if (gh_eq_p(value, gh_symbol2scm("selected"))) {
+ if (redefine) {
free(type->Sound.Selected.Name);
}
- type->Sound.Selected.Name=gh_scm2newstr(
- gh_car(sublist),NULL);
- sublist=gh_cdr(sublist);
- } else if( gh_eq_p(value,gh_symbol2scm("acknowledge")) ) {
- if( redefine ) {
+ type->Sound.Selected.Name = gh_scm2newstr(
+ gh_car(sublist), NULL);
+ sublist = gh_cdr(sublist);
+ } else if (gh_eq_p(value, gh_symbol2scm("acknowledge"))) {
+ if (redefine) {
free(type->Sound.Acknowledgement.Name);
}
- type->Sound.Acknowledgement.Name=gh_scm2newstr(
- gh_car(sublist),NULL);
- sublist=gh_cdr(sublist);
- } else if( gh_eq_p(value,gh_symbol2scm("ready")) ) {
- if( redefine ) {
+ type->Sound.Acknowledgement.Name = gh_scm2newstr(
+ gh_car(sublist), NULL);
+ sublist = gh_cdr(sublist);
+ } else if (gh_eq_p(value, gh_symbol2scm("ready"))) {
+ if (redefine) {
free(type->Sound.Ready.Name);
}
- type->Sound.Ready.Name=gh_scm2newstr(
- gh_car(sublist),NULL);
- sublist=gh_cdr(sublist);
- } else if( gh_eq_p(value,gh_symbol2scm("help")) ) {
- if( redefine ) {
+ type->Sound.Ready.Name = gh_scm2newstr(
+ gh_car(sublist), NULL);
+ sublist = gh_cdr(sublist);
+ } else if (gh_eq_p(value, gh_symbol2scm("help"))) {
+ if (redefine) {
free(type->Sound.Help.Name);
}
- type->Sound.Help.Name=gh_scm2newstr(
- gh_car(sublist),NULL);
- sublist=gh_cdr(sublist);
- } else if( gh_eq_p(value,gh_symbol2scm("dead")) ) {
- if( redefine ) {
+ type->Sound.Help.Name = gh_scm2newstr(
+ gh_car(sublist), NULL);
+ sublist = gh_cdr(sublist);
+ } else if (gh_eq_p(value, gh_symbol2scm("dead"))) {
+ if (redefine) {
free(type->Sound.Dead.Name);
}
- type->Sound.Dead.Name=gh_scm2newstr(
- gh_car(sublist),NULL);
- sublist=gh_cdr(sublist);
- } else if( gh_eq_p(value,gh_symbol2scm("attack")) ) {
- if( redefine ) {
+ type->Sound.Dead.Name = gh_scm2newstr(
+ gh_car(sublist), NULL);
+ sublist = gh_cdr(sublist);
+ } else if (gh_eq_p(value, gh_symbol2scm("attack"))) {
+ if (redefine) {
free(type->Weapon.Attack.Name);
}
- type->Weapon.Attack.Name=gh_scm2newstr(
- gh_car(sublist),NULL);
- sublist=gh_cdr(sublist);
+ type->Weapon.Attack.Name = gh_scm2newstr(
+ gh_car(sublist), NULL);
+ sublist = gh_cdr(sublist);
} else {
- errl("Unsupported sound tag",value);
+ errl("Unsupported sound tag", value);
}
}
#ifdef NEW_UI
- } else if( gh_eq_p(value,gh_symbol2scm("add-buttons")) ) {
- value=gh_car(list);
- list=gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("add-buttons"))) {
+ value = gh_car(list);
+ list = gh_cdr(list);
CclGcProtect(value);
type->AddButtonsHook = value;
#endif
} else {
// FIXME: this leaves a half initialized unit-type
printf("\n%s\n",type->Name);
- errl("Unsupported tag",value);
- DebugCheck( 1 );
+ errl("Unsupported tag", value);
+ DebugCheck(1);
}
}
//
// Unit type checks.
//
- if( type->CanCastSpell && !type->_MaxMana ) {
+ if (type->CanCastSpell && !type->_MaxMana) {
DebugLevel0Fn("%s: Need max mana value\n" _C_ type->Ident);
- type->_MaxMana=1;
+ type->_MaxMana = 1;
}
return SCM_UNSPECIFIED;
@@ -631,75 +637,75 @@
int i;
char* str;
- type=UnitTypeByIdent(str=gh_scm2newstr(gh_car(list),NULL));
+ type = UnitTypeByIdent(str = gh_scm2newstr(gh_car(list), NULL));
DebugCheck(!type);
free(str);
- list=gh_cdr(list);
- i=gh_scm2int(gh_car(list));
- DebugCheck(i>=PlayerMax);
- list=gh_cdr(list);
+ list = gh_cdr(list);
+ i = gh_scm2int(gh_car(list));
+ DebugCheck(i >= PlayerMax);
+ list = gh_cdr(list);
- stats=&type->Stats[i];
+ stats = &type->Stats[i];
//
// Parse the list: (still everything could be changed!)
//
- while( !gh_null_p(list) ) {
+ while (!gh_null_p(list)) {
- value=gh_car(list);
- list=gh_cdr(list);
+ value = gh_car(list);
+ list = gh_cdr(list);
- if( gh_eq_p(value,gh_symbol2scm("level")) ) {
- stats->Level=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("speed")) ) {
- stats->Speed=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("attack-range")) ) {
- stats->AttackRange=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("sight-range")) ) {
- stats->SightRange=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("armor")) ) {
- stats->Armor=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("basic-damage")) ) {
- stats->BasicDamage=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("piercing-damage")) ) {
- stats->PiercingDamage=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("hit-points")) ) {
- stats->HitPoints=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("regeneration-rate")) ) {
- stats->RegenerationRate=gh_scm2int(gh_car(list));
- list=gh_cdr(list);
- } else if( gh_eq_p(value,gh_symbol2scm("costs")) ) {
- sublist=gh_car(list);
- list=gh_cdr(list);
- while( !gh_null_p(sublist) ) {
-
- value=gh_car(sublist);
- sublist=gh_cdr(sublist);
-
- for( i=0; i<MaxCosts; ++i ) {
- if( gh_eq_p(value,gh_symbol2scm(DefaultResourceNames[i])) )
{
- stats->Costs[i]=gh_scm2int(gh_car(sublist));
+ if (gh_eq_p(value, gh_symbol2scm("level"))) {
+ stats->Level = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("speed"))) {
+ stats->Speed = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("attack-range"))) {
+ stats->AttackRange = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("sight-range"))) {
+ stats->SightRange = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("armor"))) {
+ stats->Armor = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("basic-damage"))) {
+ stats->BasicDamage = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("piercing-damage"))) {
+ stats->PiercingDamage = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("hit-points"))) {
+ stats->HitPoints = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("regeneration-rate"))) {
+ stats->RegenerationRate = gh_scm2int(gh_car(list));
+ list = gh_cdr(list);
+ } else if (gh_eq_p(value, gh_symbol2scm("costs"))) {
+ sublist = gh_car(list);
+ list = gh_cdr(list);
+ while (!gh_null_p(sublist)) {
+
+ value = gh_car(sublist);
+ sublist = gh_cdr(sublist);
+
+ for (i = 0; i < MaxCosts; ++i) {
+ if (gh_eq_p(value, gh_symbol2scm(DefaultResourceNames[i])))
{
+ stats->Costs[i] = gh_scm2int(gh_car(sublist));
break;
}
}
- if( i==MaxCosts ) {
+ if (i == MaxCosts) {
// FIXME: this leaves half initialized stats
- errl("Unsupported tag",value);
+ errl("Unsupported tag", value);
}
- sublist=gh_cdr(sublist);
+ sublist = gh_cdr(sublist);
}
} else {
// FIXME: this leaves a half initialized unit
- errl("Unsupported tag",value);
+ errl("Unsupported tag", value);
}
}
@@ -717,7 +723,7 @@
UnitType* type;
// Be kind allow also strings or symbols
- if( (str = CclConvertToString(ptr)) != NULL ) {
+ if ((str = CclConvertToString(ptr)) != NULL) {
DebugLevel3("CclGetUnitType: %s\n"_C_ str);
type = UnitTypeByIdent(str);
free(str);
@@ -771,18 +777,15 @@
UnitType* type;
str = CclConvertToString(ident);
- if (str)
- {
+ if (str) {
type = UnitTypeByIdent(str);
printf("CclUnitType: '%s' -> '%ld'\n", str, (long)type);
free(str);
return CclMakeSmobObj(SiodUnitTypeTag, type);
- }
- else
- {
+ } else {
errl("CclUnitType: no unittype by ident: ", ident);
return SCM_BOOL_F;
- }
+ }
}
/**
@@ -798,7 +801,7 @@
array = cons_array(gh_int2scm(UnitTypeMax), NIL);
- for( i=0; i<UnitTypeMax; ++i ) {
+ for (i = 0; i < UnitTypeMax; ++i) {
value = CclMakeSmobObj(SiodUnitTypeTag, &UnitTypes[i]);
gh_vector_set_x(array, gh_int2scm(i), value);
}
@@ -817,8 +820,8 @@
const UnitType* type;
SCM value;
- type=CclGetUnitType(ptr);
- value=gh_str02scm(type->Ident);
+ type = CclGetUnitType(ptr);
+ value = gh_str02scm(type->Ident);
return value;
}
@@ -834,8 +837,8 @@
const UnitType* type;
SCM value;
- type=CclGetUnitType(ptr);
- value=gh_str02scm(type->Name);
+ type = CclGetUnitType(ptr);
+ value = gh_str02scm(type->Name);
return value;
}
@@ -847,13 +850,13 @@
**
** @return The name of the unit-type.
*/
-local SCM CclSetUnitTypeName(SCM ptr,SCM name)
+local SCM CclSetUnitTypeName(SCM ptr, SCM name)
{
UnitType* type;
- type=CclGetUnitType(ptr);
+ type = CclGetUnitType(ptr);
free(type->Name);
- type->Name=gh_scm2newstr(name,NULL);
+ type->Name = gh_scm2newstr(name, NULL);
return name;
}
@@ -871,7 +874,7 @@
{
const UnitType* type;
- type=CclGetUnitType(ptr);
+ type = CclGetUnitType(ptr);
return type->Property;
}
@@ -883,19 +886,19 @@
**
** @return The property of the unit-type.
*/
-local SCM CclSetUnitTypeProperty(SCM ptr,SCM property)
+local SCM CclSetUnitTypeProperty(SCM ptr, SCM property)
{
UnitType* type;
- type=CclGetUnitType(ptr);
+ type = CclGetUnitType(ptr);
- if( type->Property ) {
+ if (type->Property) {
// FIXME: old value must be unprotected!!
}
- if( !property ) {
+ if (!property) {
DebugLevel0Fn("oops, my fault\n");
}
- type->Property=property;
+ type->Property = property;
CclGcProtect(type->Property);
return property;
@@ -911,8 +914,8 @@
int i;
char** cp;
- if( (cp=UnitTypeWcNames) ) { // Free all old names
- while( *cp ) {
+ if ((cp = UnitTypeWcNames)) { // Free all old names
+ while (*cp) {
free(*cp++);
}
free(UnitTypeWcNames);
@@ -921,13 +924,13 @@
//
// Get new table.
//
- i=gh_length(list);
- UnitTypeWcNames=cp=malloc((i+1)*sizeof(char*));
- while( i-- ) {
- *cp++=gh_scm2newstr(gh_car(list),NULL);
- list=gh_cdr(list);
+ i = gh_length(list);
+ UnitTypeWcNames = cp = malloc((i + 1) * sizeof(char*));
+ while (i--) {
+ *cp++ = gh_scm2newstr(gh_car(list), NULL);
+ list = gh_cdr(list);
}
- *cp=NULL;
+ *cp = NULL;
return SCM_UNSPECIFIED;
}
@@ -950,59 +953,59 @@
int i;
int frame;
- str=gh_scm2newstr(gh_car(list),NULL);
- list=gh_cdr(list);
- anims=calloc(1,sizeof(Animations));
-
- while( !gh_null_p(list) ) {
- id=gh_car(list);
- list=gh_cdr(list);
- value=gh_car(list);
- list=gh_cdr(list);
-
- t=anim=malloc(gh_length(value)*sizeof(Animation));
- frame=0;
- while( !gh_null_p(value) ) {
- t->Flags=gh_scm2int(gh_vector_ref(gh_car(value),gh_int2scm(0)));
- t->Pixel=gh_scm2int(gh_vector_ref(gh_car(value),gh_int2scm(1)));
- t->Sleep=gh_scm2int(gh_vector_ref(gh_car(value),gh_int2scm(2)));
- i=gh_scm2int(gh_vector_ref(gh_car(value),gh_int2scm(3)));
- t->Frame=i-frame;
- frame=i;
- if( t->Flags&AnimationRestart ) {
- frame=0;
+ str = gh_scm2newstr(gh_car(list), NULL);
+ list = gh_cdr(list);
+ anims = calloc(1,sizeof(Animations));
+
+ while (!gh_null_p(list)) {
+ id = gh_car(list);
+ list = gh_cdr(list);
+ value = gh_car(list);
+ list = gh_cdr(list);
+
+ t = anim = malloc(gh_length(value) * sizeof(Animation));
+ frame = 0;
+ while (!gh_null_p(value)) {
+ t->Flags = gh_scm2int(gh_vector_ref(gh_car(value), gh_int2scm(0)));
+ t->Pixel = gh_scm2int(gh_vector_ref(gh_car(value), gh_int2scm(1)));
+ t->Sleep = gh_scm2int(gh_vector_ref(gh_car(value), gh_int2scm(2)));
+ i = gh_scm2int(gh_vector_ref(gh_car(value), gh_int2scm(3)));
+ t->Frame = i - frame;
+ frame = i;
+ if (t->Flags&AnimationRestart) {
+ frame = 0;
}
++t;
- value=gh_cdr(value);
+ value = gh_cdr(value);
}
- t[-1].Flags|=0x80; // Marks end of list
+ t[-1].Flags |= 0x80; // Marks end of list
- if( gh_eq_p(id,gh_symbol2scm("still")) ) {
- if( anims->Still ) {
+ if (gh_eq_p(id, gh_symbol2scm("still"))) {
+ if (anims->Still) {
free(anims->Still);
}
- anims->Still=anim;
- } else if( gh_eq_p(id,gh_symbol2scm("move")) ) {
- if( anims->Move ) {
+ anims->Still = anim;
+ } else if (gh_eq_p(id, gh_symbol2scm("move"))) {
+ if (anims->Move) {
free(anims->Move);
}
- anims->Move=anim;
- } else if( gh_eq_p(id,gh_symbol2scm("attack")) ) {
- if( anims->Attack ) {
+ anims->Move = anim;
+ } else if (gh_eq_p(id, gh_symbol2scm("attack"))) {
+ if (anims->Attack) {
free(anims->Attack);
}
anims->Attack=anim;
- } else if( gh_eq_p(id,gh_symbol2scm("die")) ) {
- if( anims->Die ) {
+ } else if (gh_eq_p(id, gh_symbol2scm("die"))) {
+ if (anims->Die) {
free(anims->Die);
}
- anims->Die=anim;
+ anims->Die = anim;
} else {
- errl("Unsupported tag",id);
+ errl("Unsupported tag", id);
}
}
- *(Animations**)hash_add(AnimationsHash,str)=anims;
+ *(Animations**)hash_add(AnimationsHash, str) = anims;
free(str);
return SCM_UNSPECIFIED;
@@ -1015,30 +1018,30 @@
*/
global void UnitTypeCclRegister(void)
{
- gh_new_procedureN("define-unit-type",CclDefineUnitType);
- gh_new_procedureN("define-unit-stats",CclDefineUnitStats);
+ gh_new_procedureN("define-unit-type", CclDefineUnitType);
+ gh_new_procedureN("define-unit-stats", CclDefineUnitStats);
SiodUnitTypeTag = CclMakeSmobType("UnitType");
#ifndef USE_GUILE
- set_print_hooks(SiodUnitTypeTag,CclUnitTypePrin1);
+ set_print_hooks(SiodUnitTypeTag, CclUnitTypePrin1);
#endif
- gh_new_procedure1_0("unit-type",CclUnitType);
- gh_new_procedure0_0("unit-type-array",CclUnitTypeArray);
+ gh_new_procedure1_0("unit-type", CclUnitType);
+ gh_new_procedure0_0("unit-type-array", CclUnitTypeArray);
// unit type structure access
- gh_new_procedure1_0("get-unit-type-ident",CclGetUnitTypeIdent);
- gh_new_procedure1_0("get-unit-type-name",CclGetUnitTypeName);
- gh_new_procedure2_0("set-unit-type-name!",CclSetUnitTypeName);
+ gh_new_procedure1_0("get-unit-type-ident", CclGetUnitTypeIdent);
+ gh_new_procedure1_0("get-unit-type-name", CclGetUnitTypeName);
+ gh_new_procedure2_0("set-unit-type-name!", CclSetUnitTypeName);
// FIXME: write the missing access functions
- gh_new_procedure1_0("get-unit-type-property",CclGetUnitTypeProperty);
- gh_new_procedure2_0("set-unit-type-property!",CclSetUnitTypeProperty);
+ gh_new_procedure1_0("get-unit-type-property", CclGetUnitTypeProperty);
+ gh_new_procedure2_0("set-unit-type-property!", CclSetUnitTypeProperty);
- gh_new_procedureN("define-unittype-wc-names",CclDefineUnitTypeWcNames);
+ gh_new_procedureN("define-unittype-wc-names", CclDefineUnitTypeWcNames);
- gh_new_procedureN("define-animations",CclDefineAnimations);
+ gh_new_procedureN("define-animations", CclDefineAnimations);
}
//@}
Index: stratagus/src/unit/depend.c
diff -u stratagus/src/unit/depend.c:1.29 stratagus/src/unit/depend.c:1.30
--- stratagus/src/unit/depend.c:1.29 Sun Aug 17 11:57:08 2003
+++ stratagus/src/unit/depend.c Thu Oct 2 12:15:06 2003
@@ -26,7 +26,7 @@
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
// 02111-1307, USA.
//
-// $Id: depend.c,v 1.29 2003/08/17 15:57:08 n0body Exp $
+// $Id: depend.c,v 1.30 2003/10/02 16:15:06 jsalmon3 Exp $
//@{
@@ -49,7 +49,7 @@
----------------------------------------------------------------------------*/
/// All dependencies hash
-local DependRule* DependHash[101];
+local DependRule* DependHash[101];
/*----------------------------------------------------------------------------
-- Functions
@@ -63,8 +63,8 @@
** @param count Amount of the required needed.
** @param or_flag Start of or rule.
*/
-global void AddDependency(const char* target,const char* required,int count
- ,int or_flag)
+global void AddDependency(const char* target, const char* required, int count,
+ int or_flag)
{
DependRule rule;
DependRule* node;
@@ -74,106 +74,105 @@
//
// Setup structure.
//
- if ( !strncmp( target, "unit-", 5 ) ) {
+ if (!strncmp(target, "unit-", 5)) {
// target string refers to unit-xxx
rule.Type = DependRuleUnitType;
- rule.Kind.UnitType = UnitTypeByIdent( target );
- } else if ( !strncmp( target, "upgrade-", 8 ) ) {
+ rule.Kind.UnitType = UnitTypeByIdent(target);
+ } else if (!strncmp(target, "upgrade-", 8)) {
// target string refers to upgrade-XXX
rule.Type = DependRuleUpgrade;
- rule.Kind.Upgrade = UpgradeByIdent( target );
+ rule.Kind.Upgrade = UpgradeByIdent(target);
} else {
- DebugLevel0Fn("dependency target `%s' should be unit-type or upgrade\n"
- _C_ target);
+ DebugLevel0Fn("dependency target `%s' should be unit-type or upgrade\n"
_C_
+ target);
return;
}
-
hash=(int)(long)rule.Kind.UnitType%(sizeof(DependHash)/sizeof(*DependHash));
+ hash = (int)(long)rule.Kind.UnitType % (sizeof(DependHash) /
sizeof(*DependHash));
//
// Find correct hash slot.
//
- if( (node=DependHash[hash]) ) { // find correct entry
- while( node->Type!=rule.Type
- || node->Kind.Upgrade!=rule.Kind.Upgrade ) {
- if( !node->Next ) { // end of list
- temp=malloc(sizeof(DependRule));
- temp->Next=NULL;
- temp->Rule=NULL;
- temp->Type=rule.Type;
- temp->Kind=rule.Kind;
- node->Next=temp;
- node=temp;
+ if ((node = DependHash[hash])) { // find correct entry
+ while (node->Type != rule.Type ||
+ node->Kind.Upgrade != rule.Kind.Upgrade) {
+ if (!node->Next) { // end of list
+ temp = malloc(sizeof(DependRule));
+ temp->Next = NULL;
+ temp->Rule = NULL;
+ temp->Type = rule.Type;
+ temp->Kind = rule.Kind;
+ node->Next = temp;
+ node = temp;
break;
}
node=node->Next;
}
} else { // create new slow
- node=malloc(sizeof(DependRule));
- node->Next=NULL;
- node->Rule=NULL;
- node->Type=rule.Type;
- node->Kind=rule.Kind;
- DependHash[hash]=node;
+ node = malloc(sizeof(DependRule));
+ node->Next = NULL;
+ node->Rule = NULL;
+ node->Type = rule.Type;
+ node->Kind = rule.Kind;
+ DependHash[hash] = node;
}
//
// Adjust count.
//
- if ( count < 0 || count > 255 ) {
+ if (count < 0 || count > 255) {
DebugLevel0Fn("wrong count `%d' range 0 .. 255\n" _C_ count);
count = 255;
}
- temp=malloc(sizeof(DependRule));
- temp->Rule=NULL;
- temp->Next=NULL;
- temp->Count=count;
+ temp = malloc(sizeof(DependRule));
+ temp->Rule = NULL;
+ temp->Next = NULL;
+ temp->Count = count;
//
// Setup structure.
//
- if ( !strncmp( required, "unit-", 5 ) ) {
+ if (!strncmp(required, "unit-", 5)) {
// required string refers to unit-xxx
temp->Type = DependRuleUnitType;
- temp->Kind.UnitType = UnitTypeByIdent( required );
- } else if ( !strncmp( required, "upgrade-", 8 ) ) {
+ temp->Kind.UnitType = UnitTypeByIdent(required);
+ } else if (!strncmp(required, "upgrade-", 8)) {
// required string refers to upgrade-XXX
temp->Type = DependRuleUpgrade;
- temp->Kind.Upgrade = UpgradeByIdent( required );
+ temp->Kind.Upgrade = UpgradeByIdent(required);
} else {
- DebugLevel0Fn(
- "dependency required `%s' should be unit-type or upgrade\n"
- _C_ required);
+ DebugLevel0Fn("dependency required `%s' should be unit-type or
upgrade\n" _C_
+ required);
free(temp);
return;
}
- if( or_flag ) {
+ if (or_flag) {
// move rule to temp->next
- temp->Next=node->Rule; // insert rule
- node->Rule=temp;
+ temp->Next = node->Rule; // insert rule
+ node->Rule = temp;
} else {
// move rule to temp->rule
- temp->Rule=node->Rule; // insert rule
+ temp->Rule = node->Rule; // insert rule
// also Link temp to old "or" list
if (node->Rule) {
- temp->Next=node->Rule->Next;
+ temp->Next = node->Rule->Next;
}
- node->Rule=temp;
+ node->Rule = temp;
}
#ifdef neverDEBUG
printf("New rules are :");
- node=node->Rule;
- while(node){
- temp=node;
- while(temp){
- printf("temp->Kind.UnitType=%p ",temp->Kind.UnitType);
- temp=temp->Rule;
- }
- node=node->Next;
- printf("\n or ... ");
+ node = node->Rule;
+ while (node) {
+ temp = node;
+ while (temp){
+ printf("temp->Kind.UnitType=%p ", temp->Kind.UnitType);
+ temp = temp->Rule;
+ }
+ node = node->Next;
+ printf("\n or ... ");
}
printf("\n");
#endif
@@ -187,7 +186,7 @@
**
** @return True if available, false otherwise.
*/
-global int CheckDependByIdent(const Player* player,const char* target)
+global int CheckDependByIdent(const Player* player, const char* target)
{
DependRule rule;
const DependRule* node;
@@ -197,17 +196,17 @@
//
// first have to check, if target is allowed itself
//
- if ( !strncmp( target, "unit-", 5 ) ) {
+ if (!strncmp(target, "unit-", 5)) {
// target string refers to unit-XXX
- rule.Kind.UnitType = UnitTypeByIdent( target );
- if ( UnitIdAllowed( player, rule.Kind.UnitType->Type ) != 'A' ) {
+ rule.Kind.UnitType = UnitTypeByIdent(target);
+ if (UnitIdAllowed(player, rule.Kind.UnitType->Type) != 'A') {
return 0;
}
rule.Type = DependRuleUnitType;
- } else if ( !strncmp( target, "upgrade-", 8 ) ) {
+ } else if (!strncmp(target, "upgrade-", 8)) {
// target string refers to upgrade-XXX
- rule.Kind.Upgrade = UpgradeByIdent( target );
- if( UpgradeIdAllowed( player, rule.Kind.Upgrade-Upgrades ) != 'A' ) {
+ rule.Kind.Upgrade = UpgradeByIdent(target);
+ if (UpgradeIdAllowed(player, rule.Kind.Upgrade-Upgrades) != 'A') {
return 0;
}
rule.Type = DependRuleUpgrade;
@@ -219,15 +218,15 @@
//
// Find rule
//
- i=(int)(long)rule.Kind.UnitType%(sizeof(DependHash)/sizeof(*DependHash));
+ i = (int)(long)rule.Kind.UnitType % (sizeof(DependHash) /
sizeof(*DependHash));
- if( (node=DependHash[i]) ) { // find correct entry
- while( node->Type!=rule.Type
- || node->Kind.Upgrade!=rule.Kind.Upgrade ) {
- if( !node->Next ) { // end of list
+ if ((node = DependHash[i])) { // find correct entry
+ while (node->Type != rule.Type ||
+ node->Kind.Upgrade != rule.Kind.Upgrade) {
+ if (!node->Next) { // end of list
return 1;
}
- node=node->Next;
+ node = node->Next;
}
} else {
return 1;
@@ -236,31 +235,31 @@
//
// Prove the rules
//
- node=node->Rule;
+ node = node->Rule;
- while( node ) {
- temp=node;
- while( temp ) {
- switch( temp->Type ) {
- case DependRuleUnitType:
- i=HaveUnitTypeByType( player, temp->Kind.UnitType );
- if ( temp->Count ? i<temp->Count : i ) {
- goto try_or;
- }
- break;
- case DependRuleUpgrade:
- i=UpgradeIdAllowed( player, temp->Kind.Upgrade-Upgrades) != 'R';
- if ( temp->Count ? i : !i ) {
- goto try_or;
- }
- break;
+ while (node) {
+ temp = node;
+ while (temp) {
+ switch (temp->Type) {
+ case DependRuleUnitType:
+ i = HaveUnitTypeByType(player, temp->Kind.UnitType);
+ if (temp->Count ? i < temp->Count : i) {
+ goto try_or;
+ }
+ break;
+ case DependRuleUpgrade:
+ i = UpgradeIdAllowed(player, temp->Kind.Upgrade-Upgrades)
!= 'R';
+ if (temp->Count ? i : !i) {
+ goto try_or;
+ }
+ break;
}
- temp=temp->Rule;
+ temp = temp->Rule;
}
return 1; // all rules matches.
try_or:
- node=node->Next;
+ node = node->Next;
}
return 0; // no rule matches
@@ -269,7 +268,9 @@
/**
** Initialize unit and upgrade dependencies.
*/
-global void InitDependencies(void){}
+global void InitDependencies(void)
+{
+}
/**
** Save state of the dependencies to file.
@@ -284,52 +285,52 @@
const DependRule* temp;
CLprintf(file,"\n;;; -----------------------------------------\n");
- CLprintf(file,";;; MODULE: dependencies $Id: depend.c,v 1.29 2003/08/17
15:57:08 n0body Exp $\n\n");
+ CLprintf(file,";;; MODULE: dependencies $Id: depend.c,v 1.30 2003/10/02
16:15:06 jsalmon3 Exp $\n\n");
// Save all dependencies
- for( u=0; u<sizeof(DependHash)/sizeof(*DependHash); ++u ) {
- node=DependHash[u];
- while( node ) { // all hash links
- CLprintf(file,"(define-dependency '");
- switch( node->Type ) {
+ for (u = 0; u < sizeof(DependHash) / sizeof(*DependHash); ++u) {
+ node = DependHash[u];
+ while (node) { // all hash links
+ CLprintf(file, "(define-dependency '");
+ switch (node->Type) {
case DependRuleUnitType:
- CLprintf(file,"%s",node->Kind.UnitType->Ident);
+ CLprintf(file, "%s", node->Kind.UnitType->Ident);
break;
case DependRuleUpgrade:
- CLprintf(file,"%s",node->Kind.Upgrade->Ident);
+ CLprintf(file, "%s", node->Kind.Upgrade->Ident);
break;
}
// All or cases
- CLprintf(file,"\n '(");
- rule=node->Rule;
- for( ;; ) {
- temp=rule;
- while( temp ) {
- switch( temp->Type ) {
- case DependRuleUnitType:
- CLprintf(file,"%s",temp->Kind.UnitType->Ident);
- break;
- case DependRuleUpgrade:
- CLprintf(file,"%s",temp->Kind.Upgrade->Ident);
- break;
+ CLprintf(file, "\n '(");
+ rule = node->Rule;
+ for (;;) {
+ temp = rule;
+ while (temp) {
+ switch (temp->Type) {
+ case DependRuleUnitType:
+ CLprintf(file, "%s", temp->Kind.UnitType->Ident);
+ break;
+ case DependRuleUpgrade:
+ CLprintf(file, "%s", temp->Kind.Upgrade->Ident);
+ break;
}
- temp=temp->Rule;
- if( temp ) {
+ temp = temp->Rule;
+ if (temp) {
CLprintf(file," ");
}
}
- CLprintf(file,")");
- if( !(rule=rule->Next) ) {
+ CLprintf(file, ")");
+ if (!(rule = rule->Next)) {
break;
}
- CLprintf(file,"\n 'or '( ");
+ CLprintf(file, "\n 'or '( ");
}
- CLprintf(file,")\n");
+ CLprintf(file, ")\n");
- node=node->Next;
+ node = node->Next;
}
}
}
@@ -347,30 +348,30 @@
// Free all dependencies
- for( u=0; u<sizeof(DependHash)/sizeof(*DependHash); ++u ) {
- node=DependHash[u];
- while( node ) { // all hash links
+ for (u = 0; u < sizeof(DependHash) / sizeof(*DependHash); ++u) {
+ node = DependHash[u];
+ while (node) { // all hash links
// All or cases
- rule=node->Rule;
- while( rule ) {
- if( rule ) {
- temp=rule->Rule;
- while( temp ) {
- next=temp;
- temp=temp->Rule;
+ rule = node->Rule;
+ while (rule) {
+ if (rule) {
+ temp = rule->Rule;
+ while (temp) {
+ next = temp;
+ temp = temp->Rule;
free(next);
}
}
- temp=rule;
- rule=rule->Next;
+ temp = rule;
+ rule = rule->Next;
free(temp);
}
- temp=node;
- node=node->Next;
+ temp = node;
+ node = node->Next;
free(temp);
}
- DependHash[u]=NULL;
+ DependHash[u] = NULL;
}
}
@@ -394,40 +395,40 @@
SCM temp;
int or_flag;
- value=gh_car(list);
- list=gh_cdr(list);
- target=gh_scm2newstr(value,NULL);
+ value = gh_car(list);
+ list = gh_cdr(list);
+ target = gh_scm2newstr(value,NULL);
//
// All or rules.
//
- or_flag=0;
- while( !gh_null_p(list) ) {
- temp=gh_car(list);
- list=gh_cdr(list);
-
- while( !gh_null_p(temp) ) {
- value=gh_car(temp);
- temp=gh_cdr(temp);
- required=gh_scm2newstr(value,NULL);
- count=1;
- if( !gh_null_p(temp) && gh_exact_p(temp) ) {
- value=gh_car(temp);
- count=gh_scm2int(value);
- temp=gh_cdr(temp);
+ or_flag = 0;
+ while (!gh_null_p(list)) {
+ temp = gh_car(list);
+ list = gh_cdr(list);
+
+ while (!gh_null_p(temp)) {
+ value = gh_car(temp);
+ temp = gh_cdr(temp);
+ required = gh_scm2newstr(value, NULL);
+ count = 1;
+ if (!gh_null_p(temp) && gh_exact_p(temp)) {
+ value = gh_car(temp);
+ count = gh_scm2int(value);
+ temp = gh_cdr(temp);
}
- AddDependency(target,required,count,or_flag);
+ AddDependency(target, required, count, or_flag);
free(required);
- or_flag=0;
+ or_flag = 0;
}
- if( !gh_null_p(list) ) {
- if( !gh_eq_p(gh_car(list),gh_symbol2scm("or")) ) {
- errl("not or symbol",gh_car(list));
+ if (!gh_null_p(list)) {
+ if (!gh_eq_p(gh_car(list), gh_symbol2scm("or"))) {
+ errl("not or symbol", gh_car(list));
return SCM_UNSPECIFIED;
}
- or_flag=1;
- list=gh_cdr(list);
+ or_flag = 1;
+ list = gh_cdr(list);
}
}
free(target);
@@ -468,9 +469,9 @@
*/
global void DependenciesCclRegister(void)
{
- gh_new_procedureN("define-dependency",CclDefineDependency);
- gh_new_procedure1_0("get-dependency",CclGetDependency);
- gh_new_procedure1_0("check-dependency",CclCheckDependency);
+ gh_new_procedureN("define-dependency", CclDefineDependency);
+ gh_new_procedure1_0("get-dependency", CclGetDependency);
+ gh_new_procedure1_0("check-dependency", CclCheckDependency);
}
//@}
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [Stratagus-CVS] stratagus/src/unit ccl_unit.c ccl_unittype.c de...,
Jimmy Salmon <=