-
Notifications
You must be signed in to change notification settings - Fork 37
/
faction.h
268 lines (220 loc) · 6.37 KB
/
faction.h
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
// START A3HEADER
//
// This source file is part of the Atlantis PBM game program.
// Copyright (C) 1995-1999 Geoff Dunbar
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program, in the file license.txt. If not, write
// to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
// Boston, MA 02111-1307, USA.
//
// See the Atlantis Project web page for details:
// http://www.prankster.com/project
//
// END A3HEADER
// MODIFICATIONS
// Date Person Comments
// ---- ------ --------
// 2000/MAR/14 Davis Kulis Added a new reporting Template.
// 2001/Feb/18 Joseph Traub Added Apprentices from Lacandon Conquest
#ifndef FACTION_CLASS
#define FACTION_CLASS
class Faction;
class Game;
struct ShowObject;
#include "gameio.h"
#include "aregion.h"
#include "unit.h"
#include "battle.h"
#include "skills.h"
#include "items.h"
#include "alist.h"
#include "astring.h"
#include "external/nlohmann/json.hpp"
using json = nlohmann::json;
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <iostream>
#include <sstream>
enum
{
A_HOSTILE,
A_UNFRIENDLY,
A_NEUTRAL,
A_FRIENDLY,
A_ALLY,
NATTITUDES
};
extern const std::string F_WAR;
extern const std::string F_TRADE;
extern const std::string F_MAGIC;
extern const std::string F_MARTIAL;
// DK
// LLS - make templates cleaner for save/restore
enum
{
TEMPLATE_OFF,
TEMPLATE_SHORT,
TEMPLATE_LONG,
TEMPLATE_MAP,
NTEMPLATES
};
enum
{
QUIT_NONE,
QUIT_BY_ORDER,
QUIT_BY_GM,
QUIT_AND_RESTART,
QUIT_WON_GAME,
QUIT_GAME_OVER,
};
extern char const **AttitudeStrs;
extern std::vector<std::string> *FactionTypes;
// LLS - include strings for the template enum
extern char const **TemplateStrs;
int ParseTemplate(AString *);
int ParseAttitude(AString *);
int MagesByFacType(int);
struct Attitude
{
int factionnum;
int attitude;
};
enum FactionActivity
{
TAX = 1,
TRADE = 2
};
class FactionPtr : public AListElem
{
public:
Faction *ptr;
};
// Collect the faction statistics for display in the report
struct FactionStatistic {
std::string item_name;
size_t rank;
size_t max;
size_t total;
// This needs to be a friend function so that the json library can call it. This can only work for simple
// objects/structs that require no additional parameters to be passed in. On the other hand, for simple
// structures this is nice, and works with things like STL containers of structs to make the entire container
// serializable to json.
friend void to_json(json &j, const FactionStatistic &s) {
j = json{{"item_name", s.item_name}, {"rank", s.rank}, {"max", s.max}, {"total", s.total}};
};
};
struct FactionError {
std::string message;
Unit *unit;
friend void to_json(json &j, const FactionError &e);
};
struct FactionEvent {
std::string message;
std::string category;
Unit *unit;
ARegion *region;
friend void to_json(json &j, const FactionEvent &e);
};
class Faction : public AListElem
{
public:
Faction();
Faction(int);
~Faction();
void Readin(std::istream &f);
void Writeout(std::ostream &f);
void View();
void SetName(AString *);
void SetNameNoChange(AString *str);
void SetAddress(AString &strNewAddress);
void CheckExist(ARegionList *);
void error(const std::string& s, Unit *u = nullptr);
void event(const std::string& message, const std::string& category, ARegion *r = nullptr, Unit *u = nullptr);
void build_json_report(json& j, Game *pGame, size_t **citems);
void WriteFacInfo(std::ostream &f);
void set_attitude(int faction_id, int attitude); // attitude -1 clears it
int get_attitude(int faction_id);
void remove_attitude(int faction_id);
int CanCatch(ARegion *, Unit *);
/* Return 1 if can see, 2 if can see faction */
int CanSee(ARegion *, Unit *, int practice = 0);
void DefaultOrders();
void TimesReward();
bool is_npc = false; // by default factions are not NPCs
void DiscoverItem(int item, int force, int full);
int num;
//
// The type is only used if Globals->FACTION_LIMIT_TYPE ==
// FACLIM_FACTION_TYPES
//
std::unordered_map<std::string, int> type;
int lastchange;
int lastorders;
int unclaimed;
int bankaccount;
int interest; // not written to game.out
AString *name;
AString *address;
AString *password;
int times;
int showunitattitudes;
int temformat;
int battleLogFormat;
char exists;
int quit;
int numshows;
int nummages;
int numapprentices;
int numqms;
int numtacts;
// AList war_regions;
// AList trade_regions;
std::unordered_map<ARegion *, std::unordered_set<FactionActivity, std::hash<int>>> activity;
int GetActivityCost(FactionActivity type);
void RecordActivity(ARegion *region, FactionActivity type);
bool IsActivityRecorded(ARegion *region, FactionActivity type);
bool gets_gm_report(Game *game);
/* Used when writing reports */
std::vector<ARegion *> present_regions;
int defaultattitude;
// TODO: Convert this to a hashmap of <attitude, vector<factionid>>
// For now, just making it a vector of attitudes. More will come later.
std::vector<Attitude> attitudes;
// These need to not be ALists wrapped with extra behavior at some point.
SkillList skills;
ItemList items;
// Extra lines/data from the players.in file for this faction. Stored and dumped, not used.
std::vector<std::string> extra_player_data;
// Errors and events during turn processing
std::vector<FactionError> errors;
std::vector<FactionEvent> events;
std::vector<Battle *> battles;
std::vector<ShowSkill> shows;
std::vector<ShowItem> itemshows;
std::vector<ShowObject> objectshows;
// These are used for 'granting' units to a faction via the players.in
// file
ARegion *pReg;
ARegion *pStartLoc;
int noStartLeader;
int startturn;
private:
std::vector<FactionStatistic> compute_faction_statistics(Game *game, size_t **citems);
void gm_report_setup(Game *game);
void build_gm_json_report(json& j, Game *game);
};
Faction *GetFaction(AList *, int);
Faction *GetFaction2(AList *, int); /*This AList is a list of FactionPtr*/
#endif