1 #include "culture.h"
2
3 #include "building/building.h"
4 #include "building/count.h"
5 #include "building/monument.h"
6 #include "city/constants.h"
7 #include "city/data_private.h"
8 #include "city/entertainment.h"
9 #include "city/festival.h"
10 #include "city/population.h"
11 #include "core/calc.h"
12
13 #define SHRINE_COVERAGE 20
14 #define SMALL_TEMPLE_COVERAGE 750
15 #define LARGE_TEMPLE_COVERAGE 3000
16 #define ORACLE_COVERAGE 500
17 #define LARGE_ORACLE_COVERAGE 750
18 #define PANTHEON_COVERAGE 1500
19 #define GRAND_TEMPLE_COVERAGE 5000
20
21
22 static struct {
23 int theater;
24 int amphitheater;
25 int colosseum;
26 int hippodrome;
27 int hospital;
28 int school;
29 int academy;
30 int library;
31 int religion[5];
32 int oracle;
33 int tavern;
34 int arena;
35 } coverage;
36
city_culture_coverage_tavern(void)37 int city_culture_coverage_tavern(void)
38 {
39 return coverage.tavern;
40 }
41
city_culture_coverage_theater(void)42 int city_culture_coverage_theater(void)
43 {
44 return coverage.theater;
45 }
46
city_culture_coverage_amphitheater(void)47 int city_culture_coverage_amphitheater(void)
48 {
49 return coverage.amphitheater;
50 }
51
city_culture_coverage_arena(void)52 int city_culture_coverage_arena(void)
53 {
54 return coverage.arena;
55 }
56
city_culture_coverage_colosseum(void)57 int city_culture_coverage_colosseum(void)
58 {
59 return coverage.colosseum;
60 }
61
city_culture_coverage_hippodrome(void)62 int city_culture_coverage_hippodrome(void)
63 {
64 return coverage.hippodrome;
65 }
66
city_culture_coverage_average_entertainment(void)67 int city_culture_coverage_average_entertainment(void)
68 {
69 return (coverage.hippodrome + coverage.colosseum + coverage.amphitheater + coverage.theater + coverage.tavern) / 5;
70 }
71
city_culture_coverage_religion(god_type god)72 int city_culture_coverage_religion(god_type god)
73 {
74 return coverage.religion[god];
75 }
76
city_culture_coverage_school(void)77 int city_culture_coverage_school(void)
78 {
79 return coverage.school;
80 }
81
city_culture_coverage_library(void)82 int city_culture_coverage_library(void)
83 {
84 return coverage.library;
85 }
86
city_culture_coverage_academy(void)87 int city_culture_coverage_academy(void)
88 {
89 return coverage.academy;
90 }
91
city_culture_coverage_hospital(void)92 int city_culture_coverage_hospital(void)
93 {
94 return coverage.hospital;
95 }
96
city_culture_average_education(void)97 int city_culture_average_education(void)
98 {
99 return city_data.culture.average_education;
100 }
101
city_culture_average_entertainment(void)102 int city_culture_average_entertainment(void)
103 {
104 return city_data.culture.average_entertainment;
105 }
106
city_culture_average_health(void)107 int city_culture_average_health(void)
108 {
109 return city_data.culture.average_health;
110 }
111
top(int input)112 static int top(int input)
113 {
114 return input > 100 ? 100 : input;
115 }
116
city_culture_update_coverage(void)117 void city_culture_update_coverage(void)
118 {
119 int population = city_data.population.population;
120
121 // entertainment
122 coverage.tavern = top(calc_percentage(city_culture_get_tavern_person_coverage(), population));
123 coverage.theater = top(calc_percentage(city_culture_get_theatre_person_coverage(), population));
124 coverage.amphitheater = top(calc_percentage(city_culture_get_ampitheatre_person_coverage(), population));
125 coverage.arena = top(calc_percentage(city_culture_get_arena_person_coverage(), population));
126
127 if (building_monument_working(BUILDING_HIPPODROME) <= 0) {
128 coverage.hippodrome = 0;
129 } else {
130 coverage.hippodrome = 100;
131 }
132
133 if (building_monument_working(BUILDING_COLOSSEUM) <= 0) {
134 coverage.colosseum = 0;
135 } else {
136 coverage.colosseum = 100;
137 }
138
139 // religion
140 int oracles = building_count_active(BUILDING_ORACLE);
141 int shrines = building_count_total(BUILDING_LARARIUM);
142 int nymphaeums = building_count_active(BUILDING_NYMPHAEUM);
143 int small_mausoleums = building_count_active(BUILDING_SMALL_MAUSOLEUM);
144 int large_mausoleums = building_count_active(BUILDING_LARGE_MAUSOLEUM);
145 coverage.religion[GOD_CERES] = top(calc_percentage(
146 SHRINE_COVERAGE * shrines +
147 ORACLE_COVERAGE * oracles +
148 ORACLE_COVERAGE * small_mausoleums +
149 LARGE_ORACLE_COVERAGE * nymphaeums +
150 LARGE_ORACLE_COVERAGE * large_mausoleums +
151 SMALL_TEMPLE_COVERAGE * building_count_active(BUILDING_SMALL_TEMPLE_CERES) +
152 LARGE_TEMPLE_COVERAGE * building_count_active(BUILDING_LARGE_TEMPLE_CERES) +
153 PANTHEON_COVERAGE * building_count_active(BUILDING_PANTHEON) +
154 GRAND_TEMPLE_COVERAGE * building_count_active(BUILDING_GRAND_TEMPLE_CERES),
155 population));
156 coverage.religion[GOD_NEPTUNE] = top(calc_percentage(
157 SHRINE_COVERAGE * shrines +
158 ORACLE_COVERAGE * oracles +
159 ORACLE_COVERAGE * small_mausoleums +
160 LARGE_ORACLE_COVERAGE * nymphaeums +
161 LARGE_ORACLE_COVERAGE * large_mausoleums +
162 SMALL_TEMPLE_COVERAGE * building_count_active(BUILDING_SMALL_TEMPLE_NEPTUNE) +
163 LARGE_TEMPLE_COVERAGE * building_count_active(BUILDING_LARGE_TEMPLE_NEPTUNE) +
164 PANTHEON_COVERAGE * building_count_active(BUILDING_PANTHEON) +
165 GRAND_TEMPLE_COVERAGE * building_count_active(BUILDING_GRAND_TEMPLE_NEPTUNE),
166 population));
167 coverage.religion[GOD_MERCURY] = top(calc_percentage(
168 SHRINE_COVERAGE * shrines +
169 ORACLE_COVERAGE * oracles +
170 ORACLE_COVERAGE * small_mausoleums +
171 LARGE_ORACLE_COVERAGE * nymphaeums +
172 LARGE_ORACLE_COVERAGE * large_mausoleums +
173 SMALL_TEMPLE_COVERAGE * building_count_active(BUILDING_SMALL_TEMPLE_MERCURY) +
174 LARGE_TEMPLE_COVERAGE * building_count_active(BUILDING_LARGE_TEMPLE_MERCURY) +
175 PANTHEON_COVERAGE * building_count_active(BUILDING_PANTHEON) +
176 GRAND_TEMPLE_COVERAGE * building_count_active(BUILDING_GRAND_TEMPLE_MERCURY),
177 population));
178 coverage.religion[GOD_MARS] = top(calc_percentage(
179 SHRINE_COVERAGE * shrines +
180 ORACLE_COVERAGE * oracles +
181 ORACLE_COVERAGE * small_mausoleums +
182 LARGE_ORACLE_COVERAGE * nymphaeums +
183 LARGE_ORACLE_COVERAGE * large_mausoleums +
184 SMALL_TEMPLE_COVERAGE * building_count_active(BUILDING_SMALL_TEMPLE_MARS) +
185 LARGE_TEMPLE_COVERAGE * building_count_active(BUILDING_LARGE_TEMPLE_MARS) +
186 PANTHEON_COVERAGE * building_count_active(BUILDING_PANTHEON) +
187 GRAND_TEMPLE_COVERAGE * building_count_active(BUILDING_GRAND_TEMPLE_MARS),
188 population));
189 coverage.religion[GOD_VENUS] = top(calc_percentage(
190 SHRINE_COVERAGE * shrines +
191 ORACLE_COVERAGE * oracles +
192 ORACLE_COVERAGE * small_mausoleums +
193 LARGE_ORACLE_COVERAGE * nymphaeums +
194 LARGE_ORACLE_COVERAGE * large_mausoleums +
195 SMALL_TEMPLE_COVERAGE * building_count_active(BUILDING_SMALL_TEMPLE_VENUS) +
196 LARGE_TEMPLE_COVERAGE * building_count_active(BUILDING_LARGE_TEMPLE_VENUS) +
197 PANTHEON_COVERAGE * building_count_active(BUILDING_PANTHEON) +
198 GRAND_TEMPLE_COVERAGE * building_count_active(BUILDING_GRAND_TEMPLE_VENUS),
199 population));
200 coverage.oracle = top(calc_percentage(ORACLE_COVERAGE * oracles, population));
201
202 city_data.culture.religion_coverage =
203 coverage.religion[GOD_CERES] +
204 coverage.religion[GOD_NEPTUNE] +
205 coverage.religion[GOD_MERCURY] +
206 coverage.religion[GOD_MARS] +
207 coverage.religion[GOD_VENUS];
208 city_data.culture.religion_coverage /= 5;
209
210 // education
211 city_population_calculate_educational_age();
212
213 coverage.school = top(calc_percentage(
214 city_culture_get_school_person_coverage(), city_population_school_age()));
215 coverage.library = top(calc_percentage(
216 city_culture_get_library_person_coverage(), population));
217 coverage.academy = top(calc_percentage(
218 city_culture_get_academy_person_coverage(), city_population_academy_age()));
219
220 // health
221 coverage.hospital = top(calc_percentage(
222 HOSPITAL_COVERAGE * building_count_active(BUILDING_HOSPITAL), population));
223 }
224
city_culture_calculate(void)225 void city_culture_calculate(void)
226 {
227 city_data.culture.average_entertainment = 0;
228 city_data.culture.average_religion = 0;
229 city_data.culture.average_education = 0;
230 city_data.culture.average_health = 0;
231 city_data.culture.average_desirability = 0;
232 city_data.culture.population_with_venus_access = 0; //venus
233
234 int num_houses = 0;
235 for (building_type type = BUILDING_HOUSE_SMALL_TENT; type <= BUILDING_HOUSE_LUXURY_PALACE; type++) {
236 for (building *b = building_first_of_type(type); b; b = b->next_of_type) {
237 if (b->state == BUILDING_STATE_IN_USE && b->house_size) {
238 num_houses++;
239 city_data.culture.average_entertainment += b->data.house.entertainment;
240 city_data.culture.average_religion += b->data.house.num_gods;
241 city_data.culture.average_education += b->data.house.education;
242 city_data.culture.average_health += b->data.house.health;
243 city_data.culture.average_desirability += b->desirability;
244 if (b->data.house.temple_venus) {
245 city_data.culture.population_with_venus_access += b->house_population;
246 }
247 }
248 }
249 }
250 if (num_houses) {
251 city_data.culture.average_entertainment /= num_houses;
252 city_data.culture.average_religion /= num_houses;
253 city_data.culture.average_education /= num_houses;
254 city_data.culture.average_health /= num_houses;
255 city_data.culture.average_desirability /= num_houses;
256 }
257
258 city_entertainment_calculate_shows();
259 city_festival_calculate_costs();
260 }
261
city_culture_get_theatre_person_coverage(void)262 int city_culture_get_theatre_person_coverage(void)
263 {
264 return THEATER_COVERAGE * building_count_active(BUILDING_THEATER) + THEATER_UPGRADE_BONUS_COVERAGE * building_count_upgraded(BUILDING_THEATER);;
265 }
266
city_culture_get_school_person_coverage(void)267 int city_culture_get_school_person_coverage(void)
268 {
269 return SCHOOL_COVERAGE * building_count_active(BUILDING_SCHOOL) + SCHOOL_UPGRADE_BONUS_COVERAGE * building_count_upgraded(BUILDING_SCHOOL);
270 }
271
city_culture_get_library_person_coverage(void)272 int city_culture_get_library_person_coverage(void)
273 {
274 return LIBRARY_COVERAGE * building_count_active(BUILDING_LIBRARY) + LIBRARY_UPGRADE_BONUS_COVERAGE * building_count_upgraded(BUILDING_LIBRARY);;
275 }
276
city_culture_get_academy_person_coverage(void)277 int city_culture_get_academy_person_coverage(void)
278 {
279 return ACADEMY_COVERAGE * building_count_active(BUILDING_ACADEMY);
280 }
281
city_culture_get_tavern_person_coverage(void)282 int city_culture_get_tavern_person_coverage(void)
283 {
284 return TAVERN_COVERAGE * building_count_active(BUILDING_TAVERN);
285 }
286
city_culture_get_ampitheatre_person_coverage(void)287 int city_culture_get_ampitheatre_person_coverage(void)
288 {
289 return AMPHITHEATER_COVERAGE * building_count_active(BUILDING_AMPHITHEATER);
290 }
291
city_culture_get_arena_person_coverage(void)292 int city_culture_get_arena_person_coverage(void)
293 {
294 return ARENA_COVERAGE * building_count_active(BUILDING_ARENA);
295 }
296
297
city_culture_save_state(buffer * buf)298 void city_culture_save_state(buffer *buf)
299 {
300 // Yes, hospital is saved twice
301 buffer_write_i32(buf, coverage.theater);
302 buffer_write_i32(buf, coverage.amphitheater);
303 buffer_write_i32(buf, coverage.colosseum);
304 buffer_write_i32(buf, coverage.hospital);
305 buffer_write_i32(buf, coverage.hippodrome);
306 for (int i = GOD_CERES; i <= GOD_VENUS; i++) {
307 buffer_write_i32(buf, coverage.religion[i]);
308 }
309 buffer_write_i32(buf, coverage.oracle);
310 buffer_write_i32(buf, coverage.school);
311 buffer_write_i32(buf, coverage.library);
312 buffer_write_i32(buf, coverage.academy);
313 buffer_write_i32(buf, coverage.hospital);
314 }
315
city_culture_load_state(buffer * buf)316 void city_culture_load_state(buffer *buf)
317 {
318 // Yes, hospital is saved twice
319 coverage.theater = buffer_read_i32(buf);
320 coverage.amphitheater = buffer_read_i32(buf);
321 coverage.colosseum = buffer_read_i32(buf);
322 coverage.hospital = buffer_read_i32(buf);
323 coverage.hippodrome = buffer_read_i32(buf);
324 for (int i = GOD_CERES; i <= GOD_VENUS; i++) {
325 coverage.religion[i] = buffer_read_i32(buf);
326 }
327 coverage.oracle = buffer_read_i32(buf);
328 coverage.school = buffer_read_i32(buf);
329 coverage.library = buffer_read_i32(buf);
330 coverage.academy = buffer_read_i32(buf);
331 coverage.hospital = buffer_read_i32(buf);
332 }
333