Freeciv-3.3
Loading...
Searching...
No Matches
traderoutes.c
Go to the documentation of this file.
1/****************************************************************************
2 Freeciv - Copyright (C) 2004 - The Freeciv Team
3 This program is free software; you can redistribute it and/or modify
4 it under the terms of the GNU General Public License as published by
5 the Free Software Foundation; either version 2, or (at your option)
6 any later version.
7
8 This program is distributed in the hope that it will be useful,
9 but WITHOUT ANY WARRANTY; without even the implied warranty of
10 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 GNU General Public License for more details.
12****************************************************************************/
13
14#ifdef HAVE_CONFIG_H
15#include <fc_config.h>
16#endif
17
18/* utility */
19#include "log.h"
20#include "rand.h"
21
22/* common */
23#include "city.h"
24#include "effects.h"
25#include "game.h"
26#include "map.h"
27#include "tile.h"
28#include "unittype.h"
29
30#include "traderoutes.h"
31
32const char *trade_route_type_names[] = {
33 "National", "NationalIC", "IN", "INIC", "Ally", "AllyIC",
34 "Enemy", "EnemyIC", "Team", "TeamIC"
35};
36
38 "Active", "Inactive", "Cancel"
39};
40
42
44
45/*********************************************************************/
48unsigned max_trade_routes(const struct city *pcity)
49{
51
52 return CLIP(0, eft, MAX_TRADE_ROUTES);
53}
54
55/*********************************************************************/
59 const struct city *pcity2)
60{
61 struct player *plr1 = city_owner(pcity1);
62 struct player *plr2 = city_owner(pcity2);
63
64 if (plr1 != plr2) {
65 struct player_diplstate *ds = player_diplstate_get(plr1, plr2);
66
67 if (city_tile(pcity1)->continent != city_tile(pcity2)->continent) {
68 switch (ds->type) {
69 case DS_ALLIANCE:
70 return TRT_ALLY_IC;
71 case DS_WAR:
72 return TRT_ENEMY_IC;
73 case DS_TEAM:
74 return TRT_TEAM_IC;
75 case DS_ARMISTICE:
76 case DS_CEASEFIRE:
77 case DS_PEACE:
78 case DS_NO_CONTACT:
79 return TRT_IN_IC;
80 case DS_LAST:
81 fc_assert(ds->type != DS_LAST);
82 return TRT_IN_IC;
83 }
85
86 return TRT_IN_IC;
87 } else {
88 switch (ds->type) {
89 case DS_ALLIANCE:
90 return TRT_ALLY;
91 case DS_WAR:
92 return TRT_ENEMY;
93 case DS_TEAM:
94 return TRT_TEAM;
95 case DS_ARMISTICE:
96 case DS_CEASEFIRE:
97 case DS_PEACE:
98 case DS_NO_CONTACT:
99 return TRT_IN;
100 case DS_LAST:
101 fc_assert(ds->type != DS_LAST);
102 return TRT_IN;
103 }
105
106 return TRT_IN;
107 }
108 } else {
109 if (city_tile(pcity1)->continent != city_tile(pcity2)->continent) {
110 return TRT_NATIONAL_IC;
111 } else {
112 return TRT_NATIONAL;
113 }
114 }
115
116 return TRT_LAST;
117}
118
119/*********************************************************************/
123{
124 if (type >= TRT_LAST) {
125 return 0;
126 }
127
128 return trtss[type].trade_pct;
129}
130
131/*********************************************************************/
135{
137
138 for (type = TRT_NATIONAL; type < TRT_LAST; type++) {
140
141 set->trade_pct = 100;
142 }
143}
144
145/*********************************************************************/
154
155/*********************************************************************/
159{
161
162 for (type = TRT_NATIONAL; type < TRT_LAST; type++) {
164 return type;
165 }
166 }
167
168 return TRT_LAST;
169}
170
171/*********************************************************************/
180
181/*********************************************************************/
196
197/*********************************************************************/
207
208/*********************************************************************/
214bool can_cities_trade(const struct city *pc1, const struct city *pc2)
215{
216 /* If you change the logic here, make sure to update the help in
217 * helptext_unit(). */
218 return (pc1 && pc2 && pc1 != pc2
220 || map_distance(pc1->tile, pc2->tile)
223 > 0));
224}
225
226/*********************************************************************/
231int city_trade_removable(const struct city *pcity, int priority,
233{
235 int num, i, j;
236
237 /* Sort trade route values. */
238 num = 0;
240 if (proute->goods->priority <= priority) {
241 for (j = num; j > 0 && proute->goods->priority > sorted[j - 1]->goods->priority; j--) ;
242
243 /* Search place amoung same priority ones. */
244 for (; j > 0
245 && (proute->value < sorted[j - 1]->value)
246 && (proute->goods->priority == sorted[j - 1]->goods->priority) ;
247 j--) {
248 sorted[j] = sorted[j - 1];
249 }
250 sorted[j] = proute;
251 num++;
252 }
254
255 /* No trade routes at all. */
256 if (num == 0) {
257 return 0;
258 }
259
260 /* Adjust number of concerned trade routes. */
261 num += 1 - max_trade_routes(pcity);
262 if (num < 0) {
263 num = 1;
264 }
265
266 /* Return values. */
267 for (i = j = 0; i < num; i++) {
268 j += sorted[i]->value;
269 if (NULL != would_remove) {
271 }
272 }
273
274 return j;
275}
276
277/*********************************************************************/
283bool can_establish_trade_route(const struct city *pc1, const struct city *pc2,
284 int priority)
285{
286 int trade = -1;
287 int maxpc1;
288 int maxpc2;
289
290 if (!pc1 || !pc2 || pc1 == pc2
293 return FALSE;
294 }
295
296 /* First check if cities can have trade routes at all. */
298 if (maxpc1 <= 0) {
299 return FALSE;
300 }
302 if (maxpc2 <= 0) {
303 return FALSE;
304 }
305
308 /* Can we replace trade route? */
309 if (city_trade_removable(pc1, priority, NULL) >= trade) {
310 return FALSE;
311 }
312 }
313
315 if (trade == -1) {
317 }
318 /* Can we replace trade route? */
319 if (city_trade_removable(pc2, priority, NULL) >= trade) {
320 return FALSE;
321 }
322 }
323
324 return TRUE;
325}
326
327/*********************************************************************/
331int trade_base_between_cities(const struct city *pc1, const struct city *pc2)
332{
333 int bonus = 0;
334
335 if (NULL == pc1 || NULL == pc1->tile || NULL == pc2 || NULL == pc2->tile) {
336 return 0;
337 }
338
340 /* Classic Freeciv */
341 int real_dist = real_map_distance(pc1->tile, pc2->tile);
346
347 bonus = weighted_distance
349 } else if (game.info.trade_revenue_style == TRS_SIMPLE) {
350 /* Simple revenue style */
351 bonus = (pc1->citizen_base[O_TRADE] + pc2->citizen_base[O_TRADE] + 4)
352 * 3;
353 }
354
355 bonus = bonus
357 / 100;
358
359 bonus /= 12;
360
361 return bonus;
362}
363
364/*********************************************************************/
367int trade_from_route(const struct city *pc1, const struct trade_route *route,
368 int base)
369{
370 int val;
371
372 if (route->dir == RDIR_TO) {
373 val = base * route->goods->to_pct / 100;
374
375 if (route->goods->to_pct > 0) {
376 val = MAX(val, game.info.min_trade_route_val);
377 }
378 } else {
379 val = base * route->goods->from_pct / 100;
380
381 if (route->goods->from_pct > 0) {
382 val = MAX(val, game.info.min_trade_route_val);
383 }
384 }
385
386 return val;
387}
388
389/*********************************************************************/
392int city_num_trade_routes(const struct city *pcity)
393{
394 return trade_route_list_size(pcity->routes);
395}
396
397/*********************************************************************/
400static int best_value(const void *a, const void *b)
401{
402 return *(int *)a < *(int *)b;
403}
404
405/*********************************************************************/
408static int max_tile_trade(const struct city *pcity)
409{
410 int i, total = 0;
411 int radius_sq = city_map_radius_sq_get(pcity);
412 int tile_trade[city_map_tiles(radius_sq)];
413 size_t size = 0;
415 const struct civ_map *nmap = &(wld.map);
416
417 if (pcity->tile == NULL) {
418 return 0;
419 }
420
421 city_map_iterate(radius_sq, cindex, cx, cy) {
422 struct tile *ptile = city_map_to_tile(nmap, pcity->tile, radius_sq, cx, cy);
423
424 if (ptile == NULL) {
425 continue;
426 }
427
428 if (is_free_worked_index(cindex)) {
429 total += city_tile_output(pcity, ptile, is_celebrating, O_TRADE);
430 continue;
431 }
432
433 if (!city_can_work_tile(pcity, ptile)) {
434 continue;
435 }
436
438 O_TRADE);
440
442
443 for (i = 0; i < pcity->size && i < size; i++) {
444 total += tile_trade[i];
445 }
446
447 return total;
448}
449
450/*********************************************************************/
453int max_trade_prod(const struct city *pcity)
454{
455 /* Trade tile base */
456 int trade_prod = max_tile_trade(pcity);
457
458 /* Add trade routes values */
459 trade_partners_iterate(pcity, partner) {
460 trade_prod += trade_base_between_cities(pcity, partner);
462
463 return trade_prod;
464}
465
466/*********************************************************************/
477 const struct city *pc2,
478 const struct unit_type *ut,
479 struct goods_type *pgood,
480 const bool establish_trade)
481{
482 int tb = 0, bonus = 0;
484
485 if (trtss[trtype].bonus_type == TBONUS_NONE) {
486 return 0;
487 }
488
490 /* Should this be real_map_distance? */
491 int distance = map_distance(pc1->tile, pc2->tile);
493 = ((100 - game.info.trade_world_rel_pct) * distance
495 * (distance * 40 / MAX(MAP_NATIVE_WIDTH, MAP_NATIVE_HEIGHT))) / 100;
496
497 tb = weighted_distance + 10;
498 tb = (tb * (pc1->surplus[O_TRADE] + pc2->surplus[O_TRADE])) / 24;
500 /* Logarithmic bonus */
501 int distance = real_map_distance(pc1->tile, pc2->tile);
503 = ((100 - game.info.trade_world_rel_pct) * distance
505 * (distance * 40 / MAX(MAP_NATIVE_WIDTH, MAP_NATIVE_HEIGHT))) / 100;
506
508 + max_trade_prod(pc1) + max_trade_prod(pc2)) * 2, 2);
509 }
510
511 if (pgood != NULL) {
512 tb = tb * pgood->onetime_pct / 100;
513 }
514
515 /* Trade_revenue_bonus increases revenue by power of 2 in milimes */
517 &(const struct req_context) {
518 .player = city_owner(pc1),
519 .city = pc1,
520 .tile = city_tile(pc1),
521 /* Putting .unit things like unit veterancy
522 * in the scope give little gameplay
523 * and overcomplicate the AI logic */
524 .unittype = ut,
525 /* Could be used to reduce the one time
526 * bonus if no trade route is
527 * established. */
528 .action = action_by_number(
532 ),
533 },
534 &(const struct req_context) {
535 .player = city_owner(pc2),
536 .city = pc2,
537 .tile = city_tile(pc2),
538 },
540
541 /* Be mercy full to players with small amounts. Round up. */
542 tb = ceil((float)tb * pow(2.0, (double)bonus / 1000.0));
543
544 return tb;
545}
546
547/*********************************************************************/
550bool have_cities_trade_route(const struct city *pc1, const struct city *pc2)
551{
553 if (route_to->id == pc2->id) {
554 return TRUE;
555 }
557
558 return FALSE;
559}
560
561/*********************************************************************/
564void goods_init(void)
565{
566 int i;
567
568 for (i = 0; i < MAX_GOODS_TYPES; i++) {
569 goods[i].id = i;
570
573 goods[i].helptext = NULL;
574 }
575}
576
577/*********************************************************************/
580void goods_free(void)
581{
582 int i;
583
584 for (i = 0; i < MAX_GOODS_TYPES; i++) {
586
587 if (NULL != goods[i].helptext) {
588 strvec_destroy(goods[i].helptext);
589 goods[i].helptext = NULL;
590 }
591 }
592}
593
594/*********************************************************************/
598{
600
601 return pgood->id;
602}
603
604/*********************************************************************/
611{
613
614 return pgood - goods;
615}
616
617/*********************************************************************/
621{
623
624 return &goods[id];
625}
626
627/*********************************************************************/
631{
632 return name_translation_get(&pgood->name);
633}
634
635/*********************************************************************/
638const char *goods_rule_name(struct goods_type *pgood)
639{
640 return rule_name_get(&pgood->name);
641}
642
643/*********************************************************************/
648{
649 const char *qs;
650
651 if (name == NULL) {
652 return NULL;
653 }
654
655 qs = Qn_(name);
656
659 return pgood;
660 }
662
663 return NULL;
664}
665
666/*********************************************************************/
671{
674 return pgood;
675 }
677
678 return NULL;
679}
680
681/*********************************************************************/
684bool goods_has_flag(const struct goods_type *pgood, enum goods_flag_id flag)
685{
686 return BV_ISSET(pgood->flags, flag);
687}
688
689/*********************************************************************/
692bool goods_can_be_provided(const struct city *pcity,
693 const struct goods_type *pgood,
694 const struct unit *punit)
695{
696 return are_reqs_active(&(const struct req_context) {
697 .player = city_owner(pcity),
698 .city = pcity,
699 .tile = city_tile(pcity),
700 .unit = punit,
701 .unittype = punit ? unit_type_get(punit) : NULL,
702 },
703 NULL,
704 &pgood->reqs, RPT_CERTAIN);
705}
706
707/*********************************************************************/
710bool city_receives_goods(const struct city *pcity,
711 const struct goods_type *pgood)
712{
714 if (proute->goods == pgood
715 && (proute->dir == RDIR_TO || proute->dir == RDIR_BIDIRECTIONAL)) {
716 struct city *tcity = game_city_by_number(proute->partner);
719
720 if (can_cities_trade(pcity, tcity)) {
721 return TRUE;
722 }
723
726
727 if (settings->cancelling == TRI_ACTIVE) {
728 return TRUE;
729 }
730 }
732
733 return FALSE;
734}
735
736/*********************************************************************/
743struct goods_type *goods_from_city_to_unit(const struct city *src,
744 const struct unit *punit)
745{
746 int i = 0;
747 int prio = -1;
749
751 if (goods_can_be_provided(src, pgood, punit)) {
752 if (pgood->select_priority >= prio) {
753 if (pgood->select_priority > prio) {
754 /* New highest priority */
755 i = 0;
757 }
758
759 potential[i++] = pgood;
760 }
761 }
763
764 if (i == 0) {
765 return NULL;
766 }
767
768 return potential[fc_rand(i)];
769}
770
771/*********************************************************************/
779 const struct city *homecity)
780{
782 return goods_from_city_to_unit(homecity, punit);
783 }
784
785 return punit->carrying;
786}
static struct action * action_by_number(action_id act_id)
Definition actions.h:390
#define BV_ISSET(bv, bit)
Definition bitvector.h:78
bool base_city_celebrating(const struct city *pcity)
Definition city.c:1633
struct tile * city_map_to_tile(const struct civ_map *nmap, const struct tile *city_center, int city_radius_sq, int city_map_x, int city_map_y)
Definition city.c:305
int city_map_radius_sq_get(const struct city *pcity)
Definition city.c:137
int city_tile_output(const struct city *pcity, const struct tile *ptile, bool is_celebrating, Output_type_id otype)
Definition city.c:1279
int city_map_tiles(int city_radius_sq)
Definition city.c:171
bool city_can_work_tile(const struct city *pcity, const struct tile *ptile)
Definition city.c:1452
#define city_tile(_pcity_)
Definition city.h:564
static citizens city_size_get(const struct city *pcity)
Definition city.h:569
#define city_owner(_pcity_)
Definition city.h:563
#define city_map_iterate_end
Definition city.h:177
#define city_map_iterate(_radius_sq, _index, _x, _y)
Definition city.h:173
#define is_free_worked_index(city_tile_index)
Definition city.h:871
char * incite_cost
Definition comments.c:74
static void base(QVariant data1, QVariant data2)
Definition dialogs.cpp:2938
struct unit struct city struct unit struct tile struct extra_type const struct act_prob *act_probs int actor_unit_id struct unit struct unit * punit
Definition dialogs_g.h:74
int int id
Definition editgui_g.h:28
struct @21::@22 reqs
int get_city_bonus(const struct city *pcity, enum effect_type effect_type)
Definition effects.c:842
int get_target_bonus_effects(struct effect_list *plist, const struct req_context *context, const struct req_context *other_context, enum effect_type effect_type)
Definition effects.c:744
#define MAX_TRADE_ROUTES
Definition fc_types.h:1239
int Goods_type_id
Definition fc_types.h:391
#define MAX_GOODS_TYPES
Definition fc_types.h:51
@ RPT_CERTAIN
Definition fc_types.h:678
@ O_TRADE
Definition fc_types.h:101
#define Qn_(String)
Definition fcintl.h:89
struct civ_game game
Definition game.c:61
struct world wld
Definition game.c:62
struct city * game_city_by_number(int id)
Definition game.c:106
GType type
Definition repodlgs.c:1313
const char * name
Definition inputfile.c:127
#define fc_assert(condition)
Definition log.h:176
#define fc_assert_ret_val(condition, val)
Definition log.h:194
int real_map_distance(const struct tile *tile0, const struct tile *tile1)
Definition map.c:636
int map_distance(const struct tile *tile0, const struct tile *tile1)
Definition map.c:660
static const char * rule_name_get(const struct name_translation *ptrans)
static const char * name_translation_get(const struct name_translation *ptrans)
struct player_diplstate * player_diplstate_get(const struct player *plr1, const struct player *plr2)
Definition player.c:324
#define fc_rand(_size)
Definition rand.h:56
bool are_reqs_active(const struct req_context *context, const struct req_context *other_context, const struct requirement_vector *reqs, const enum req_problem_type prob_type)
static struct setting settings[]
Definition settings.c:1474
#define CLIP(lower, current, upper)
Definition shared.h:57
#define MAX(x, y)
Definition shared.h:54
SPECPQ_PRIORITY_TYPE priority
Definition specpq.h:86
size_t size
Definition specvec.h:72
void strvec_destroy(struct strvec *psv)
Definition city.h:320
struct trade_route_list * routes
Definition city.h:344
citizens size
Definition city.h:332
struct tile * tile
Definition city.h:322
struct packet_ruleset_control control
Definition game.h:83
struct packet_game_info info
Definition game.h:89
bool ruledit_disabled
int select_priority
struct strvec * helptext
enum goods_selection_method goods_selection
enum trade_revenue_style trade_revenue_style
enum caravan_bonus_style caravan_bonus_style
Definition tile.h:50
Definition unit.h:140
struct goods_type * carrying
Definition unit.h:189
struct civ_map map
int fc_strcasecmp(const char *str0, const char *str1)
Definition support.c:186
#define TRUE
Definition support.h:46
#define FALSE
Definition support.h:47
int max_trade_prod(const struct city *pcity)
bool can_cities_trade(const struct city *pc1, const struct city *pc2)
enum trade_route_type cities_trade_route_type(const struct city *pcity1, const struct city *pcity2)
Definition traderoutes.c:58
const char * trade_route_cancelling_type_names[]
Definition traderoutes.c:37
int trade_route_type_trade_pct(enum trade_route_type type)
int trade_base_between_cities(const struct city *pc1, const struct city *pc2)
bool goods_can_be_provided(const struct city *pcity, const struct goods_type *pgood, const struct unit *punit)
int city_num_trade_routes(const struct city *pcity)
Goods_type_id goods_number(const struct goods_type *pgood)
static struct goods_type goods[MAX_GOODS_TYPES]
Definition traderoutes.c:43
bool goods_has_flag(const struct goods_type *pgood, enum goods_flag_id flag)
enum trade_route_illegal_cancelling trade_route_cancelling_type_by_name(const char *name)
const char * trade_route_type_name(enum trade_route_type type)
static int max_tile_trade(const struct city *pcity)
struct trade_route_settings * trade_route_settings_by_type(enum trade_route_type type)
struct trade_route_settings trtss[TRT_LAST]
Definition traderoutes.c:41
struct goods_type * goods_by_rule_name(const char *name)
int trade_from_route(const struct city *pc1, const struct trade_route *route, int base)
const char * goods_rule_name(struct goods_type *pgood)
struct goods_type * goods_from_city_to_unit(const struct city *src, const struct unit *punit)
struct goods_type * unit_current_goods(const struct unit *punit, const struct city *homecity)
unsigned max_trade_routes(const struct city *pcity)
Definition traderoutes.c:48
const char * goods_name_translation(struct goods_type *pgood)
void trade_route_types_init(void)
Goods_type_id goods_index(const struct goods_type *pgood)
static int best_value(const void *a, const void *b)
struct goods_type * goods_by_translated_name(const char *name)
int city_trade_removable(const struct city *pcity, int priority, struct trade_route_list *would_remove)
bool can_establish_trade_route(const struct city *pc1, const struct city *pc2, int priority)
struct goods_type * goods_by_number(Goods_type_id id)
const char * trade_route_cancelling_type_name(enum trade_route_illegal_cancelling type)
void goods_init(void)
bool city_receives_goods(const struct city *pcity, const struct goods_type *pgood)
void goods_free(void)
const char * trade_route_type_names[]
Definition traderoutes.c:32
enum trade_route_type trade_route_type_by_name(const char *name)
bool have_cities_trade_route(const struct city *pc1, const struct city *pc2)
int get_caravan_enter_city_trade_bonus(const struct city *pc1, const struct city *pc2, const struct unit_type *ut, struct goods_type *pgood, const bool establish_trade)
#define goods_type_iterate_end
trade_route_illegal_cancelling
Definition traderoutes.h:29
@ TRI_LAST
Definition traderoutes.h:33
@ TRI_ACTIVE
Definition traderoutes.h:30
#define goods_type_iterate(_p)
#define trade_routes_iterate_end
#define trade_partners_iterate_end
#define trade_routes_iterate(c, proute)
#define trade_partners_iterate(c, p)
trade_route_type
Definition traderoutes.h:37
@ TRT_NATIONAL_IC
Definition traderoutes.h:39
@ TRT_TEAM_IC
Definition traderoutes.h:47
@ TRT_ALLY_IC
Definition traderoutes.h:43
@ TRT_IN_IC
Definition traderoutes.h:41
@ TRT_NATIONAL
Definition traderoutes.h:38
@ TRT_LAST
Definition traderoutes.h:48
@ TRT_IN
Definition traderoutes.h:40
@ TRT_TEAM
Definition traderoutes.h:46
@ TRT_ALLY
Definition traderoutes.h:42
@ TRT_ENEMY_IC
Definition traderoutes.h:45
@ TRT_ENEMY
Definition traderoutes.h:44
const struct unit_type * unit_type_get(const struct unit *punit)
Definition unittype.c:123
#define MAP_NATIVE_WIDTH
#define MAP_NATIVE_HEIGHT