1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
|
/*
* File: externs.h
* Summary: Fixed size 2D vector class that asserts if you do something bad.
* Written by: Linley Henzell
*
* Modified for Crawl Reference by $Author$ on $Date$
*
* Change History (most recent first):
*
* <3> 7/29/00 JDJ Renamed sh_x, sh_y, sh_greed, sh_type, sh_level so
* they start with shop.
* <2> 7/29/00 JDJ Switched to using bounds checked array classes.
* Made a few char arrays unsigned char arrays.
*/
#ifndef EXTERNS_H
#define EXTERNS_H
#include <vector>
#include <list>
#include <string>
#include <map>
#include <set>
#include <memory>
#include <cstdlib>
#include <deque>
#include <time.h>
#include "defines.h"
#include "enum.h"
#include "FixAry.h"
#include "libutil.h"
#include "mpr.h"
#include "store.h"
#ifdef USE_TILE
struct TileFlavor
{
char floor;
char wall;
char special;
};
#endif
#define INFO_SIZE 200 // size of message buffers
#define ITEMNAME_SIZE 200 // size of item names/shop names/etc
#define HIGHSCORE_SIZE 800 // <= 10 Lines for long format scores
#define MAX_NUM_GODS 21
extern char info[INFO_SIZE]; // defined in acr.cc {dlb}
extern unsigned char show_green; // defined in view.cc {dlb}
// defined in mon-util.cc -- w/o this screen redraws *really* slow {dlb}
extern FixedVector<unsigned short, 1000> mcolour;
const int kNameLen = 30;
#ifdef SHORT_FILE_NAMES
const int kFileNameLen = 6;
#else
const int kFileNameLen = 250;
#endif
// Used only to bound the init file name length
const int kPathLen = 256;
// This value is used to mark that the current berserk is free from
// penalty (Xom's granted or from a deck of cards).
#define NO_BERSERK_PENALTY -1
class item_def;
class melee_attack;
class coord_def;
class level_id;
class actor
{
public:
virtual ~actor();
virtual int id() const = 0;
virtual actor_type atype() const = 0;
virtual kill_category kill_alignment() const = 0;
virtual god_type deity() const = 0;
virtual bool alive() const = 0;
virtual coord_def pos() const = 0;
virtual bool swimming() const = 0;
virtual bool submerged() const = 0;
virtual bool floundering() const = 0;
virtual int get_experience_level() const = 0;
virtual bool can_pass_through_feat(dungeon_feature_type grid) const = 0;
virtual bool can_pass_through(int x, int y) const;
virtual bool can_pass_through(const coord_def &c) const;
virtual size_type body_size(int psize = PSIZE_TORSO,
bool base = false) const = 0;
virtual int body_weight() const = 0;
virtual int total_weight() const = 0;
virtual int damage_type(int which_attack = -1) = 0;
virtual int damage_brand(int which_attack = -1) = 0;
virtual item_def *weapon(int which_attack = -1) = 0;
virtual item_def *shield() = 0;
virtual item_def *slot_item(equipment_type eq) = 0;
virtual const item_def *slot_item(equipment_type eq) const
{
return const_cast<actor*>(this)->slot_item(eq);
}
virtual bool has_equipped(equipment_type eq, int sub_type) const;
virtual int hunger_level() const { return HS_ENGORGED; }
virtual void make_hungry(int nutrition, bool silent = true)
{
}
// Need not be implemented for the player - player action costs
// are explicitly calculated.
virtual void lose_energy(energy_use_type)
{
}
virtual std::string name(description_level_type type) const = 0;
virtual std::string pronoun(pronoun_type which_pronoun) const = 0;
virtual std::string conj_verb(const std::string &verb) const = 0;
virtual bool fumbles_attack(bool verbose = true) = 0;
// Returns true if the actor has no way to attack (plants, statues).
// (statues have only indirect attacks).
virtual bool cannot_fight() const = 0;
virtual void attacking(actor *other) = 0;
virtual bool can_go_berserk() const = 0;
virtual bool can_see_invisible() const = 0;
virtual bool invisible() const = 0;
virtual bool visible_to(const actor *looker) const = 0;
virtual bool can_see(const actor *target) const = 0;
virtual bool is_icy() const = 0;
virtual void go_berserk(bool intentional) = 0;
virtual void mutate() = 0;
virtual void hurt(const actor *attacker, int amount) = 0;
virtual void heal(int amount, bool max_too = false) = 0;
virtual void banish(const std::string &who = "") = 0;
virtual void blink() = 0;
virtual void teleport(bool right_now = false, bool abyss_shift = false) = 0;
virtual void poison(actor *attacker, int amount = 1) = 0;
virtual bool sicken(int amount) = 0;
virtual void paralyse(int strength) = 0;
virtual void slow_down(int strength) = 0;
virtual void confuse(int strength) = 0;
virtual void rot(actor *attacker, int rotlevel, int immediate_rot) = 0;
virtual void expose_to_element(beam_type element, int strength = 0) = 0;
virtual void drain_stat(int stat, int amount, actor* attacker) { }
virtual void put_to_sleep(int power = 0) { };
virtual void check_awaken(int disturbance) = 0;
virtual bool wearing_light_armour(bool = false) const { return (true); }
virtual int skill(skill_type sk, bool skill_bump = false) const
{
return (0);
}
virtual void exercise(skill_type sk, int qty) { }
virtual int stat_hp() const = 0;
virtual int stat_maxhp() const = 0;
virtual int armour_class() const = 0;
virtual int melee_evasion(const actor *attacker) const = 0;
virtual int shield_bonus() const = 0;
virtual int shield_block_penalty() const = 0;
virtual int shield_bypass_ability(int tohit) const = 0;
virtual void shield_block_succeeded() { }
virtual int mons_species() const = 0;
virtual mon_holy_type holiness() const = 0;
virtual int res_fire() const = 0;
virtual int res_steam() const = 0;
virtual int res_cold() const = 0;
virtual int res_elec() const = 0;
virtual int res_poison() const = 0;
virtual int res_negative_energy() const = 0;
virtual flight_type flight_mode() const = 0;
virtual bool is_levitating() const = 0;
virtual bool airborne() const;
virtual bool paralysed() const = 0;
virtual bool confused() const = 0;
virtual bool caught() const = 0;
virtual bool asleep() const { return (false); }
virtual bool backlit() const = 0;
virtual void god_conduct(conduct_type thing_done, int level) { }
virtual bool incapacitated() const
{
return paralysed() || asleep() || confused() || caught();
}
virtual int holy_aura() const
{
return (0);
}
virtual int warding() const
{
return (0);
}
virtual bool visible() const
{
return (true);
}
virtual bool has_spell(spell_type spell) const = 0;
virtual bool will_trigger_shaft() const;
virtual level_id shaft_dest() const;
virtual bool do_shaft() = 0;
};
struct coord_def
{
int x;
int y;
explicit coord_def( int x_in = 0, int y_in = 0 ) : x(x_in), y(y_in) { }
void set(int xi, int yi)
{
x = xi;
y = yi;
}
void reset()
{
set(0, 0);
}
int distance_from(const coord_def &b) const;
bool operator == (const coord_def &other) const
{
return x == other.x && y == other.y;
}
bool operator != (const coord_def &other) const
{
return !operator == (other);
}
bool operator < (const coord_def &other) const
{
return (x < other.x) || (x == other.x && y < other.y);
}
const coord_def &operator += (const coord_def &other)
{
x += other.x;
y += other.y;
return (*this);
}
const coord_def &operator += (int offset)
{
x += offset;
y += offset;
return (*this);
}
const coord_def &operator -= (const coord_def &other)
{
x -= other.x;
y -= other.y;
return (*this);
}
const coord_def &operator -= (int offset)
{
x -= offset;
y -= offset;
return (*this);
}
const coord_def &operator /= (int div)
{
x /= div;
y /= div;
return (*this);
}
const coord_def &operator *= (int mul)
{
x *= mul;
y *= mul;
return (*this);
}
coord_def operator + (const coord_def &other) const
{
coord_def copy = *this;
return (copy += other);
}
coord_def operator + (int other) const
{
coord_def copy = *this;
return (copy += other);
}
coord_def operator - (const coord_def &other) const
{
coord_def copy = *this;
return (copy -= other);
}
coord_def operator - (int other) const
{
coord_def copy = *this;
return (copy -= other);
}
coord_def operator / (int div) const
{
coord_def copy = *this;
return (copy /= div);
}
coord_def operator * (int mul) const
{
coord_def copy = *this;
return (copy *= mul);
}
int abs() const
{
return (x * x + y * y);
}
int rdist() const
{
return (std::max(std::abs(x), std::abs(y)));
}
bool origin() const
{
return (!x && !y);
}
};
typedef bool (*coord_predicate)(const coord_def &c);
struct dice_def
{
int num;
int size;
dice_def( int n = 0, int s = 0 ) : num(n), size(s) {}
};
struct run_check_dir
{
dungeon_feature_type grid;
int dx;
int dy;
};
struct delay_queue_item
{
delay_type type;
int duration;
int parm1;
int parm2;
bool started;
};
struct item_def
{
object_class_type base_type; // basic class (ie OBJ_WEAPON)
unsigned char sub_type; // type within that class (ie WPN_DAGGER)
short plus; // +to hit, charges, corpse mon id
short plus2; // +to dam, sub-sub type for boots and helms
long special; // special stuff
unsigned char colour; // item colour
unsigned long flags; // item status flags
short quantity; // number of items
short x; // x-location; for inventory items = -1
short y; // y-location; for inventory items = -1
short link; // link to next item; for inventory items = slot
short slot; // Inventory letter
unsigned short orig_place;
short orig_monnum;
std::string inscription;
CrawlHashTable props;
public:
item_def() : base_type(OBJ_UNASSIGNED), sub_type(0), plus(0), plus2(0),
special(0L), colour(0), flags(0L), quantity(0),
x(0), y(0), link(NON_ITEM), slot(0), orig_place(0),
orig_monnum(0), inscription()
{
}
std::string name(description_level_type descrip,
bool terse = false, bool ident = false,
bool with_inscription = true,
bool quantity_in_words = false,
unsigned long ignore_flags = 0x0) const;
bool has_spells() const;
bool cursed() const;
int book_number() const;
int zap() const; // what kind of beam it shoots (if wand).
// XXX should really return zap_type!
// Returns index in mitm array. Results are undefined if this item is
// not in the array!
int index() const;
int armour_rating() const;
bool launched_by(const item_def &launcher) const;
void clear()
{
*this = item_def();
}
private:
std::string name_aux( description_level_type desc,
bool terse, bool ident,
unsigned long ignore_flags ) const;
};
class runrest
{
public:
int runmode;
int mp;
int hp;
int x, y;
FixedVector<run_check_dir,3> run_check; // array of grids to check
public:
runrest();
void initialise(int rdir, int mode);
operator int () const;
const runrest &operator = (int newrunmode);
// Returns true if we're currently resting.
bool is_rest() const;
bool is_explore() const;
// Clears run state.
void clear();
// Stops running.
void stop();
// Take one off the rest counter.
void rest();
// Checks if shift-run should be aborted and aborts the run if necessary.
// Returns true if you were running and are now no longer running.
bool check_stop_running();
// Check if we've reached the HP/MP stop-rest condition
void check_hp();
void check_mp();
private:
void set_run_check(int index, int compass_dir);
bool run_grids_changed() const;
};
class PlaceInfo
{
public:
int level_type;
int branch;
unsigned long num_visits;
unsigned long levels_seen;
unsigned long mon_kill_exp;
unsigned long mon_kill_exp_avail;
unsigned long mon_kill_num[KC_NCATEGORIES];
long turns_total;
long turns_explore;
long turns_travel;
long turns_interlevel;
long turns_resting;
long turns_other;
double elapsed_total;
double elapsed_explore;
double elapsed_travel;
double elapsed_interlevel;
double elapsed_resting;
double elapsed_other;
public:
PlaceInfo();
bool is_global() const;
void make_global();
void assert_validity() const;
const std::string short_name() const;
const PlaceInfo &operator += (const PlaceInfo &other);
const PlaceInfo &operator -= (const PlaceInfo &other);
PlaceInfo operator + (const PlaceInfo &other) const;
PlaceInfo operator - (const PlaceInfo &other) const;
};
typedef std::vector<delay_queue_item> delay_queue_type;
class KillMaster;
class player : public actor
{
public:
bool turn_is_over; // flag signaling that player has performed a timed action
// If true, player is headed to the Abyss.
bool banished;
std::string banished_by;
std::vector<int> beheld_by; // monsters beholding player
bool just_autoprayed; // autopray just kicked in
unsigned short prev_targ;
coord_def prev_grd_targ;
char your_name[kNameLen];
species_type species;
job_type char_class;
// Coordinates of last travel target; note that this is never used by
// travel itself, only by the level-map to remember the last travel target.
short travel_x, travel_y;
runrest running; // Nonzero if running/traveling.
char special_wield;
double elapsed_time; // total amount of elapsed time in the game
unsigned char synch_time; // amount to wait before calling handle_time
unsigned char disease;
char max_level;
int x_pos;
int y_pos;
int prev_move_x;
int prev_move_y;
int hunger;
FixedVector<char, NUM_EQUIP> equip;
int hp;
int hp_max;
int base_hp; // temporary max HP loss (rotting)
int base_hp2; // base HPs from levels (and permanent loss)
int magic_points;
int max_magic_points;
int base_magic_points; // temporary max MP loss? (currently unused)
int base_magic_points2; // base MPs from levels and potions of magic
char strength;
char intel;
char dex;
char max_strength;
char max_intel;
char max_dex;
char hunger_state;
bool wield_change; // redraw weapon
bool quiver_change; // redraw quiver
bool received_weapon_warning;
unsigned long redraw_status_flags;
// PC's symbol (usually @) and colour.
int symbol;
int colour;
bool redraw_hit_points;
bool redraw_magic_points;
bool redraw_strength;
bool redraw_intelligence;
bool redraw_dexterity;
bool redraw_experience;
bool redraw_armour_class;
bool redraw_gold;
bool redraw_evasion;
unsigned char flash_colour;
unsigned char hit_points_regeneration;
unsigned char magic_points_regeneration;
unsigned long experience;
int experience_level;
int gold;
char class_name[30];
int time_taken;
char shield_blocks; // number of shield blocks since last action
FixedVector< item_def, ENDOFPACK > inv;
int burden;
burden_state_type burden_state;
FixedVector<spell_type, 25> spells;
char spell_no;
game_direction_type char_direction;
unsigned short pet_target;
int your_level; // offset by one (-1 == 0, 0 == 1, etc.) for display
// durational things
FixedVector<int, NUM_DURATIONS> duration;
int rotting;
int berserk_penalty; // penalty for moving while berserk
FixedVector<unsigned char, NUM_ATTRIBUTES> attribute;
FixedVector<unsigned char, NUM_QUIVER> quiver; // default items for quiver
FixedVector<long, NUM_OBJECT_CLASSES> sacrifice_value;
undead_state_type is_undead;
delay_queue_type delay_queue; // pending actions
FixedVector<unsigned char, 50> skills;
FixedVector<bool, 50> practise_skill;
FixedVector<unsigned int, 50> skill_points;
FixedVector<unsigned char, 50> skill_order;
skill_type sage_bonus_skill; // if Sage is in effect, which skill it affects
int sage_bonus_degree; // how much bonus XP to give in that skill
int skill_cost_level;
int total_skill_points;
int exp_available;
FixedArray<unsigned char, 5, 50> item_description;
FixedVector<unique_item_status_type, 50> unique_items;
FixedVector<bool, NUM_MONSTERS> unique_creatures;
// NOTE: The kills member is a pointer to a KillMaster object,
// rather than the object itself, so that we can get away with
// just a foward declare of the KillMaster class, rather than
// having to #include Kills.h and thus make every single .cc file
// dependant on Kills.h. Having a pointer means that we have
// to do our own implementations of copying the player object,
// since the default implementations will lead to the kills member
// pointing to freed memory, or worse yet lead to the same piece of
// memory being freed twice.
KillMaster* kills;
level_area_type level_type;
std::string level_type_name;
entry_cause_type entry_cause;
god_type entry_cause_god;
branch_type where_are_you;
FixedVector<unsigned char, 30> branch_stairs;
god_type religion;
unsigned char piety;
unsigned char gift_timeout;
FixedVector<unsigned char, MAX_NUM_GODS> penance;
FixedVector<unsigned char, MAX_NUM_GODS> worshipped;
FixedVector<short, MAX_NUM_GODS> num_gifts;
FixedVector<unsigned char, NUM_MUTATIONS> mutation;
FixedVector<unsigned char, NUM_MUTATIONS> demon_pow;
unsigned char magic_contamination;
FixedVector<bool, NUM_BOOKS> had_book;
unsigned char normal_vision; // how far the species gets to see
unsigned char current_vision; // current sight radius (cells)
unsigned char hell_exit; // which level plyr goes to on hell exit.
// This field is here even in non-WIZARD compiles, since the
// player might have been playing previously under wiz mode.
bool wizard; // true if player has entered wiz mode.
time_t birth_time; // start time of game
time_t start_time; // start time of session
long real_time; // real time played (in seconds)
long num_turns; // number of turns taken
long last_view_update; // what turn was the view last updated?
int old_hunger; // used for hunger delta-meter (see output.cc)
// Set when the character is going to a new level, to guard against levgen
// failures
dungeon_feature_type transit_stair;
bool entering_level;
// Warning: these two are quite different.
//
// The spell table is an index to a specific spell slot (you.spells).
// The ability table lists the ability (ABIL_*) which prefers that letter.
//
// In other words, the spell table contains hard links and the ability
// table contains soft links.
FixedVector<int, 52> spell_letter_table; // ref to spell by slot
FixedVector<ability_type, 52> ability_letter_table; // ref to abil by enum
std::set<std::string> uniq_map_tags;
std::set<std::string> uniq_map_names;
PlaceInfo global_info;
protected:
FixedVector<PlaceInfo, NUM_BRANCHES> branch_info;
FixedVector<PlaceInfo, NUM_LEVEL_AREA_TYPES - 1> non_branch_info;
public:
player();
player(const player &other);
~player();
void copy_from(const player &other);
void init();
// Low-level move the player to (x, y). Use these functions instead of
// changing x_pos and y_pos directly.
void moveto(int x, int y);
void moveto(const coord_def &c);
coord_def prev_move() const;
void reset_prev_move();
bool in_water() const;
bool can_swim() const;
bool is_levitating() const;
bool cannot_speak() const;
bool invisible() const;
bool can_see_invisible() const;
bool visible_to(const actor *looker) const;
bool can_see(const actor *target) const;
bool is_icy() const;
bool light_flight() const;
bool travelling_light() const;
kill_category kill_alignment() const;
bool has_spell(spell_type spell) const;
size_type transform_size(int psize = PSIZE_TORSO) const;
std::string shout_verb() const;
item_def *slot_item(equipment_type eq);
// actor
int id() const;
int get_experience_level() const;
actor_type atype() const { return ACT_PLAYER; }
god_type deity() const;
bool alive() const;
coord_def pos() const;
bool swimming() const;
bool submerged() const;
bool floundering() const;
bool can_pass_through_feat(dungeon_feature_type grid) const;
size_type body_size(int psize = PSIZE_TORSO, bool base = false) const;
int body_weight() const;
int total_weight() const;
int damage_type(int attk = -1);
int damage_brand(int attk = -1);
int has_claws(bool allow_tran = true) const;
bool has_usable_claws(bool allow_tran = true) const;
item_def *weapon(int which_attack = -1);
item_def *shield();
std::string name(description_level_type type) const;
std::string pronoun(pronoun_type pro) const;
std::string conj_verb(const std::string &verb) const;
bool fumbles_attack(bool verbose = true);
bool cannot_fight() const;
void attacking(actor *other);
bool can_go_berserk() const;
bool can_go_berserk(bool verbose) const;
void go_berserk(bool intentional);
void mutate();
void banish(const std::string &who = "");
void blink();
void teleport(bool right_now = false, bool abyss_shift = false);
void drain_stat(int stat, int amount, actor* attacker);
void expose_to_element(beam_type element, int strength = 0);
void god_conduct(conduct_type thing_done, int level);
int hunger_level() const { return hunger_state; }
void make_hungry(int nutrition, bool silent = true);
void poison(actor *agent, int amount = 1);
bool sicken(int amount);
void paralyse(int str);
void slow_down(int str);
void confuse(int strength);
void rot(actor *agent, int rotlevel, int immed_rot);
void heal(int amount, bool max_too = false);
void hurt(const actor *agent, int amount);
int holy_aura() const;
int warding() const;
int mons_species() const;
mon_holy_type holiness() const;
int res_fire() const;
int res_steam() const;
int res_cold() const;
int res_elec() const;
int res_poison() const;
int res_negative_energy() const;
bool confusable() const;
bool slowable() const;
bool omnivorous() const;
flight_type flight_mode() const;
bool permanent_levitation() const;
bool permanent_flight() const;
bool paralysed() const;
bool confused() const;
bool caught() const;
bool backlit() const;
bool asleep() const;
void put_to_sleep(int power = 0);
void awake();
void check_awaken(int disturbance);
bool cannot_act() const;
bool can_throw_rocks() const;
int armour_class() const;
int melee_evasion(const actor *attacker) const;
int stat_hp() const { return hp; }
int stat_maxhp() const { return hp_max; }
int shield_bonus() const;
int shield_block_penalty() const;
int shield_bypass_ability(int tohit) const;
void shield_block_succeeded();
bool wearing_light_armour(bool with_skill = false) const;
void exercise(skill_type skill, int qty);
int skill(skill_type skill, bool skill_bump = false) const;
PlaceInfo& get_place_info() const ; // Current place info
PlaceInfo& get_place_info(branch_type branch,
level_area_type level_type2) const;
PlaceInfo& get_place_info(branch_type branch) const;
PlaceInfo& get_place_info(level_area_type level_type2) const;
void set_place_info(PlaceInfo info);
// Returns copies of the PlaceInfo; modifying the vector won't
// modify the player object.
std::vector<PlaceInfo> get_all_place_info(bool visited_only = false,
bool dungeon_only = false) const;
bool do_shaft();
};
extern player you;
struct player_save_info
{
std::string name;
unsigned long experience;
int experience_level;
bool wizard;
species_type species;
std::string class_name;
player_save_info operator=(const player& rhs);
bool operator<(const player_save_info& rhs) const;
std::string short_desc() const;
};
class monster_spells : public FixedVector<spell_type, NUM_MONSTER_SPELL_SLOTS>
{
public:
monster_spells()
: FixedVector<spell_type, NUM_MONSTER_SPELL_SLOTS>(SPELL_NO_SPELL)
{ }
void clear() { init(SPELL_NO_SPELL); }
};
class ghost_demon;
class mon_enchant
{
public:
enchant_type ench;
int degree;
int duration, maxduration;
kill_category who; // Who set this enchantment?
public:
mon_enchant(enchant_type e = ENCH_NONE, int deg = 0,
kill_category whose = KC_OTHER,
int dur = 0);
killer_type killer() const;
int kill_agent() const;
operator std::string () const;
const char *kill_category_desc(kill_category) const;
void merge_killer(kill_category who);
void cap_degree();
void set_duration(const monsters *mons, const mon_enchant *exist);
bool operator < (const mon_enchant &other) const
{
return (ench < other.ench);
}
bool operator == (const mon_enchant &other) const
{
// NOTE: This does *not* check who/degree.
return (ench == other.ench);
}
mon_enchant &operator += (const mon_enchant &other);
mon_enchant operator + (const mon_enchant &other) const;
private:
int modded_speed(const monsters *mons, int hdplus) const;
int calc_duration(const monsters *mons, const mon_enchant *added) const;
};
typedef std::map<enchant_type, mon_enchant> mon_enchant_list;
struct monsterentry;
class monsters : public actor
{
public:
monsters();
monsters(const monsters &other);
~monsters();
monsters &operator = (const monsters &other);
public:
int type;
int hit_points;
int max_hit_points;
int hit_dice;
int ac;
int ev;
int speed;
int speed_increment;
unsigned char x;
unsigned char y;
unsigned char target_x;
unsigned char target_y;
FixedVector<short, NUM_MONSTER_SLOTS> inv;
monster_spells spells;
mon_attitude_type attitude;
beh_type behaviour;
unsigned int foe;
char ench_countdown;
mon_enchant_list enchantments;
unsigned long flags; // bitfield of boolean flags
unsigned long experience;
unsigned int number; // #heads (hydra), etc.
int colour;
int foe_memory; // how long to 'remember' foe x,y
// once they go out of sight.
int shield_blocks; // Count of shield blocks this round.
god_type god; // Usually GOD_NO_GOD.
std::auto_ptr<ghost_demon> ghost; // Ghost information.
std::string seen_context; // Non-standard context for
// AI_SEE_MONSTER
public:
void init_experience();
void mark_summoned(int longevity, bool mark_items_summoned );
bool has_action_energy() const;
void check_redraw(const coord_def &oldpos) const;
void apply_location_effects();
kill_category kill_alignment() const;
int foe_distance() const;
bool needs_berserk(bool check_spells = true) const;
bool has_ench(enchant_type ench) const;
bool has_ench(enchant_type ench, enchant_type ench2) const;
mon_enchant get_ench(enchant_type ench,
enchant_type ench2 = ENCH_NONE) const;
bool add_ench(const mon_enchant &);
void update_ench(const mon_enchant &);
bool del_ench(enchant_type ench, bool quiet = false);
bool lose_ench_duration(const mon_enchant &e, int levels);
bool lose_ench_levels(const mon_enchant &e, int lev);
void lose_energy(energy_use_type et);
void scale_hp(int num, int den);
void gain_exp(int xp);
void add_enchantment_effect(const mon_enchant &me, bool quiet = false);
void remove_enchantment_effect(const mon_enchant &me, bool quiet = false);
void apply_enchantments();
void apply_enchantment(const mon_enchant &me);
void timeout_enchantments(int levels);
bool needs_transit() const;
void set_transit(const level_id &destination);
bool find_place_to_live(bool near_player = false);
bool find_place_near_player();
bool find_home_around(const coord_def &c, int radius);
bool find_home_anywhere();
void set_ghost(const ghost_demon &ghost);
void ghost_init();
void pandemon_init();
void destroy_inventory();
void reset();
void load_spells(mon_spellbook_type spellbook);
actor *get_foe() const;
// actor interface
int id() const;
int get_experience_level() const;
god_type deity() const;
bool alive() const;
coord_def pos() const;
coord_def target_pos() const;
bool swimming() const;
bool submerged() const;
bool can_drown() const;
bool floundering() const;
bool can_pass_through_feat(dungeon_feature_type grid) const;
size_type body_size(int psize = PSIZE_TORSO, bool base = false) const;
int body_weight() const;
int total_weight() const;
int damage_type(int attk = -1);
int damage_brand(int attk = -1);
item_def *slot_item(equipment_type eq);
item_def *mslot_item(mon_inv_type sl) const;
item_def *weapon(int which_attack = -1);
item_def *launcher();
item_def *missiles();
item_def *shield();
int missile_count();
void wield_melee_weapon(int near = -1);
void swap_weapons(int near = -1);
bool pickup_item(item_def &item, int near = -1, bool force = false);
void pickup_message(const item_def &item, int near);
bool pickup_wand(item_def &item, int near);
bool pickup_scroll(item_def &item, int near);
bool pickup_potion(item_def &item, int near);
bool pickup_gold(item_def &item, int near);
bool pickup_launcher(item_def &launcher, int near);
bool pickup_melee_weapon(item_def &item, int near);
bool pickup_throwable_weapon(item_def &item, int near);
bool pickup_weapon(item_def &item, int near, bool force);
bool pickup_armour(item_def &item, int near, bool force);
bool pickup_misc(item_def &item, int near);
bool pickup_missile(item_def &item, int near, bool force);
bool eat_corpse(item_def &carrion, int near);
void equip(item_def &item, int slot, int near = -1);
bool unequip(item_def &item, int slot, int near = -1,
bool force = false);
bool can_use_missile(const item_def &item) const;
std::string name(description_level_type type) const;
std::string name(description_level_type type, bool force_visible) const;
std::string pronoun(pronoun_type pro) const;
std::string conj_verb(const std::string &verb) const;
bool fumbles_attack(bool verbose = true);
bool cannot_fight() const;
int skill(skill_type skill, bool skill_bump = false) const;
void attacking(actor *other);
bool can_go_berserk() const;
void go_berserk(bool intentional);
void mutate();
void banish(const std::string &who = "");
void expose_to_element(beam_type element, int strength = 0);
bool visible() const;
int mons_species() const;
mon_holy_type holiness() const;
int res_fire() const;
int res_steam() const;
int res_cold() const;
int res_elec() const;
int res_poison() const;
int res_negative_energy() const;
flight_type flight_mode() const;
bool is_levitating() const;
bool invisible() const;
bool can_see_invisible() const;
bool visible_to(const actor *looker) const ;
bool can_see(const actor *target) const;
bool is_icy() const;
bool paralysed() const;
bool confused() const;
bool caught() const;
bool asleep() const;
bool backlit() const;
int holy_aura() const;
bool has_spell(spell_type spell) const;
int armour_class() const;
int melee_evasion(const actor *attacker) const;
void poison(actor *agent, int amount = 1);
bool sicken(int strength);
void paralyse(int str);
void slow_down(int str);
void confuse(int strength);
void rot(actor *agent, int rotlevel, int immed_rot);
void hurt(const actor *agent, int amount);
void heal(int amount, bool max_too = false);
void blink();
void teleport(bool right_now = false, bool abyss_shift = false);
void put_to_sleep(int power = 0);
void check_awaken(int disturbance);
int stat_hp() const { return hit_points; }
int stat_maxhp() const { return max_hit_points; }
int shield_bonus() const;
int shield_block_penalty() const;
void shield_block_succeeded();
int shield_bypass_ability(int tohit) const;
actor_type atype() const { return ACT_MONSTER; }
// Hack, with a capital H.
void fix_speed();
void check_speed();
std::string describe_enchantments() const;
int action_energy(energy_use_type et) const;
static int base_speed(int mcls);
bool do_shaft();
private:
void init_with(const monsters &mons);
void swap_slots(mon_inv_type a, mon_inv_type b);
bool need_message(int &near) const;
bool level_up();
bool level_up_change();
bool pickup(item_def &item, int slot, int near, bool force_merge = false);
void equip_weapon(item_def &item, int near);
void equip_armour(item_def &item, int near);
void unequip_weapon(item_def &item, int near);
void unequip_armour(item_def &item, int near);
bool decay_enchantment(const mon_enchant &me, bool decay_degree = true);
bool drop_item(int eslot, int near);
bool wants_weapon(const item_def &item) const;
bool wants_armour(const item_def &item) const;
bool can_throw_rocks() const;
void lose_pickup_energy();
bool check_set_valid_home(const coord_def &place,
coord_def &chosen,
int &nvalid) const;
bool has_spell_of_type(unsigned) const;
const monsterentry *find_monsterentry() const;
};
struct cloud_struct
{
int x;
int y;
cloud_type type;
int decay;
unsigned char spread_rate;
kill_category whose;
killer_type beam_thrower() const;
};
struct shop_struct
{
unsigned char x;
unsigned char y;
unsigned char greed;
shop_type type;
unsigned char level;
FixedVector<unsigned char, 3> keeper_name;
};
struct trap_struct
{
unsigned char x;
unsigned char y;
trap_type type;
};
struct map_cell
{
short object; // The object: monster, item, feature, or cloud.
unsigned short flags; // Flags describing the mappedness of this square.
unsigned short colour;
unsigned short property;
map_cell() : object(0), flags(0), colour(0), property(0) { }
void clear() { flags = object = colour = property = 0; }
unsigned glyph() const;
bool known() const;
bool seen() const;
};
class map_marker;
class tagHeader;
class map_markers
{
public:
map_markers();
map_markers(const map_markers &);
map_markers &operator = (const map_markers &);
~map_markers();
void activate_all(bool verbose = true);
void add(map_marker *marker);
void remove(map_marker *marker);
void remove_markers_at(const coord_def &c, map_marker_type type = MAT_ANY);
map_marker *find(const coord_def &c, map_marker_type type = MAT_ANY);
map_marker *find(map_marker_type type);
void move(const coord_def &from, const coord_def &to);
std::vector<map_marker*> get_all(map_marker_type type = MAT_ANY);
std::vector<map_marker*> get_all(const std::string &key,
const std::string &val = "");
std::vector<map_marker*> get_markers_at(const coord_def &c);
std::string property_at(const coord_def &c, map_marker_type type,
const std::string &key);
void clear();
void write(tagHeader &th) const;
void read(tagHeader &);
private:
typedef std::multimap<coord_def, map_marker *> dgn_marker_map;
typedef std::pair<coord_def, map_marker *> dgn_pos_marker;
void init_from(const map_markers &);
private:
dgn_marker_map markers;
};
typedef FixedArray<dungeon_feature_type, GXM, GYM> feature_grid;
typedef FixedArray<unsigned, ENV_SHOW_DIAMETER, ENV_SHOW_DIAMETER>
env_show_grid;
struct crawl_environment
{
public:
unsigned char rock_colour;
unsigned char floor_colour;
FixedVector< item_def, MAX_ITEMS > item; // item list
FixedVector< monsters, MAX_MONSTERS > mons; // monster list
feature_grid grid; // terrain grid
FixedArray< unsigned short, GXM, GYM > mgrid; // monster grid
FixedArray< int, GXM, GYM > igrid; // item grid
FixedArray< unsigned short, GXM, GYM > cgrid; // cloud grid
FixedArray< unsigned short, GXM, GYM > grid_colours; // colour overrides
FixedArray< map_cell, GXM, GYM > map; // discovered terrain
// Glyphs of squares that are in LOS.
env_show_grid show;
// What would be visible, if all of the translucent wall were
// made opaque.
env_show_grid no_trans_show;
FixedArray<unsigned short, ENV_SHOW_DIAMETER, ENV_SHOW_DIAMETER>
show_col; // view window colour
#ifdef USE_TILE
// indexed by grid coords
FixedArray<unsigned int,GXM, GYM> tile_bk_fg; // tile fg
FixedArray<unsigned int,GXM, GYM> tile_bk_bg; // tile bg
FixedArray<TileFlavor, GXM, GYM> tile_flavor;
// indexed by (show-1) coords
FixedArray<unsigned int,ENV_SHOW_DIAMETER-2,ENV_SHOW_DIAMETER-2> tile_fg;
FixedArray<unsigned int,ENV_SHOW_DIAMETER-2,ENV_SHOW_DIAMETER-2> tile_bg;
#endif
FixedVector< cloud_struct, MAX_CLOUDS > cloud; // cloud list
unsigned char cloud_no;
FixedVector< shop_struct, MAX_SHOPS > shop; // shop list
FixedVector< trap_struct, MAX_TRAPS > trap; // trap list
FixedVector< int, 20 > mons_alloc;
map_markers markers;
double elapsed_time; // used during level load
// Number of turns the player has spent on this level.
int turns_on_level;
// Flags for things like preventing teleport control; see
// level_flag_type in enum.h
unsigned long level_flags;
coord_def sanctuary_pos;
int sanctuary_time;
};
extern struct crawl_environment env;
struct message_filter
{
int channel; // Use -1 to match any channel.
text_pattern pattern; // Empty pattern matches any message
message_filter( int ch, const std::string &s )
: channel(ch), pattern(s)
{
}
message_filter( const std::string &s ) : channel(-1), pattern(s) { }
bool is_filtered( int ch, const std::string &s ) const {
bool channel_match = ch == channel || channel == -1;
if (!channel_match || pattern.empty())
return channel_match;
return pattern.matches(s);
}
};
struct sound_mapping
{
text_pattern pattern;
std::string soundfile;
};
struct colour_mapping
{
std::string tag;
text_pattern pattern;
int colour;
};
struct message_colour_mapping
{
message_filter message;
int colour;
};
struct feature_def
{
dungeon_char_type dchar;
unsigned symbol; // symbol used for seen terrain
unsigned magic_symbol; // symbol used for magic-mapped terrain
unsigned short colour; // normal in LoS colour
unsigned short map_colour; // colour when out of LoS on display
unsigned short seen_colour; // map_colour when is_terrain_seen()
unsigned short em_colour; // Emphasised colour when in LoS.
unsigned short seen_em_colour; // Emphasised colour when out of LoS
unsigned flags;
bool is_notable() const { return (flags & FFT_NOTABLE); }
};
struct feature_override
{
dungeon_feature_type feat;
feature_def override;
};
class InvEntry;
typedef int (*item_sort_fn)(const InvEntry *a, const InvEntry *b);
struct item_comparator
{
item_sort_fn cmpfn;
bool negated;
item_comparator(item_sort_fn cfn, bool neg = false)
: cmpfn(cfn), negated(neg)
{
}
int compare(const InvEntry *a, const InvEntry *b) const
{
return (negated? -cmpfn(a, b) : cmpfn(a, b));
}
};
typedef std::vector<item_comparator> item_sort_comparators;
struct menu_sort_condition
{
public:
menu_type mtype;
int sort;
item_sort_comparators cmp;
public:
menu_sort_condition(menu_type mt = MT_INVLIST, int sort = 0);
menu_sort_condition(const std::string &s);
bool matches(menu_type mt) const;
private:
void set_menu_type(std::string &s);
void set_sort(std::string &s);
void set_comparators(std::string &s);
};
struct mon_display
{
monster_type type;
unsigned glyph;
unsigned colour;
mon_display(monster_type m = MONS_PROGRAM_BUG,
unsigned gly = 0,
unsigned col = 0) : type(m), glyph(gly), colour(col) { }
};
class InitLineInput;
struct game_options
{
public:
game_options();
void reset_startup_options();
void reset_options();
void read_option_line(const std::string &s, bool runscripts = false);
void read_options(InitLineInput &, bool runscripts,
bool clear_aliases = true);
public:
// View options
std::vector<feature_override> feature_overrides;
std::vector<mon_display> mon_glyph_overrides;
unsigned cset_override[NUM_CSET][NUM_DCHAR_TYPES];
std::string save_dir; // Directory where saves and bones go.
std::string macro_dir; // Directory containing macro.txt
std::string morgue_dir; // Directory where character dumps and morgue
// dumps are saved. Overrides crawl_dir.
std::string player_name;
#ifdef DGL_SIMPLE_MESSAGING
bool messaging; // Check for messages.
#endif
bool suppress_startup_errors;
bool mouse_input;
int view_max_width;
int view_max_height;
// The view lock variables force centering the viewport around the PC @
// at all times (the default). If view locking is not enabled, the viewport
// scrolls only when the PC hits the edge of it.
bool view_lock_x;
bool view_lock_y;
// For an unlocked viewport, this will center the viewport when scrolling.
bool center_on_scroll;
// If symmetric_scroll is set, for diagonal moves, if the view
// scrolls at all, it'll scroll diagonally.
bool symmetric_scroll;
// How far from the viewport edge is scrolling forced.
int scroll_margin_x;
int scroll_margin_y;
bool autopickup_on;
bool autoprayer_on;
bool show_more_prompt;
bool show_turns; // Show turns used in HUD.
bool show_beam; // Show targeting beam by default.
long autopickups; // items to autopickup
bool show_inventory_weights; // show weights in inventory listings
bool colour_map; // add colour to the map
bool clean_map; // remove unseen clouds/monsters
bool show_uncursed; // label known uncursed items as "uncursed"
bool easy_open; // open doors with movement
bool easy_unequip; // allow auto-removing of armour / jewellery
bool easy_butcher; // autoswap to butchering tool
bool always_confirm_butcher; // even if only one corpse
bool list_rotten; // list slots for rotting corpses/chunks
bool default_target; // start targeting on a real target
bool autopickup_no_burden; // don't autopickup if it changes burden
bool note_all_skill_levels; // take note for all skill levels (1-27)
bool note_skill_max; // take note when skills reach new max
bool note_all_spells; // take note when learning any spell
std::string user_note_prefix;// Prefix for user notes
int note_hp_percent; // percentage hp for notetaking
int ood_interesting; // how many levels OOD is noteworthy?
int easy_confirm; // make yesno() confirming easier
int easy_quit_item_prompts; // make item prompts quitable on space
int colour[16]; // macro fg colours to other colours
int background; // select default background colour
int channels[NUM_MESSAGE_CHANNELS]; // msg channel colouring
int weapon; // auto-choose weapon for character
int book; // auto-choose book for character
int chaos_knight; // choice of god for Chaos Knights (Xom/Makleb)
int death_knight; // choice of god/necromancy for Death Knights
god_type priest; // choice of god for priests (Zin/Yred)
bool random_pick; // randomly generate character
int hp_warning; // percentage hp for danger warning
int magic_point_warning; // percentage mp for danger warning
char race; // preselected race
char cls; // preselected class
bool delay_message_clear; // avoid clearing messages each turn
unsigned friend_brand; // Attribute for branding friendly monsters
bool no_dark_brand; // Attribute for branding friendly monsters
bool macro_meta_entry;// Allow user to use numeric sequences when
// creating macros
int fire_items_start;// index of first item for fire command
std::vector<unsigned> fire_order; // missile search order for 'f' command
bool auto_list; // automatically jump to appropriate item lists
bool flush_input[NUM_FLUSH_REASONS]; // when to flush input buff
char_set_type char_set;
FixedVector<unsigned, NUM_DCHAR_TYPES> char_table;
int num_colours; // used for setting up curses colour table (8 or 16)
#ifdef WIZARD
int wiz_mode; // yes, no, never in wiz mode to start
#endif
// internal use only:
int sc_entries; // # of score entries
int sc_format; // Format for score entries
std::vector<std::pair<int, int> > hp_colour;
std::vector<std::pair<int, int> > mp_colour;
std::string map_file_name; // name of mapping file to use
std::vector<text_pattern> never_pickup; // Objects we'll never pick up
std::vector<text_pattern> always_pickup; // Stuff we always pick up
std::vector<text_pattern> note_monsters; // Interesting monsters
std::vector<text_pattern> note_messages; // Interesting messages
std::vector<std::pair<text_pattern, std::string> > autoinscriptions;
std::vector<text_pattern> note_items; // Objects to note
std::vector<int> note_skill_levels; // Skill levels to note
bool pickup_thrown; // Pickup thrown missiles
bool pickup_dropped; // Pickup dropped objects
int travel_delay; // How long to pause between travel moves
// Messages that stop travel
std::vector<message_filter> travel_stop_message;
int stash_tracking; // How stashes are tracked
int tc_reachable; // Colour for squares that are reachable
int tc_excluded; // Colour for excluded squares.
int tc_exclude_circle; // Colour for squares in the exclusion radius
int tc_dangerous; // Colour for trapped squares, deep water, lava.
int tc_disconnected;// Areas that are completely disconnected.
int travel_stair_cost;
bool show_waypoints;
bool classic_item_colours; // Use old-style item colours
bool item_colour; // Colour items on level map
unsigned detected_monster_colour; // Colour of detected monsters
unsigned detected_item_colour; // Colour of detected items
unsigned heap_brand; // Highlight heaps of items
unsigned stab_brand; // Highlight monsters that are stabbable
unsigned may_stab_brand; // Highlight potential stab candidates
unsigned feature_item_brand; // Highlight features covered by items.
unsigned trap_item_brand; // Highlight traps covered by items.
// What is the minimum number of items in a stack for which
// you show summary (one-line) information
int item_stack_summary_minimum;
int explore_stop; // Stop exploring if a previously unseen
// item comes into view
int explore_stop_prompt;
bool explore_greedy; // Explore goes after items as well.
// How much more eager greedy-explore is for items than to explore.
int explore_item_greed;
// Some experimental improvments to explore
bool explore_improved;
std::vector<sound_mapping> sound_mappings;
std::vector<colour_mapping> menu_colour_mappings;
std::vector<message_colour_mapping> message_colour_mappings;
bool menu_colour_prefix_class; // Prefix item class to string
bool menu_colour_prefix_id; // Prefix id-status to string
std::vector<menu_sort_condition> sort_menus;
int dump_kill_places; // How to dump place information for kills.
int dump_message_count; // How many old messages to dump
int dump_item_origins; // Show where items came from?
int dump_item_origin_price;
// Order of sections in the character dump.
std::vector<std::string> dump_order;
bool level_map_title; // Show title in level map
bool target_zero_exp; // If true, targeting targets zero-exp
// monsters.
bool target_wrap; // Wrap around from last to first target
bool target_oos; // 'x' look around can target out-of-LOS
bool target_los_first; // 'x' look around first goes to visible
// objects/features, then goes to stuff
// outside LOS.
bool target_unshifted_dirs; // Unshifted keys target if cursor is
// on player.
int drop_mode; // Controls whether single or multidrop
// is the default.
int pickup_mode; // -1 for single, 0 for menu,
// X for 'if at least X items present'
bool easy_exit_menu; // Menus are easier to get out of
int assign_item_slot; // How free slots are assigned
std::vector<text_pattern> drop_filter;
FixedArray<bool, NUM_DELAYS, NUM_AINTERRUPTS> activity_interrupts;
// Previous startup options
bool remember_name; // Remember and reprompt with last name
bool dos_use_background_intensity;
bool use_fake_cursor; // Draw a fake cursor instead of relying
// on the term's own cursor.
int level_map_cursor_step; // The cursor increment in the level
// map.
// If the player prefers to merge kill records, this option can do that.
int kill_map[KC_NCATEGORIES];
#ifdef WIZARD
// Parameters for fight simulations.
long fsim_rounds;
int fsim_str, fsim_int, fsim_dex;
int fsim_xl;
std::string fsim_mons;
std::vector<std::string> fsim_kit;
#endif // WIZARD
#ifdef USE_TILE
char show_items[20]; // show which item types in tile inventory
bool title_screen; // display title screen?
// minimap colours
char tile_player_col;
char tile_monster_col;
char tile_friendly_col;
char tile_item_col;
char tile_unseen_col;
char tile_floor_col;
char tile_wall_col;
char tile_mapped_wall_col;
char tile_door_col;
char tile_downstairs_col;
char tile_upstairs_col;
char tile_feature_col;
char tile_trap_col;
char tile_water_col;
char tile_lava_col;
char tile_excluded_col;
#endif
#ifdef WIN32TILES
bool use_dos_char;
#endif
typedef std::map<std::string, std::string> opt_map;
opt_map named_options; // All options not caught above are
// recorded here.
///////////////////////////////////////////////////////////////////////
// These options cannot be directly set by the user. Instead they're
// set indirectly to the choices the user made for the last character
// created. XXX: Isn't there a better place for these?
std::string prev_name;
char prev_race;
char prev_cls;
int prev_ck, prev_dk;
god_type prev_pr;
int prev_weapon;
int prev_book;
bool prev_randpick;
///////////////////////////////////////////////////////////////////////
// tutorial
FixedVector<bool, 48> tutorial_events;
// bool tut_made_note;
bool tut_explored;
bool tut_stashes;
bool tut_travel;
unsigned int tut_spell_counter;
unsigned int tut_throw_counter;
unsigned int tut_berserk_counter;
unsigned int tut_melee_counter;
unsigned int tut_last_healed;
bool tut_just_triggered;
unsigned int tutorial_type;
unsigned int tutorial_left;
private:
std::map<std::string, std::string> aliases;
public:
// Convenience accessors for the second-class options in named_options.
int o_int(const char *name, int def = 0) const;
long o_long(const char *name, long def = 0L) const;
bool o_bool(const char *name, bool def = false) const;
std::string o_str(const char *name, const char *def = NULL) const;
int o_colour(const char *name, int def = LIGHTGREY) const;
// Fix option values if necessary, specifically file paths.
void fixup_options();
private:
std::string unalias(const std::string &key) const;
void add_alias(const std::string &alias, const std::string &name);
void clear_feature_overrides();
void clear_cset_overrides();
void add_cset_override(char_set_type set, const std::string &overrides);
void add_cset_override(char_set_type set, dungeon_char_type dc,
unsigned symbol);
void add_feature_override(const std::string &);
void add_message_colour_mappings(const std::string &);
void add_message_colour_mapping(const std::string &);
message_filter parse_message_filter(const std::string &s);
void set_default_activity_interrupts();
void clear_activity_interrupts(FixedVector<bool, NUM_AINTERRUPTS> &eints);
void set_activity_interrupt(
FixedVector<bool, NUM_AINTERRUPTS> &eints,
const std::string &interrupt);
void set_activity_interrupt(const std::string &activity_name,
const std::string &interrupt_names,
bool append_interrupts,
bool remove_interrupts);
void set_fire_order(const std::string &full, bool add);
void add_fire_order_slot(const std::string &s);
void set_menu_sort(std::string field);
void new_dump_fields(const std::string &text, bool add = true);
void do_kill_map(const std::string &from, const std::string &to);
int read_explore_stop_conditions(const std::string &) const;
void split_parse(const std::string &s, const std::string &separator,
void (game_options::*add)(const std::string &));
void add_mon_glyph_override(monster_type mtype, mon_display &mdisp);
void add_mon_glyph_overrides(const std::string &mons, mon_display &mdisp);
void add_mon_glyph_override(const std::string &);
mon_display parse_mon_glyph(const std::string &s) const;
void set_option_fragment(const std::string &s);
static const std::string interrupt_prefix;
};
extern game_options Options;
#endif // EXTERNS_H
|