Path: utzoo!attcan!uunet!husc6!bloom-beacon!tut.cis.ohio-state.edu!mailrus!utah-gr!utah-cs!shebs From: shebs@utah-cs.UUCP (Stanley Shebs) Newsgroups: comp.sources.bugs Subject: Xconq Patch1 (part 2 of 2) Keywords: many fixes, Godzilla Message-ID: <5621@utah-cs.UUCP> Date: 20 Jul 88 23:18:34 GMT Organization: PASS Research Group Lines: 2044 #! /bin/sh # This is a shell archive. Remove anything before this line, then unpack # it by saving it into a file and typing "sh file". To overwrite existing # files, type "sh file -c". You can also feed this as standard input via # unshar, or by typing "sh lib/beirut.per <<'END_OF_lib/beirut.per' XXconq 0 -+---- The heroic fighters of Beirut XPeriod 0 X X; buildings should be able to be neutral after revolt X; death squads should be as fast as leaders and shouldn't retreat X; and should be able to take over buildings. X; no capturing if leader if they are win/lose condition. X X"Beirut 1982" period-name X X0 scale ; well under 1 km per hex... X X"m" "militia" "hide and fight from building to building" utype X"d" "death squad" "hit people and not buildings" utype X"l" "leader" "an individual" utype X"c" "car bomb" "destroys buildings" utype X"t" "tank" "also destroys buildings and other things" utype X"B" "building" "good for hiding out" utype X X; hostages rtype? X X"." "sea" "sky blue" ttype X"," "beach" "yellow" ttype X"+" "street" "light gray" ttype X"^" "junkheap" "sienna" ttype X"=" "fields" "green" ttype X"%" "trees" "forest green" ttype X Xtrue junkheap dark X X[ 0 20 25 35 80 90 ] t* min-alt X[ 20 25 35 80 90 100 ] t* max-alt X X"soldiers" m icon-name X"45" d icon-name X"man" l icon-name X"auto" c icon-name X"tank" t icon-name X"city20" B icon-name X X[ m d l c t ] "movers" define X[ c t ] "vehicles" define X[ sea ] "water" define X[ beach street junkheap fields trees ] "land" define X X1 B territory X10 l territory X X[ 5 1 1 2 2 1 ] u* in-country X3000 B density X100 street movers favored X100 junkheap B favored X X; 100 t* u* favored X X5 country-size X5 country-min-distance X;10 country-max-distance X X100 B revolt X X[ 1 1 2 3 3 ] movers speed X X0 land [ m d l ] moves X0 [ beach street ] vehicles moves X X2 [ m d l ] B capacity X X0 d visibility Xtrue B already-seen X Xtrue all-seen X X[ 1 1 1 1 2 10 ] u* hp X X[ 50 50 50 50 50 50 ] u* m hit X[ 5 50 70 20 20 0 ] u* d hit X[ 0 20 50 0 20 0 ] u* l hit X[ 90 90 90 90 90 90 ] u* c hit X[ 90 90 90 90 90 90 ] u* t hit X[ 10 10 10 10 0 0 ] u* B hit X X1 u* u* damage X1 B t damage X[ 2 10 ] [ t B ] c damage X X-100 neutrality X Xtrue c self-destruct X X100 B m capture X100 c m capture X; 50 l m capture X50 t m capture X X[ 20 80 90 0 0 ] movers retreat X X;30 m control X X50 [ m d ] B protect X90 B m protect X Xtrue B neutral X Xend END_OF_lib/beirut.per if test 2050 -ne `wc -c lib/breath.b11 <<'END_OF_lib/breath.b11' X#define breath_width 16 X#define breath_height 16 Xstatic char breath_bits[] = { X 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x92, 0x00, 0x54, 0x00, 0x94, 0x00, X 0x64, 0x01, 0x48, 0x03, 0x5a, 0x0d, 0xd4, 0xf2, 0xa8, 0x7a, 0xf0, 0x0f, X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; END_OF_lib/breath.b11 if test 281 -ne `wc -c lib/fire.b11 <<'END_OF_lib/fire.b11' X#define fire_width 16 X#define fire_height 16 Xstatic char fire_bits[] = { X 0x00, 0x00, 0x60, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0xc0, 0x01, 0x60, 0x01, X 0x70, 0x03, 0x78, 0x03, 0x38, 0x03, 0xd8, 0x01, 0xd8, 0x02, 0x58, 0x02, X 0x70, 0x01, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00}; END_OF_lib/fire.b11 if test 275 -ne `wc -c lib/fireman.b11 <<'END_OF_lib/fireman.b11' X#define fireman_width 16 X#define fireman_height 16 Xstatic char fireman_bits[] = { X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, X 0x00, 0x00, 0xee, 0x3f, 0xfe, 0x3f, 0xfe, 0x3f, 0xfe, 0x7f, 0x0c, 0x1c, X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; END_OF_lib/fireman.b11 if test 284 -ne `wc -c lib/flattop.per <<'END_OF_lib/flattop.per' XXconq 0 -+---- Carrier operations in the Pacific XPeriod 0 X X"WW II, in the Pacific, aboard a carrier" period-name X X"f" "fighter" "" utype X"d" "dive bomber" "" utype X"t" "torpedo bomber" "" utype X"p" "PBY" "" utype X"D" "destroyer" "" utype X"S" "submarine" "" utype X"E" "escort carrier" "" utype X"r" "light cruiser" "" utype X"R" "heavy cruiser" "" utype X"C" "carrier" "" utype X"B" "battleship" "" utype X"/" "base" "" utype X X"o" "fuel" "how to get around" rtype X"a" "ammo" "small stuff" rtype X"A" "shell" "8 to 16 inch" rtype X"b" "bomb" "iron bombs" rtype X"!" "torps" "death to ships" rtype X X"." "sea" "sky blue" ttype X"," "atoll" "cyan" ttype X"+" "island" "forest green" ttype X X[ 0 96 98 ] t* min-alt X[ 96 98 100 ] t* max-alt X X95 alt-roughness X Xsea default-terrain Xsea edge-terrain X X"1e" f icon-name X"1e" d icon-name X"torpbombr" t icon-name X"pby" p icon-name X"dd" D icon-name X"ca" r icon-name X"sub" S icon-name X"cv" E icon-name X"cv" C icon-name X"ca" R icon-name X"bb" B icon-name X"airbase" / icon-name X X[ f d t p ] "air" define X[ r R B ] "heavy" define X[ E C ] "carriers" define X[ D S E r R C B ] "ships" define X[ o a A b ! ] "stuff" define X X100 sea ships favored X100 [ atoll island ] / favored X X4 country-size X30 country-min-distance X32 country-max-distance X X[ 8 8 8 4 6 2 4 2 2 2 2 1 ] u* in-country X Xtrue / always-seen X X500 [ fuel ammo ] ships storage X20 fuel air storage X40 fuel p storage X2 a air storage X0 a p storage X2 b d storage X2 ! t storage X10 ! [ D S ] storage X50 [ b ! ] C storage X25 [ b ! ] E storage X50 A heavy storage X1000 r* / storage X X3 fuel air consume X X9 air speed X6 p speed X3 ships speed ; gross simplification X X0 t* air moves X0 t* p moves X0 sea ships moves X2 atoll ships moves X X1 fuel u* to-move X X4 air E capacity X8 air C capacity X100 u* / capacity X100 u* u* enter-time X1 air volume X4 E hold-volume X8 C hold-volume X100 / hold-volume X X10 S visibility X X[ 5 5 5 5 10 10 20 ] ships hp X100 / hp X X50 u* u* hit X80 air f hit X60 f f hit X0 u* p hit X20 carriers f hit X20 air S hit X70 S D hit X100 / u* hit X0 / [ S E C ] hit X10 u* carriers hit X X1 u* u* damage X3 u* heavy damage X4 ships [ t D S ] damage X10 [ C B ] [ t D S ] damage X10 / B damage X X1 a air hits-with X1 a [ E C ] hits-with X1 b d hits-with X1 ! [ t D S ] hits-with X1 A heavy hits-with X X1 [ b ! ] ships hit-by X1 a air hit-by X1 A u* hit-by X X50 air carriers protect X X"sinks" ships destroy-message X"shoots down" air destroy-message X X; 0 air control X Xbegin{notes} XThis is a somewhat expanded version of the navy in the standard period. XEach side commands a large fleet, and the sole objective is to wipe out Xthe enemy's fleet. There are different kinds of planes and ships, but Xnothing else. X XSpeeds of ships are uniform, so that formations work better (don't want Xthe carriers outstripping their escorts). X XYou do *not* get complete control over the aircraft! Those undisciplined Xpilots just do what they feel like doing, and only take about half their Xorders. Xend{notes} X Xend END_OF_lib/flattop.per if test 2947 -ne `wc -c lib/monster.b11 <<'END_OF_lib/monster.b11' X#define monster_width 16 X#define monster_height 16 Xstatic char monster_bits[] = { X 0x00, 0x00, 0x2e, 0x00, 0x1e, 0x00, 0x58, 0x00, 0x38, 0x00, 0x7e, 0x01, X 0xf0, 0x00, 0xf8, 0x02, 0xf8, 0x01, 0xf0, 0x0b, 0xe0, 0x07, 0x60, 0x0e, X 0x78, 0x38, 0x14, 0xe0, 0x00, 0x00, 0x00, 0x00}; END_OF_lib/monster.b11 if test 284 -ne `wc -c lib/monster.b11 <<'END_OF_lib/monster.b11' X#define monster_width 16 X#define monster_height 16 Xstatic char monster_bits[] = { X 0x00, 0x00, 0x2e, 0x00, 0x1e, 0x00, 0x58, 0x00, 0x38, 0x00, 0x7e, 0x01, X 0xf0, 0x00, 0xf8, 0x02, 0xf8, 0x01, 0xf0, 0x0b, 0xe0, 0x07, 0x60, 0x0e, X 0x78, 0x38, 0x14, 0xe0, 0x00, 0x00, 0x00, 0x00}; END_OF_lib/monster.b11 if test 284 -ne `wc -c lib/monster.per <<'END_OF_lib/monster.per' XXconq 0 -+---- Save Tokyo from the fire-breathing monsters! XPeriod 0 X X"Tokyo 1962" period-name X X0 scale ; well under 1 km per hex... X X"m" "monster" "breathes fire and stomps on buildings" utype X"b" "fire breath" "burns things up" utype X"f" "fire" "burns things up" utype X"p" "panic-stricken mob" "helpless civilians, mostly just get in the way" utype X"F" "fire department" "puts out fires" utype X"g" "national guard" "does battle with the monster" utype X"B" "building" "good for hiding out" utype X X"e" "energy" "required to make fires move" rtype X X; hostages rtype? X X"." "sea" "sky blue" ttype X"," "beach" "yellow" ttype X"+" "street" "light gray" ttype X"^" "junkheap" "sienna" ttype X"=" "fields" "green" ttype X"%" "trees" "forest green" ttype X Xtrue junkheap dark X X[ 0 20 25 35 80 90 ] t* min-alt X[ 20 25 35 80 90 100 ] t* max-alt X X"monster" m icon-name X"breath" b icon-name X"fire" f icon-name X"man" p icon-name X"fireman" F icon-name X"soldiers" g icon-name X"city20" B icon-name X X X[ m b f p F g ] "movers" define X[ sea ] "water" define X[ beach street junkheap fields trees ] "land" define X X[ b f ] "fires" define X X1 B territory X100 m territory X X[ 1 0 0 10 3 3 10 ] u* in-country X100 street movers favored X100 junkheap B favored X X; 100 t* u* favored X X5 country-size X5 country-min-distance X;10 country-max-distance X X; 100 B revolt X X3000 t* fires attrition X5000 street fires attrition X2000 junkheap fires attrition X X1 fires attrition-damage X"" fires attrition-message X X1 e m produce X100 t* m productivity X1 e m storage X1 e b storage X1 f b make X100 t* f productivity X5 b m make Xtrue b maker Xtrue m maker X X[ 1 1 1 1 2 2 ] movers speed X X0 land movers moves X-1 t* F moves X0 street F moves X1 e b to-move X X1 [ p F g ] B capacity X2 f b capacity X2 b m capacity X Xtrue B already-seen Xtrue all-seen X X[ 100 5 5 1 2 5 6 ] u* hp X X[ 50 50 50 50 100 80 100 ] u* m hit X[ 0 0 0 40 40 40 90 ] u* b hit X[ 0 0 0 40 0 40 90 ] u* f hit X[ 0 10 10 0 0 0 0 ] u* p hit X[ 0 90 90 0 0 0 0 ] u* F hit X[ 80 40 40 0 0 0 0 ] u* g hit X[ 10 20 20 0 0 0 0 ] u* B hit X X1 u* u* damage X4 m g damage X5 f F damage X2 b F damage X3 B m damage X6 B b damage X3 B f damage X X X"extinguishes" fires destroy-message X"massacres" p destroy-message X"wipes out" g destroy-message X"wipes out" F destroy-message X"flattens" B destroy-message X X[ 05 0 90 50 20 ] movers retreat X X0 p control X0 f control X X50 [ p F g ] B protect X X; this doesn't work X; false f free-move X X2 [ m B ] named ; special hack to display names only X Xclear-unit-names X"Godzilla" uname X"Rodan" uname X"Mothra" uname X"Megalon" uname X"Gajira" uname X"Aspidra" uname X"Reptilicus" uname X"Gamera" uname X Xbegin{notes} X XTypically, one would set up a scenario with one or more monsters on Xone side, and mobs, fire departments, and national guards on the Xother. The machine players work best if buildings are neutral. Note Xthat the monster can easily defeat national guards one after another, Xand that the most successful strategy for the "human" side is to Xattack the monster with several units at once. The monster can use Xfires as a barricade to keep the national guards from getting close Xenough to attack. Destroying buildings is fun but not very useful. X XNote that the bitmaps are defined in X11 format and won't work in X10. X XSandra Loosemore (sandra@cs.utah.edu) is the person to blame for this Xpiece of silliness (well, Stan aided and abetted). X Xend{notes} Xend END_OF_lib/monster.per if test 3410 -ne `wc -c lib/monster.scn <<'END_OF_lib/monster.scn' XXconq 1 --++++ Save Tokyo from the fire-breathing monsters! Xmonster.per XMap 40 20 0 1 0 X40. X40. X++5.,6+21.5+ X^^+4.,+3^+^+20.+^^+1^ X^^+,3.,++^^+^^5+15.+3^1+ X4+4,+^+^+^^+3^++14.5+ X=%=6+^^5+3^+%+13.+^+=1% X%==+^+^^+^^+^+==4+=%+12.+^^+1= X=3+^^+^^3+^^+=+^^+=%=+11.+^^2+ X++^+^^+^^++^+^^++^^+==%=+11.3+1^ X^+^^7+^^3+^+^+=%%=+12.+2^ X^+3^+^^+==+^^+3^++%3=+13.+1^ X6+^^+=%=3+3^+%%4+14.1+ X+3^5+%=4%7+18. X.++^3+^^+%=3%+5,19. X3.++^^+^++4=+24. X4.+^^+^+^5+24. X5.+^3+^^+27. X6.++,,3+27. X40. XGlobals 0 200 1 0 2 0 X0 1 0 200 0 X0 1000 1000 0 0 0 0 X0 1 0 200 1 X0 0 0 1000 1000 0 1000 XSides 2 1 0 XGiant XJapanese XUnits 126 1 0 Xm Godzilla 14,12 0 XB * 1,6 -1 XB * 0,8 -1 Xp * 1,7 1 XB * 2,6 -1 XB * 3,5 -1 Xp * 4,4 1 XB * 5,3 -1 XB City*Hall 6,2 -1 XB * 0,9 -1 XB * 3,6 -1 XB Courthouse 5,4 -1 XB * 6,3 -1 XF * 1,9 1 XB * 2,8 -1 XB * 6,4 -1 Xg * 8,2 1 XB * 2,9 -1 XB Capitalists*Trust 3,8 -1 XF * 5,6 1 XB * 8,3 -1 Xg * 9,2 1 Xg * 10,1 1 Xp * 0,12 1 XB * 2,10 -1 XB * 3,9 -1 XB * 4,8 -1 XB * 7,5 -1 XB * 8,4 -1 XB * 10,2 -1 Xg * 11,1 1 XB * 6,7 -1 XB * 8,5 -1 XB Sears 10,3 -1 XB * 11,2 -1 Xg * 12,1 1 Xp * 1,13 1 XB * 4,10 -1 XB * 6,8 -1 XB * 7,7 -1 XB * 0,15 -1 XB * 4,11 -1 XB Mormon*Temple 5,10 -1 XB * 7,8 -1 Xp * 9,6 1 XB * 0,16 -1 XB Hi-Rise*Apts 1,15 -1 XF * 2,14 1 XB * 4,12 -1 XB * 5,11 -1 Xp * 6,10 1 XF * 13,3 1 XB * 1,16 -1 XB * 6,12 -1 XB Last*National*Bank 7,11 -1 XB * 8,10 -1 Xp * 9,9 1 Xp * 6,13 1 XB * 7,12 -1 XB * 8,11 -1 XB * 11,9 -1 XB * 12,8 -1 Xp * 13,7 1 XB * 9,12 -1 Xp * 10,11 1 XB Smiths 11,10 -1 XB * 12,9 -1 XB * 13,8 -1 Xp * 8,14 1 XB * 9,13 -1 XB * 10,12 -1 XB * 15,7 -1 XB * 9,14 -1 XB * 10,13 -1 XB * 13,10 -1 Xp * 14,9 1 XB * 15,8 -1 XB * 16,7 -1 XB K-Mart 12,12 -1 XB * 13,11 -1 XB * 14,10 -1 XB * 16,8 -1 XB * 17,7 -1 XB * 9,16 -1 XB * 10,15 -1 XB * 11,14 -1 XB * 16,9 -1 XB * 17,8 -1 XB * 10,16 -1 XB * 11,15 -1 Xp * 18,8 1 Xp * 10,17 1 XB * 11,16 -1 XB * 13,14 -1 XB Fawlty*Towers 17,10 -1 XB Hilton*Tokyo 18,9 -1 XB * 13,15 -1 XB * 14,14 -1 XB * 17,11 -1 XB * 18,10 -1 XB * 13,16 -1 XB * 14,15 -1 XB * 16,13 -1 XB * 18,11 -1 XB * 16,14 -1 XB * 17,13 -1 XB * 17,14 -1 XB * 18,13 -1 Xp * 19,12 1 XB * 18,14 -1 XB * 36,11 -1 XB * 38,9 -1 XB * 39,8 -1 XB * 36,12 -1 XB * 37,11 -1 XB * 39,9 -1 XB * 36,13 -1 XB * 37,12 -1 XB * 39,10 -1 XB * 36,15 -1 XF * 37,14 1 XB * 36,16 -1 XB * 37,15 -1 XB * 37,16 -1 XB * 38,15 -1 XB * 39,16 -1 END_OF_lib/monster.scn if test 2218 -ne `wc -c lib/starwars.per <<'END_OF_lib/starwars.per' XXconq 0 -+---- Star Wars, sort of XPeriod 0 X X"long long ago in a galaxy far far away" period-name X X"s" "stormtrooper" "" utype X"w" "walker" "" utype X"h" "hovercraft" "" utype X"x" "x-wing fighter" "" utype X"t" "tie fighter" "" utype X"y" "y-wing fighter-bomber" "" utype X"C" "cruiser" "" utype X"D" "death star" "" utype X"d" "death beam" "" utype X"*" "town" "" utype X"@" "city" "" utype X X"trooper" s icon-name X"walker" w icon-name X"hovcraft" h icon-name X"xwing" x icon-name X"tiefightr" t icon-name X"ywing" y icon-name X"impcruisr" C icon-name X"deathstar" D icon-name X"deathray" d icon-name X"town22" * icon-name X"city30" @ icon-name X X"F" "fuel" "basic motive power" rtype X X"." "sea" "sky blue" ttype X"+" "plains" "green" ttype X"%" "forest" "forest green" ttype X"~" "desert" "yellow" ttype X"^" "mountains" "sienna" ttype X"_" "ice" "white" ttype X":" "vacuum" "black" ttype X Xtrue vacuum dark X Xt* t* nuked ; most terrain won't actually change Xdesert [ plains forest ] nuked Xmountains ice nuked X X[ 0 70 70 70 95 99 0 ] t* min-alt X[ 70 95 95 95 99 100 0 ] t* max-alt X[ 0 20 80 0 0 0 0 ] t* min-wet X[ 100 80 100 20 100 100 0 ] t* max-wet X Xvacuum edge-terrain X X[ * @ ] "cities" define X[ D * @ ] "makers" define X[ s w h x t y C D d @ ] "movers" define X[ sea ] "water" define X[ plains forest desert mountains ] "land" define X X1 cities named X[ 10 5 25 ] makers territory X X1 @ in-country X3 * in-country X100 * density X@ first-unit Xs first-product X20 land * favored X40 plains * favored X100 plains @ favored X8 country-min-distance X48 country-max-distance X X; no disasters yet X X[ 4 6 6 5 5 8 15 40 0 0 0 ] u* @ make X[ 4 6 6 5 5 8 15 40 0 0 0 ] u* * make X3 d D make X1 makers maker X20 u* startup X; no special resources to make X1 u* makers repair X10 [ C D ] [ C D ] repair X X20 fuel cities produce X[ 30 30 30 20 22 35 200 1000 2 100 100 ] fuel u* storage X100 t* cities productivity X X[ 3 4 6 9 8 7 6 5 2 1 ] movers speed X X0 land s moves X0 land w moves X0 ice w moves X0 t* D moves X0 t* [ h C ] moves X0 t* [ x t y ] moves X0 t* d moves X0 t* @ moves X-1 vacuum @ moves X X1 fuel movers to-move X0 fuel s to-move X X10 u* * capacity X20 u* @ capacity X[ 2 1 6 4 4 2 ] [ s w h x t y ] C capacity X[ 5 3 8 8 4 4 1 3 ] [ s w h x t y C d ] D capacity X X1 cities always-seen X X[ 1 2 1 1 1 2 10 40 1 20 40 ] u* hp X X[ 65 40 30 20 20 30 10 5 0 3 5 ] u* s hit X[ 75 59 39 20 20 30 20 10 0 3 5 ] u* w hit X[ 50 60 80 20 20 30 0 0 0 3 5 ] u* h hit X[ 40 35 80 80 80 80 20 5 0 40 40 ] u* x hit X[ 40 25 80 80 80 80 20 5 0 40 40 ] u* t hit X[ 20 35 50 50 50 50 50 25 0 75 75 ] u* y hit X[ 20 25 80 80 80 80 80 50 0 90 90 ] u* C hit X[ 20 25 80 80 80 80 80 50 0 90 90 ] u* D hit X100 u* d hit X[ 30 20 60 80 90 50 50 50 0 0 0 ] u* * hit X[ 50 40 60 80 90 50 50 50 0 0 0 ] u* @ hit X X1 u* u* damage X2 w [ C D ] damage X3 [ C D ] [ C D ] damage X4 [ C D ] cities damage X5 C [ x t y ] damage X10 D D damage X20 D [ x t y ] damage X49 u* d damage X X50 nuke-hit ; death rays are not nukes? X X-50 neutrality X X1 d self-destruct X X[ 50 30 ] cities s capture X[ 40 15 ] cities w capture X10% cities w protect X50% cities s protect Xtrue cities s bridge X X1 fuel u* hits-with X1 fuel u* hit-by X X1 [ * @ ] always-seen X X1 movers can-disband X X1 cities neutral X Xtrue movers changes-side Xtrue cities changes-side X X"defeats" [ s w ] destroy-message X"shoots down" [ x t y ] destroy-message X"flattens" cities destroy-message X Xbegin{notes} XOriginally designed as a test, and so we could fly Death Stars around. XAdditional plausibility supplied by Alan Wexelblat . Xend{notes} X Xend X X END_OF_lib/starwars.per if test 3673 -ne `wc -c xconq.patch1 <<'END_OF_xconq.patch1' Xdiff xconq5.0/Makefile xconq/Makefile X5c5 X< # RCS $Header: Makefile,v 1.1 88/06/21 13:49:15 shebs Exp $ X--- X> # RCS $Header: Makefile,v 1.2 88/07/18 22:06:05 shebs Exp $ X67c67 X< cc -o xconq $(CFLAGS) $(OBJ) X10.o $(X10LIB) X--- X> $(CC) -o xconq $(CFLAGS) $(OBJ) X10.o $(X10LIB) X72c72 X< cc -o x11conq $(CFLAGS) $(OBJ) X11.o $(X11LIB) X--- X> $(CC) -o x11conq $(CFLAGS) $(OBJ) X11.o $(X11LIB) X77c77 X< cc -o cconq $(CFLAGS) $(OBJ) curses.o $(CURSESLIB) X--- X> $(CC) -o cconq $(CFLAGS) $(OBJ) curses.o $(CURSESLIB) X82c82 X< per2c $(PERIOD).c X--- X> ./per2c $(PERIOD).c X87c87 X< cc -o per2c $(CFLAGS) per2c.o period.o X--- X> $(CC) -o per2c $(CFLAGS) per2c.o period.o X90c90 X< cc -o hexify $(CFLAGS) hexify.o X--- X> $(CC) -o hexify $(CFLAGS) hexify.o X111c111 X< X--- X> X148c148 X< (cd lib; fc xconq.bdf; fc standard.bdf) X--- X> (cd lib; fc xconq.bdf >xconq.snf; fc standard.bdf >standard.snf) Xdiff xconq5.0/ToDo xconq/ToDo X3c3 X< Try *again* to get display updating to work for captured always-seen units. X--- X> Fix occasional problem where screen is not scrolled over to cursor. X5c5,6 X< Fix loss of first input character after reconfiguring display. X--- X> Fix lack of terrain drawing when passing by hidden unit on unseen terrain X> in mono mode. X7c8 X< Fix to not fail if favorite terrain type is not present on the map. X--- X> Fix oddities due to fiddling with help windows. X9c10 X< Fix save/restore of counts so they don't get incremented twice. X--- X> Fix bogus unit name that can appear during attack of self-destructing unit. X11c12 X< Eliminate redraw of unit info during another displayed side's turn. X--- X> Fix ambiguity in occupant death messages if attacker and defender occupied. X13c14,15 X< Make machine players adjust construction to current situation better. X--- X> Change mode switching so multi-input commands not aborted when another X> player's turn is over. X14a17,18 X> Add ability to randomly name unnamed "named" units read from mapfiles. X> X19,20d22 X< Fix machine player attached to iconified window (wedges other players). X< X25,26c27 X< Fix Sun bug causing display of char 0 instead of usual box-shaped cursor. X< (Appears to be due to server rather than library?) X--- X> Add period words for ability of attack to steal (or give?) resources. X27a29,34 X> Add period word for hidden unit not to be revealed until after it has attacked. X> X> Add an index of words and word types to period manual. X> X> Add a capability for outlines of hexes in monochrome. X> X32,33d38 X< Implement view coverage of hex due to population. X< X34a40,42 X> X> Eliminate redraw of unit info during another displayed side's turn, X> and generally reduce text window traffic. Xdiff xconq5.0/X10.c xconq/X10.c X5c5 X< /* RCS $Header: X10.c,v 1.1 88/06/21 12:29:56 shebs Exp $ */ X--- X> /* RCS $Header: X10.c,v 1.3 88/07/19 11:11:35 shebs Exp $ */ X27a28,29 X> Font open_font(); /* To keep some systems happy */ X> X621a624 X> side->reqtype = GARBAGE; X623,664c626,634 X< while (TRUE) { X< XNextEvent(&evt); X< switch (evt.type) { X< case KeyPressed: X< buf = XLookupMapping(&evt, &nchar); X< if (nchar > 0) { X< side->reqtype = KEYBOARD; X< side->reqch = *buf; X< if (Debug) printf("Host %s returns key '%c'\n", X< side->host, side->reqch); X< return; X< } X< break; X< case ButtonPressed: X< XQueryMouse(side->map, &rawx, &rawy, &dummy); X< XQueryMouse(side->state, &rux, &ruy, &dummy); X< if (rux < 0) { X< side->reqtype = MAPPOS; X< deform(side, rawx, rawy, &(side->reqx), &(side->reqy)); X< if (Debug) printf("Host %s returns map %d %d\n", X< side->host, side->reqx, side->reqy); X< } else { X< side->reqtype = UNITTYPE; X< side->requtype = ruy / max(side->hh, side->fh); X< if (Debug) printf("Host %s returns unit type %d\n", X< side->host, side->requtype); X< } X< return; X< case ExposeRegion: X< /* Too much work to be clever about redrawing part of screen */ X< case ExposeWindow: X< if (evt.window == side->main) { X< flush_input(side); X< redraw(side); X< } X< if (Debug) printf("Host %s exposes itself\n", side->host); X< /* Test so machines with screens don't wedge everybody else... */ X< if (!humanside(side)) return; X< break; X< default: X< case_panic("event type", evt.type); X< break; X--- X> XNextEvent(&evt); X> switch (evt.type) { X> case KeyPressed: X> buf = XLookupMapping(&evt, &nchar); X> if (nchar > 0) { X> side->reqtype = KEYBOARD; X> side->reqch = *buf; X> if (Debug) printf("Host %s returns key '%c'\n", X> side->host, side->reqch); X665a636,663 X> break; X> case ButtonPressed: X> XQueryMouse(side->map, &rawx, &rawy, &dummy); X> XQueryMouse(side->state, &rux, &ruy, &dummy); X> if (rux < 0) { X> side->reqtype = MAPPOS; X> deform(side, rawx, rawy, &(side->reqx), &(side->reqy)); X> if (Debug) printf("Host %s returns map %d %d\n", X> side->host, side->reqx, side->reqy); X> } else { X> side->reqtype = UNITTYPE; X> side->requtype = ruy / max(side->hh, side->fh); X> if (Debug) printf("Host %s returns unit type %d\n", X> side->host, side->requtype); X> } X> break; X> case ExposeRegion: X> /* Too much work to be clever about redrawing part of screen */ X> case ExposeWindow: X> if (evt.window == side->main) { X> flush_input(side); X> redraw(side); X> } X> if (Debug) printf("Host %s exposes itself\n", side->host); X> break; X> default: X> case_panic("event type", evt.type); X> break; X777c775 X< flash_position(side, sx, sy) X--- X> flash_position(side, sx, sy, tm) X779c777 X< int sx, sy; X--- X> int sx, sy, tm; X781c779 X< int i, sx1, sy1, sx2, sy2; X--- X> int sx1, sy1, sx2, sy2; X783,794c781,794 X< sx1 = sx - 50 + side->hw/2; sy1 = sy + 50 + side->hch/2; X< sx2 = sx + 50 + side->hw/2; sy2 = sy - 50 + side->hch/2; X< XLine(side->map, sx1, sy1, sx2, sy2, X< 1, 1, side->owncolor, GXinvert, AllPlanes); X< XLine(side->map, sx1, sy2, sx2, sy1, X< 1, 1, side->owncolor, GXinvert, AllPlanes); X< flush_output(side); X< for (i = 0; i < DELAY; ++i); X< XLine(side->map, sx1, sy1, sx2, sy2, X< 1, 1, side->owncolor, GXinvert, AllPlanes); X< XLine(side->map, sx1, sy2, sx2, sy1, X< 1, 1, side->owncolor, GXinvert, AllPlanes); X--- X> if (tm > 0) { X> sx1 = sx - 50 + side->hw/2; sy1 = sy + 50 + side->hch/2; X> sx2 = sx + 50 + side->hw/2; sy2 = sy - 50 + side->hch/2; X> XLine(side->map, sx1, sy1, sx2, sy2, X> 1, 1, side->owncolor, GXinvert, AllPlanes); X> XLine(side->map, sx1, sy2, sx2, sy1, X> 1, 1, side->owncolor, GXinvert, AllPlanes); X> flush_output(side); X> nap(tm); X> XLine(side->map, sx1, sy1, sx2, sy2, X> 1, 1, side->owncolor, GXinvert, AllPlanes); X> XLine(side->map, sx1, sy2, sx2, sy1, X> 1, 1, side->owncolor, GXinvert, AllPlanes); X> } X880a881 X> char *title; Xdiff xconq5.0/X11.c xconq/X11.c X7c7 X< /* RCS $Header: X11.c,v 1.1 88/06/21 12:30:00 shebs Exp $ */ X--- X> /* RCS $Header: X11.c,v 1.3 88/07/19 11:10:03 shebs Exp $ */ X146d145 X< #define DELAY 100000 X244c243,244 X< 50, 3, 100, 100, X--- X> 50, 3, X> display_width(side), display_height(side), X260c260 X< return ((19 * XDisplayWidth(sdd(), 0)) / 20); X--- X> return ((19 * XDisplayWidth(sdd(), DefaultScreen(sdd()))) / 20); X266c266 X< return ((19 * XDisplayHeight(sdd(), 0)) / 20); X--- X> return ((19 * XDisplayHeight(sdd(), DefaultScreen(sdd()))) / 20); X367c367 X< DefaultDepth(sdd(), 0) ); X--- X> DefaultDepth(sdd(), DefaultScreen(sdd()))); X369c369 X< DefaultDepth(sdd(), 0) ); X--- X> DefaultDepth(sdd(), DefaultScreen(sdd()))); X424c424 X< XQueryColors(dpy, DefaultColormap(dpy, 0), defs, 2); X--- X> XQueryColors(dpy, DefaultColormap(dpy, DefaultScreen(dpy)), defs, 2); X563c563,564 X< /* Specify the sorts of input that will be allowed. */ X--- X> /* Specify the sorts of input that will be allowed - main window needs to */ X> /* see mouse buttons so unit type selection works right. */ X569c570,571 X< XSelectInput(sdd(), side->map, ButtonPressMask|ExposureMask); X--- X> XSelectInput(sdd(), side->map, ButtonPressMask|ExposureMask); X> XSelectInput(sdd(), side->state, ButtonPressMask|ExposureMask); X657c659,663 X< display_colors(side) Side *side; { return XDisplayCells(sdd(), 0); } X--- X> display_colors(side) X> Side *side; X> { X> return XDisplayCells(sdd(), DefaultScreen(sdd())); X> } X659c665,669 X< white_color(side) Side *side; { return WhitePixel(sdd(), 0); } X--- X> white_color(side) X> Side *side; X> { X> return WhitePixel(sdd(), DefaultScreen(sdd())); X> } X661c671,675 X< black_color(side) Side *side; { return BlackPixel(sdd(), 0); } X--- X> black_color(side) X> Side *side; X> { X> return BlackPixel(sdd(), DefaultScreen(sdd())); X> } X673c687,688 X< XAllocNamedColor(sdd(), DefaultColormap(sdd(), 0), name, &avail, &c); X--- X> XAllocNamedColor(sdd(), DefaultColormap(sdd(), DefaultScreen(sdd())), name, X> &avail, &c); X743,772c758,762 X< while (TRUE) { X< XNextEvent(sdd(), &evt); X< switch (evt.type) { X< case KeyPress: X< if (evt.xkey.window != side->main && X< evt.xkey.window != side->help) X< return FALSE; X< nchar = XLookupString(&evt, buf, BUFSIZE, NULL, NULL); X< if (nchar > 0) { X< side->reqtype = KEYBOARD; X< side->reqch = *buf; X< if (Debug) printf("Host %s returns key '%c'\n", X< side->host, side->reqch); X< return; X< } X< break; X< case ButtonPress: X< if (evt.xbutton.window == side->map) { X< rawx = evt.xbutton.x; rawy = evt.xbutton.y; X< side->reqtype = MAPPOS; X< deform(side, rawx, rawy, &(side->reqx), &(side->reqy)); X< if (Debug) printf("Host %s returns map %d %d\n", X< side->host, side->reqx, side->reqy); X< } else if (evt.xbutton.window == side->state) { X< rawx = evt.xbutton.x; rawy = evt.xbutton.y; X< side->reqtype = UNITTYPE; X< side->requtype = rawy / max(side->hh, side->fh); X< if (Debug) printf("Host %s returns unit type %d\n", X< side->host, side->requtype); X< } X--- X> side->reqtype = GARBAGE; X> XNextEvent(sdd(), &evt); X> switch (evt.type) { X> case KeyPress: X> if (evt.xkey.window != side->main && evt.xkey.window != side->help) X774,785c764,769 X< case Expose: X< if (evt.xexpose.window == side->main || X< evt.xexpose.window == side->map) { X< flush_input(side); X< redraw(side); X< } X< if (Debug) printf("Host %s exposes itself\n", side->host); X< return FALSE; X< break; X< default: X< case_panic("event type", evt.type); X< break; X--- X> nchar = XLookupString(&evt, buf, BUFSIZE, NULL, NULL); X> if (nchar > 0) { X> side->reqtype = KEYBOARD; X> side->reqch = *buf; X> if (Debug) printf("Host %s returns key '%c'\n", X> side->host, side->reqch); X786a771,797 X> break; X> case ButtonPress: X> if (evt.xbutton.window == side->map) { X> rawx = evt.xbutton.x; rawy = evt.xbutton.y; X> side->reqtype = MAPPOS; X> deform(side, rawx, rawy, &(side->reqx), &(side->reqy)); X> if (Debug) printf("Host %s returns map %d %d\n", X> side->host, side->reqx, side->reqy); X> } else if (evt.xbutton.window == side->state) { X> rawx = evt.xbutton.x; rawy = evt.xbutton.y; X> side->reqtype = UNITTYPE; X> side->requtype = rawy / max(side->hh, side->fh); X> if (Debug) printf("Host %s returns unit type %d\n", X> side->host, side->requtype); X> } X> break; X> case Expose: X> if (evt.xexpose.window == side->main || X> evt.xexpose.window == side->map) { X> flush_input(side); X> redraw(side); X> } X> if (Debug) printf("Host %s exposes itself\n", side->host); X> break; X> default: X> case_panic("event type", evt.type); X> break; X864a876,878 X> #ifdef STUPIDFLUSH X> XFlush(sdd()); X> #endif STUPIDFLUSH X903a918,920 X> #ifdef STUPIDFLUSH X> XFlush(sdd()); X> #endif STUPIDFLUSH X909c926 X< flash_position(side, sx, sy) X--- X> flash_position(side, sx, sy, tm) X911c928 X< int sx, sy; X--- X> int sx, sy, tm; X913c930 X< int i, sx1, sy1, sx2, sy2; X--- X> int sx1, sy1, sx2, sy2; X915,922c932,941 X< sx1 = sx - 50 + side->hw/2; sy1 = sy + 50 + side->hch/2; X< sx2 = sx + 50 + side->hw/2; sy2 = sy - 50 + side->hch/2; X< XDrawLine(sdd(), side->map, sd()->flashgc, sx1, sy1, sx2, sy2); X< XDrawLine(sdd(), side->map, sd()->flashgc, sx1, sy2, sx2, sy1); X< flush_output(side); X< for (i = 0; i < DELAY; ++i); X< XDrawLine(sdd(), side->map, sd()->flashgc, sx1, sy1, sx2, sy2); X< XDrawLine(sdd(), side->map, sd()->flashgc, sx1, sy2, sx2, sy1); X--- X> if (tm > 0) { X> sx1 = sx - 50 + side->hw/2; sy1 = sy + 50 + side->hch/2; X> sx2 = sx + 50 + side->hw/2; sy2 = sy - 50 + side->hch/2; X> XDrawLine(sdd(), side->map, sd()->flashgc, sx1, sy1, sx2, sy2); X> XDrawLine(sdd(), side->map, sd()->flashgc, sx1, sy2, sx2, sy1); X> flush_output(side); X> nap(tm); X> XDrawLine(sdd(), side->map, sd()->flashgc, sx1, sy1, sx2, sy2); X> XDrawLine(sdd(), side->map, sd()->flashgc, sx1, sy2, sx2, sy1); X> } X1092a1112,1114 X> #ifdef STUPIDFLUSH X> XFlush(sdd()); X> #endif STUPIDFLUSH X1110c1132 X< XBell(sdd(), 0); X--- X> XBell(sdd(), DefaultScreen(sdd())); Xdiff xconq5.0/attack.c xconq/attack.c X5c5 X< /* RCS $Header: attack.c,v 1.2 88/06/28 10:38:26 shebs Exp $ */ X--- X> /* RCS $Header: attack.c,v 1.3 88/07/17 16:18:22 shebs Exp $ */ X382a383 X> draw_hex(ps, px, py, TRUE); XOnly in xconq: config.h Xdiff xconq5.0/curses.c xconq/curses.c X5c5 X< /* RCS $Header: curses.c,v 1.1 88/06/21 12:30:04 shebs Exp $ */ X--- X> /* RCS $Header: curses.c,v 1.2 88/07/17 15:26:31 shebs Exp $ */ X75c75 X< #ifdef HPUX X--- X> #ifdef USECBREAK X77,78c77,78 X< #endif HPUX X< #ifdef BSD X--- X> #endif USECBREAK X> #ifdef USECRMODE X80c80 X< #endif BSD X--- X> #endif USECRMODE X281c281 X< flash_position(side, x, y) Side *side; int x, y; {} X--- X> flash_position(side, x, y, tm) Side *side; int x, y, tm; {} Xdiff xconq5.0/custom.ms xconq/custom.ms X28a29,35 X> Since they are mostly read by variations on C's \fIscanf\fP function, X> the format is rather rigid; numbers may not be omitted, no blank lines X> are allowed (but whitespace between numbers on a line is OK), X> and mistakes will not always be recognized. X> The one general exception is the period description, which is read by X> a lexical analyzer, which allows free-format input. Other more specific X> exceptions will be noted below. X202c209,210 X< To lose, must be at or below that number for any one of the types X--- X> To lose, must be at or below that many for \fIall\fP unit types X> simultaneously X203a212,214 X> To make this condition apply to only one unit type, set all the other X> numbers to very low (for win condition) or very high (for lose condition) X> values, outside the range normally occurring during a game. X386,390d396 X< The \fBto-make\fP word actually specifies the amount of resource to be X< consumed each turn, rather than the total, which can be a problem for X< small resource amounts and long construction times. This will probably X< be changed to a total amount at some point in the future. X< .LP X393d398 X< Xdiff xconq5.0/do.c xconq/do.c X5c5 X< /* RCS $Header: do.c,v 1.1 88/06/21 12:30:06 shebs Exp $ */ X--- X> /* RCS $Header: do.c,v 1.2 88/07/17 17:08:59 shebs Exp $ */ X707a708,719 X> /* Flicker on the current position, in case it's not easily visible. */ X> X> do_flash(side, n) X> Side *side; X> int n; X> { X> int sx, sy; X> X> xform(side, unwrap(side, side->curx), side->cury, &sx, &sy); X> flash_position(side, sx, sy, 1000); X> } X> X754c766 X< sort_units(); X--- X> sort_units(TRUE); Xdiff xconq5.0/draw.c xconq/draw.c X5c5 X< /* RCS $Header: draw.c,v 1.1 88/06/21 12:30:08 shebs Exp $ */ X--- X> /* RCS $Header: draw.c,v 1.3 88/07/18 17:10:44 shebs Exp $ */ X469c469 X< flash_position(side, sx, sy); X--- X> flash_position(side, sx, sy, DELAY); Xdiff xconq5.0/ginit.c xconq/ginit.c X5c5 X< /* RCS $Header: ginit.c,v 1.1 88/06/21 12:30:10 shebs Exp $ */ X--- X> /* RCS $Header: ginit.c,v 1.2 88/07/15 14:56:16 shebs Exp $ */ X113c113 X< 20 * side->fw, period.numutypes*max(side->hh, side->fh)); X--- X> 22 * side->fw, period.numutypes*max(side->hh, side->fh)); X195c195 X< side->monochrome = (display_colors(side) == 2); X--- X> side->monochrome = (display_colors(side) <= 2); Xdiff xconq5.0/init.c xconq/init.c X5c5 X< /* RCS $Header: init.c,v 1.2 88/06/28 10:06:13 shebs Exp $ */ X--- X> /* RCS $Header: init.c,v 1.5 88/07/20 14:29:13 shebs Exp $ */ X31a32 X> bool inopen[MAXUTYPES]; /* true if unit type need not be occ at start */ X33d33 X< int favterr[MAXUTYPES]; /* "favorite terrain" of each unit type */ X138c138,139 X< if (utypes[unit->type].alreadyseen || X--- X> if (period.allseen || X> utypes[unit->type].alreadyseen || X152a154,155 X> /* More code to initialize views of area. */ X> X221a225 X> /* Favorite terrains are sorted by order of preference. */ X225c229 X< int u, t, i; X--- X> int i; X228,235d231 X< for_all_unit_types(u) { X< favterr[u] = 0; /* doesn't really matter which one */ X< for_all_terrain_types(t) { X< if (utypes[u].favored[t] > utypes[u].favored[favterr[u]]) X< favterr[u] = t; X< } X< } X< /* Check for existence of favorite terrain on map */ X247c243 X< int x0, y0, u, i, num, first = period.firstutype, numleft[MAXUTYPES]; X--- X> int x0, y0, u, t, i, num, first = period.firstutype, numleft[MAXUTYPES]; X250a247,253 X> /* Precompute some important info */ X> for_all_unit_types(u) { X> inopen[u] = FALSE; X> for_all_terrain_types(t) { X> if (utypes[u].favored[t] > 0) inopen[u] = TRUE; X> } X> } X308c311 X< int tries, x, y, diam = (2 * period.countrysize + 1); X--- X> int tries, x, y, diameter = (2 * period.countrysize + 1); X313c316 X< y = random(world.height - diam) + period.countrysize; X--- X> y = random(world.height - diameter) + period.countrysize; X321c324 X< max(world.width, world.height), good_place, cxp, cyp)) { X--- X> world.width/2+world.height/2, good_place, cxp, cyp)) { X326c329 X< fprintf(stderr, "Try bigger maps or fewer sides next time.\n"); X--- X> fprintf(stderr, "Try a bigger map, different map, or fewer sides.\n"); X339c342 X< int u, terr = terrain_at(x, y); X--- X> int u, t = terrain_at(x, y); X341c344,346 X< for_all_unit_types(u) if (terr == favterr[u]) numhexes[u]++; X--- X> for_all_unit_types(u) { X> if (probability(utypes[u].favored[t])) numhexes[u]++; X> } X359c364,365 X< if (first != NOTHING && terrain_at(cx, cy) != favterr[first]) X--- X> if (first != NOTHING && X> !probability(utypes[first].favored[terrain_at(cx, cy)])) X365c371 X< if (utypes[u].incountry > numhexes[u]) return FALSE; X--- X> if (inopen[u] && utypes[u].incountry > numhexes[u]) return FALSE; X392a399 X> set_cover(side, wrap(x), y, 100); X415,416d421 X< /* "favterr" is poorly and unrobustly handled here... */ X< X422c427 X< int u = unit->type, t, tries, x, y, chance, r, favterr = 0; X--- X> int u = unit->type, t, tries, x, y, chance, r; X425,430c430 X< for_all_terrain_types(t) { X< if (could_move(u, t)) X< canmove = TRUE; X< if (utypes[u].favored[t] > utypes[u].favored[favterr]) X< favterr = t; X< } X--- X> for_all_terrain_types(t) if (could_move(u, t)) canmove = TRUE; Xdiff xconq5.0/input.c xconq/input.c X5c5 X< /* RCS $Header: input.c,v 1.1 88/06/21 12:30:17 shebs Exp $ */ X--- X> /* RCS $Header: input.c,v 1.4 88/07/20 15:03:51 shebs Exp $ */ X53c53 X< do_redraw(), do_disband(), do_return(), X--- X> do_redraw(), do_flash(), do_disband(), do_return(), X81a82 X> 'v', do_flash, 1, FALSE, "highlight current position", X171,175c172,178 X< if (side->reqactive && side->reqtype != GARBAGE) { X< if (Debug) printf("Fulfilling %s request with input type %d\n", X< side->name, side->reqtype); X< side->reqactive = FALSE; X< (*(side->reqhandler))(side); X--- X> if (side->reqactive) { X> if (side->reqtype != GARBAGE) { X> if (Debug) printf("Answering %s request with inptype %d\n", X> side->name, side->reqtype); X> side->reqactive = FALSE; X> (*(side->reqhandler))(side); X> } XCommon subdirectories: xconq5.0/lib and xconq/lib Xdiff xconq5.0/map.c xconq/map.c X5c5 X< /* RCS $Header: map.c,v 1.1 88/06/21 12:30:19 shebs Exp $ */ X--- X> /* RCS $Header: map.c,v 1.4 88/07/20 14:29:55 shebs Exp $ */ X60a61,62 X> bool sidecountsread; /* Obscure, fixes numbers of restored units */ X> X141a144 X> sidecountsread = FALSE; X165a169 X> sidecountsread = FALSE; X363a368 X> sidecountsread = TRUE; X879c884 X< sort_units(); X--- X> sort_units(TRUE); X1019,1020c1024,1026 X< /* Dumb use of "limit" means hexes at edge of map may be searched repeatedly */ X< /* A good place to optimize things... */ X--- X> /* Note that points far outside the map may be generated, but the predicate */ X> /* will not be called on them. It may be applied to the same point several */ X> /* times, however. */ X1033,1034c1039,1040 X< x1 = wrap(x0 + dist * dirx[dir]); X< y1 = limit(y0 + dist * diry[dir]); X--- X> x1 = x0 + dist * dirx[dir]; X> y1 = y0 + dist * diry[dir]; X1037,1041c1043,1049 X< x = wrap(x1 + i * dirx[dir2]); X< y = limit(y1 + i * diry[dir2]); X< if ((*pred)(x, y)) { X< *rxp = x; *ryp = y; X< return TRUE; X--- X> x = x1 + i * dirx[dir2]; X> y = y1 + i * diry[dir2]; X> if (between(0, y, world.height-1)) { X> if ((*pred)(wrap(x), y)) { X> *rxp = wrap(x); *ryp = y; X> return TRUE; X> } X1057c1065 X< int x, y, y1 = y0 - dist, y2 = y0 + dist, x1, x2; X--- X> int x, y, x1, y1, x2, y2; X1058a1067,1069 X> dist = min(dist, max(world.width, world.height)); X> y1 = y0 - dist; X> y2 = y0 + dist; Xdiff xconq5.0/move.c xconq/move.c X5c5 X< /* RCS $Header: move.c,v 1.1 88/06/21 12:30:23 shebs Exp $ */ X--- X> /* RCS $Header: move.c,v 1.4 88/07/20 15:06:31 shebs Exp $ */ X128,129c128 X< /* since this causes endless difficulties, despite the apparent improvement */ X< /* in realism. (or allow 0 but round up when possible?) */ X--- X> /* unless it is out of movement supplies. */ X136c135 X< int u = unit->type, moves = 0; X--- X> int u = unit->type, r, moves = 0; X149a149,154 X> for_all_resource_types(r) { X> if (utypes[u].tomove[r] > 0 && unit->supply[r] <= 0) { X> moves = 0; X> break; X> } X> } X295a301,302 X> char *unit_desig(); X> X303,305c310,312 X< if (Debug) printf("%s doing %s with %d moves left\n", X< unit_handle(NULL, unit), order_desig(&(unit->orders)), X< unit->movesleft); X--- X> if (Debug) printf("%d: %s doing %s with %d moves left\n", X> global.time, unit_desig(unit), X> order_desig(&(unit->orders)), unit->movesleft); X732a740 X> /* Only die now if will die during consumption phase. */ X744,745c752,755 X< exhaust_supply(unit); X< return; X--- X> if (utypes[u].consume[r] > 0) { X> exhaust_supply(unit); X> return; X> } XOnly in xconq: mplay.c Xdiff xconq5.0/output.c xconq/output.c X5c5 X< /* RCS $Header: output.c,v 1.1 88/06/21 12:30:32 shebs Exp $ */ X--- X> /* RCS $Header: output.c,v 1.3 88/07/20 16:05:49 shebs Exp $ */ X125c125 X< draw_fg_text(side, side->info, side->margin, 0, tmpbuf); X--- X> draw_info_text(side, 0, 0, 30, tmpbuf); X143a144 X> sprintf(spbuf, ""); X146d146 X< draw_fg_text(side, side->info, side->margin, 1*side->fh, spbuf); X147a148,149 X> draw_info_text(side, 0, 1, 30, spbuf); X> sprintf(spbuf, ""); X158d159 X< draw_fg_text(side, side->info, side->margin, 2*side->fh, spbuf); X160c161,162 X< sprintf(spbuf, "%s %s Moves %d", X--- X> draw_info_text(side, 0, 2, 30, spbuf); X> sprintf(spbuf, "%s %s Moves %d ", X163c165 X< draw_fg_text(side, side->info, side->margin, 3*side->fh, spbuf); X--- X> draw_info_text(side, 0, 3, 30, spbuf); X197c199 X< draw_fg_text(side, side->info, side->margin+30*side->fw, 0, spbuf); X--- X> draw_info_text(side, 30, 0, -1, spbuf); X201,202c203 X< draw_fg_text(side, side->info, X< side->margin+30*side->fw, 1*side->fh, spbuf); X--- X> draw_info_text(side, 30, 1, -1, spbuf); X212,213c213 X< draw_fg_text(side, side->info, X< side->margin+30*side->fw, 3*side->fh, spbuf); X--- X> draw_info_text(side, 30, 3, -1, spbuf); X214a215,233 X> } X> X> /* Display improvement can be achieved by padding out lines with blanks, */ X> /* then the lines need not be cleared before redrawing. */ X> X> draw_info_text(side, x, y, len, buf) X> Side *side; X> int x, y, len; X> char *buf; X> { X> int i; X> char full[BUFSIZE]; X> X> if (len < 0) len = BUFSIZE; X> strcpy(full, buf); X> for (i = strlen(buf); i < len; ++i) full[i] = ' '; X> full[len-1] = '\0'; X> draw_fg_text(side, side->info, X> side->margin + x * side->fw, y * side->fh, full); Xdiff xconq5.0/period.c xconq/period.c X5c5 X< /* RCS $Header: period.c,v 1.1 88/06/21 12:30:35 shebs Exp $ */ X--- X> /* RCS $Header: period.c,v 1.2 88/07/15 14:51:00 shebs Exp $ */ X893c893 X< add_word("spy", P0, 1, OFFSET(Period, spychance)); X--- X> add_word("spy-chance", P0, 1, OFFSET(Period, spychance)); Xdiff xconq5.0/period.ms xconq/period.ms X156c156 X< .IP \fIchar\ name\ color\ \fBrtype\fR 5 X--- X> .IP \fIchar\ name\ color\ \fBttype\fR 5 X282c282 X< Set the type of unit to get a random name during initialization. The X--- X> Set a type of unit to get a random name during initialization. The X285a286,287 X> The value can also be set to \fB2\fP, in which case the unit name X> will be displayed by itself, without side name or unit type name. X385a388 X> If the string is \fB""\fP, then the message will be suppressed entirely. X421c424,426 X< This amount is [should be] amortized over the total construction schedule. X--- X> This amount is amortized over the normal construction schedule, which X> means that extra resources are consumed by startup or research times X> (representing mistakes and experiments). X453a459,460 X> If the unit runs out of a resource that it must consume, X> it dies due to starvation. X512a520,521 X> If the unit is out of any movement resource, it is immobilized X> until it gets more. Xdiff xconq5.0/phases.c xconq/phases.c X5c5 X< /* RCS $Header: phases.c,v 1.1 88/06/21 12:30:38 shebs Exp $ */ X--- X> /* RCS $Header: phases.c,v 1.3 88/07/20 14:35:19 shebs Exp $ */ X21a22,26 X> bool anyrevolt = FALSE; X> bool anysurrender = FALSE; X> bool anyaccident = FALSE; X> bool anyattrition = FALSE; X> X61,65c66,76 X< for_all_units(unit) { X< if (alive(unit)) unit_revolt(unit); X< if (alive(unit)) unit_surrender(unit); X< if (alive(unit)) unit_accident(unit); X< if (alive(unit)) unit_attrition(unit); X--- X> { X> int u, t; X> X> for_all_unit_types(u) { X> if (utypes[u].revolt > 0) anyrevolt = TRUE; X> if (utypes[u].surrender > 0) anysurrender = TRUE; X> for_all_terrain_types(t) { X> if (utypes[u].accident[t] > 0) anyaccident = TRUE; X> if (utypes[u].attrition[t] > 0) anyattrition = TRUE; X> } X> } X66a78,89 X> if (anyrevolt) { X> for_all_units(unit) if (alive(unit)) unit_revolt(unit); X> } X> if (anysurrender) { X> for_all_units(unit) if (alive(unit)) unit_surrender(unit); X> } X> if (anyaccident) { X> for_all_units(unit) if (alive(unit)) unit_accident(unit); X> } X> if (anyattrition) { X> for_all_units(unit) if (alive(unit)) unit_attrition(unit); X> } X76c99 X< int u = unit->type, maxmor, chance; X--- X> int u = unit->type, ux = unit->x, uy = unit->y, maxmor, chance; X79c102 X< if (utypes[u].revolt > 0) { X--- X> if (utypes[unit->type].revolt > 0) { X86,88c109,111 X< see_exact(oldside, unit->x, unit->y); X< draw_hex(oldside, unit->x, unit->y, TRUE); X< all_see_hex(unit->x, unit->y); X--- X> see_exact(oldside, ux, uy); X> draw_hex(oldside, ux, uy, TRUE); X> all_see_hex(ux, uy); X154c177,178 X< notify(us, "%s %s!", unit_handle(us, unit), utypes[u].accidentmsg); X--- X> if (strlen(utypes[u].accidentmsg) > 0) X> notify(us, "%s %s!", unit_handle(us, unit), utypes[u].accidentmsg); X169,173c193,202 X< unit->hp -= utypes[u].attdamage; X< notify(us, "%s %s!%s", X< unit_handle(us, unit), utypes[u].attritionmsg, X< (unit->hp <= 0 ? " The blow is fatal!" : "")); X< if (unit->hp <= 0) kill_unit(unit, DISASTER); X--- X> if (unit->hp <= utypes[u].attdamage) { X> notify(us, "%s dies from attrition!", unit_handle(us, unit)); X> kill_unit(unit, DISASTER); X> } else { X> if (strlen(utypes[u].attritionmsg) > 0) { X> notify(us, "%s %s!", X> unit_handle(us, unit), utypes[u].attritionmsg); X> } X> unit->hp -= utypes[u].attdamage; X> } X221c250 X< for_all_resource_types(r) X--- X> for_all_resource_types(r) { X222a252 X> } X238c268 X< int u = unit->type, r; X--- X> int u = unit->type, r, mk, rmk, use; X241a272 X> mk = utypes[u].make[unit->product]; X243c274,278 X< if (unit->supply[r] < utypes[unit->product].tomake[r]) return; X--- X> if ((rmk = utypes[unit->product].tomake[r]) > 0) { X> use = (rmk / mk) + (unit->schedule < (rmk % mk) ? 1 : 0); X> if (unit->supply[r] < use) return; X> unit->supply[r] -= use; X> } X245,247d279 X< for_all_resource_types(r) { X< unit->supply[r] -= utypes[unit->product].tomake[r]; X< } X302c334 X< kill_unit(newunit, -1); X--- X> kill_unit(newunit, DISASTER); X314c346 X< notify(us, "Idiots! - %s can't build a %s in a %s!\n", X--- X> notify(us, "Idiots! - %s can't build a %s while in a %s!", X342d373 X< flush_dead_units(); X453,457c484 X< for_all_units(unit) { X< if (alive(unit)) { X< unit_consumes(unit); X< } X< } X--- X> for_all_units(unit) if (alive(unit)) unit_consumes(unit); Xdiff xconq5.0/side.c xconq/side.c X5c5 X< /* RCS $Header: side.c,v 1.1 88/06/21 12:30:40 shebs Exp $ */ X--- X> /* RCS $Header: side.c,v 1.2 88/07/18 22:07:28 shebs Exp $ */ X152a153,154 X> extern bool sidecountsread; X> X158c160,161 X< unit->number = (side != NULL ? (side->counts)[unit->type]++ : 0); X--- X> if (!sidecountsread) X> unit->number = (side != NULL ? (side->counts)[unit->type]++ : 0); X447a451 X> draw_hex(side, x, y, TRUE); XOnly in xconq5.0: standard.c Xdiff xconq5.0/unit.c xconq/unit.c X5c5 X< /* RCS $Header: unit.c,v 1.1 88/06/21 12:30:44 shebs Exp $ */ X--- X> /* RCS $Header: unit.c,v 1.5 88/07/20 15:23:42 shebs Exp $ */ X265c265 X< Order *neworders; X--- X> Order *newords; X272,273c272,273 X< neworders = (transport->standing->orders)[unit->type]; X< if (neworders->type != NONE) { X--- X> newords = (transport->standing->orders)[unit->type]; X> if (newords && newords->type != NONE) { X275,276c275,276 X< unit_handle(NULL, unit), order_desig(neworders)); X< copy_orders(&(unit->orders), neworders); X--- X> unit_desig(unit), order_desig(newords)); X> copy_orders(&(unit->orders), newords); X406c406,407 X< int schedule, prod = unit->product; X--- X> if (producing(unit)) unit->schedule = build_time(unit, unit->product); X> } X408,415c409,421 X< if (producing(unit)) { X< schedule = utypes[unit->type].make[prod]; X< if (unit->built == 0) X< schedule += ((schedule * utypes[prod].startup) / 100); X< if (unit->side->counts[prod] <= 1) X< schedule += ((schedule * utypes[prod].research) / 100); X< unit->schedule = schedule; X< } X--- X> /* Basic routine to compute how long a unit will take to build something. */ X> X> build_time(unit, prod) X> Unit *unit; X> int prod; X> { X> int schedule = utypes[unit->type].make[prod]; X> X> if (unit->built == 0) X> schedule += ((schedule * utypes[prod].startup) / 100); X> if (unit->side->counts[prod] <= 1) X> schedule += ((schedule * utypes[prod].research) / 100); X> return schedule; X504c510,511 X< sort_units() X--- X> sort_units(doall) X> bool doall; X510c517 X< while (flips && passes < numunits / 10) { X--- X> while (flips && (doall || passes < numunits / 10)) { X583a591 X> Order *ords; X588c596,597 X< if (unit->standing->orders[u]->type != NONE) { X--- X> ords = unit->standing->orders[u]; X> if (ords && ords->type != NONE) { X590,591c599 X< utypes[u].name, X< order_desig(unit->standing->orders[u])); X--- X> utypes[u].name, order_desig(ords)); X611a620 X> if (utypes[unit->type].named == 2 && unit->name) return unit->name; X674c683 X< for_all_units(unit) if (unit->id == n) return unit; X--- X> for_all_units(unit) if (alive(unit) && unit->id == n) return unit; Xdiff xconq5.0/util.c xconq/util.c X5c5 X< /* RCS $Header: util.c,v 1.1 88/06/21 12:30:46 shebs Exp $ */ X--- X> /* RCS $Header: util.c,v 1.2 88/07/15 16:04:31 shebs Exp $ */ X41a42,56 X> #endif UNIX X> } X> X> /* Napping is like sleeping, but maybe shorter. Arg is milliseconds. */ X> X> nap(t) X> long t; X> { X> #ifdef UNIX X> #ifdef BSD X> usleep(t*1000); X> #endif BSD X> #ifndef BSD X> if (t >= 1000) sleep(t/1000); X> #endif BSD Xdiff xconq5.0/version.h xconq/version.h X1c1 X< #define VERSION "5.0 (6/28/88)" X--- X> #define VERSION "5.1 (7/20/88)" Xdiff xconq5.0/xconq.6 xconq/xconq.6 X164a165,168 X> .PP X> Typically the left button should be used to place the window at startup; X> other buttons can cause it to end up somewhere off the screen. X> .PP Xdiff xconq5.0/xconq.c xconq/xconq.c X5c5 X< /* RCS $Header: xconq.c,v 1.2 88/06/28 10:38:57 shebs Exp $ */ X--- X> /* RCS $Header: xconq.c,v 1.4 88/07/17 17:11:08 shebs Exp $ */ X215a216 X> flush_dead_units(); X217c218 X< sort_units(); X--- X> sort_units(FALSE); X512,513c513 X< sprintf(tmpbuf, "%s(%s)", X< side->name, (side->host ? side->host : "")); X--- X> sprintf(tmpbuf, "%s", side->name); X514a515,518 X> if (side->host) { X> sprintf(tmpbuf, "(%s)", side->host); X> strcat(spbuf, tmpbuf); X> } Xdiff xconq5.0/xconq2.ms xconq/xconq2.ms X104,105c104,105 X< Commands to give units orders typically default to a repetition of 100 turns. X< In some cases, this is meaningless (as in moving to a place). X--- X> Commands to give units orders typically default to a repetition of 100 turns X> (In some cases, this is meaningless, as in moving to a place): X337a338,340 X> .IP v 6 X> View current unit; display a flash that should be bright enough to X> catch the eye and make it easier to see where the current unit is. END_OF_xconq.patch1 if test 33991 -ne `wc -c