Freeciv-3.2
Loading...
Searching...
No Matches
packhand.c
Go to the documentation of this file.
1/***********************************************************************
2 Freeciv - Copyright (C) 1996 - A Kjeldberg, L Gregersen, P Unold
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#include <string.h>
19
20/* utility */
21#include "bitvector.h"
22#include "capability.h"
23#include "fcintl.h"
24#include "log.h"
25#include "mem.h"
26#include "rand.h"
27#include "string_vector.h"
28#include "support.h"
29
30/* common */
31#include "achievements.h"
32#include "actions.h"
33#include "capstr.h"
34#include "citizens.h"
35#include "counters.h"
36#include "events.h"
37#include "extras.h"
38#include "game.h"
39#include "government.h"
40#include "idex.h"
41#include "map.h"
42#include "name_translation.h"
43#include "movement.h"
44#include "multipliers.h"
45#include "nation.h"
46#include "packets.h"
47#include "player.h"
48#include "research.h"
49#include "rgbcolor.h"
50#include "road.h"
51#include "spaceship.h"
52#include "specialist.h"
53#include "style.h"
54#include "traderoutes.h"
55#include "unit.h"
56#include "unitlist.h"
57#include "worklist.h"
58
59/* client/include */
60#include "chatline_g.h"
61#include "citydlg_g.h"
62#include "cityrep_g.h"
63#include "connectdlg_g.h"
64#include "dialogs_g.h"
65#include "editgui_g.h"
66#include "gui_main_g.h"
67#include "inteldlg_g.h"
68#include "mapctrl_g.h" /* popup_newcity_dialog() */
69#include "mapview_g.h"
70#include "menu_g.h"
71#include "messagewin_g.h"
72#include "pages_g.h"
73#include "plrdlg_g.h"
74#include "ratesdlg_g.h"
75#include "repodlgs_g.h"
76#include "spaceshipdlg_g.h"
77#include "voteinfo_bar_g.h"
78#include "wldlg_g.h"
79
80/* client */
81#include "agents.h"
82#include "attribute.h"
83#include "audio.h"
84#include "client_main.h"
85#include "climap.h"
86#include "climisc.h"
87#include "clitreaty.h"
88#include "connectdlg_common.h"
89#include "control.h"
90#include "editor.h"
91#include "goto.h" /* client_goto_init() */
92#include "helpdata.h" /* boot_help_texts() */
93#include "mapview_common.h"
94#include "music.h"
95#include "options.h"
96#include "overview_common.h"
97#include "tilespec.h"
98#include "update_queue.h"
99#include "voteinfo.h"
100
101/* client/luascript */
102#include "script_client.h"
103
104#include "packhand.h"
105
106/* Define this macro to get additional debug output about the transport
107 * status of the units. */
108#undef DEBUG_TRANSPORT
109
110static void city_packet_common(struct city *pcity, struct tile *pcenter,
111 struct player *powner,
112 struct tile_list *worked_tiles,
113 bool is_new, bool popup, bool investigate);
114static bool handle_unit_packet_common(struct unit *packet_unit);
115
116
117/* The dumbest of cities, placeholders for unknown and unseen cities. */
118static struct {
119 struct city_list *cities;
121} invisible = {
122 .cities = NULL,
123 .placeholder = NULL
125
126static struct {
127 int len;
129 char *caption;
130 char *headline;
131 char *lines;
132 int parts;
133} page_msg_report = { .parts = 0 };
134
135extern const char forced_tileset_name[];
136
137static int last_turn = 0;
138
139/* Refresh the action selection dialog */
140#define REQEST_BACKGROUND_REFRESH (1)
141/* Get possible actions for fast auto attack. */
142#define REQEST_BACKGROUND_FAST_AUTO_ATTACK (2)
143
144/* A unit will auto attack with the following actions. */
160
161/* A unit will not auto attack if any of these actions are legal. */
209 /* Actually an attack but it needs a target to be specified. */
211 /* End the action list. */
213};
214
215/************************************************************************/
219{
220 if (NULL != invisible.cities) {
221 city_list_iterate(invisible.cities, pcity) {
222 idex_unregister_city(&wld, pcity);
225
227 invisible.cities = NULL;
228 }
229
230 if (NULL != invisible.placeholder) {
231 free(invisible.placeholder);
232 invisible.placeholder = NULL;
233 }
234}
235
236/************************************************************************/
239static void packhand_init(void)
240{
242
243 invisible.cities = city_list_new();
244
245 /* Can't use player_new() here, as it will register the player. */
246 invisible.placeholder = fc_calloc(1, sizeof(*invisible.placeholder));
247 memset(invisible.placeholder, 0, sizeof(*invisible.placeholder));
248 /* Set some values to prevent bugs ... */
249 sz_strlcpy(invisible.placeholder->name, ANON_PLAYER_NAME);
250 sz_strlcpy(invisible.placeholder->username, _(ANON_USER_NAME));
251 invisible.placeholder->unassigned_user = TRUE;
252 sz_strlcpy(invisible.placeholder->ranked_username, ANON_USER_NAME);
253 invisible.placeholder->unassigned_ranked = TRUE;
254}
255
256/************************************************************************/
264static struct unit *unpackage_unit(const struct packet_unit_info *packet)
265{
267 NULL,
268 utype_by_number(packet->type),
269 packet->veteran);
270
271 /* Owner, veteran, and type fields are already filled in by
272 * unit_virtual_create() */
274 punit->id = packet->id;
276 punit->facing = packet->facing;
277 punit->homecity = packet->homecity;
279 punit->upkeep[o] = packet->upkeep[o];
281 punit->moves_left = packet->movesleft;
282 punit->hp = packet->hp;
283 punit->activity = packet->activity;
285
286 if (packet->activity_tgt == EXTRA_NONE) {
288 } else {
290 }
291
294
295 if (packet->changed_from_tgt == EXTRA_NONE) {
297 } else {
299 }
300
302 punit->fuel = packet->fuel;
304 punit->paradropped = packet->paradropped;
305 punit->done_moving = packet->done_moving;
306 punit->stay = packet->stay;
307 punit->birth_turn = packet->birth_turn;
309
310 /* Transporter / transporting information. */
311 punit->client.occupied = packet->occupied;
312 if (packet->transported) {
314 } else {
316 }
317 if (packet->carrying >= 0) {
319 } else {
321 }
322
323 punit->battlegroup = packet->battlegroup;
324 punit->has_orders = packet->has_orders;
325 punit->orders.length = packet->orders_length;
326 punit->orders.index = packet->orders_index;
327 punit->orders.repeat = packet->orders_repeat;
329 if (punit->has_orders) {
330 int i;
331
332 for (i = 0; i < packet->orders_length; i++) {
333 /* Just an assert. The client doesn't use the action data. */
335 || action_id_exists(packet->orders[i].action));
336 }
338 = fc_malloc(punit->orders.length * sizeof(*punit->orders.list));
339 memcpy(punit->orders.list, packet->orders,
340 punit->orders.length * sizeof(*punit->orders.list));
341 }
342
346
348
349 return punit;
350}
351
352/************************************************************************/
362static struct unit *
364{
366 NULL,
367 utype_by_number(packet->type),
368 0);
369
370 /* Owner and type fields are already filled in by unit_virtual_create() */
371 punit->id = packet->id;
373 punit->facing = packet->facing;
375 punit->veteran = packet->veteran;
376 punit->hp = packet->hp;
377 punit->activity = packet->activity;
378
379 if (packet->activity_tgt == EXTRA_NONE) {
381 } else {
383 }
384
385 /* Transporter / transporting information. */
386 punit->client.occupied = packet->occupied;
387 if (packet->transported) {
389 } else {
391 }
392
393 return punit;
394}
395
396/************************************************************************/
400void handle_server_join_reply(bool you_can_join, const char *message,
401 const char *capability,
402 const char *challenge_file, int conn_id)
403{
404 const char *s_capability = client.conn.capability;
405
406 conn_set_capability(&client.conn, capability);
408
409 if (you_can_join) {
411
412 log_verbose("join game accept:%s", message);
414 client.conn.id = conn_id;
415
418
422 }
423
425#ifdef EMERGENCY_VERSION
426 client_info.emerg_version = EMERGENCY_VERSION;
427#else
428 client_info.emerg_version = 0;
429#endif
431 sizeof(client_info.distribution));
433
434 /* We could always use hack, verify we're local */
435#ifdef FREECIV_DEBUG
436 if (!hackless)
437#endif /* FREECIV_DEBUG */
438 {
439 send_client_wants_hack(challenge_file);
440 }
441
443 } else {
445 _("You were rejected from the game: %s"), message);
446 client.conn.id = -1; /* not in range of conn_info id */
447
448 if (auto_connect) {
449 log_normal(_("You were rejected from the game: %s"), message);
450 }
452
454 }
456 return;
457 }
458 output_window_printf(ftc_client, _("Client capability string: %s"),
460 output_window_printf(ftc_client, _("Server capability string: %s"),
462}
463
464/************************************************************************/
468void handle_city_remove(int city_id)
469{
470 struct city *pcity = game_city_by_number(city_id);
472
473 fc_assert_ret_msg(NULL != pcity, "Bad city %d.", city_id);
474
476
477 agents_city_remove(pcity);
479 client_remove_city(pcity);
480
481 /* Update menus if the focus unit is on the tile. */
482 if (need_menus_update) {
483 menus_update();
484 }
485}
486
487/************************************************************************/
491void handle_unit_remove(int unit_id)
492{
493 struct unit *punit = game_unit_by_number(unit_id);
494 struct unit_list *cargos;
495 struct player *powner;
497
498 if (!punit) {
499 log_error("Server wants us to remove unit id %d, "
500 "but we don't know about this unit!",
501 unit_id);
502 return;
503 }
504
505 /* Close the action selection dialog if the actor unit is lost. */
508 /* Open another action selection dialog if there are other actors in the
509 * current selection that want a decision. */
511 }
512
514 powner = unit_owner(punit);
515
516 /* Unload cargo if this is a transporter. */
518 if (unit_list_size(cargos) > 0) {
522 }
523
524 /* Unload unit if it is transported. */
527 }
529
533
534 if (!client_has_player() || powner == client_player()) {
537 }
539 }
540}
541
542/************************************************************************/
549
550/************************************************************************/
553void handle_team_name_info(int team_id, const char *team_name)
554{
555 struct team_slot *tslot = team_slot_by_number(team_id);
556
560}
561
562/************************************************************************/
569{
570 bool show_combat = FALSE;
573
574 if (punit0 && punit1) {
576 packet->attacker_hp, packet->defender_hp,
577 packet->make_att_veteran, packet->make_def_veteran);
584 } else {
586 }
588 }
589
590 if (show_combat) {
591 int hp0 = packet->attacker_hp, hp1 = packet->defender_hp;
592
594 unit_type_get(punit0)->sound_fight_alt,
595 NULL);
597 unit_type_get(punit1)->sound_fight_alt,
598 NULL);
599
602 } else {
603 punit0->hp = hp0;
604 punit1->hp = hp1;
605
609 }
610 }
611 if (packet->make_att_veteran && punit0) {
612 punit0->veteran++;
614 }
615 if (packet->make_def_veteran && punit1) {
616 punit1->veteran++;
618 }
619 }
620}
621
622/************************************************************************/
628static bool update_improvement_from_packet(struct city *pcity,
629 struct impr_type *pimprove,
630 bool have_impr)
631{
632 if (have_impr) {
633 if (pcity->built[improvement_index(pimprove)].turn <= I_NEVER) {
634 city_add_improvement(pcity, pimprove);
635 return TRUE;
636 }
637 } else {
638 if (pcity->built[improvement_index(pimprove)].turn > I_NEVER) {
639 city_remove_improvement(pcity, pimprove);
640 return TRUE;
641 }
642 }
643 return FALSE;
644}
645
646/************************************************************************/
650void handle_city_info(const struct packet_city_info *packet)
651{
652 struct universal product;
653 int i;
654 bool popup;
655 bool city_is_new = FALSE;
660 bool name_changed = FALSE;
663 bool production_changed = FALSE;
665 struct unit_list *pfocus_units = get_units_in_focus();
666 struct city *pcity = game_city_by_number(packet->id);
667 struct tile_list *worked_tiles = NULL;
668 struct tile *pcenter = index_to_tile(&(wld.map), packet->tile);
669 struct tile *ptile = NULL;
670 struct player *powner = player_by_number(packet->owner);
671
672 fc_assert_ret_msg(NULL != powner, "Bad player number %d.", packet->owner);
673 fc_assert_ret_msg(NULL != pcenter, "Invalid tile index %d.", packet->tile);
674
676 log_error("handle_city_info() bad production_kind %d.",
677 packet->production_kind);
678 product.kind = VUT_NONE;
679 } else {
681 packet->production_value);
682 if (!universals_n_is_valid(product.kind)) {
683 log_error("handle_city_info() "
684 "production_kind %d with bad production_value %d.",
685 packet->production_kind, packet->production_value);
686 product.kind = VUT_NONE;
687 }
688 }
689
690 if (NULL != pcity) {
691 ptile = city_tile(pcity);
692
693 if (NULL == ptile) {
694 /* Invisible worked city */
695 city_list_remove(invisible.cities, pcity);
697
698 pcity->tile = pcenter;
699 ptile = pcenter;
700 pcity->owner = powner;
701 } else if (city_owner(pcity) != powner) {
702 /* Remember what were the worked tiles. The server won't
703 * send them to us again. */
705 ptile, pworked, _index, _x, _y) {
706 if (pcity == tile_worked(pworked)) {
707 if (NULL == worked_tiles) {
708 worked_tiles = tile_list_new();
709 }
710 tile_list_append(worked_tiles, pworked);
711 }
713 client_remove_city(pcity);
714 pcity = NULL;
716 }
717 }
718
719 if (NULL == pcity) {
721 pcity = create_city_virtual(powner, pcenter, packet->name);
722 pcity->id = packet->id;
723 idex_register_city(&wld, pcity);
725 } else if (pcity->id != packet->id) {
726 log_error("handle_city_info() city id %d != id %d.",
727 pcity->id, packet->id);
728 return;
729 } else if (ptile != pcenter) {
730 log_error("handle_city_info() city tile (%d, %d) != (%d, %d).",
731 TILE_XY(ptile), TILE_XY(pcenter));
732 return;
733 } else {
734 name_changed = (fc_strncmp(packet->name, pcity->name, MAX_LEN_CITYNAME));
735
736 while (trade_route_list_size(pcity->routes) > packet->trade_route_count) {
737 struct trade_route *proute = trade_route_list_get(pcity->routes, -1);
738
742 }
743
744 /* Descriptions should probably be updated if the
745 * city name, production or time-to-grow changes.
746 * Note that if either the food stock or surplus
747 * have changed, the time-to-grow is likely to
748 * have changed as well. */
752 || pcity->surplus[O_SHIELD] != packet->surplus[O_SHIELD]
753 || pcity->shield_stock != packet->shield_stock))
755 && (pcity->food_stock != packet->food_stock
756 || pcity->surplus[O_FOOD] != packet->surplus[O_FOOD]))
758
759 city_name_set(pcity, packet->name);
760 }
761
762 pcity->original = player_by_number(packet->original);
763
764 /* Check data */
765 city_size_set(pcity, 0);
766 for (i = 0; i < FEELING_LAST; i++) {
767 pcity->feel[CITIZEN_HAPPY][i] = packet->ppl_happy[i];
768 pcity->feel[CITIZEN_CONTENT][i] = packet->ppl_content[i];
769 pcity->feel[CITIZEN_UNHAPPY][i] = packet->ppl_unhappy[i];
770 pcity->feel[CITIZEN_ANGRY][i] = packet->ppl_angry[i];
771 }
772 for (i = 0; i < CITIZEN_LAST; i++) {
773 city_size_add(pcity, pcity->feel[i][FEELING_FINAL]);
774 }
776 pcity->specialists[sp] = packet->specialists[sp];
777 city_size_add(pcity, pcity->specialists[sp]);
779
780 if (city_size_get(pcity) != packet->size) {
781 log_error("handle_city_info() "
782 "%d citizens not equal %d city size in \"%s\".",
783 city_size_get(pcity), packet->size, city_name_get(pcity));
784 city_size_set(pcity, packet->size);
785 }
786
787 pcity->history = packet->history;
788 pcity->client.culture = packet->culture;
789 pcity->client.buy_cost = packet->buy_cost;
790
791 pcity->city_radius_sq = packet->city_radius_sq;
792
793 pcity->city_options = packet->city_options;
794 pcity->wlcb = packet->wl_cb;
795
796 pcity->acquire_t = packet->acquire_type;
797
798 if (pcity->surplus[O_SCIENCE] != packet->surplus[O_SCIENCE]
799 || pcity->surplus[O_SCIENCE] != packet->surplus[O_SCIENCE]
800 || pcity->waste[O_SCIENCE] != packet->waste[O_SCIENCE]
801 || (pcity->unhappy_penalty[O_SCIENCE]
802 != packet->unhappy_penalty[O_SCIENCE])
803 || pcity->prod[O_SCIENCE] != packet->prod[O_SCIENCE]
804 || pcity->citizen_base[O_SCIENCE] != packet->citizen_base[O_SCIENCE]
805 || pcity->usage[O_SCIENCE] != packet->usage[O_SCIENCE]) {
807 }
808
809 pcity->food_stock = packet->food_stock;
810 if (pcity->shield_stock != packet->shield_stock) {
812 pcity->shield_stock = packet->shield_stock;
813 }
814 pcity->pollution = packet->pollution;
815 pcity->illness_trade = packet->illness_trade;
816
817 if (!are_universals_equal(&pcity->production, &product)) {
818 production_changed = TRUE;
819 }
820 /* Need to consider shield stock/surplus for unit dialog as used build
821 * slots may change, affecting number of "in-progress" units. */
822 if ((city_is_new && VUT_UTYPE == product.kind)
823 || (production_changed && (VUT_UTYPE == pcity->production.kind
824 || VUT_UTYPE == product.kind))
825 || pcity->surplus[O_SHIELD] != packet->surplus[O_SHIELD]
828 }
829 pcity->production = product;
830
832 pcity->surplus[o] = packet->surplus[o];
833 pcity->waste[o] = packet->waste[o];
834 pcity->unhappy_penalty[o] = packet->unhappy_penalty[o];
835 pcity->prod[o] = packet->prod[o];
836 pcity->citizen_base[o] = packet->citizen_base[o];
837 pcity->usage[o] = packet->usage[o];
839
840#ifdef DONE_BY_create_city_virtual
841 if (city_is_new) {
842 worklist_init(&pcity->worklist);
843
844 for (i = 0; i < ARRAY_SIZE(pcity->built); i++) {
845 pcity->built[i].turn = I_NEVER;
846 }
847 }
848#endif /* DONE_BY_create_city_virtual */
849
850 worklist_copy(&pcity->worklist, &packet->worklist);
851
852 pcity->airlift = packet->airlift;
853 pcity->did_buy = packet->did_buy;
854 pcity->did_sell = packet->did_sell;
855 pcity->was_happy = packet->was_happy;
856 pcity->had_famine = packet->had_famine;
857
858 pcity->turn_founded = packet->turn_founded;
859 pcity->turn_last_built = packet->turn_last_built;
860
862 log_error("handle_city_info() bad changed_from_kind %d.",
863 packet->changed_from_kind);
864 product.kind = VUT_NONE;
865 } else {
867 packet->changed_from_value);
868 if (!universals_n_is_valid(product.kind)) {
869 log_error("handle_city_info() bad changed_from_value %d.",
870 packet->changed_from_value);
871 product.kind = VUT_NONE;
872 }
873 }
874 pcity->changed_from = product;
875
877 pcity->disbanded_shields = packet->disbanded_shields;
878 pcity->caravan_shields = packet->caravan_shields;
880
881 improvement_iterate(pimprove) {
882 bool have = BV_ISSET(packet->improvements, improvement_index(pimprove));
883
884 if (have && !city_is_new
885 && pcity->built[improvement_index(pimprove)].turn <= I_NEVER) {
886 audio_play_sound(pimprove->soundtag, pimprove->soundtag_alt,
887 pimprove->soundtag_alt2);
888 }
890 update_improvement_from_packet(pcity, pimprove, have);
892
893 /* We should be able to see units in the city. But for a diplomat
894 * investigating an enemy city we can't. In that case we don't update
895 * the occupied flag at all: it's already been set earlier and we'll
896 * get an update if it changes. */
898 pcity->client.occupied
899 = (unit_list_size(pcity->tile->units) > 0);
900 }
901
902 pcity->client.walls = packet->walls;
903 if (pcity->client.walls > NUM_WALL_TYPES) {
904 pcity->client.walls = NUM_WALL_TYPES;
905 }
906 pcity->style = packet->style;
907 pcity->capital = packet->capital;
908 if (packet->capital == CAPITAL_PRIMARY) {
909 powner->primary_capital_id = pcity->id;
910 } else if (powner->primary_capital_id == pcity->id) {
911 powner->primary_capital_id = 0;
912 }
913 pcity->client.city_image = packet->city_image;
914 pcity->steal = packet->steal;
915
916 pcity->client.happy = city_happy(pcity);
917 pcity->client.unhappy = city_unhappy(pcity);
918
920 && powner == client.conn.playing
922 || packet->diplomat_investigate;
923
924 city_packet_common(pcity, pcenter, powner, worked_tiles,
926
928 agents_city_new(pcity);
929 } else {
930 agents_city_changed(pcity);
931 }
932
933 /* Update the description if necessary. */
936 }
937
938 /* Update focus unit info label if necessary. */
939 if (name_changed) {
941 if (pfocus_unit->homecity == pcity->id) {
943 break;
944 }
946 }
947
948 /* Update the science dialog if necessary. */
951 }
952
953 /* Update the units dialog if necessary. */
956 }
957
958 /* Update the economy dialog if necessary. */
961 }
962
963 /* Update the panel text (including civ population). */
965
966 /* Update caravan dialog */
967 if ((production_changed || shield_stock_changed)
968 && action_selection_target_city() == pcity->id) {
972 city_tile(pcity)->index,
975 }
976
979 || (city_is_new && 0 < city_num_trade_routes(pcity)))) {
981 }
982}
983
984/************************************************************************/
988{
989 struct city *pcity = game_city_by_number(packet->id);
990
991 /* The nationality of the citizens. */
992 if (pcity != NULL && game.info.citizen_nationality) {
993 int i;
994
995 citizens_init(pcity);
996 for (i = 0; i < packet->nationalities_count; i++) {
998 packet->nation_citizens[i]);
999 }
1000 fc_assert(citizens_count(pcity) == city_size_get(pcity));
1001 }
1002}
1003
1004/************************************************************************/
1008{
1009 struct city *pcity = game_city_by_number(packet->id);
1010
1011 if (pcity != NULL) {
1012 city_rally_point_receive(packet, pcity);
1013 }
1014}
1015
1016/************************************************************************/
1021static void city_packet_common(struct city *pcity, struct tile *pcenter,
1022 struct player *powner,
1023 struct tile_list *worked_tiles,
1024 bool is_new, bool popup, bool investigate)
1025{
1026 if (NULL != worked_tiles) {
1027 /* We need to transfer the worked infos because the server will assume
1028 * those infos are kept in our side and won't send to us again. */
1029 tile_list_iterate(worked_tiles, pwork) {
1030 tile_set_worked(pwork, pcity);
1032 tile_list_destroy(worked_tiles);
1033 }
1034
1035 if (is_new) {
1036 tile_set_worked(pcenter, pcity); /* is_free_worked() */
1037 city_list_prepend(powner->cities, pcity);
1038
1039 if (client_is_global_observer() || powner == client_player()) {
1041 }
1042
1044 unit_list_iterate(pp->units, punit) {
1045 if (punit->homecity == pcity->id) {
1047 }
1050
1052 } else {
1053 if (client_is_global_observer() || powner == client_player()) {
1055 }
1056 }
1057
1058 if (can_client_change_view()) {
1060 }
1061
1062 if (city_workers_display == pcity) {
1064 }
1065
1066 if (investigate) {
1067 /* Commit the collected supported and present units. */
1069 /* We got units, let's move the unit lists. */
1071
1073 pcity->client.info_units_present =
1076
1081 } else {
1082 /* We didn't get any unit, let's clear the unit lists. */
1084
1087 }
1088 }
1089
1090 if (popup
1091 && NULL != client.conn.playing
1094 menus_update();
1095 if (!city_dialog_is_open(pcity)) {
1096 popup_city_dialog(pcity);
1097 }
1098 }
1099
1100 if (!is_new
1102 refresh_city_dialog(pcity);
1103 }
1104
1105 /* update menus if the focus unit is on the tile. */
1107 menus_update();
1108 }
1109
1110 if (is_new) {
1111 log_debug("(%d,%d) creating city %d, %s %s", TILE_XY(pcenter),
1112 pcity->id, nation_rule_name(nation_of_city(pcity)),
1113 city_name_get(pcity));
1114 }
1115
1117}
1118
1119/************************************************************************/
1124{
1125 struct city *pcity = game_city_by_number(packet->city);
1126 struct trade_route *proute;
1127 bool city_changed = FALSE;
1128
1129 if (pcity == NULL) {
1130 return;
1131 }
1132
1133 proute = trade_route_list_get(pcity->routes, packet->index);
1134 if (proute == NULL) {
1135 fc_assert(trade_route_list_size(pcity->routes) == packet->index);
1136
1137 proute = fc_malloc(sizeof(struct trade_route));
1140 }
1141
1142 proute->partner = packet->partner;
1143 proute->value = packet->value;
1144 proute->dir = packet->direction;
1145 proute->goods = goods_by_number(packet->goods);
1146
1150 }
1151}
1152
1153/************************************************************************/
1159{
1161 bool city_is_new = FALSE;
1162 bool name_changed = FALSE;
1164 struct city *pcity = game_city_by_number(packet->id);
1165 struct tile *pcenter = index_to_tile(&(wld.map), packet->tile);
1166 struct tile *ptile = NULL;
1167 struct tile_list *worked_tiles = NULL;
1168 struct player *powner = player_by_number(packet->owner);
1169 struct player *original = player_by_number(packet->original);
1170 int radius_sq = game.info.init_city_radius_sq;
1171
1172 fc_assert_ret_msg(NULL != powner, "Bad player number %d.", packet->owner);
1173 fc_assert_ret_msg(NULL != pcenter, "Invalid tile index %d.", packet->tile);
1174
1175 if (NULL != pcity) {
1176 ptile = city_tile(pcity);
1177
1178 if (NULL == ptile) {
1179 /* Invisible worked city */
1180 city_list_remove(invisible.cities, pcity);
1181 city_is_new = TRUE;
1182
1183 pcity->tile = pcenter;
1184 pcity->owner = powner;
1185 pcity->original = original;
1186
1188 if (wtile->worked == pcity) {
1190
1191 if (dist_sq > city_map_radius_sq_get(pcity)) {
1193 }
1194 }
1196 } else if (city_owner(pcity) != powner) {
1197 /* Remember what were the worked tiles. The server won't
1198 * send to us again. */
1200 pworked, _index, _x, _y) {
1201 if (pcity == tile_worked(pworked)) {
1202 if (NULL == worked_tiles) {
1203 worked_tiles = tile_list_new();
1204 }
1205 tile_list_append(worked_tiles, pworked);
1206 }
1208 radius_sq = city_map_radius_sq_get(pcity);
1209 client_remove_city(pcity);
1210 pcity = NULL;
1212 }
1213 }
1214
1215 if (NULL == pcity) {
1216 city_is_new = TRUE;
1217 pcity = create_city_virtual(powner, pcenter, packet->name);
1218 pcity->id = packet->id;
1219 pcity->original = original;
1220 city_map_radius_sq_set(pcity, radius_sq);
1221 idex_register_city(&wld, pcity);
1222 } else if (pcity->id != packet->id) {
1223 log_error("handle_city_short_info() city id %d != id %d.",
1224 pcity->id, packet->id);
1225 return;
1226 } else if (city_tile(pcity) != pcenter) {
1227 log_error("handle_city_short_info() city tile (%d, %d) != (%d, %d).",
1228 TILE_XY(city_tile(pcity)), TILE_XY(pcenter));
1229 return;
1230 } else {
1231 name_changed = (fc_strncmp(packet->name, pcity->name, MAX_LEN_CITYNAME));
1232
1233 /* Check if city descriptions should be updated */
1236 }
1237
1238 city_name_set(pcity, packet->name);
1239
1240 memset(pcity->feel, 0, sizeof(pcity->feel));
1241 memset(pcity->specialists, 0, sizeof(pcity->specialists));
1242 }
1243
1244 pcity->specialists[DEFAULT_SPECIALIST] = packet->size;
1245 city_size_set(pcity, packet->size);
1246
1247 /* We can't actually see the internals of the city, but the server tells
1248 * us this much. */
1249 if (pcity->client.occupied != packet->occupied) {
1250 pcity->client.occupied = packet->occupied;
1253 }
1254 }
1255 pcity->client.walls = packet->walls;
1256 if (pcity->client.walls > NUM_WALL_TYPES) {
1257 pcity->client.walls = NUM_WALL_TYPES;
1258 }
1259 pcity->style = packet->style;
1260 pcity->capital = packet->capital;
1261 if (packet->capital == CAPITAL_PRIMARY) {
1262 powner->primary_capital_id = pcity->id;
1263 } else if (powner->primary_capital_id == pcity->id) {
1264 powner->primary_capital_id = 0;
1265 }
1266 pcity->client.city_image = packet->city_image;
1267
1268 pcity->client.happy = packet->happy;
1269 pcity->client.unhappy = packet->unhappy;
1270
1271 improvement_iterate(pimprove) {
1272 /* Don't update the non-visible improvements, they could hide the
1273 * previously seen informations about the city (diplomat investigation).
1274 */
1275 if (is_improvement_visible(pimprove)) {
1276 bool have = BV_ISSET(packet->improvements,
1277 improvement_index(pimprove));
1278 update_improvement_from_packet(pcity, pimprove, have);
1279 }
1281
1282 city_packet_common(pcity, pcenter, powner, worked_tiles,
1284
1286 agents_city_new(pcity);
1287 } else {
1288 agents_city_changed(pcity);
1289 }
1290
1291 /* Update the description if necessary. */
1292 if (update_descriptions) {
1294 }
1295}
1296
1297/************************************************************************/
1300void handle_worker_task(const struct packet_worker_task *packet)
1301{
1302 struct city *pcity = game_city_by_number(packet->city_id);
1303 struct worker_task *ptask = NULL;
1304
1305 if (pcity == NULL
1306 || (pcity->owner != client.conn.playing && !client_is_global_observer())) {
1307 return;
1308 }
1309
1311 if (tile_index(ptask_old->ptile) == packet->tile_id) {
1312 ptask = ptask_old;
1313 break;
1314 }
1316
1317 if (ptask == NULL) {
1318 if (packet->activity == ACTIVITY_LAST) {
1319 return;
1320 } else {
1321 ptask = fc_malloc(sizeof(struct worker_task));
1323 }
1324 } else {
1325 if (packet->activity == ACTIVITY_LAST) {
1327 free(ptask);
1328 ptask = NULL;
1329 }
1330 }
1331
1332 if (ptask != NULL) {
1333 ptask->ptile = index_to_tile(&(wld.map), packet->tile_id);
1334 ptask->act = packet->activity;
1335 if (packet->tgt >= 0) {
1336 ptask->tgt = extra_by_number(packet->tgt);
1337 } else {
1338 ptask->tgt = NULL;
1339 }
1340 ptask->want = packet->want;
1341 }
1342
1343 if (ptask && !worker_task_is_sane(ptask)) {
1344 log_debug("Bad worker task");
1346 free(ptask);
1347 ptask = NULL;
1348 return;
1349 }
1350
1351 refresh_city_dialog(pcity);
1352}
1353
1354/************************************************************************/
1357void handle_new_year(int year, int fragments, int turn)
1358{
1359 game.info.year = year;
1360 game.info.fragment_count = fragments;
1361 /*
1362 * The turn was increased in handle_end_turn()
1363 */
1364 fc_assert(game.info.turn == turn);
1366
1369
1371 menus_update();
1372
1374
1375#if 0
1376 /* This information shouldn't be needed, but if it is this is the only
1377 * way we can get it. */
1378 if (NULL != client.conn.playing) {
1382 }
1383#endif
1384
1387
1390 _("Start of turn %d"), game.info.turn);
1391 }
1392
1394
1395 if (last_turn != turn) {
1396 start_turn();
1397 last_turn = turn;
1398 }
1399}
1400
1401/************************************************************************/
1407{
1408 /* Messagewindow will contain events happened since our own phase ended,
1409 * so player of the first phase and last phase are in equal situation. */
1411}
1412
1413/************************************************************************/
1417void handle_start_phase(int phase)
1418{
1420 /* We are on detached state, let ignore this packet. */
1421 return;
1422 }
1423
1424 if (phase < 0
1426 && phase >= player_count())
1428 && phase >= team_count())) {
1429 log_error("handle_start_phase() illegal phase %d.", phase);
1430 return;
1431 }
1432
1434
1435 game.info.phase = phase;
1436
1437 /* Possibly replace wait cursor with something else */
1438 if (phase == 0) {
1439 /* TODO: Have server set as busy also if switching phase
1440 * is taking long in a alternating phases mode. */
1442 }
1443
1444 if (NULL != client.conn.playing
1445 && is_player_phase(client.conn.playing, phase)) {
1448
1450
1454 }
1455
1457
1459 pcity->client.colored = FALSE;
1461
1465
1467 }
1468
1470}
1471
1472/************************************************************************/
1477{
1478 log_debug("handle_begin_turn()");
1479
1480 /* Server is still considered busy until it handles also the beginning
1481 * of the first phase. */
1482
1484}
1485
1486/************************************************************************/
1491{
1492 log_debug("handle_end_turn()");
1493
1494 /* Make sure wait cursor is in use */
1496
1498
1499 /*
1500 * The local idea of the game.info.turn is increased here since the
1501 * client will get unit updates (reset of move points for example)
1502 * between handle_end_turn() and handle_new_year(). These
1503 * unit updates will look like they did take place in the old turn
1504 * which is incorrect. If we get the authoritative information about
1505 * the game.info.turn in handle_new_year() we will check it.
1506 */
1507 game.info.turn++;
1508
1509 log_verbose(_("Beginning turn %d"), game.info.turn);
1510
1512}
1513
1514/************************************************************************/
1518{
1519 const char *sound_tag = get_event_tag(type);
1520
1521 if (sound_tag) {
1522 audio_play_sound(sound_tag, NULL, NULL);
1523 }
1524}
1525
1526/************************************************************************/
1530void handle_chat_msg(const struct packet_chat_msg *packet)
1531{
1532 handle_event(packet->message,
1533 index_to_tile(&(wld.map), packet->tile),
1534 packet->event,
1535 packet->turn,
1536 packet->phase,
1537 packet->conn_id);
1538}
1539
1540/************************************************************************/
1551{
1552 handle_event(packet->message,
1553 index_to_tile(&(wld.map), packet->tile),
1554 packet->event,
1555 packet->turn,
1556 packet->phase,
1557 packet->conn_id);
1558}
1559
1560/************************************************************************/
1565{
1566 popup_connect_msg(_("Welcome"), message);
1567}
1568
1569/************************************************************************/
1573void handle_server_info(const char *version_label, int major_version,
1574 int minor_version, int patch_version, int emerg_version)
1575{
1576 if (emerg_version > 0) {
1577 log_verbose("Server has version %d.%d.%d.%d%s",
1578 major_version, minor_version, patch_version, emerg_version,
1579 version_label);
1580 } else {
1581 log_verbose("Server has version %d.%d.%d%s",
1582 major_version, minor_version, patch_version, version_label);
1583 }
1584}
1585
1586/************************************************************************/
1589void handle_page_msg(const char *caption, const char *headline,
1590 enum event_type event, int len, int parts)
1591{
1592 if (!client_has_player()
1594 || event != E_BROADCAST_REPORT) {
1595 if (page_msg_report.parts > 0) {
1596 /* Previous one was never finished */
1597 free(page_msg_report.caption);
1598 free(page_msg_report.headline);
1599 free(page_msg_report.lines);
1600 }
1601 page_msg_report.len = len;
1602 page_msg_report.event = event;
1605 page_msg_report.parts = parts;
1606 page_msg_report.lines = fc_malloc(len + 1);
1607 page_msg_report.lines[0] = '\0';
1608
1609 if (parts == 0) {
1610 /* Empty report - handle as if last part was just received. */
1611 page_msg_report.parts = 1;
1613 }
1614 }
1615}
1616
1617/************************************************************************/
1621{
1622 if (page_msg_report.lines != NULL) {
1623 /* We have already decided to show the message at the time we got
1624 * the header packet. */
1626 page_msg_report.parts--;
1627
1628 if (page_msg_report.parts == 0) {
1629 /* This is the final part */
1631 page_msg_report.headline,
1632 page_msg_report.lines);
1634
1635 free(page_msg_report.caption);
1636 free(page_msg_report.headline);
1637 free(page_msg_report.lines);
1638 page_msg_report.lines = NULL;
1639 }
1640 }
1641}
1642
1643/************************************************************************/
1646void handle_unit_info(const struct packet_unit_info *packet)
1647{
1648 struct unit *punit;
1649
1650 punit = unpackage_unit(packet);
1654 }
1655}
1656
1657/**********************************************************************/
1663{
1666 if (utype_can_do_action(unit_type_get(punit), act_id)) {
1667 /* An auto action like auto attack could be legal. Check for those
1668 * at once so they won't have to wait for player focus. */
1670 punit->id,
1673 EXTRA_NONE,
1675 return;
1676 }
1678 }
1679
1680 /* This should be done in the foreground */
1682}
1683
1684/************************************************************************/
1701{
1702 struct city *pcity;
1703 struct unit *punit;
1704 bool need_menus_update = FALSE;
1707 bool repaint_unit = FALSE;
1708 bool repaint_city = FALSE; /* regards unit's homecity */
1709 struct tile *old_tile = NULL;
1710 bool check_focus = FALSE; /* conservative focus change */
1711 bool moved = FALSE;
1712 bool ret = FALSE;
1713
1715 if (!punit && game_unit_by_number(packet_unit->id)) {
1716 /* This means unit has changed owner. We deal with this here
1717 * by simply deleting the old one and creating a new one. */
1719 }
1720
1721 if (punit) {
1722 /* In some situations, the size of repaint units require can change;
1723 * in particular, city-builder units sometimes get a potential-city
1724 * outline, but to speed up redraws we don't repaint this whole area
1725 * unnecessarily. We need to ensure that when the footprint shrinks,
1726 * old bits aren't left behind on the canvas.
1727 * If the current (old) status of the unit is such that it gets a large
1728 * repaint, as a special case, queue a large repaint immediately, to
1729 * schedule the correct amount/location to be redrawn; but rely on the
1730 * repaint being deferred until the unit is updated, so that what's
1731 * drawn reflects the new status (e.g., no city outline). */
1734 }
1735
1736 ret = TRUE;
1737 punit->activity_count = packet_unit->activity_count;
1739 if (punit->ssa_controller != packet_unit->ssa_controller) {
1740 punit->ssa_controller = packet_unit->ssa_controller;
1742 /* AI is set: may change focus */
1743 /* AI is cleared: keep focus */
1744 if (packet_unit->ssa_controller != SSA_NONE
1745 && unit_is_in_focus(punit)) {
1746 check_focus = TRUE;
1747 }
1748 }
1749
1750 if (punit->facing != packet_unit->facing) {
1751 punit->facing = packet_unit->facing;
1753 }
1754
1755 if (punit->activity != packet_unit->activity
1756 || punit->activity_target == packet_unit->activity_target
1757 || punit->client.transported_by != packet_unit->client.transported_by
1758 || punit->client.occupied != packet_unit->client.occupied
1759 || punit->has_orders != packet_unit->has_orders
1760 || punit->orders.repeat != packet_unit->orders.repeat
1761 || punit->orders.vigilant != packet_unit->orders.vigilant
1762 || punit->orders.index != packet_unit->orders.index) {
1763
1764 /*** Change in activity or activity's target. ***/
1765
1766 /* May change focus if focus unit gets a new activity.
1767 * But if new activity is Idle, it means user specifically selected
1768 * the unit */
1770 && (packet_unit->activity != ACTIVITY_IDLE
1771 || packet_unit->has_orders)) {
1772 check_focus = TRUE;
1773 }
1774
1776
1777 /* Wakeup Focus */
1779 && NULL != client.conn.playing
1783 && packet_unit->activity == ACTIVITY_IDLE
1786 /* many wakeup units per tile are handled */
1788 check_focus = FALSE; /* and keep it */
1789 }
1790
1791 punit->activity = packet_unit->activity;
1792 punit->activity_target = packet_unit->activity_target;
1793
1795 != packet_unit->client.transported_by) {
1796 if (packet_unit->client.transported_by == -1) {
1797 /* The unit was unloaded from its transport. The check for a new
1798 * transport is done below. */
1800 }
1801
1802 punit->client.transported_by = packet_unit->client.transported_by;
1803 }
1804
1805 if (punit->client.occupied != packet_unit->client.occupied) {
1807 /* Special case: (un)loading a unit in a transporter on the same
1808 *tile as the focus unit may (dis)allow the focus unit to be
1809 * loaded. Thus the orders->(un)load menu item needs updating. */
1811 }
1812 punit->client.occupied = packet_unit->client.occupied;
1813 }
1814
1815 punit->has_orders = packet_unit->has_orders;
1816 punit->orders.length = packet_unit->orders.length;
1817 punit->orders.index = packet_unit->orders.index;
1818 punit->orders.repeat = packet_unit->orders.repeat;
1819 punit->orders.vigilant = packet_unit->orders.vigilant;
1820
1821 /* We cheat by just stealing the packet unit's list. */
1822 if (punit->orders.list) {
1824 }
1825 punit->orders.list = packet_unit->orders.list;
1826 packet_unit->orders.list = NULL;
1827
1828 if (NULL == client.conn.playing
1831 }
1832 } /*** End of Change in activity or activity's target. ***/
1833
1834 /* These two lines force the menus to be updated as appropriate when
1835 * the focus unit changes. */
1836 if (unit_is_in_focus(punit)) {
1838 }
1839
1840 if (punit->homecity != packet_unit->homecity) {
1841 /* change homecity */
1842 struct city *hcity;
1843
1845 unit_list_remove(hcity->units_supported, punit);
1847 }
1848
1849 punit->homecity = packet_unit->homecity;
1851 unit_list_prepend(hcity->units_supported, punit);
1853 }
1854
1855 /* This can change total upkeep figures */
1857 }
1858
1859 if (punit->hp != packet_unit->hp) {
1860 /* hp changed */
1861 punit->hp = packet_unit->hp;
1863 }
1864
1866 /* Unit type has changed (been upgraded) */
1867 struct city *ccity = tile_city(unit_tile(punit));
1868
1872 if (ccity != NULL && (ccity->id != punit->homecity)) {
1874 }
1875 if (unit_is_in_focus(punit)) {
1876 /* Update the orders menu -- the unit might have new abilities */
1878 }
1880 }
1881
1882 /* May change focus if an attempted move or attack exhausted unit */
1883 if (punit->moves_left != packet_unit->moves_left
1884 && unit_is_in_focus(punit)) {
1885 check_focus = TRUE;
1886 }
1887
1889 /*** Change position ***/
1890 struct city *ccity = tile_city(unit_tile(punit));
1891
1893 moved = TRUE;
1894
1895 /* Show where the unit is going. */
1897
1898 if (ccity != NULL) {
1900 /* Unit moved out of a city - update the occupied status. */
1901 bool new_occupied =
1902 (unit_list_size(ccity->tile->units) > 0);
1903
1904 if (ccity->client.occupied != new_occupied) {
1905 ccity->client.occupied = new_occupied;
1909 }
1910 }
1911 }
1912
1913 if (ccity->id == punit->homecity) {
1915 } else {
1917 }
1918 }
1919
1920 if ((ccity = tile_city(unit_tile(punit)))) {
1922 /* Unit moved into a city - obviously it's occupied. */
1923 if (!ccity->client.occupied) {
1924 ccity->client.occupied = TRUE;
1928 }
1929 }
1930 }
1931
1932 if (ccity->id == punit->homecity) {
1934 } else {
1936 }
1937 }
1938
1939 } /*** End of Change position. ***/
1940
1941 if (repaint_city || repaint_unit) {
1942 /* We repaint the city if the unit itself needs repainting or if
1943 * there is a special city-only redrawing to be done. */
1944 if ((pcity = game_city_by_number(punit->homecity))) {
1945 refresh_city_dialog(pcity);
1946 }
1948 && tile_city(unit_tile(punit)) != pcity) {
1949 /* Refresh the city we're occupying too. */
1951 }
1952 }
1953
1955 != packet_unit->upkeep[O_GOLD]);
1956 /* unit upkeep information */
1958 punit->upkeep[o] = packet_unit->upkeep[o];
1960
1961 punit->nationality = packet_unit->nationality;
1962 punit->veteran = packet_unit->veteran;
1963 punit->moves_left = packet_unit->moves_left;
1964 punit->fuel = packet_unit->fuel;
1965 punit->goto_tile = packet_unit->goto_tile;
1966 punit->paradropped = packet_unit->paradropped;
1967 punit->stay = packet_unit->stay;
1968 if (punit->done_moving != packet_unit->done_moving) {
1969 punit->done_moving = packet_unit->done_moving;
1970 check_focus = TRUE;
1971 }
1972
1973 /* This won't change punit; it enqueues the call for later handling. */
1976
1977 if ((punit->action_decision_want != packet_unit->action_decision_want
1979 != packet_unit->action_decision_tile))
1981 /* The unit wants the player to decide. */
1983 /* Pop up an action selection dialog if the unit has focus or give
1984 * the unit higher priority in the focus queue if not. */
1985 punit->action_decision_tile = packet_unit->action_decision_tile;
1987 check_focus = TRUE;
1988 } else {
1989 /* Refresh already open action selection dialog. */
1993 tile_index(
1994 packet_unit->action_decision_tile),
1997 }
1998 }
1999 punit->action_decision_want = packet_unit->action_decision_want;
2000 punit->action_decision_tile = packet_unit->action_decision_tile;
2001 } else {
2002 /*** Create new unit ***/
2005
2008
2010
2011 if ((pcity = game_city_by_number(punit->homecity))) {
2013 }
2014
2015 log_debug("New %s %s id %d (%d %d) hc %d %s",
2019 (pcity ? city_name_get(pcity) : "(unknown)"));
2020
2023
2024 /* Check if we should link cargo units.
2025 * (This might be necessary if the cargo info was sent to us before
2026 * this transporter.) */
2027 if (punit->client.occupied) {
2029 if (aunit->client.transported_by == punit->id) {
2030 fc_assert(aunit->transporter == NULL);
2032 }
2034 }
2035
2036 if ((pcity = tile_city(unit_tile(punit)))) {
2037 /* The unit is in a city - obviously it's occupied. */
2038 pcity->client.occupied = TRUE;
2039 }
2040
2042 /* The unit wants the player to decide. */
2044 check_focus = TRUE;
2045 }
2046
2048 } /*** End of Create new unit ***/
2049
2051
2052 /* Check if we have to load the unit on a transporter. */
2053 if (punit->client.transported_by != -1) {
2054 struct unit *ptrans
2055 = game_unit_by_number(packet_unit->client.transported_by);
2056
2057 /* Load unit only if transporter is known by the client.
2058 * (If not, cargo will be loaded later when the transporter info is
2059 * sent to the client.) */
2061 /* First, we have to unload the unit from its old transporter. */
2064#ifdef DEBUG_TRANSPORT
2065 log_debug("load %s (ID: %d) onto %s (ID: %d)",
2068 } else if (ptrans && ptrans == unit_transport_get(punit)) {
2069 log_debug("%s (ID: %d) is loaded onto %s (ID: %d)",
2072 } else {
2073 log_debug("%s (ID: %d) is not loaded", unit_name_translation(punit),
2074 punit->id);
2075#endif /* DEBUG_TRANSPORT */
2076 }
2077 }
2078
2083 /* Update (an possible active) unit select dialog. */
2085 }
2086
2087 if (repaint_unit) {
2089 }
2090
2091 if ((check_focus || get_num_units_in_focus() == 0)
2092 && NULL != client.conn.playing
2096 }
2097
2098 if (need_menus_update) {
2099 menus_update();
2100 }
2101
2105 }
2108 }
2109 }
2110
2111 return ret;
2112}
2113
2114/************************************************************************/
2121{
2122 struct city *pcity = game_city_by_number(packet->city_id);
2123
2124 if (!pcity) {
2125 log_error("Investigate city: unknown city id %d!",
2126 packet->city_id);
2127 return;
2128 }
2129
2130 /* Start collecting supported and present units. */
2131
2132 /* Ensure we are not already in an investigate cycle. */
2139}
2140
2141/************************************************************************/
2145{
2146}
2147
2148/************************************************************************/
2152{
2153 struct city *pcity;
2154 struct unit *punit;
2155
2156 /* Special case for a diplomat/spy investigating a city: The investigator
2157 * needs to know the supported and present units of a city, whether or not
2158 * they are fogged. So, we send a list of them all before sending the city
2159 * info. */
2161 || packet->packet_use == UNIT_INFO_CITY_PRESENT) {
2162
2163 pcity = game_city_by_number(packet->info_city_id);
2164 if (!pcity) {
2165 log_error("Investigate city: unknown city id %d!",
2166 packet->info_city_id);
2167 return;
2168 }
2169
2170 /* Append a unit struct to the proper list. */
2171 punit = unpackage_short_unit(packet);
2172 if (packet->packet_use == UNIT_INFO_CITY_SUPPORTED) {
2175 } else {
2179 }
2180
2181 /* Done with special case. */
2182 return;
2183 }
2184
2185 if (player_by_number(packet->owner) == client.conn.playing) {
2186 log_error("handle_unit_short_info() for own unit.");
2187 }
2188
2189 punit = unpackage_short_unit(packet);
2193 }
2194}
2195
2196/************************************************************************/
2199void handle_set_topology(int topology_id, int wrap_id)
2200{
2201 wld.map.topology_id = topology_id;
2202 wld.map.wrap_id = wrap_id;
2203
2204 if (forced_tileset_name[0] == '\0'
2205 && (tileset_map_topo_compatible(topology_id, tileset, NULL)
2208 const char *ts_to_load;
2209
2211
2212 if (ts_to_load != NULL && ts_to_load[0] != '\0' && strcmp(tileset_basename(tileset), ts_to_load)) {
2214 }
2215 }
2216}
2217
2218/************************************************************************/
2222void handle_map_info(const struct packet_map_info *packet)
2223{
2224 int ts_topo;
2225
2226 if (!map_is_empty()) {
2227 map_free(&(wld.map));
2229 }
2230
2231 wld.map.xsize = packet->xsize;
2232 wld.map.ysize = packet->ysize;
2233
2236
2239 _("Map topology (%s) and tileset (%s) incompatible."),
2241 }
2242
2243 wld.map.topology_id = packet->topology_id;
2244 wld.map.wrap_id = packet->wrap_id;
2245
2250 mapdeco_init();
2251
2253
2255
2256 packhand_init();
2257}
2258
2259/************************************************************************/
2263{
2264 bool boot_help;
2266 bool toggle_edit_ui = FALSE;
2267
2268 if (game.info.aifill != pinfo->aifill) {
2270 }
2271 if (game.info.skill_level != pinfo->skill_level) {
2273 }
2274
2275 if (game.info.is_edit_mode != pinfo->is_edit_mode) {
2277
2279 /* Clears the current goto command. */
2281
2282 if (pinfo->is_edit_mode) {
2284 /* Gui didn't handle this */
2286 _("This scenario may have manually set properties the editor "
2287 "cannot handle."));
2289 _("They won't be saved when scenario is saved from the editor."));
2290 }
2291 }
2292 }
2293
2294 game.info = *pinfo;
2295
2296 /* check the values! */
2297#define VALIDATE(_count, _maximum, _string) \
2298 if (game.info._count > _maximum) { \
2299 log_error("handle_game_info(): Too many " _string "; using %d of %d", \
2300 _maximum, game.info._count); \
2301 game.info._count = _maximum; \
2302 }
2303
2304 VALIDATE(granary_num_inis, MAX_GRANARY_INIS, "granary entries");
2305#undef VALIDATE
2306
2311
2313 && game.info.victory_conditions != pinfo->victory_conditions);
2314 if (boot_help) {
2315 boot_help_texts(); /* reboot, after setting game.spacerace */
2316 }
2318 menus_update();
2322 }
2323
2324 if (can_client_change_view()) {
2326 }
2327
2328 if (toggle_edit_ui) {
2330 }
2331
2333}
2334
2335/************************************************************************/
2342
2343/************************************************************************/
2346void handle_timeout_info(float seconds_to_phasedone, float last_turn_change_time)
2347{
2348 if (current_turn_timeout() != 0 && seconds_to_phasedone >= 0) {
2349 /* If this packet is received in the middle of a turn, this value
2350 * represents the number of seconds from now to the end of the turn
2351 * (not from the start of the turn). So we need to restart our
2352 * timer. */
2353 set_seconds_to_turndone(seconds_to_phasedone);
2354 }
2355
2356 game.tinfo.last_turn_change_time = last_turn_change_time;
2357}
2358
2359/************************************************************************/
2371
2372/************************************************************************/
2381
2382/************************************************************************/
2387void handle_player_remove(int playerno)
2388{
2389 struct player_slot *pslot;
2390 struct player *pplayer;
2391 int plr_nbr;
2392
2393 pslot = player_slot_by_number(playerno);
2394
2395 if (NULL == pslot || !player_slot_is_used(pslot)) {
2396 /* Ok, just ignore. */
2397 return;
2398 }
2399
2400 pplayer = player_slot_get_player(pslot);
2401
2402 if (can_client_change_view()) {
2403 close_intel_dialog(pplayer);
2404 }
2405
2406 /* Update the connection informations. */
2407 if (client_player() == pplayer) {
2409 }
2411 pconn->playing = NULL;
2413 conn_list_clear(pplayer->connections);
2414
2415 /* Save player number before player is freed */
2416 plr_nbr = player_number(pplayer);
2417
2418 player_destroy(pplayer);
2419
2422
2425}
2426
2427/************************************************************************/
2433{
2434 bool is_new_nation = FALSE;
2435 bool turn_done_changed = FALSE;
2436 bool new_player = FALSE;
2437 int i;
2438 struct player *pplayer, *my_player;
2439 struct nation_type *pnation;
2440 struct government *pgov, *ptarget_gov;
2441 struct player_slot *pslot;
2442 struct team_slot *tslot;
2443 bool gov_change;
2444
2445 /* Player. */
2446 pslot = player_slot_by_number(pinfo->playerno);
2447 fc_assert(NULL != pslot);
2449 pplayer = player_new(pslot);
2450
2451 if ((pplayer->rgb == NULL) != !pinfo->color_valid
2452 || (pinfo->color_valid
2453 && (pplayer->rgb->r != pinfo->color_red
2454 || pplayer->rgb->g != pinfo->color_green
2455 || pplayer->rgb->b != pinfo->color_blue))) {
2456 struct rgbcolor *prgbcolor;
2457
2458 if (pinfo->color_valid) {
2459 prgbcolor = rgbcolor_new(pinfo->color_red,
2460 pinfo->color_green,
2461 pinfo->color_blue);
2463 } else {
2464 prgbcolor = NULL;
2465 }
2466
2467 player_set_color(pplayer, prgbcolor);
2468 tileset_player_init(tileset, pplayer);
2469
2471
2472 /* Queue a map update -- may need to redraw borders, etc. */
2474 }
2475 pplayer->client.color_changeable = pinfo->color_changeable;
2476
2477 if (new_player) {
2478 /* Initialise client side player data (tile vision). At the moment
2479 * redundant as the values are initialised with 0 due to fc_calloc(). */
2480 client_player_init(pplayer);
2481 }
2482
2483 /* Team. */
2485 fc_assert(NULL != tslot);
2486
2487 /* Should never fail when slot given is not NULL */
2488 team_add_player(pplayer, team_new(tslot));
2489
2490 pnation = nation_by_number(pinfo->nation);
2491 pgov = government_by_number(pinfo->government);
2492 ptarget_gov = government_by_number(pinfo->target_government);
2493
2494 /* Now update the player information. */
2495 sz_strlcpy(pplayer->name, pinfo->name);
2496 sz_strlcpy(pplayer->username, pinfo->username);
2497 pplayer->unassigned_user = pinfo->unassigned_user;
2498
2499 is_new_nation = player_set_nation(pplayer, pnation);
2500 pplayer->is_male = pinfo->is_male;
2501 pplayer->score.game = pinfo->score;
2502 pplayer->was_created = pinfo->was_created;
2503
2504 pplayer->autoselect_weight = pinfo->autoselect_weight;
2505 pplayer->economic.gold = pinfo->gold;
2506 pplayer->economic.tax = pinfo->tax;
2507 pplayer->economic.science = pinfo->science;
2508 pplayer->economic.luxury = pinfo->luxury;
2509 pplayer->client.tech_upkeep = pinfo->tech_upkeep;
2510 gov_change = (!new_player && pgov != pplayer->government
2511 && pplayer->government != NULL);
2512 pplayer->government = pgov;
2513 pplayer->target_government = ptarget_gov;
2514 pplayer->real_embassy = pinfo->real_embassy;
2515 pplayer->gives_shared_vision = pinfo->gives_shared_vision;
2516 pplayer->gives_shared_tiles = pinfo->gives_shared_tiles;
2517 pplayer->style = style_by_number(pinfo->style);
2518
2519 if (pplayer == client.conn.playing) {
2520 bool music_change = FALSE;
2521
2522 if (pplayer->music_style != pinfo->music_style) {
2523 pplayer->music_style = pinfo->music_style;
2525 }
2526 if (pplayer->client.mood != pinfo->mood) {
2527 pplayer->client.mood = pinfo->mood;
2529 }
2530
2531 if (music_change) {
2533 }
2534
2535 if (gov_change) {
2536 audio_play_sound(pgov->sound_str, pgov->sound_alt, pgov->sound_alt2);
2537 }
2538 }
2539
2540 pplayer->history = pinfo->history;
2541 pplayer->client.culture = pinfo->culture;
2542
2543 if (pplayer->economic.infra_points != pinfo->infrapoints) {
2544 pplayer->economic.infra_points = pinfo->infrapoints;
2546 }
2547
2548 /* Don't use player_iterate or player_slot_count here, because we ignore
2549 * the real number of players and we want to read all the datas. */
2550 fc_assert(ARRAY_SIZE(pplayer->ai_common.love) >= ARRAY_SIZE(pinfo->love));
2551 for (i = 0; i < ARRAY_SIZE(pinfo->love); i++) {
2552 pplayer->ai_common.love[i] = pinfo->love[i];
2553 }
2554
2556
2557 pplayer->is_connected = pinfo->is_connected;
2558
2559 for (i = 0; i < B_LAST; i++) {
2560 pplayer->wonders[i] = pinfo->wonders[i];
2561 }
2562
2563 /* Set AI.control. */
2564 if (is_ai(pplayer) != BV_ISSET(pinfo->flags, PLRF_AI)) {
2565 BV_SET_VAL(pplayer->flags, PLRF_AI, BV_ISSET(pinfo->flags, PLRF_AI));
2566 if (pplayer == my_player) {
2567 if (is_ai(my_player)) {
2568 output_window_append(ftc_client, _("AI mode is now ON."));
2569 if (!gui_options.ai_manual_turn_done && !pplayer->phase_done) {
2570 /* End turn immediately */
2572 }
2573 } else {
2574 output_window_append(ftc_client, _("AI mode is now OFF."));
2575 }
2576 }
2577 }
2578
2579 pplayer->flags = pinfo->flags;
2580
2581 pplayer->ai_common.science_cost = pinfo->science_cost;
2582
2583 turn_done_changed = (pplayer->phase_done != pinfo->phase_done
2584 || (BV_ISSET(pplayer->flags, PLRF_AI) !=
2585 BV_ISSET(pinfo->flags, PLRF_AI)));
2586 pplayer->phase_done = pinfo->phase_done;
2587
2588 pplayer->is_ready = pinfo->is_ready;
2589 pplayer->nturns_idle = pinfo->nturns_idle;
2590 pplayer->is_alive = pinfo->is_alive;
2591 pplayer->turns_alive = pinfo->turns_alive;
2592 pplayer->ai_common.barbarian_type = pinfo->barbarian_type;
2593 pplayer->revolution_finishes = pinfo->revolution_finishes;
2594 pplayer->ai_common.skill_level = pinfo->ai_skill_level;
2595
2596 fc_assert(pinfo->multip_count == multiplier_count());
2597 game.control.num_multipliers = pinfo->multip_count;
2598 multipliers_iterate(pmul) {
2599 int idx = multiplier_index(pmul);
2600
2601 pplayer->multipliers[idx].value = pinfo->multiplier[idx];
2602 pplayer->multipliers[idx].target = pinfo->multiplier_target[idx];
2603 pplayer->multipliers[idx].changed = pinfo->multiplier_changed[idx];
2605
2606 /* if the server requests that the client reset, then information about
2607 * connections to this player are lost. If this is the case, insert the
2608 * correct conn back into the player->connections list */
2609 if (conn_list_size(pplayer->connections) == 0) {
2611 if (pplayer == pconn->playing) {
2612 /* insert the controller into first position */
2613 if (pconn->observer) {
2615 } else {
2617 }
2618 }
2620 }
2621
2622
2623 /* The player information is now fully set. Update the GUI. */
2624
2625 if (pplayer == my_player && can_client_change_view()) {
2626 if (turn_done_changed) {
2628 }
2635 menus_update();
2636 }
2637
2639
2642
2643 if (is_new_nation) {
2645
2646 /* When changing nation during a running game, some refreshing is needed.
2647 * This may not be the only one! */
2649 }
2650
2651 if (can_client_change_view()) {
2652 /* Just about any changes above require an update to the intelligence
2653 * dialog. */
2654 update_intel_dialog(pplayer);
2655 }
2656
2659 FALSE);
2660}
2661
2662/************************************************************************/
2666{
2667 struct research *presearch;
2668 bool tech_changed = FALSE;
2669 bool poptechup = FALSE;
2671 int gained_techs_num = 0, i;
2673
2674#ifdef FREECIV_DEBUG
2675 log_verbose("Research nb %d inventions: %s",
2676 packet->id,
2677 packet->inventions);
2678#endif
2679 presearch = research_by_number(packet->id);
2681
2682 poptechup = (presearch->researching != packet->researching
2683 || presearch->tech_goal != packet->tech_goal);
2684 presearch->techs_researched = packet->techs_researched;
2685 if (presearch->future_tech == 0 && packet->future_tech > 0) {
2687 }
2688 presearch->future_tech = packet->future_tech;
2689 presearch->researching = packet->researching;
2690 presearch->client.researching_cost = packet->researching_cost;
2691 presearch->bulbs_researched = packet->bulbs_researched;
2692 presearch->tech_goal = packet->tech_goal;
2693 presearch->client.total_bulbs_prod = packet->total_bulbs_prod;
2694
2696 newstate = packet->inventions[advi] - '0';
2698
2699 if (newstate != oldstate) {
2700 if (TECH_KNOWN == newstate) {
2702 if (A_NONE != advi) {
2704 }
2705 } else if (TECH_KNOWN == oldstate) {
2707 }
2708 }
2710
2712
2713 if (C_S_RUNNING == client_state()) {
2715 if (poptechup && is_human(client_player())) {
2717 }
2719 if (tech_changed) {
2720 /* Some ways a new or lost tech can affect menus:
2721 * - If tech is needed for certain governments, the government
2722 * switching menus need updating.
2723 * - If we just learned/lost bridge building and focus is on a
2724 * worker on a river, the road menu item needs updating. */
2725 menus_update();
2726
2727 script_client_signal_emit("new_tech");
2728
2729 /* If we got a new tech the tech tree news an update. */
2731 }
2732 for (i = 0; i < gained_techs_num; i++) {
2734 }
2735 }
2736 if (editor_is_active()) {
2740 FALSE);
2742 }
2743 }
2744}
2745
2746/************************************************************************/
2750{
2752
2753 if (presearch == NULL) {
2754 log_error("Received unknown research for clearing: %d.", id);
2755 return;
2756 }
2757
2758 /* Do we need to set other fields? */
2759 presearch->researching = A_UNKNOWN;
2760 presearch->future_tech = 0;
2761 presearch->tech_goal = A_UNKNOWN;
2762
2766
2767 if (editor_is_active()) {
2771 FALSE);
2773 }
2774}
2775
2776/************************************************************************/
2780{
2781 struct player *plr1 = player_by_number(packet->plr1);
2782 struct player *plr2 = player_by_number(packet->plr2);
2783 struct player *my_player = client_player();
2784 struct player_diplstate *ds = player_diplstate_get(plr1, plr2);
2786
2787 fc_assert_ret(ds != NULL);
2788
2789 if (client_has_player() && my_player == plr2) {
2790 if (ds->type != packet->type) {
2792 }
2793
2794 /* Check if we detect change to armistice with us. If so,
2795 * ready all units for movement out of the territory in
2796 * question; otherwise they will be disbanded. */
2798 && DS_ARMISTICE == packet->type) {
2801 || tile_owner(unit_tile(punit)) != plr1) {
2802 continue;
2803 }
2806 }
2807 if (punit->activity != ACTIVITY_IDLE) {
2809 }
2811 }
2812 }
2813
2814 ds->type = packet->type;
2815 ds->turns_left = packet->turns_left;
2816 ds->has_reason_to_cancel = packet->has_reason_to_cancel;
2817 ds->contact_turns_left = packet->contact_turns_left;
2818
2821 }
2822
2825 /* An action selection dialog is open and our diplomatic state just
2826 * changed. Find out if the relationship that changed was to a
2827 * potential target. */
2828 struct tile *tgt_tile = NULL;
2829
2830 /* Is a refresh needed because of a unit target? */
2832 struct unit *tgt_unit;
2833
2835
2836 if (tgt_unit != NULL && tgt_unit->owner == plr1) {
2837 /* An update is needed because of this unit target. */
2840 }
2841 }
2842
2843 /* Is a refresh needed because of a city target? */
2845 struct city *tgt_city;
2846
2848
2849 if (tgt_city != NULL && tgt_city->owner == plr1) {
2850 /* An update is needed because of this city target.
2851 * Overwrites any target tile from a unit. */
2854 }
2855 }
2856
2857 if (tgt_tile
2858 || ((tgt_tile = index_to_tile(&(wld.map),
2860 && tile_owner(tgt_tile) == plr1)) {
2861 /* The diplomatic relationship to the target in an open action
2862 * selection dialog have changed. This probably changes
2863 * the set of available actions. */
2867 tgt_tile->index,
2870 }
2871 }
2872}
2873
2874/************************************************************************/
2881{
2882 struct connection *pconn = conn_by_number(pinfo->id);
2884
2885 log_debug("conn_info id%d used%d est%d plr%d obs%d acc%d",
2886 pinfo->id, pinfo->used, pinfo->established, pinfo->player_num,
2887 pinfo->observer, (int) pinfo->access_level);
2888 log_debug("conn_info \"%s\" \"%s\" \"%s\"",
2889 pinfo->username, pinfo->addr, pinfo->capability);
2890
2891 if (!pinfo->used) {
2892 /* Forget the connection */
2893 if (!pconn) {
2894 log_verbose("Server removed unknown connection %d", pinfo->id);
2895 return;
2896 }
2898 pconn = NULL;
2899 } else {
2900 struct player_slot *pslot = player_slot_by_number(pinfo->player_num);
2901 struct player *pplayer = NULL;
2902
2903 if (NULL != pslot) {
2904 pplayer = player_slot_get_player(pslot);
2905 }
2906
2907 if (!pconn) {
2908 log_verbose("Server reports new connection %d %s",
2909 pinfo->id, pinfo->username);
2910
2911 pconn = fc_calloc(1, sizeof(struct connection));
2912 pconn->buffer = NULL;
2913 pconn->send_buffer = NULL;
2914 pconn->ping_time = -1.0;
2915 if (pplayer) {
2917 }
2920 } else {
2921 log_packet("Server reports updated connection %d %s",
2922 pinfo->id, pinfo->username);
2923 if (pplayer != pconn->playing) {
2924 if (NULL != pconn->playing) {
2925 conn_list_remove(pconn->playing->connections, pconn);
2926 }
2927 if (pplayer) {
2929 }
2930 }
2931 }
2932
2933 pconn->id = pinfo->id;
2934 pconn->established = pinfo->established;
2935 pconn->observer = pinfo->observer;
2936 pconn->access_level = pinfo->access_level;
2937 pconn->playing = pplayer;
2938
2939 sz_strlcpy(pconn->username, pinfo->username);
2940 sz_strlcpy(pconn->addr, pinfo->addr);
2941 sz_strlcpy(pconn->capability, pinfo->capability);
2942
2943 if (pinfo->id == client.conn.id) {
2944 /* NB: In this case, pconn is not a duplication of client.conn.
2945 *
2946 * pconn->addr is our address that the server knows whereas
2947 * client.conn.addr is the address to the server. Also,
2948 * pconn->capability stores our capabilites known at server side
2949 * whereas client.conn.capability represents the capabilities of the
2950 * server. */
2951 if (client.conn.playing != pplayer
2952 || client.conn.observer != pinfo->observer) {
2953 /* Our connection state changed, let prepare the changes and reset
2954 * the game. */
2956 }
2957
2958 /* Copy our current state into the static structure (our connection
2959 * to the server). */
2960 client.conn.established = pinfo->established;
2961 client.conn.observer = pinfo->observer;
2962 client.conn.access_level = pinfo->access_level;
2963 client.conn.playing = pplayer;
2964 sz_strlcpy(client.conn.username, pinfo->username);
2965 }
2966 }
2967
2970
2971 if (pinfo->used && pinfo->id == client.conn.id) {
2972 /* For updating the sensitivity of the "Edit Mode" menu item,
2973 * among other things. */
2974 menus_update();
2975 }
2976
2979 }
2980}
2981
2982/************************************************************************/
2986void handle_conn_ping_info(int connections, const int *conn_id,
2987 const float *ping_time)
2988{
2989 int i;
2990
2991 for (i = 0; i < connections; i++) {
2992 struct connection *pconn = conn_by_number(conn_id[i]);
2993
2994 if (!pconn) {
2995 continue;
2996 }
2997
2998 pconn->ping_time = ping_time[i];
2999 log_debug("conn-id=%d, ping=%fs", pconn->id, pconn->ping_time);
3000 }
3001 /* The old_ping_time data is ignored. */
3002
3004}
3005
3006/************************************************************************/
3009void handle_achievement_info(int id, bool gained, bool first)
3010{
3011 struct achievement *pach;
3012
3014 log_error("Received illegal achievement info %d", id);
3015 return;
3016 }
3017
3019
3020 if (gained) {
3021 BV_SET(pach->achievers, player_index(client_player()));
3022 } else {
3023 BV_CLR(pach->achievers, player_index(client_player()));
3024 }
3025
3026 if (first) {
3027 pach->first = client_player();
3028 }
3029}
3030
3031/************************************************************************/
3046static bool spaceship_autoplace(struct player *pplayer,
3047 struct player_spaceship *ship)
3048{
3051
3052 if (next_spaceship_component(pplayer, ship, &place)) {
3054
3055 return TRUE;
3056 }
3057 }
3058
3059 return FALSE;
3060}
3061
3062/************************************************************************/
3066{
3067 struct player_spaceship *ship;
3068 struct player *pplayer = player_by_number(p->player_num);
3069
3070 fc_assert_ret_msg(NULL != pplayer, "Invalid player number %d.",
3071 p->player_num);
3072
3073 ship = &pplayer->spaceship;
3074 ship->state = p->sship_state;
3075 ship->structurals = p->structurals;
3076 ship->components = p->components;
3077 ship->modules = p->modules;
3078 ship->fuel = p->fuel;
3079 ship->propulsion = p->propulsion;
3080 ship->habitation = p->habitation;
3081 ship->life_support = p->life_support;
3082 ship->solar_panels = p->solar_panels;
3083 ship->launch_year = p->launch_year;
3084 ship->population = p->population;
3085 ship->mass = p->mass;
3086 ship->support_rate = p->support_rate;
3087 ship->energy_rate = p->energy_rate;
3088 ship->success_rate = p->success_rate;
3089 ship->travel_time = p->travel_time;
3090 ship->structure = p->structure;
3091
3092 if (pplayer != client_player()) {
3093 refresh_spaceship_dialog(pplayer);
3094 menus_update();
3095 return;
3096 }
3097
3098 if (!spaceship_autoplace(pplayer, ship)) {
3099 /* We refresh the dialog when the packet did *not* cause placing
3100 * of new part. That's because those cases where part is placed, are
3101 * followed by exactly one case where there's no more parts to place -
3102 * we want to refresh the dialog only when that last packet comes. */
3103 refresh_spaceship_dialog(pplayer);
3104 }
3105}
3106
3107/************************************************************************/
3110void handle_tile_info(const struct packet_tile_info *packet)
3111{
3112 enum known_type new_known;
3113 enum known_type old_known;
3114 bool known_changed = FALSE;
3115 bool tile_changed = FALSE;
3116 struct player *powner = player_by_number(packet->owner);
3117 struct player *eowner = player_by_number(packet->extras_owner);
3118 struct extra_type *presource = NULL;
3119 struct terrain *pterrain = terrain_by_number(packet->terrain);
3120 struct tile *ptile = index_to_tile(&(wld.map), packet->tile);
3121
3122 fc_assert_ret_msg(NULL != ptile, "Invalid tile index %d.", packet->tile);
3124
3125 if (packet->resource != MAX_EXTRA_TYPES) {
3126 presource = extra_by_number(packet->resource);
3127 }
3128
3129 if (NULL == tile_terrain(ptile) || pterrain != tile_terrain(ptile)) {
3131 switch (old_known) {
3132 case TILE_UNKNOWN:
3133 tile_set_terrain(ptile, pterrain);
3134 break;
3135 case TILE_KNOWN_UNSEEN:
3136 case TILE_KNOWN_SEEN:
3137 if (NULL != pterrain || TILE_UNKNOWN == packet->known) {
3138 tile_set_terrain(ptile, pterrain);
3139 } else {
3141 log_error("handle_tile_info() unknown terrain (%d, %d).",
3142 TILE_XY(ptile));
3143 }
3144 break;
3145 };
3146 }
3147
3148 if (!BV_ARE_EQUAL(ptile->extras, packet->extras)) {
3149 ptile->extras = packet->extras;
3151 }
3152
3153 tile_changed = tile_changed || (tile_resource(ptile) != presource);
3154
3155 /* always called after setting terrain */
3156 tile_set_resource(ptile, presource);
3157
3158 if (tile_owner(ptile) != powner) {
3159 tile_set_owner(ptile, powner, NULL);
3161 }
3162 if (extra_owner(ptile) != eowner) {
3163 ptile->extras_owner = eowner;
3165 }
3166
3167 if (packet->placing < 0) {
3168 if (ptile->placing != NULL) {
3170 ptile->placing = NULL;
3171 ptile->infra_turns = 0;
3172 }
3173 } else {
3174 struct extra_type *old = ptile->placing;
3175
3176 ptile->placing = extra_by_number(packet->placing);
3177 if (ptile->placing != old
3178 || ptile->infra_turns != packet->place_turn - game.info.turn) {
3180 }
3181 ptile->infra_turns = packet->place_turn - game.info.turn;
3182 }
3183
3184 if (NULL == tile_worked(ptile)
3185 || tile_worked(ptile)->id != packet->worked) {
3186 if (IDENTITY_NUMBER_ZERO != packet->worked) {
3187 struct city *pwork = game_city_by_number(packet->worked);
3188
3189 if (NULL == pwork) {
3190 char named[MAX_LEN_CITYNAME];
3191
3192 /* New unseen ("invisible") city, or before city_info */
3193 fc_snprintf(named, sizeof(named), "%06u", packet->worked);
3194
3195 pwork = create_city_virtual(invisible.placeholder, NULL, named);
3196 pwork->id = packet->worked;
3198
3200
3201 log_debug("(%d,%d) invisible city %d, %s",
3202 TILE_XY(ptile), pwork->id, city_name_get(pwork));
3203 } else if (NULL == city_tile(pwork)) {
3204 /* Old unseen ("invisible") city, or before city_info */
3205 if (NULL != powner && city_owner(pwork) != powner) {
3206 /* Update placeholder with current owner */
3207 pwork->owner = powner;
3208 pwork->original = NULL;
3209 }
3210 } else {
3211 /* We have a real (not invisible) city record for this ID, but
3212 * perhaps our info about that city is out of date. */
3213 int dist_sq = sq_map_distance(city_tile(pwork), ptile);
3214
3216 /* This is probably enemy city which has grown in diameter since we
3217 * last saw it. We need city_radius_sq to be at least big enough so
3218 * that all workers fit in, so set it so. */
3220 }
3221 /* This might be a known city that is open in a dialog.
3222 * (And this might be our only prompt to refresh the worked tiles
3223 * display in its city map, if a worker rearrangement does not
3224 * change anything else about the city such as output.) */
3225 {
3226 struct city *oldwork = tile_worked(ptile);
3227 if (oldwork && NULL != city_tile(oldwork)) {
3228 /* Refresh previous city too if it's real and different */
3230 }
3231 /* Refresh new city working tile (which we already know is real) */
3233 }
3234 }
3235
3236 /* This marks tile worked by (possibly invisible) city. Other
3237 * parts of the code have to handle invisible cities correctly
3238 * (ptile->worked->tile == NULL) */
3239 tile_set_worked(ptile, pwork);
3240 } else {
3241 /* Tile is no longer being worked by a city.
3242 * (Again, this might be our only prompt to refresh the worked tiles
3243 * display for the previous working city.) */
3244 if (tile_worked(ptile) && NULL != city_tile(tile_worked(ptile))) {
3246 }
3247 tile_set_worked(ptile, NULL);
3248 }
3249
3251 }
3252
3253 if (old_known != packet->known) {
3255 }
3256
3257 if (NULL != client.conn.playing) {
3262
3263 switch (packet->known) {
3264 case TILE_KNOWN_SEEN:
3269 break;
3270 case TILE_KNOWN_UNSEEN:
3272 break;
3273 case TILE_UNKNOWN:
3274 break;
3275 default:
3276 log_error("handle_tile_info() invalid known (%d).", packet->known);
3277 break;
3278 };
3279 }
3281
3282 if (packet->spec_sprite[0] != '\0') {
3283 if (!ptile->spec_sprite
3284 || strcmp(ptile->spec_sprite, packet->spec_sprite) != 0) {
3285 if (ptile->spec_sprite) {
3286 free(ptile->spec_sprite);
3287 }
3288 ptile->spec_sprite = fc_strdup(packet->spec_sprite);
3290 }
3291 } else {
3292 if (ptile->spec_sprite) {
3293 free(ptile->spec_sprite);
3294 ptile->spec_sprite = NULL;
3296 }
3297 }
3298
3300 /* This is an error. So first we log the error,
3301 * then make an assertion. */
3302 unit_list_iterate(ptile->units, punit) {
3303 log_error("%p %d %s at (%d,%d) %s", punit, punit->id,
3307 fc_assert_msg(0 == unit_list_size(ptile->units), "Ghost units seen");
3308 /* Repairing... */
3309 unit_list_clear(ptile->units);
3310 }
3311
3312 ptile->continent = packet->continent;
3314
3315 if (packet->label[0] == '\0') {
3316 if (ptile->label != NULL) {
3317 FC_FREE(ptile->label);
3318 ptile->label = NULL;
3320 }
3321 } else if (ptile->label == NULL || strcmp(packet->label, ptile->label)) {
3322 tile_set_label(ptile, packet->label);
3324 }
3325
3326 if (known_changed || tile_changed) {
3327 /*
3328 * A tile can only change if it was known before and is still
3329 * known. In the other cases the tile is new or removed.
3330 */
3332 agents_tile_new(ptile);
3333 } else if (known_changed && TILE_KNOWN_UNSEEN == new_known) {
3334 agents_tile_remove(ptile);
3335 } else {
3336 agents_tile_changed(ptile);
3337 }
3339 }
3340
3341 /* refresh tiles */
3342 if (can_client_change_view()) {
3343 /* the tile itself (including the necessary parts of adjacent tiles) */
3344 if (tile_changed || old_known != new_known) {
3346 }
3347 }
3348
3349 /* update menus if the focus unit is on the tile. */
3350 if (tile_changed) {
3351 if (get_focus_unit_on_tile(ptile)) {
3352 menus_update();
3353 }
3354 }
3355
3356 /* FIXME: we really ought to call refresh_city_dialog() for any city
3357 * whose radii include this tile, to update the city map display.
3358 * But that would be expensive. We deal with the (common) special
3359 * case of changes in worked tiles above. */
3360}
3361
3362/************************************************************************/
3382
3383/************************************************************************/
3386void handle_scenario_description(const char *description)
3387{
3389
3391}
3392
3393/************************************************************************/
3399{
3400 /* The ruleset is going to load new nations. So close
3401 * the nation selection dialog if it is open. */
3403
3409 game.control = *packet;
3410
3411 /* check the values! */
3412#define VALIDATE(_count, _maximum, _string) \
3413 if (game.control._count > _maximum) { \
3414 log_error("handle_ruleset_control(): Too many " _string \
3415 "; using %d of %d", _maximum, game.control._count); \
3416 game.control._count = _maximum; \
3417 }
3418
3419 VALIDATE(num_unit_classes, UCL_LAST, "unit classes");
3420 VALIDATE(num_unit_types, U_LAST, "unit types");
3421 VALIDATE(num_impr_types, B_LAST, "improvements");
3422 VALIDATE(num_tech_types, A_LAST, "advances");
3423 VALIDATE(num_base_types, MAX_EXTRA_TYPES, "bases");
3424 VALIDATE(num_road_types, MAX_EXTRA_TYPES, "roads");
3425 VALIDATE(num_resource_types, MAX_EXTRA_TYPES, "resources");
3426 VALIDATE(num_disaster_types, MAX_DISASTER_TYPES, "disasters");
3427 VALIDATE(num_achievement_types, MAX_ACHIEVEMENT_TYPES, "achievements");
3428 VALIDATE(num_counters, MAX_COUNTERS, "counters");
3429
3430 /* game.control.government_count, game.control.nation_count and
3431 * game.control.num_city_styles are allocated dynamically, and do
3432 * not need a size check. See the allocation below. */
3433
3435
3436 VALIDATE(num_specialist_types, SP_MAX, "specialists");
3437#undef VALIDATE
3438
3444
3445 if (game.control.desc_length > 0) {
3447 game.ruleset_description[0] = '\0';
3448 }
3449
3450 if (packet->preferred_tileset[0] != '\0') {
3451 /* There is tileset suggestion */
3453 /* It's not currently in use */
3456 } else {
3458 }
3459 }
3460 }
3461
3462 if (packet->preferred_soundset[0] != '\0') {
3463 /* There is soundset suggestion */
3465 /* It's not currently in use */
3468 } else {
3470 }
3471 }
3472 }
3473
3474 if (packet->preferred_musicset[0] != '\0') {
3475 /* There is musicset suggestion */
3477 /* It's not currently in use */
3480 } else {
3482 }
3483 }
3484 }
3485
3487
3489}
3490
3491/************************************************************************/
3495{
3496 int len;
3497
3498 if (game.ruleset_summary != NULL) {
3500 }
3501
3502 len = strlen(packet->text);
3503
3505
3506 fc_strlcpy(game.ruleset_summary, packet->text, len + 1);
3507}
3508
3509/************************************************************************/
3518
3519/************************************************************************/
3523{
3524 /* Setup extra hiders caches */
3525 extra_type_iterate(pextra) {
3526 pextra->hiders = extra_type_list_new();
3528 if (BV_ISSET(pextra->hidden_by, extra_index(phider))) {
3529 extra_type_list_append(pextra->hiders, phider);
3530 }
3532 pextra->bridged = extra_type_list_new();
3534 if (BV_ISSET(pextra->bridged_over, extra_index(pbridged))) {
3535 extra_type_list_append(pextra->bridged, pbridged);
3536 }
3539
3544
3545 /* Setup improvement feature caches */
3547
3548 /* Setup road integrators caches */
3550
3551 /* Pre calculate action related data. */
3553
3554 /* Setup unit unknown move cost caches */
3556 ptype->unknown_move_cost = utype_unknown_move_cost(ptype);
3560
3561 /* Cache what city production can receive help from caravans. */
3563
3564 /* Adjust editor for changed ruleset. */
3566
3567 /* We are not going to crop any more sprites from big sprites, free them. */
3569
3571}
3572
3573/************************************************************************/
3577{
3578 struct unit_class *c = uclass_by_number(p->id);
3579
3580 fc_assert_ret_msg(NULL != c, "Bad unit_class %d.", p->id);
3581
3582 names_set(&c->name, NULL, p->name, p->rule_name);
3583 c->min_speed = p->min_speed;
3584 c->hp_loss_pct = p->hp_loss_pct;
3586 c->flags = p->flags;
3587
3589}
3590
3591/************************************************************************/
3595{
3596 int i;
3597 struct unit_type *u = utype_by_number(p->id);
3598
3599 fc_assert_ret_msg(NULL != u, "Bad unit_type %d.", p->id);
3600
3601 names_set(&u->name, NULL, p->name, p->rule_name);
3609
3611 u->build_cost = p->build_cost;
3612 u->pop_cost = p->pop_cost;
3615 u->move_rate = p->move_rate;
3616 for (i = 0; i < p->build_reqs_count; i++) {
3618 }
3621 u->hp = p->hp;
3622 u->firepower = p->firepower;
3625 u->convert_time = p->convert_time;
3626 u->fuel = p->fuel;
3627 u->flags = p->flags;
3628 u->roles = p->roles;
3629 u->happy_cost = p->happy_cost;
3631 u->upkeep[o] = p->upkeep[o];
3634 u->bombard_rate = p->bombard_rate;
3635 u->city_size = p->city_size;
3636 u->city_slots = p->city_slots;
3637 u->tp_defense = p->tp_defense;
3638 u->cargo = p->cargo;
3639 u->targets = p->targets;
3640 u->embarks = p->embarks;
3641 u->disembarks = p->disembarks;
3642 u->vlayer = p->vlayer;
3643
3644 if (p->veteran_levels == 0) {
3645 u->veteran = NULL;
3646 } else {
3648
3649 for (i = 0; i < p->veteran_levels; i++) {
3651 p->power_fact[i], p->move_bonus[i],
3652 p->base_raise_chance[i],
3653 p->work_raise_chance[i]);
3654 }
3655 }
3656
3658
3659 u->adv.worker = p->worker;
3660
3662}
3663
3664/************************************************************************/
3668{
3669 struct unit_type *u = utype_by_number(p->unit);
3670 struct combat_bonus *bonus;
3671
3672 fc_assert_ret_msg(NULL != u, "Bad unit_type %d.", p->unit);
3673
3674 bonus = malloc(sizeof(*bonus));
3675
3676 bonus->flag = p->flag;
3677 bonus->type = p->type;
3678 bonus->value = p->value;
3679 bonus->quiet = p->quiet;
3680
3682}
3683
3684/************************************************************************/
3688{
3689 const char *flagname;
3690 const char *helptxt;
3691
3692 fc_assert_ret_msg(p->id >= UTYF_USER_FLAG_1 && p->id <= UTYF_LAST_USER_FLAG, "Bad user flag %d.", p->id);
3693
3694 if (p->name[0] == '\0') {
3695 flagname = NULL;
3696 } else {
3697 flagname = p->name;
3698 }
3699
3700 if (p->helptxt[0] == '\0') {
3701 helptxt = NULL;
3702 } else {
3703 helptxt = p->helptxt;
3704 }
3705
3707}
3708
3709/************************************************************************/
3713 const struct packet_ruleset_unit_class_flag *p)
3714{
3715 const char *flagname;
3716 const char *helptxt;
3717
3719 "Bad user flag %d.", p->id);
3720
3721 if (p->name[0] == '\0') {
3722 flagname = NULL;
3723 } else {
3724 flagname = p->name;
3725 }
3726
3727 if (p->helptxt[0] == '\0') {
3728 helptxt = NULL;
3729 } else {
3730 helptxt = p->helptxt;
3731 }
3732
3734}
3735
3736/************************************************************************/
3744static int unpack_tech_req(const enum tech_req r_num,
3745 const int reqs_size,
3746 const struct requirement *reqs,
3747 struct advance *a,
3748 int i)
3749{
3750 if (i < reqs_size
3751 && reqs[i].source.kind == VUT_ADVANCE) {
3752 /* Extract the tech req so the old code can reason about it. */
3753
3754 /* This IS a traditional tech req... right? */
3755 fc_assert(reqs[i].present);
3757
3758 /* Put it in the advance structure. */
3759 a->require[r_num] = reqs[i].source.value.advance;
3760
3761 /* Move on in the requirement vector. */
3762 i++;
3763 } else {
3764 /* No tech req. */
3766 }
3767
3768 return i;
3769}
3770
3771/************************************************************************/
3775{
3776 int i;
3777 struct advance *a = advance_by_number(p->id);
3778
3779 fc_assert_ret_msg(NULL != a, "Bad advance %d.", p->id);
3780
3781 names_set(&a->name, NULL, p->name, p->rule_name);
3784
3785 i = 0;
3786
3788 if (p->tclass >= 0) {
3790 } else {
3791 a->tclass = NULL;
3792 }
3793
3794 /* The tech requirements req1 and req2 are send inside research_reqs
3795 * since they too are required to be fulfilled before the tech can be
3796 * researched. */
3797
3798 if (p->removed) {
3799 /* The Freeciv data structures currently records that a tech is removed
3800 * by setting req1 and req2 to "Never". */
3801 a->require[AR_ONE] = A_NEVER;
3802 a->require[AR_TWO] = A_NEVER;
3803 } else {
3804 /* Unpack req1 and req2 from the research_reqs requirement vector. */
3807 }
3808
3809 /* Any remaining requirements are a part of the research_reqs requirement
3810 * vector. */
3811 for (; i < p->research_reqs_count; i++) {
3813 }
3814
3815 /* The packet's research_reqs should contain req1, req2 and the
3816 * requirements of the tech's research_reqs. */
3817 fc_assert((a->research_reqs.size
3818 + ((a->require[AR_ONE]
3819 && (advance_number(a->require[AR_ONE]) != A_NONE)) ?
3820 1 : 0)
3821 + ((a->require[AR_TWO]
3822 && (advance_number(a->require[AR_TWO]) != A_NONE)) ?
3823 1 : 0))
3824 == p->research_reqs_count);
3825
3827
3828 a->flags = p->flags;
3829 a->cost = p->cost;
3830 a->num_reqs = p->num_reqs;
3832
3834}
3835
3836/************************************************************************/
3840{
3842
3843 fc_assert_ret_msg(NULL != ptclass, "Bad tech_class %d.", p->id);
3844
3845 names_set(&ptclass->name, NULL, p->name, p->rule_name);
3846 ptclass->cost_pct = p->cost_pct;
3847}
3848
3849/************************************************************************/
3853{
3854 const char *flagname;
3855 const char *helptxt;
3856
3857 fc_assert_ret_msg(p->id >= TECH_USER_1 && p->id <= TECH_USER_LAST, "Bad user flag %d.", p->id);
3858
3859 if (p->name[0] == '\0') {
3860 flagname = NULL;
3861 } else {
3862 flagname = p->name;
3863 }
3864
3865 if (p->helptxt[0] == '\0') {
3866 helptxt = NULL;
3867 } else {
3868 helptxt = p->helptxt;
3869 }
3870
3871 set_user_tech_flag_name(p->id, flagname, helptxt);
3872}
3873
3874/************************************************************************/
3878{
3879 int i;
3880 struct impr_type *b = improvement_by_number(p->id);
3881
3882 fc_assert_ret_msg(NULL != b, "Bad improvement %d.", p->id);
3883
3884 b->genus = p->genus;
3885 names_set(&b->name, NULL, p->name, p->rule_name);
3889 for (i = 0; i < p->reqs_count; i++) {
3891 }
3892 fc_assert(b->reqs.size == p->reqs_count);
3893 for (i = 0; i < p->obs_count; i++) {
3895 }
3896 fc_assert(b->obsolete_by.size == p->obs_count);
3897 b->build_cost = p->build_cost;
3898 b->upkeep = p->upkeep;
3899 b->sabotage = p->sabotage;
3900 b->flags = p->flags;
3905
3906#ifdef FREECIV_DEBUG
3907 if (p->id == improvement_count() - 1) {
3909 log_debug("Improvement: %s...", improvement_rule_name(bdbg));
3910 log_debug(" build_cost %3d", bdbg->build_cost);
3911 log_debug(" upkeep %2d", bdbg->upkeep);
3912 log_debug(" sabotage %3d", bdbg->sabotage);
3913 if (NULL != bdbg->helptext) {
3914 strvec_iterate(bdbg->helptext, text) {
3915 log_debug(" helptext %s", text);
3917 }
3919 }
3920#endif /* FREECIV_DEBUG */
3921
3923}
3924
3925/************************************************************************/
3929{
3930 const char *flagname;
3931 const char *helptxt;
3932
3934 "Bad user flag %d.", p->id);
3935
3936 if (p->name[0] == '\0') {
3937 flagname = NULL;
3938 } else {
3939 flagname = p->name;
3940 }
3941
3942 if (p->helptxt[0] == '\0') {
3943 helptxt = NULL;
3944 } else {
3945 helptxt = p->helptxt;
3946 }
3947
3948 set_user_impr_flag_name(p->id, flagname, helptxt);
3949}
3950
3951/************************************************************************/
3955{
3956 struct multiplier *pmul = multiplier_by_number(p->id);
3957 int j;
3958
3959 fc_assert_ret_msg(NULL != pmul, "Bad multiplier %d.", p->id);
3960
3961 pmul->start = p->start;
3962 pmul->stop = p->stop;
3963 pmul->step = p->step;
3964 pmul->def = p->def;
3965 pmul->offset = p->offset;
3966 pmul->factor = p->factor;
3967 pmul->minimum_turns = p->minimum_turns;
3968
3969 names_set(&pmul->name, NULL, p->name, p->rule_name);
3970
3971 for (j = 0; j < p->reqs_count; j++) {
3972 requirement_vector_append(&pmul->reqs, p->reqs[j]);
3973 }
3974 fc_assert(pmul->reqs.size == p->reqs_count);
3975
3977}
3978
3979/************************************************************************/
3983{
3984 int j;
3985 struct government *gov = government_by_number(p->id);
3986
3987 fc_assert_ret_msg(NULL != gov, "Bad government %d.", p->id);
3988
3989 gov->item_number = p->id;
3990
3991 for (j = 0; j < p->reqs_count; j++) {
3992 requirement_vector_append(&gov->reqs, p->reqs[j]);
3993 }
3994 fc_assert(gov->reqs.size == p->reqs_count);
3995
3996 names_set(&gov->name, NULL, p->name, p->rule_name);
3999 sz_strlcpy(gov->sound_str, p->sound_str);
4000 sz_strlcpy(gov->sound_alt, p->sound_alt);
4002
4004
4006}
4007
4008/************************************************************************/
4012 (const struct packet_ruleset_government_ruler_title *packet)
4013{
4014 struct government *gov = government_by_number(packet->gov);
4015
4016 fc_assert_ret_msg(NULL != gov, "Bad government %d.", packet->gov);
4017
4019 packet->male_title,
4020 packet->female_title);
4021}
4022
4023/************************************************************************/
4027{
4028 int j;
4029 struct terrain *pterrain = terrain_by_number(p->id);
4030
4031 fc_assert_ret_msg(NULL != pterrain, "Bad terrain %d.", p->id);
4032
4033 pterrain->tclass = p->tclass;
4034 pterrain->native_to = p->native_to;
4035 names_set(&pterrain->name, NULL, p->name, p->rule_name);
4036 sz_strlcpy(pterrain->graphic_str, p->graphic_str);
4037 sz_strlcpy(pterrain->graphic_alt, p->graphic_alt);
4038 sz_strlcpy(pterrain->graphic_alt2, p->graphic_alt2);
4039 pterrain->movement_cost = p->movement_cost;
4040 pterrain->defense_bonus = p->defense_bonus;
4041
4043 pterrain->output[o] = p->output[o];
4045
4046 if (pterrain->resources != NULL) {
4047 free(pterrain->resources);
4048 }
4049 pterrain->resources = fc_calloc(p->num_resources + 1,
4050 sizeof(*pterrain->resources));
4051 if (pterrain->resource_freq != NULL) {
4052 free(pterrain->resource_freq);
4053 }
4054 pterrain->resource_freq = fc_calloc(p->num_resources + 1,
4055 sizeof(*pterrain->resource_freq));
4056 for (j = 0; j < p->num_resources; j++) {
4057 pterrain->resources[j] = extra_by_number(p->resources[j]);
4058 if (!pterrain->resources[j]) {
4059 log_error("handle_ruleset_terrain() "
4060 "Mismatched resource %d for terrain \"%s\".",
4061 p->resources[j], terrain_rule_name(pterrain));
4062 }
4063 pterrain->resource_freq[j] = p->resource_freq[j];
4064 }
4065 pterrain->resources[p->num_resources] = NULL;
4066 pterrain->resource_freq[p->num_resources] = 0;
4067
4071
4072 pterrain->base_time = p->base_time;
4073 pterrain->road_time = p->road_time;
4075 pterrain->cultivate_time = p->cultivate_time;
4077 pterrain->plant_time = p->plant_time;
4079 pterrain->irrigation_time = p->irrigation_time;
4081 pterrain->mining_time = p->mining_time;
4082 if (p->animal < 0) {
4083 pterrain->animal = NULL;
4084 } else {
4085 pterrain->animal = utype_by_number(p->animal);
4086 }
4088 pterrain->transform_time = p->transform_time;
4089 pterrain->placing_time = p->placing_time;
4090 pterrain->pillage_time = p->pillage_time;
4091
4092 for (j = 0; j < p->extra_count; j++) {
4093 pterrain->extra_removal_times[j] = p->extra_removal_times[j];
4094 }
4095
4096 pterrain->flags = p->flags;
4097
4098 fc_assert_ret(pterrain->rgb == NULL);
4099 pterrain->rgb = rgbcolor_new(p->color_red, p->color_green, p->color_blue);
4100
4102
4104}
4105
4106/************************************************************************/
4110{
4111 const char *flagname;
4112 const char *helptxt;
4113
4114 fc_assert_ret_msg(p->id >= TER_USER_1 && p->id <= TER_USER_LAST, "Bad user flag %d.", p->id);
4115
4116 if (p->name[0] == '\0') {
4117 flagname = NULL;
4118 } else {
4119 flagname = p->name;
4120 }
4121
4122 if (p->helptxt[0] == '\0') {
4123 helptxt = NULL;
4124 } else {
4125 helptxt = p->helptxt;
4126 }
4127
4129}
4130
4131/************************************************************************/
4135{
4136 struct resource_type *presource;
4137
4138 if (p->id < 0 || p->id > MAX_EXTRA_TYPES) {
4139 log_error("Bad resource %d.", p->id);
4140 return;
4141 }
4142
4143 presource = resource_type_init(extra_by_number(p->id));
4144
4146 presource->output[o] = p->output[o];
4148}
4149
4150/************************************************************************/
4154{
4155 struct extra_type *pextra = extra_by_number(p->id);
4156 int i;
4157 bool cbase;
4158 bool croad;
4159 bool cres;
4160
4161 fc_assert_ret_msg(NULL != pextra, "Bad extra %d.", p->id);
4162
4163 names_set(&pextra->name, NULL, p->name, p->rule_name);
4164
4165 pextra->category = p->category;
4166
4167 pextra->causes = 0;
4168 for (i = 0; i < EC_COUNT; i++) {
4169 if (BV_ISSET(p->causes, i)) {
4170 pextra->causes |= (1 << i);
4171 }
4172 }
4173
4174 pextra->rmcauses = 0;
4175 for (i = 0; i < ERM_COUNT; i++) {
4176 if (BV_ISSET(p->rmcauses, i)) {
4177 pextra->rmcauses |= (1 << i);
4178 }
4179 }
4180
4181 if (pextra->causes == 0) {
4183 } else {
4184 for (i = 0; i < EC_COUNT; i++) {
4185 if (is_extra_caused_by(pextra, i)) {
4186 extra_to_caused_by_list(pextra, i);
4187 }
4188 }
4189 }
4190
4191 cbase = is_extra_caused_by(pextra, EC_BASE);
4192 croad = is_extra_caused_by(pextra, EC_ROAD);
4194 if (cbase) {
4195 /* Index is one less than size of list when this base is already added. */
4197 }
4198 if (croad) {
4199 /* Index is one less than size of list when this road is already added. */
4201 }
4202 if (!cbase && !croad && !cres) {
4205 }
4206
4207 for (i = 0; i < ERM_COUNT; i++) {
4208 if (is_extra_removed_by(pextra, i)) {
4209 extra_to_removed_by_list(pextra, i);
4210 }
4211 }
4212
4214 sz_strlcpy(pextra->act_gfx_alt, p->act_gfx_alt);
4216 sz_strlcpy(pextra->rmact_gfx, p->rmact_gfx);
4219 sz_strlcpy(pextra->graphic_str, p->graphic_str);
4220 sz_strlcpy(pextra->graphic_alt, p->graphic_alt);
4221
4222 for (i = 0; i < p->reqs_count; i++) {
4223 requirement_vector_append(&pextra->reqs, p->reqs[i]);
4224 }
4225 fc_assert(pextra->reqs.size == p->reqs_count);
4226
4227 for (i = 0; i < p->rmreqs_count; i++) {
4229 }
4230 fc_assert(pextra->rmreqs.size == p->rmreqs_count);
4231
4233 for (i = 0; i < p->appearance_reqs_count; i++) {
4235 }
4237
4239 for (i = 0; i < p->disappearance_reqs_count; i++) {
4241 }
4243
4244 pextra->visibility_req = p->visibility_req;
4245 pextra->buildable = p->buildable;
4246 pextra->generated = p->generated;
4247 pextra->build_time = p->build_time;
4249 pextra->removal_time = p->removal_time;
4251 pextra->infracost = p->infracost;
4252 pextra->defense_bonus = p->defense_bonus;
4253
4254 if (pextra->defense_bonus != 0) {
4255 if (extra_has_flag(pextra, EF_NATURAL_DEFENSE)) {
4257 } else {
4259 }
4260 }
4261
4263
4264 pextra->eus = p->eus;
4265 if (pextra->eus == EUS_HIDDEN) {
4267 }
4268
4269 pextra->native_to = p->native_to;
4270
4271 pextra->flags = p->flags;
4272 if (pextra->no_aggr_near_city >= 0) {
4274 }
4275 if (extra_has_flag(pextra, EF_CAUSE_ZOC)) {
4277 }
4278
4279 pextra->hidden_by = p->hidden_by;
4280 pextra->bridged_over = p->bridged_over;
4281 pextra->conflicts = p->conflicts;
4282
4284
4286}
4287
4288/************************************************************************/
4292{
4293 const char *flagname;
4294 const char *helptxt;
4295
4297 "Bad user flag %d.", p->id);
4298
4299 if (p->name[0] == '\0') {
4300 flagname = NULL;
4301 } else {
4302 flagname = p->name;
4303 }
4304
4305 if (p->helptxt[0] == '\0') {
4306 helptxt = NULL;
4307 } else {
4308 helptxt = p->helptxt;
4309 }
4310
4311 set_user_extra_flag_name(p->id, flagname, helptxt);
4312}
4313
4314/************************************************************************/
4318{
4319 struct base_type *pbase = base_by_number(p->id);
4320
4321 fc_assert_ret_msg(NULL != pbase, "Bad base %d.", p->id);
4322
4323 pbase->gui_type = p->gui_type;
4324 pbase->border_sq = p->border_sq;
4325 pbase->vision_main_sq = p->vision_main_sq;
4326 pbase->vision_invis_sq = p->vision_invis_sq;
4327 pbase->vision_subs_sq = p->vision_subs_sq;
4328
4332 }
4333}
4334
4335/************************************************************************/
4339{
4340 int i;
4341 struct road_type *proad = road_by_number(p->id);
4342
4343 fc_assert_ret_msg(NULL != proad, "Bad road %d.", p->id);
4344
4345 proad->gui_type = p->gui_type;
4346
4347 for (i = 0; i < p->first_reqs_count; i++) {
4348 requirement_vector_append(&proad->first_reqs, p->first_reqs[i]);
4349 }
4350 fc_assert(proad->first_reqs.size == p->first_reqs_count);
4351
4352 proad->move_cost = p->move_cost;
4353 proad->move_mode = p->move_mode;
4354
4356 proad->tile_incr_const[o] = p->tile_incr_const[o];
4357 proad->tile_incr[o] = p->tile_incr[o];
4358 proad->tile_bonus[o] = p->tile_bonus[o];
4360
4361 proad->compat = p->compat;
4362 proad->integrates = p->integrates;
4363 proad->flags = p->flags;
4364}
4365
4366/************************************************************************/
4370{
4371 struct goods_type *pgood = goods_by_number(p->id);
4372 int i;
4373
4374 fc_assert_ret_msg(NULL != pgood, "Bad goods %d.", p->id);
4375
4376 names_set(&pgood->name, NULL, p->name, p->rule_name);
4377
4378 for (i = 0; i < p->reqs_count; i++) {
4380 }
4381 fc_assert(pgood->reqs.size == p->reqs_count);
4382
4383 pgood->from_pct = p->from_pct;
4384 pgood->to_pct = p->to_pct;
4385 pgood->onetime_pct = p->onetime_pct;
4386 pgood->flags = p->flags;
4387
4388 PACKET_STRVEC_EXTRACT(pgood->helptext, p->helptext);
4389}
4390
4391/************************************************************************/
4395{
4396 struct action *act;
4397
4398 if (!action_id_exists(p->id)) {
4399 /* Action id out of range */
4400 log_error("handle_ruleset_action() the action id %d is out of range.",
4401 p->id);
4402
4403 return;
4404 }
4405
4406 act = action_by_number(p->id);
4407
4408 sz_strlcpy(act->ui_name, p->ui_name);
4409 act->quiet = p->quiet;
4410
4411 act->result = p->result;
4412 act->sub_results = p->sub_results;
4414
4415 act->actor_kind = p->act_kind;
4416 act->target_kind = p->tgt_kind;
4417 act->sub_target_kind = p->sub_tgt_kind;
4418
4419 act->min_distance = p->min_distance;
4420 act->max_distance = p->max_distance;
4421 act->blocked_by = p->blocked_by;
4422}
4423
4424/************************************************************************/
4427void
4429{
4430 struct action_enabler *enabler;
4431 int i;
4432
4434 /* Non existing action */
4435 log_error("handle_ruleset_action_enabler() the action %d "
4436 "doesn't exist.",
4437 p->enabled_action);
4438
4439 return;
4440 }
4441
4443
4444 enabler->action = p->enabled_action;
4445
4446 for (i = 0; i < p->actor_reqs_count; i++) {
4447 requirement_vector_append(&enabler->actor_reqs, p->actor_reqs[i]);
4448 }
4449 fc_assert(enabler->actor_reqs.size == p->actor_reqs_count);
4450
4451 for (i = 0; i < p->target_reqs_count; i++) {
4452 requirement_vector_append(&enabler->target_reqs, p->target_reqs[i]);
4453 }
4454 fc_assert(enabler->target_reqs.size == p->target_reqs_count);
4455
4457}
4458
4459/************************************************************************/
4463{
4465 int i;
4466
4468
4469 auto_perf->cause = p->cause;
4470
4471 for (i = 0; i < p->reqs_count; i++) {
4473 }
4474 fc_assert(auto_perf->reqs.size == p->reqs_count);
4475
4476 for (i = 0; i < p->alternatives_count; i++) {
4477 auto_perf->alternatives[i] = p->alternatives[i];
4478 }
4479}
4480
4481/************************************************************************/
4485{
4487 int i;
4488
4489 fc_assert_ret_msg(NULL != pdis, "Bad disaster %d.", p->id);
4490
4491 names_set(&pdis->name, NULL, p->name, p->rule_name);
4492
4493 for (i = 0; i < p->reqs_count; i++) {
4494 requirement_vector_append(&pdis->reqs, p->reqs[i]);
4495 }
4496 fc_assert(pdis->reqs.size == p->reqs_count);
4497
4498 pdis->frequency = p->frequency;
4499
4500 pdis->effects = p->effects;
4501}
4502
4503/************************************************************************/
4507{
4509
4510 fc_assert_ret_msg(NULL != pach, "Bad achievement %d.", p->id);
4511
4512 names_set(&pach->name, NULL, p->name, p->rule_name);
4513
4514 pach->type = p->type;
4515 pach->unique = p->unique;
4516 pach->value = p->value;
4517}
4518
4519/************************************************************************/
4523{
4525
4526 if (pset != NULL) {
4527 pset->trade_pct = p->trade_pct;
4528 pset->cancelling = p->cancelling;
4529 pset->bonus_type = p->bonus_type;
4530 }
4531}
4532
4533/************************************************************************/
4537 (const struct packet_ruleset_terrain_control *p)
4538{
4539 /* Since terrain_control is the same as packet_ruleset_terrain_control
4540 * we can just copy the data directly. */
4541 terrain_control = *p;
4542 /* terrain_control.move_fragments likely changed */
4544}
4545
4546/************************************************************************/
4550 (const struct packet_ruleset_nation_sets *packet)
4551{
4552 int i;
4553
4554 for (i = 0; i < packet->nsets; i++) {
4555 struct nation_set *pset =
4556 nation_set_new(packet->names[i], packet->rule_names[i],
4557 packet->descriptions[i]);
4558
4559 if (pset == NULL) {
4560 break;
4561 } else {
4563 }
4564 }
4565}
4566
4567/************************************************************************/
4571 (const struct packet_ruleset_nation_groups *packet)
4572{
4573 int i;
4574
4575 for (i = 0; i < packet->ngroups; i++) {
4576 struct nation_group *pgroup;
4577
4578 pgroup = nation_group_new(packet->groups[i]);
4579
4580 if (pgroup != NULL) {
4582 pgroup->hidden = packet->hidden[i];
4583 } else {
4584 break;
4585 }
4586 }
4587}
4588
4589/************************************************************************/
4593{
4594 struct nation_type *pnation = nation_by_number(packet->id);
4595 int i;
4596
4597 fc_assert_ret_msg(NULL != pnation, "Bad nation %d.", packet->id);
4598
4599 if (packet->translation_domain[0] != '\0') {
4600 size_t len = strlen(packet->translation_domain) + 1;
4601 pnation->translation_domain = fc_malloc(len);
4603 } else {
4604 pnation->translation_domain = NULL;
4605 }
4606 names_set(&pnation->adjective, pnation->translation_domain,
4607 packet->adjective, packet->rule_name);
4608 name_set(&pnation->noun_plural, pnation->translation_domain, packet->noun_plural);
4609 sz_strlcpy(pnation->flag_graphic_str, packet->graphic_str);
4610 sz_strlcpy(pnation->flag_graphic_alt, packet->graphic_alt);
4611 pnation->style = style_by_number(packet->style);
4612 for (i = 0; i < packet->leader_count; i++) {
4613 (void) nation_leader_new(pnation, packet->leader_name[i],
4614 packet->leader_is_male[i]);
4615 }
4616
4617 /* set later by PACKET_NATION_AVAILABILITY */
4618 pnation->client.is_pickable = FALSE;
4619 pnation->is_playable = packet->is_playable;
4620 pnation->barb_type = packet->barbarian_type;
4621
4622 if ('\0' != packet->legend[0]) {
4623 pnation->legend = fc_strdup(nation_legend_translation(pnation, packet->legend));
4624 } else {
4625 pnation->legend = fc_strdup("");
4626 }
4627
4628 for (i = 0; i < packet->nsets; i++) {
4629 struct nation_set *pset = nation_set_by_number(packet->sets[i]);
4630
4631 if (NULL != pset) {
4632 nation_set_list_append(pnation->sets, pset);
4633 } else {
4634 log_error("handle_ruleset_nation() \"%s\" have unknown set %d.",
4635 nation_rule_name(pnation), packet->sets[i]);
4636 }
4637 }
4638
4639 for (i = 0; i < packet->ngroups; i++) {
4641
4642 if (NULL != pgroup) {
4644 } else {
4645 log_error("handle_ruleset_nation() \"%s\" have unknown group %d.",
4646 nation_rule_name(pnation), packet->groups[i]);
4647 }
4648 }
4649
4650 /* init_government may be NULL */
4652 for (i = 0; i < MAX_NUM_TECH_LIST; i++) {
4653 if (i < packet->init_techs_count) {
4654 pnation->init_techs[i] = packet->init_techs[i];
4655 } else {
4656 pnation->init_techs[i] = A_LAST;
4657 }
4658 }
4659 for (i = 0; i < MAX_NUM_UNIT_LIST; i++) {
4660 if (i < packet->init_units_count) {
4661 pnation->init_units[i] = utype_by_number(packet->init_units[i]);
4662 } else {
4663 /* TODO: should init_units be initialized in common/nation.c? */
4664 pnation->init_units[i] = utype_by_number(U_LAST);
4665 }
4666 }
4667 for (i = 0; i < MAX_NUM_BUILDING_LIST; i++) {
4668 if (i < packet->init_buildings_count) {
4669 pnation->init_buildings[i] = packet->init_buildings[i];
4670 } else {
4671 pnation->init_buildings[i] = B_LAST;
4672 }
4673 }
4674
4676}
4677
4678/************************************************************************/
4682void handle_nation_availability(int ncount, const bool *is_pickable,
4683 bool nationset_change)
4684{
4685 int i;
4686
4687 fc_assert_action(ncount == nation_count(),
4688 ncount = MIN(ncount, nation_count()));
4689
4690 for (i = 0; i < ncount; i++) {
4691 nation_by_number(i)->client.is_pickable = is_pickable[i];
4692 }
4693
4694 races_update_pickable(nationset_change);
4695}
4696
4697/************************************************************************/
4701{
4702 struct nation_style *pstyle = style_by_number(p->id);
4703
4704 fc_assert_ret_msg(NULL != pstyle, "Bad style %d.", p->id);
4705
4706 names_set(&pstyle->name, NULL, p->name, p->rule_name);
4707}
4708
4709/************************************************************************/
4713{
4714 struct clause_info *info = clause_info_get(p->type);
4715 int i;
4716
4717 fc_assert_ret_msg(NULL != info, "Bad clause %d.", p->type);
4718
4719 info->enabled = p->enabled;
4720
4721 for (i = 0; i < p->giver_reqs_count; i++) {
4723 }
4724 fc_assert(info->giver_reqs.size == p->giver_reqs_count);
4725
4726 for (i = 0; i < p->receiver_reqs_count; i++) {
4728 }
4730}
4731
4732/************************************************************************/
4736{
4737 int id, j;
4738 struct citystyle *cs;
4739
4740 id = packet->style_id;
4742 "Bad citystyle %d.", id);
4743 cs = &city_styles[id];
4744
4745 for (j = 0; j < packet->reqs_count; j++) {
4746 requirement_vector_append(&cs->reqs, packet->reqs[j]);
4747 }
4748 fc_assert(cs->reqs.size == packet->reqs_count);
4749
4750 names_set(&cs->name, NULL, packet->name, packet->rule_name);
4751 sz_strlcpy(cs->graphic, packet->graphic);
4752 sz_strlcpy(cs->graphic_alt, packet->graphic_alt);
4753 sz_strlcpy(cs->citizens_graphic, packet->citizens_graphic);
4754
4756}
4757
4758/************************************************************************/
4762{
4763 int id, j;
4764 struct music_style *pmus;
4765
4766 id = packet->id;
4768 "Bad music_style %d.", id);
4769
4771
4772 for (j = 0; j < packet->reqs_count; j++) {
4773 requirement_vector_append(&pmus->reqs, packet->reqs[j]);
4774 }
4775 fc_assert(pmus->reqs.size == packet->reqs_count);
4776
4777 sz_strlcpy(pmus->music_peaceful, packet->music_peaceful);
4778 sz_strlcpy(pmus->music_combat, packet->music_combat);
4779}
4780
4781/************************************************************************/
4785{
4786 int i;
4787
4788 /* Must set num_specialist_types before iterating over them. */
4790
4791 fc_assert_ret(packet->veteran_levels > 0);
4792
4794 game.veteran->levels = packet->veteran_levels;
4795
4796 for (i = 0; i < MAX_NUM_TECH_LIST; i++) {
4797 if (i < packet->global_init_techs_count) {
4799 } else {
4801 }
4802 }
4803 for (i = 0; i < MAX_NUM_BUILDING_LIST; i++) {
4804 if (i < packet->global_init_buildings_count) {
4806 } else {
4808 }
4809 }
4810
4811 for (i = 0; i < packet->veteran_levels; i++) {
4813 packet->power_fact[i], packet->move_bonus[i],
4814 packet->base_raise_chance[i],
4815 packet->work_raise_chance[i]);
4816 }
4817
4820 packet->background_green,
4821 packet->background_blue);
4822
4824}
4825
4826/************************************************************************/
4830{
4831 int j;
4832 struct specialist *s = specialist_by_number(p->id);
4833
4834 fc_assert_ret_msg(NULL != s, "Bad specialist %d.", p->id);
4835
4836 names_set(&s->name, NULL, p->plural_name, p->rule_name);
4838
4841
4842 for (j = 0; j < p->reqs_count; j++) {
4844 }
4845 fc_assert(s->reqs.size == p->reqs_count);
4846
4848
4850}
4851
4852/************************************************************************/
4855void handle_city_name_suggestion_info(int unit_id, const char *name)
4856{
4857 struct unit *punit = player_unit_by_number(client_player(), unit_id);
4858
4859 if (!can_client_issue_orders()) {
4860 return;
4861 }
4862
4863 if (punit) {
4865 bool other_asking = FALSE;
4866
4868 if (other->client.asking_city_name) {
4870 }
4873
4874 if (!other_asking) {
4876 }
4877 } else {
4879 unit_id, tile_index(unit_tile(punit)),
4880 0, name);
4881 }
4882 }
4883}
4884
4885/************************************************************************/
4891void handle_unit_action_answer(int actor_id, int target_id, int cost,
4892 action_id action_type,
4893 int request_kind)
4894{
4895 struct city *pcity = game_city_by_number(target_id);
4896 struct unit *punit = game_unit_by_number(target_id);
4897 struct unit *pactor = player_unit_by_number(client_player(), actor_id);
4898 struct action *paction = action_by_number(action_type);
4899
4900 if (ACTION_NONE != action_type
4901 && !action_id_exists(action_type)) {
4902 /* Non existing action */
4903 log_error("handle_unit_action_answer() the action %d doesn't exist.",
4904 action_type);
4905
4906 if (request_kind == REQEST_PLAYER_INITIATED) {
4910 }
4911
4912 return;
4913 }
4914
4915 if (!pactor) {
4916 log_debug("Bad actor %d.", actor_id);
4917
4918 if (request_kind == REQEST_PLAYER_INITIATED) {
4921 }
4922
4923 return;
4924 }
4925
4926 switch ((enum gen_action)action_type) {
4928 if (punit && client.conn.playing
4930 if (request_kind == REQEST_PLAYER_INITIATED) {
4931 /* Focus on the unit so the player knows where it is */
4933
4935 } else {
4936 /* Not in use (yet). */
4937 log_error("Unimplemented: received background unit bribe cost.");
4938 }
4939 } else {
4940 log_debug("Bad target %d.", target_id);
4941 if (request_kind == REQEST_PLAYER_INITIATED) {
4945 }
4946 }
4947 break;
4950 if (pcity && client.conn.playing
4952 if (request_kind == REQEST_PLAYER_INITIATED) {
4953 /* Focus on the unit so the player knows where it is */
4955
4957 } else {
4958 /* Not in use (yet). */
4959 log_error("Unimplemented: received background city incite cost.");
4960 }
4961 } else {
4962 log_debug("Bad target %d.", target_id);
4963 if (request_kind == REQEST_PLAYER_INITIATED) {
4967 }
4968 }
4969 break;
4971 if (pcity && client.conn.playing
4973 /* TODO: The bundled clients will have to start showing the upgrade
4974 * price sent from the server before it can be allowed to rely on
4975 * things the player can't see. (Example: it becomes legal to upgrade
4976 * a unit in a foreign city.) */
4977
4978 /* Getting unit upgrade cost from the server is currently only used by
4979 * Freeciv-web. */
4980 log_error("Received upgrade unit price but can't forward it.");
4981 }
4982 break;
4983 case ACTION_NONE:
4984 log_debug("Server didn't respond to query.");
4985 if (request_kind == REQEST_PLAYER_INITIATED) {
4989 }
4990 break;
4991 default:
4992 log_error("handle_unit_action_answer() invalid action_type (%d).",
4993 action_type);
4994 if (request_kind == REQEST_PLAYER_INITIATED) {
4998 }
4999 break;
5000 };
5001}
5002
5003/************************************************************************/
5008{
5010
5012 if (action_prob_possible(act_probs[act_id])) {
5013 /* An attack. */
5014 if (attack_action == ACTION_NONE) {
5015 /* No previous attack action found. */
5016 attack_action = act_id;
5017 } else {
5018 /* More than one legal attack action found. */
5019 return ACTION_NONE;
5020 }
5021 }
5024 if (action_prob_possible(act_probs[act_id])) {
5025 /* An interesting non attack action has been found. */
5026 return ACTION_NONE;
5027 }
5029
5030 return attack_action;
5031}
5032
5033/**********************************************************************/
5038 const struct act_prob *act_probs,
5039 struct unit *target_unit,
5040 struct city *target_city,
5041 struct tile *target_tile)
5042{
5044
5046
5048
5049 if (auto_action != ACTION_NONE) {
5050 /* No interesting actions except a single attack action has been
5051 * found. The player wants it performed without questions. */
5052
5053 /* The order requests below doesn't send additional details. */
5055
5056 /* Give the order. */
5058 case ATK_TILE:
5059 case ATK_UNITS:
5060 case ATK_EXTRAS:
5061 if (target_tile != NULL) {
5064 0, "");
5065 }
5066 break;
5067 case ATK_CITY:
5068 if (target_city != NULL) {
5071 0, "");
5072 }
5073 break;
5074 case ATK_UNIT:
5075 if (target_unit != NULL) {
5078 0, "");
5079 }
5080 break;
5081 case ATK_SELF:
5084 0, "");
5085 break;
5086 case ATK_COUNT:
5088 break;
5089 }
5090
5091 /* Clean up. */
5093 } else {
5094 /* This should be done in the foreground */
5096 }
5097}
5098
5099/************************************************************************/
5106{
5108
5109 struct tile *target_tile = index_to_tile(&(wld.map), packet->target_tile_id);
5110 struct extra_type *target_extra = packet->target_extra_id == EXTRA_NONE ?
5114
5115 const struct act_prob *act_probs = packet->action_probabilities;
5116
5117 int request_kind = packet->request_kind;
5118 bool valid = FALSE;
5119
5120 /* The dead can't act */
5122 /* At least one action must be possible */
5123 action_iterate(act) {
5124 if (action_prob_possible(act_probs[act])) {
5125 valid = TRUE;
5126 break;
5127 }
5129 }
5130
5131 switch (request_kind) {
5133 if (valid) {
5134 /* The player can select an action and should be informed. */
5135
5136 /* Show the client specific action dialog */
5140 act_probs);
5141 } else {
5142 /* Nothing to do. */
5146 }
5147 break;
5149 /* This was a background action selection dialog refresh. */
5150
5151 if (actor_unit != NULL
5153 /* The situation may have changed. */
5157 act_probs);
5158 }
5159 break;
5161 if (actor_unit != NULL) {
5164 }
5165 break;
5166 default:
5167 log_warn("Unknown request_kind %d in reply", request_kind);
5168 break;
5169 }
5170}
5171
5172/************************************************************************/
5175void handle_city_sabotage_list(int actor_id, int city_id,
5176 bv_imprs improvements,
5177 action_id act_id,
5178 int request_kind)
5179{
5180 struct city *pcity = game_city_by_number(city_id);
5181 struct unit *pactor = player_unit_by_number(client_player(), actor_id);
5182 struct action *paction = action_by_number(act_id);
5183
5184 if (!pactor) {
5185 log_debug("Bad diplomat %d.", actor_id);
5186
5187 if (request_kind == REQEST_PLAYER_INITIATED) {
5190 }
5191
5192 return;
5193 }
5194
5195 if (!pcity) {
5196 log_debug("Bad city %d.", city_id);
5197
5198 if (request_kind == REQEST_PLAYER_INITIATED) {
5202 }
5203
5204 return;
5205 }
5206
5208 improvement_iterate(pimprove) {
5209 update_improvement_from_packet(pcity, pimprove,
5210 BV_ISSET(improvements,
5211 improvement_index(pimprove)));
5213
5214 if (request_kind == REQEST_PLAYER_INITIATED) {
5215 /* Focus on the unit so the player knows where it is */
5217
5219 } else {
5220 /* Not in use (yet). */
5221 log_error("Unimplemented: received background city building list.");
5222 }
5223 } else {
5224 log_debug("Can't issue orders");
5225 if (request_kind == REQEST_PLAYER_INITIATED) {
5228 }
5229 }
5230}
5231
5232/************************************************************************/
5241
5242/************************************************************************/
5246{
5247 if (client_has_player()
5248 && packet->player_id == player_number(client_player())) {
5249 if (packet->winner) {
5250 start_menu_music("music_victory", NULL);
5251 } else {
5252 start_menu_music("music_defeat", NULL);
5253 }
5254 }
5256}
5257
5258/************************************************************************/
5262 (const struct packet_player_attribute_chunk *packet)
5263{
5264 if (!client_has_player()) {
5265 return;
5266 }
5267
5269
5270 if (packet->offset + packet->chunk_length == packet->total_length) {
5271 /* We successful received the last chunk. The attribute block is
5272 now complete. */
5274 }
5275}
5276
5277/************************************************************************/
5281{
5283
5287 client.last_processed_request_id_seen);
5289 request_id_of_currently_handled_packet);
5290
5291 log_debug("start processing packet %d",
5293}
5294
5295/************************************************************************/
5314
5315/************************************************************************/
5319 int packet_type, int size)
5320{
5321 fc_assert(pc == &client.conn);
5322 log_debug("incoming packet={type=%d, size=%d}", packet_type, size);
5323}
5324
5325/************************************************************************/
5329 int packet_type, int size,
5330 int request_id)
5331{
5332 fc_assert(pc == &client.conn);
5333 log_debug("outgoing packet={type=%d, size=%d, request_id=%d}",
5335
5337}
5338
5339/************************************************************************/
5343{
5344 log_debug("handle_freeze_client");
5345
5347}
5348
5349/************************************************************************/
5353{
5354 log_debug("handle_thaw_client");
5355
5358}
5359
5360/************************************************************************/
5364{
5366}
5367
5368/************************************************************************/
5372{
5373 log_verbose("server shutdown");
5374}
5375
5376/************************************************************************/
5380{
5381 recv_ruleset_effect(packet);
5382}
5383
5384/************************************************************************/
5390void handle_edit_object_created(int tag, int id)
5391{
5393}
5394
5395/************************************************************************/
5399{
5400 struct tile *ptile = index_to_tile(&(wld.map), packet->id);
5401 bool changed = FALSE;
5402
5403 /* Check. */
5404 if (NULL == ptile) {
5405 log_error("%s(): invalid tile index %d.", __FUNCTION__, packet->id);
5406 return;
5407 }
5408
5409 /* Handle. */
5410 if (packet->removal) {
5411 changed = map_startpos_remove(ptile);
5412 } else {
5413 if (NULL != map_startpos_get(ptile)) {
5414 changed = FALSE;
5415 } else {
5416 map_startpos_new(ptile);
5417 changed = TRUE;
5418 }
5419 }
5420
5421 /* Notify. */
5422 if (changed && can_client_change_view()) {
5424 if (packet->removal) {
5426 packet->id, TRUE);
5427 } else {
5428 editgui_notify_object_created(packet->tag, packet->id);
5429 }
5430 }
5431}
5432
5433/************************************************************************/
5437 packet)
5438{
5439 struct tile *ptile = index_to_tile(&(wld.map), packet->id);
5440 struct startpos *psp;
5441
5442 /* Check. */
5443 if (NULL == ptile) {
5444 log_error("%s(): invalid tile index %d.", __FUNCTION__, packet->id);
5445 return;
5446 }
5447
5448 psp = map_startpos_get(ptile);
5449 if (NULL == psp) {
5450 log_error("%s(): no start position at (%d, %d)",
5451 __FUNCTION__, TILE_XY(ptile));
5452 return;
5453 }
5454
5455 /* Handle. */
5456 if (startpos_unpack(psp, packet) && can_client_change_view()) {
5457 /* Notify. */
5460 FALSE);
5461 }
5462}
5463
5464/************************************************************************/
5468{
5469 game.client.fog_of_war = enabled;
5470
5471 menus_update();
5472}
5473
5474/************************************************************************/
5477void handle_vote_remove(int vote_no)
5478{
5481}
5482
5483/************************************************************************/
5486void handle_vote_update(int vote_no, int yes, int no, int abstain,
5487 int num_voters)
5488{
5489 struct voteinfo *vi;
5490
5492
5494 "Got packet_vote_update for non-existent vote %d!",
5495 vote_no);
5496
5497 vi->yes = yes;
5498 vi->no = no;
5499 vi->abstain = abstain;
5500 vi->num_voters = num_voters;
5501
5503}
5504
5505/************************************************************************/
5508void handle_vote_new(const struct packet_vote_new *packet)
5509{
5511 "Got a packet_vote_new for already existing "
5512 "vote %d!", packet->vote_no);
5513
5515 packet->user,
5516 packet->desc,
5517 packet->percent_required,
5518 packet->flags);
5520}
5521
5522/************************************************************************/
5526{
5527 struct voteinfo *vi;
5528
5530
5532 "Got packet_vote_resolve for non-existent vote %d!",
5533 vote_no);
5534
5535 vi->resolved = TRUE;
5536 vi->passed = passed;
5537
5539}
5540
5541/************************************************************************/
5544void handle_play_music(const char *tag)
5545{
5546 play_single_track(tag);
5547}
5548
5549/************************************************************************/
5552void handle_popup_image(const char *tag)
5553{
5554 popup_image(tag);
5555}
5556
5557/************************************************************************/
5560void handle_diplomacy_init_meeting(int counterpart, int initiated_from)
5561{
5562 client_init_meeting(counterpart, initiated_from);
5563}
5564
5565/************************************************************************/
5568void handle_diplomacy_accept_treaty(int counterpart, bool I_accepted,
5569 bool other_accepted)
5570{
5571 client_recv_accept_treaty(counterpart, I_accepted, other_accepted);
5572}
5573
5574/************************************************************************/
5577void handle_diplomacy_cancel_meeting(int counterpart, int initiated_from)
5578{
5579 client_recv_cancel_meeting(counterpart, initiated_from);
5580}
5581
5582/************************************************************************/
5585void handle_diplomacy_create_clause(int counterpart, int giver,
5586 enum clause_type type, int value)
5587{
5588 client_recv_create_clause(counterpart, giver, type, value);
5589}
5590
5591/************************************************************************/
5594void handle_diplomacy_remove_clause(int counterpart, int giver,
5595 enum clause_type type, int value)
5596{
5597 client_recv_remove_clause(counterpart, giver, type, value);
5598}
5599
5600/**********************************************************************/
5605{
5608
5609 names_set(&curr->name, NULL, packet->name, packet->rule_name);
5610 curr->checkpoint = packet->checkpoint;
5611 curr->type = packet->behaviour;
5612 curr->target = packet->type;
5613 curr->def = packet->def;
5614
5616 || curr->target != CTGT_CITY) {
5617 return;
5618 }
5619
5620 PACKET_STRVEC_EXTRACT(curr->helptext, packet->helptext);
5622}
5623
5624/**********************************************************************/
5628{
5629 int i;
5630 int counters_count;
5631 struct city *pcity = game_city_by_number(packet->city);
5632
5633 if (NULL == pcity) {
5634 return;
5635 }
5636
5638 if (counters_count != packet->count) {
5639 return;
5640 }
5641
5642 for (i = 0; i < counters_count; i++) {
5643 pcity->counter_values[i] = packet->counters[i];
5644 }
5645
5646 if (pcity->tile != NULL) {
5647 /* City's location known */
5649 }
5650
5652}
5653
5654/**********************************************************************/
5658{
5659}
struct achievement * achievement_by_number(int id)
struct action_auto_perf * action_auto_perf_slot_number(const int num)
Definition actions.c:6421
bool action_prob_possible(const struct act_prob probability)
Definition actions.c:5821
void actions_rs_pre_san_gen(void)
Definition actions.c:1654
void action_enabler_add(struct action_enabler *enabler)
Definition actions.c:2282
struct action_enabler * action_enabler_new(void)
Definition actions.c:2236
bool action_id_exists(const action_id act_id)
Definition actions.c:1829
static struct action * action_by_number(action_id act_id)
Definition actions.h:635
#define action_array_iterate(_act_array_, _act_id_)
Definition actions.h:497
#define action_id_requires_details(act_id)
Definition actions.h:673
#define action_array_iterate_end
Definition actions.h:509
#define action_iterate_end
Definition actions.h:465
#define action_iterate(_act_)
Definition actions.h:461
#define action_id_get_target_kind(act_id)
Definition actions.h:652
#define ACTION_NONE
Definition actions.h:311
void agents_unit_changed(struct unit *punit)
Definition agents.c:511
void agents_city_remove(struct city *pcity)
Definition agents.c:640
void agents_thaw_hint(void)
Definition agents.c:440
void agents_tile_remove(struct tile *ptile)
Definition agents.c:667
void agents_city_new(struct city *pcity)
Definition agents.c:614
void agents_start_turn(void)
Definition agents.c:474
void agents_tile_changed(struct tile *ptile)
Definition agents.c:691
void agents_unit_new(struct unit *punit)
Definition agents.c:536
void agents_unit_remove(struct unit *punit)
Definition agents.c:562
void agents_processing_started(void)
Definition agents.c:413
void agents_tile_new(struct tile *ptile)
Definition agents.c:715
void agents_processing_finished(void)
Definition agents.c:422
void agents_new_turn(void)
Definition agents.c:483
void agents_city_changed(struct city *pcity)
Definition agents.c:588
void agents_game_joined(void)
Definition agents.c:449
void agents_freeze_hint(void)
Definition agents.c:431
void agents_before_new_turn(void)
Definition agents.c:466
void attribute_restore(void)
Definition attribute.c:355
void audio_restart(const char *soundset_name, const char *musicset_name)
Definition audio.c:376
void audio_play_sound(const char *const tag, const char *const alt_tag, const char *const alt_tag2)
Definition audio.c:528
void base_type_init(struct extra_type *pextra, int idx)
Definition base.c:117
struct extra_type * base_extra_get(const struct base_type *pbase)
Definition base.c:101
struct base_type * base_by_number(const Base_type_id id)
Definition base.c:76
bool territory_claiming_base(const struct base_type *pbase)
Definition base.c:158
void dbv_set(struct dbv *pdbv, int bit)
Definition bitvector.c:144
void dbv_clr(struct dbv *pdbv, int bit)
Definition bitvector.c:167
#define BV_SET_VAL(bv, bit, val)
Definition bitvector.h:91
#define BV_SET(bv, bit)
Definition bitvector.h:81
#define BV_ARE_EQUAL(vec1, vec2)
Definition bitvector.h:113
#define BV_ISSET(bv, bit)
Definition bitvector.h:78
#define BV_CLR(bv, bit)
Definition bitvector.h:86
const char *const our_capability
Definition capstr.c:32
void output_window_append(const struct ft_color color, const char *featured_text)
void output_window_printf(const struct ft_color color, const char *format,...)
void citizens_nation_set(struct city *pcity, const struct player_slot *pslot, citizens count)
Definition citizens.c:145
citizens citizens_count(const struct city *pcity)
Definition citizens.c:162
void citizens_init(struct city *pcity)
Definition citizens.c:32
void city_map_radius_sq_set(struct city *pcity, int radius_sq)
Definition city.c:148
void city_name_set(struct city *pcity, const char *new_name)
Definition city.c:1145
void city_styles_alloc(int num)
Definition city.c:3396
const char * city_name_get(const struct city *pcity)
Definition city.c:1137
void city_production_caravan_shields_init(void)
Definition city.c:1778
void city_remove_improvement(struct city *pcity, const struct impr_type *pimprove)
Definition city.c:3371
void city_size_add(struct city *pcity, int add)
Definition city.c:1164
void free_city_map_index(void)
Definition city.c:609
bool city_unhappy(const struct city *pcity)
Definition city.c:1626
struct city * create_city_virtual(struct player *pplayer, struct tile *ptile, const char *name)
Definition city.c:3430
bool city_happy(const struct city *pcity)
Definition city.c:1614
void city_size_set(struct city *pcity, citizens size)
Definition city.c:1180
void city_add_improvement(struct city *pcity, const struct impr_type *pimprove)
Definition city.c:3357
int city_map_radius_sq_get(const struct city *pcity)
Definition city.c:137
void destroy_city_virtual(struct city *pcity)
Definition city.c:3516
void city_rally_point_receive(const struct packet_city_rally_point *packet, struct city *pcity)
Definition city.c:3641
static const struct city struct citystyle * city_styles
Definition city.c:84
#define city_list_iterate(citylist, pcity)
Definition city.h:508
#define city_tile(_pcity_)
Definition city.h:564
static citizens city_size_get(const struct city *pcity)
Definition city.h:569
#define city_tile_iterate_skip_free_worked(_nmap, _radius_sq, _city_tile, _tile, _index, _x, _y)
Definition city.h:214
@ CITIZEN_LAST
Definition city.h:272
@ CITIZEN_ANGRY
Definition city.h:271
@ CITIZEN_HAPPY
Definition city.h:268
@ CITIZEN_CONTENT
Definition city.h:269
@ CITIZEN_UNHAPPY
Definition city.h:270
#define output_type_iterate(output)
Definition city.h:845
#define city_owner(_pcity_)
Definition city.h:563
#define city_tile_iterate_skip_free_worked_end
Definition city.h:222
#define city_list_iterate_end
Definition city.h:510
#define I_NEVER
Definition city.h:247
@ FEELING_FINAL
Definition city.h:284
@ FEELING_LAST
Definition city.h:285
#define output_type_iterate_end
Definition city.h:851
void generate_citydlg_dimensions(void)
void popup_city_dialog(struct city *pcity)
void refresh_city_dialog(struct city *pcity)
void city_report_dialog_update_city(struct city *pcity)
void city_report_dialog_update(void)
char music_set_name[512]
void start_turn_change_wait(void)
bool client_is_global_observer(void)
void client_remove_cli_conn(struct connection *pconn)
bool client_is_observer(void)
void stop_turn_change_wait(void)
void set_server_busy(bool busy)
void user_ended_turn(void)
struct civclient client
bool auto_connect
enum client_states client_state(void)
void set_seconds_to_turndone(double seconds)
char sound_set_name[512]
bool can_client_issue_orders(void)
bool client_has_player(void)
void set_client_state(enum client_states newstate)
bool can_client_change_view(void)
#define client_player()
@ C_S_PREPARING
Definition client_main.h:46
@ C_S_RUNNING
Definition client_main.h:47
@ C_S_OVER
Definition client_main.h:48
enum known_type client_tile_get_known(const struct tile *ptile)
Definition climap.c:36
void create_event(struct tile *ptile, enum event_type event, const struct ft_color color, const char *format,...)
Definition climisc.c:1092
void client_player_init(struct player *pplayer)
Definition climisc.c:1372
void client_remove_city(struct city *pcity)
Definition climisc.c:134
void client_player_maps_reset(void)
Definition climisc.c:1383
void client_remove_unit(struct unit *punit)
Definition climisc.c:72
void unit_focus_set_status(struct player *pplayer)
Definition climisc.c:1362
void handle_event(const char *featured_text, struct tile *ptile, enum event_type event, int turn, int phase, int conn_id)
Definition climisc.c:967
void client_recv_remove_clause(int counterpart, int giver, enum clause_type type, int value)
Definition clitreaty.c:131
void client_recv_create_clause(int counterpart, int giver, enum clause_type type, int value)
Definition clitreaty.c:105
void client_recv_accept_treaty(int counterpart, bool I_accepted, bool other_accepted)
Definition clitreaty.c:59
void client_recv_cancel_meeting(int counterpart, int initiated_from)
Definition clitreaty.c:83
void client_init_meeting(int counterpart, int initiated_from)
Definition clitreaty.c:33
static void city_changed(int city_id)
Definition cma_core.c:448
char * incite_cost
Definition comments.c:75
void send_client_wants_hack(const char *filename)
int get_next_request_id(int old_request_id)
Definition connection.c:530
void conn_set_capability(struct connection *pconn, const char *capability)
Definition connection.c:661
struct connection * conn_by_number(int id)
Definition connection.c:421
#define conn_list_iterate(connlist, pconn)
Definition connection.h:108
#define conn_list_iterate_end
Definition connection.h:110
void do_move_unit(struct unit *punit, struct unit *target_unit)
Definition control.c:2802
bool unit_is_in_focus(const struct unit *punit)
Definition control.c:388
void action_selection_no_longer_in_progress(const int old_actor_id)
Definition control.c:1051
struct unit * get_focus_unit_on_tile(const struct tile *ptile)
Definition control.c:396
void action_decision_request(struct unit *actor_unit)
Definition control.c:1110
void set_units_in_combat(struct unit *pattacker, struct unit *pdefender)
Definition control.c:1032
void clear_hover_state(void)
Definition control.c:328
void unit_focus_set(struct unit *punit)
Definition control.c:506
bool should_ask_server_for_actions(const struct unit *punit)
Definition control.c:339
struct unit_list * get_units_in_focus(void)
Definition control.c:177
void request_do_action(action_id action, int actor_id, int target_id, int sub_tgt, const char *name)
Definition control.c:1730
void unit_focus_urgent(struct unit *punit)
Definition control.c:207
void unit_change_battlegroup(struct unit *punit, int battlegroup)
Definition control.c:255
bool non_ai_unit_focus
Definition control.c:125
void action_decision_clear_want(const int old_actor_id)
Definition control.c:1080
int get_num_units_in_focus(void)
Definition control.c:185
void unit_register_battlegroup(struct unit *punit)
Definition control.c:275
void unit_focus_update(void)
Definition control.c:789
void auto_center_on_focus_unit(void)
Definition control.c:434
void request_new_unit_activity(struct unit *punit, enum unit_activity act)
Definition control.c:1929
void action_selection_next_in_focus(const int old_actor_id)
Definition control.c:1092
int counters_get_city_counters_count(void)
Definition counters.c:74
struct counter * counter_by_id(int id)
Definition counters.c:82
void attach_city_counter(struct counter *counter)
Definition counters.c:94
struct unit struct city struct unit * target_unit
Definition dialogs_g.h:56
popup_action_selection
Definition dialogs_g.h:55
struct unit * actor_unit
Definition dialogs_g.h:55
struct unit struct city struct unit struct tile struct extra_type const struct act_prob *act_probs int actor_unit_id popup_bribe_dialog
Definition dialogs_g.h:73
const char * caption
Definition dialogs_g.h:37
const char const char * headline
Definition dialogs_g.h:38
popup_notify_dialog
Definition dialogs_g.h:37
struct unit struct city struct unit struct tile * target_tile
Definition dialogs_g.h:57
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
struct unit struct city * target_city
Definition dialogs_g.h:56
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 int cost
Definition dialogs_g.h:74
struct unit struct city struct unit struct tile struct extra_type * target_extra
Definition dialogs_g.h:57
struct clause_info * clause_info_get(enum clause_type type)
Definition diptreaty.c:276
struct disaster_type * disaster_by_number(Disaster_type_id id)
Definition disaster.c:87
editgui_notify_object_changed
Definition editgui_g.h:27
int int id
Definition editgui_g.h:28
bool editor_is_active(void)
Definition editor.c:346
void editor_ruleset_changed(void)
Definition editor.c:180
@ OBJTYPE_PLAYER
Definition editor.h:30
@ OBJTYPE_UNIT
Definition editor.h:28
@ OBJTYPE_STARTPOS
Definition editor.h:27
@ OBJTYPE_GAME
Definition editor.h:31
@ OBJTYPE_CITY
Definition editor.h:29
@ OBJTYPE_TILE
Definition editor.h:26
void recv_ruleset_effect(const struct packet_ruleset_effect *packet)
Definition effects.c:591
struct @21::@22 reqs
enum event_type event
Definition events.c:81
const char * get_event_tag(enum event_type event)
Definition events.c:276
struct player * extra_owner(const struct tile *ptile)
Definition extras.c:1114
void set_user_extra_flag_name(enum extra_flag_id id, const char *name, const char *helptxt)
Definition extras.c:933
struct extra_type_list * extra_type_list_of_zoccers(void)
Definition extras.c:267
bool extra_has_flag(const struct extra_type *pextra, enum extra_flag_id flag)
Definition extras.c:861
struct extra_type_list * extra_type_list_by_cause(enum extra_cause cause)
Definition extras.c:249
void extra_to_caused_by_list(struct extra_type *pextra, enum extra_cause cause)
Definition extras.c:312
struct extra_type * extra_by_number(int id)
Definition extras.c:183
struct extra_type_list * extra_type_list_of_terr_claimers(void)
Definition extras.c:275
bool is_extra_removed_by(const struct extra_type *pextra, enum extra_rmcause rmcause)
Definition extras.c:353
struct extra_type_list * extra_type_list_of_unit_hiders(void)
Definition extras.c:259
#define extra_type_iterate(_p)
Definition extras.h:315
static void extra_to_removed_by_list(struct extra_type *pextra, enum extra_rmcause rmcause)
Definition extras.h:214
#define extra_type_iterate_end
Definition extras.h:321
#define is_extra_caused_by(e, c)
Definition extras.h:203
#define extra_index(_e_)
Definition extras.h:183
#define EXTRA_NONE
Definition extras.h:85
#define EF_LAST_USER_FLAG
Definition extras.h:82
#define MAX_DISASTER_TYPES
Definition fc_types.h:52
#define MAX_GRANARY_INIS
Definition fc_types.h:72
#define MAX_NUM_BUILDING_LIST
Definition fc_types.h:46
int Tech_type_id
Definition fc_types.h:377
#define EC_NATURAL_DEFENSIVE
Definition fc_types.h:1116
#define EC_SPECIAL
Definition fc_types.h:1114
int action_id
Definition fc_types.h:389
#define SP_MAX
Definition fc_types.h:409
#define EC_NONE
Definition fc_types.h:1113
#define EC_NOT_AGGRESSIVE
Definition fc_types.h:1117
#define EC_DEFENSIVE
Definition fc_types.h:1115
#define IF_LAST_USER_FLAG
Definition fc_types.h:677
#define MAX_NUM_UNIT_LIST
Definition fc_types.h:45
#define MAX_EXTRA_TYPES
Definition fc_types.h:50
@ CTGT_CITY
Definition fc_types.h:126
#define MAX_ACHIEVEMENT_TYPES
Definition fc_types.h:53
#define MAX_NUM_TECH_LIST
Definition fc_types.h:44
@ O_SHIELD
Definition fc_types.h:101
@ O_FOOD
Definition fc_types.h:101
@ O_SCIENCE
Definition fc_types.h:101
@ O_GOLD
Definition fc_types.h:101
#define MAX_LEN_CITYNAME
Definition fc_types.h:67
#define MAX_COUNTERS
Definition fc_types.h:106
#define UCL_LAST
Definition fc_types.h:417
#define IDENTITY_NUMBER_ZERO
Definition fc_types.h:92
#define _(String)
Definition fcintl.h:67
const struct ft_color ftc_client
struct civ_game game
Definition game.c:62
void game_ruleset_init(void)
Definition game.c:512
bool is_player_phase(const struct player *pplayer, int phase)
Definition game.c:707
int current_turn_timeout(void)
Definition game.c:848
void game_ruleset_free(void)
Definition game.c:561
struct world wld
Definition game.c:63
struct unit * game_unit_by_number(int id)
Definition game.c:116
struct city * game_city_by_number(int id)
Definition game.c:107
void init_client_goto(void)
Definition goto.c:152
struct ruler_title * government_ruler_title_new(struct government *pgovern, const struct nation_type *pnation, const char *ruler_male_title, const char *ruler_female_title)
Definition government.c:325
struct government * government_by_number(const Government_type_id gov)
Definition government.c:103
struct government * government_of_player(const struct player *pplayer)
Definition government.c:114
void governments_alloc(int num)
Definition government.c:529
Government_type_id government_number(const struct government *pgovern)
Definition government.c:91
int action_selection_target_extra(void)
int action_selection_target_tile(void)
int action_selection_actor_unit(void)
void action_selection_close(void)
int action_selection_target_city(void)
void action_selection_refresh(struct unit *actor_unit, struct city *target_city, struct unit *target_unit, struct tile *target_tile, struct extra_type *target_extra, const struct act_prob *act_probs)
void popup_sabotage_dialog(struct unit *actor, struct city *pcity, const struct action *paction)
int action_selection_target_unit(void)
void popup_incite_dialog(struct unit *actor, struct city *pcity, int cost, const struct action *paction)
bool city_dialog_is_open(struct city *pcity)
Definition citydlg.c:587
void popdown_all_city_dialogs(void)
Definition citydlg.c:607
void refresh_unit_city_dialogs(struct unit *punit)
Definition citydlg.c:546
void server_connect(void)
Definition connectdlg.c:60
void close_connection_dialog(void)
Definition connectdlg.c:52
void races_update_pickable(bool nationset_change)
Definition dialogs.c:731
void show_tech_gained_dialog(Tech_type_id tech)
Definition dialogs.c:1524
void popdown_races_dialog(void)
Definition dialogs.c:1230
void popup_connect_msg(const char *headline, const char *message)
Definition dialogs.c:239
bool handmade_scenario_warning(void)
Definition dialogs.c:1573
void races_toggles_set_sensitive(void)
Definition dialogs.c:1245
void popup_combat_info(int attacker_unit_id, int defender_unit_id, int attacker_hp, int defender_hp, bool make_att_veteran, bool make_def_veteran)
Definition dialogs.c:1583
void popup_image(const char *tag)
Definition dialogs.c:1636
void editgui_notify_object_created(int tag, int id)
Definition editgui.c:1922
void editgui_refresh(void)
Definition editgui.c:1796
static GtkWidget * source
Definition gotodlg.c:58
enum gui_type get_gui_type(void)
Definition gui_main.c:2077
void update_infra_dialog(void)
Definition infradlg.c:138
void close_intel_dialog(struct player *p)
Definition inteldlg.c:223
void update_intel_dialog(struct player *p)
Definition inteldlg.c:462
void popup_newcity_dialog(struct unit *punit, const char *suggestname)
Definition mapctrl.c:197
void update_info_label(void)
Definition mapview.c:138
void start_turn(void)
Definition mapview.c:805
void update_unit_info_label(struct unit_list *punits)
Definition mapview.c:275
void update_city_descriptions(void)
Definition mapview.c:488
void update_start_page(void)
Definition pages.c:1675
void science_report_dialog_popup(bool raise)
Definition repodlgs.c:716
void endgame_report_dialog_start(const struct packet_endgame_report *packet)
Definition repodlgs.c:1983
GType type
Definition repodlgs.c:1313
void science_report_dialog_redraw(void)
Definition repodlgs.c:761
void popup_musicset_suggestion_dialog(void)
void popup_soundset_suggestion_dialog(void)
void refresh_spaceship_dialog(struct player *pplayer)
void popup_tileset_suggestion_dialog(void)
Definition tileset_dlg.c:58
void voteinfo_gui_update(void)
void conn_list_dialog_update(void)
void boot_help_texts(void)
Definition helpdata.c:710
void idex_register_unit(struct world *iworld, struct unit *punit)
Definition idex.c:82
void idex_unregister_city(struct world *iworld, struct city *pcity)
Definition idex.c:97
void idex_register_city(struct world *iworld, struct city *pcity)
Definition idex.c:67
struct impr_type * improvement_by_number(const Impr_type_id id)
const char * improvement_rule_name(const struct impr_type *pimprove)
bool is_improvement_visible(const struct impr_type *pimprove)
Impr_type_id improvement_index(const struct impr_type *pimprove)
void improvement_feature_cache_init(void)
Definition improvement.c:92
void set_user_impr_flag_name(enum impr_flag_id id, const char *name, const char *helptxt)
Impr_type_id improvement_count(void)
#define improvement_iterate_end
#define improvement_iterate(_p)
#define B_LAST
Definition improvement.h:42
const char * name
Definition inputfile.c:127
#define fc_assert_msg(condition, message,...)
Definition log.h:181
#define fc_assert_ret(condition)
Definition log.h:191
#define log_packet
Definition log.h:137
#define log_warn(message,...)
Definition log.h:105
#define log_verbose(message,...)
Definition log.h:109
#define fc_assert(condition)
Definition log.h:176
#define fc_assert_ret_msg(condition, message,...)
Definition log.h:205
#define fc_assert_ret_val(condition, val)
Definition log.h:194
#define fc_assert_action(condition, action)
Definition log.h:187
#define log_debug(message,...)
Definition log.h:115
#define log_normal(message,...)
Definition log.h:107
@ LOG_NORMAL
Definition log.h:32
#define log_error(message,...)
Definition log.h:103
struct startpos * map_startpos_get(const struct tile *ptile)
Definition map.c:1883
int startpos_number(const struct startpos *psp)
Definition map.c:1633
void map_free(struct civ_map *fmap)
Definition map.c:530
int sq_map_distance(const struct tile *tile0, const struct tile *tile1)
Definition map.c:641
struct startpos * map_startpos_new(struct tile *ptile)
Definition map.c:1866
void map_init_topology(struct civ_map *nmap)
Definition map.c:303
void main_map_allocate(void)
Definition map.c:519
struct tile * index_to_tile(const struct civ_map *imap, int mindex)
Definition map.c:456
bool map_startpos_remove(struct tile *ptile)
Definition map.c:1899
bool same_pos(const struct tile *tile1, const struct tile *tile2)
Definition map.c:940
bool startpos_unpack(struct startpos *psp, const struct packet_edit_startpos_full *packet)
Definition map.c:1726
struct terrain_misc terrain_control
Definition map.c:69
bool map_is_empty(void)
Definition map.c:149
#define whole_map_iterate(_map, _tile)
Definition map.h:545
#define whole_map_iterate_end
Definition map.h:554
void upgrade_canvas_clipboard(void)
void update_turn_done_button_state(void)
struct city * city_workers_display
void put_nuke_mushroom_pixmaps(struct tile *ptile)
void update_map_canvas_visible(void)
bool tile_visible_mapcanvas(struct tile *ptile)
enum topo_comp_lvl tileset_map_topo_compatible(int topology_id, struct tileset *tset, int *tset_topo)
void refresh_city_mapcanvas(struct city *pcity, struct tile *ptile, bool full_refresh, bool write_to_screen)
void mapdeco_init(void)
void center_tile_mapcanvas(const struct tile *ptile)
void link_marks_decrease_turn_counters(void)
void update_city_description(struct city *pcity)
const char * describe_topology(int topo)
void refresh_tile_mapcanvas(struct tile *ptile, bool full_refresh, bool write_to_screen)
void refresh_unit_mapcanvas(struct unit *punit, struct tile *ptile, bool full_refresh, bool write_to_screen)
void decrease_unit_hp_smooth(struct unit *punit0, int hp0, struct unit *punit1, int hp1)
@ TOPO_INCOMP_HARD
#define fc_calloc(n, esz)
Definition mem.h:38
#define FC_FREE(ptr)
Definition mem.h:41
#define fc_strdup(str)
Definition mem.h:43
#define fc_malloc(sz)
Definition mem.h:34
void menus_update(void)
void meswin_clear_older(int turn, int phase)
int utype_unknown_move_cost(const struct unit_type *utype)
Definition movement.c:105
void init_move_fragments(void)
Definition movement.c:927
Multiplier_type_id multiplier_count(void)
Definition multipliers.c:88
struct multiplier * multiplier_by_number(Multiplier_type_id id)
Definition multipliers.c:57
Multiplier_type_id multiplier_index(const struct multiplier *pmul)
Definition multipliers.c:80
#define multipliers_iterate(_mul_)
Definition multipliers.h:61
#define multipliers_iterate_end
Definition multipliers.h:67
void play_single_track(const char *const tag)
Definition music.c:116
void start_menu_music(const char *const tag, char *const alt_tag)
Definition music.c:98
void start_style_music(void)
Definition music.c:44
static void name_set(struct name_translation *ptrans, const char *domain, const char *vernacular_name)
static void names_set(struct name_translation *ptrans, const char *domain, const char *vernacular_name, const char *rule_name)
const char * nation_rule_name(const struct nation_type *pnation)
Definition nation.c:138
int nation_group_index(const struct nation_group *pgroup)
Definition nation.c:943
Nation_type_id nation_count(void)
Definition nation.c:507
struct nation_group * nation_group_new(const char *name)
Definition nation.c:960
struct nation_type * nation_of_unit(const struct unit *punit)
Definition nation.c:463
struct nation_set * nation_set_new(const char *set_name, const char *set_rule_name, const char *set_description)
Definition nation.c:716
struct nation_type * nation_by_number(const Nation_type_id nation)
Definition nation.c:475
int nation_set_index(const struct nation_set *pset)
Definition nation.c:699
struct nation_type * nation_of_city(const struct city *pcity)
Definition nation.c:454
struct nation_set * nation_set_by_number(int id)
Definition nation.c:762
struct nation_group * nation_group_by_number(int id)
Definition nation.c:1004
struct nation_leader * nation_leader_new(struct nation_type *pnation, const char *name, bool is_male)
Definition nation.c:239
void nations_alloc(int num)
Definition nation.c:622
const char * nation_legend_translation(const struct nation_type *pnation, const char *legend)
Definition nation.c:299
void resend_desired_settable_options(void)
Definition options.c:5754
const char * tileset_name_for_topology(int topology_id)
Definition options.c:6523
struct client_options gui_options
Definition options.c:71
void calculate_overview_dimensions(void)
void generic_handle_player_attribute_chunk(struct player *pplayer, const struct packet_player_attribute_chunk *chunk)
Definition packets.c:690
#define PACKET_STRVEC_EXTRACT(strvec, str)
Definition packets.h:191
#define REQEST_PLAYER_INITIATED
Definition packets.h:63
@ UNIT_INFO_CITY_PRESENT
Definition packets.h:69
@ UNIT_INFO_CITY_SUPPORTED
Definition packets.h:68
int dsend_packet_spaceship_place(struct connection *pc, enum spaceship_place_type type, int num)
int send_packet_conn_pong(struct connection *pc)
int dsend_packet_unit_get_actions(struct connection *pc, int actor_unit_id, int target_unit_id, int target_tile_id, int target_extra_id, int request_kind)
int dsend_packet_player_change_government(struct connection *pc, Government_type_id government)
int send_packet_client_info(struct connection *pc, const struct packet_client_info *packet)
packet_type
void handle_ruleset_game(const struct packet_ruleset_game *packet)
Definition packhand.c:4784
void handle_player_diplstate(const struct packet_player_diplstate *packet)
Definition packhand.c:2779
static action_id auto_attack_act(const struct act_prob *act_probs)
Definition packhand.c:5007
void handle_ruleset_nation_sets(const struct packet_ruleset_nation_sets *packet)
Definition packhand.c:4550
void handle_ruleset_nation(const struct packet_ruleset_nation *packet)
Definition packhand.c:4592
void handle_city_name_suggestion_info(int unit_id, const char *name)
Definition packhand.c:4855
void handle_sync_serial_reply(int serial)
Definition packhand.c:5657
static struct unit * unpackage_short_unit(const struct packet_unit_short_info *packet)
Definition packhand.c:363
void handle_nuke_tile_info(int tile)
Definition packhand.c:545
void handle_unknown_research(int id)
Definition packhand.c:2749
const action_id auto_attack_blockers[]
Definition packhand.c:162
void handle_ruleset_government_ruler_title(const struct packet_ruleset_government_ruler_title *packet)
Definition packhand.c:4012
void handle_city_info(const struct packet_city_info *packet)
Definition packhand.c:650
void handle_end_turn(void)
Definition packhand.c:1490
static struct unit * unpackage_unit(const struct packet_unit_info *packet)
Definition packhand.c:264
char * caption
Definition packhand.c:129
enum event_type event
Definition packhand.c:128
void handle_conn_info(const struct packet_conn_info *pinfo)
Definition packhand.c:2880
void handle_vote_remove(int vote_no)
Definition packhand.c:5477
void handle_investigate_finished(const struct packet_investigate_finished *packet)
Definition packhand.c:2144
void handle_page_msg_part(const char *lines)
Definition packhand.c:1620
void handle_unit_combat_info(const struct packet_unit_combat_info *packet)
Definition packhand.c:568
void handle_ruleset_style(const struct packet_ruleset_style *p)
Definition packhand.c:4700
void handle_unit_remove(int unit_id)
Definition packhand.c:491
void handle_vote_update(int vote_no, int yes, int no, int abstain, int num_voters)
Definition packhand.c:5486
static int last_turn
Definition packhand.c:137
void handle_ruleset_multiplier(const struct packet_ruleset_multiplier *p)
Definition packhand.c:3954
void handle_player_info(const struct packet_player_info *pinfo)
Definition packhand.c:2432
void handle_ruleset_extra(const struct packet_ruleset_extra *p)
Definition packhand.c:4153
void handle_ruleset_action_auto(const struct packet_ruleset_action_auto *p)
Definition packhand.c:4462
void handle_map_info(const struct packet_map_info *packet)
Definition packhand.c:2222
void handle_ruleset_unit_bonus(const struct packet_ruleset_unit_bonus *p)
Definition packhand.c:3667
void handle_start_phase(int phase)
Definition packhand.c:1417
void start_revolution(void)
Definition packhand.c:2376
void handle_timeout_info(float seconds_to_phasedone, float last_turn_change_time)
Definition packhand.c:2346
void handle_ruleset_terrain_control(const struct packet_ruleset_terrain_control *p)
Definition packhand.c:4537
static struct @229 page_msg_report
const action_id auto_attack_actions[]
Definition packhand.c:145
void handle_play_music(const char *tag)
Definition packhand.c:5544
static struct @228 invisible
void handle_investigate_started(const struct packet_investigate_started *packet)
Definition packhand.c:2120
void handle_edit_object_created(int tag, int id)
Definition packhand.c:5390
int parts
Definition packhand.c:132
void handle_conn_ping(void)
Definition packhand.c:5363
void handle_ruleset_tech_class(const struct packet_ruleset_tech_class *p)
Definition packhand.c:3839
void handle_diplomacy_init_meeting(int counterpart, int initiated_from)
Definition packhand.c:5560
void handle_ruleset_control(const struct packet_ruleset_control *packet)
Definition packhand.c:3398
void handle_end_phase(void)
Definition packhand.c:1406
void handle_ruleset_counter(const struct packet_ruleset_counter *packet)
Definition packhand.c:5604
void handle_server_info(const char *version_label, int major_version, int minor_version, int patch_version, int emerg_version)
Definition packhand.c:1573
void handle_ruleset_nation_groups(const struct packet_ruleset_nation_groups *packet)
Definition packhand.c:4571
void handle_ruleset_effect(const struct packet_ruleset_effect *packet)
Definition packhand.c:5379
void handle_new_year(int year, int fragments, int turn)
Definition packhand.c:1357
char * headline
Definition packhand.c:130
void handle_research_info(const struct packet_research_info *packet)
Definition packhand.c:2665
void handle_ruleset_goods(const struct packet_ruleset_goods *p)
Definition packhand.c:4369
void handle_unit_info(const struct packet_unit_info *packet)
Definition packhand.c:1646
void handle_ruleset_city(const struct packet_ruleset_city *packet)
Definition packhand.c:4735
void handle_ruleset_unit_class(const struct packet_ruleset_unit_class *p)
Definition packhand.c:3576
void handle_ruleset_government(const struct packet_ruleset_government *p)
Definition packhand.c:3982
void handle_ruleset_terrain_flag(const struct packet_ruleset_terrain_flag *p)
Definition packhand.c:4109
void handle_connect_msg(const char *message)
Definition packhand.c:1564
#define REQEST_BACKGROUND_REFRESH
Definition packhand.c:140
void handle_rulesets_ready(void)
Definition packhand.c:3522
void handle_tile_info(const struct packet_tile_info *packet)
Definition packhand.c:3110
void handle_ruleset_action(const struct packet_ruleset_action *p)
Definition packhand.c:4394
static void action_decision_handle(struct unit *punit)
Definition packhand.c:1662
void handle_achievement_info(int id, bool gained, bool first)
Definition packhand.c:3009
void handle_scenario_description(const char *description)
Definition packhand.c:3386
void play_sound_for_event(enum event_type type)
Definition packhand.c:1517
void handle_edit_startpos(const struct packet_edit_startpos *packet)
Definition packhand.c:5398
void handle_processing_finished(void)
Definition packhand.c:5298
static int unpack_tech_req(const enum tech_req r_num, const int reqs_size, const struct requirement *reqs, struct advance *a, int i)
Definition packhand.c:3744
void handle_diplomacy_cancel_meeting(int counterpart, int initiated_from)
Definition packhand.c:5577
void handle_city_short_info(const struct packet_city_short_info *packet)
Definition packhand.c:1158
void handle_edit_fogofwar_state(bool enabled)
Definition packhand.c:5467
void handle_popup_image(const char *tag)
Definition packhand.c:5552
void handle_diplomacy_create_clause(int counterpart, int giver, enum clause_type type, int value)
Definition packhand.c:5585
void handle_endgame_player(const struct packet_endgame_player *packet)
Definition packhand.c:5245
void handle_ruleset_resource(const struct packet_ruleset_resource *p)
Definition packhand.c:4134
void handle_unit_action_answer(int actor_id, int target_id, int cost, action_id action_type, int request_kind)
Definition packhand.c:4891
void handle_ruleset_tech(const struct packet_ruleset_tech *p)
Definition packhand.c:3774
void handle_team_name_info(int team_id, const char *team_name)
Definition packhand.c:553
void handle_thaw_client(void)
Definition packhand.c:5352
void handle_calendar_info(const struct packet_calendar_info *pcalendar)
Definition packhand.c:2338
void packhand_free(void)
Definition packhand.c:218
void set_government_choice(struct government *government)
Definition packhand.c:2363
void handle_city_rally_point(const struct packet_city_rally_point *packet)
Definition packhand.c:1007
void handle_ruleset_disaster(const struct packet_ruleset_disaster *p)
Definition packhand.c:4484
static bool handle_unit_packet_common(struct unit *packet_unit)
Definition packhand.c:1700
void handle_ruleset_unit_class_flag(const struct packet_ruleset_unit_class_flag *p)
Definition packhand.c:3712
void handle_server_join_reply(bool you_can_join, const char *message, const char *capability, const char *challenge_file, int conn_id)
Definition packhand.c:400
void handle_ruleset_summary(const struct packet_ruleset_summary *packet)
Definition packhand.c:3494
void handle_set_topology(int topology_id, int wrap_id)
Definition packhand.c:2199
void handle_ruleset_impr_flag(const struct packet_ruleset_impr_flag *p)
Definition packhand.c:3928
void handle_page_msg(const char *caption, const char *headline, enum event_type event, int len, int parts)
Definition packhand.c:1589
void handle_city_update_counters(const struct packet_city_update_counters *packet)
Definition packhand.c:5627
void handle_edit_startpos_full(const struct packet_edit_startpos_full *packet)
Definition packhand.c:5436
void handle_conn_ping_info(int connections, const int *conn_id, const float *ping_time)
Definition packhand.c:2986
void handle_diplomacy_remove_clause(int counterpart, int giver, enum clause_type type, int value)
Definition packhand.c:5594
static bool spaceship_autoplace(struct player *pplayer, struct player_spaceship *ship)
Definition packhand.c:3046
void handle_player_remove(int playerno)
Definition packhand.c:2387
void handle_processing_started(void)
Definition packhand.c:5280
void handle_begin_turn(void)
Definition packhand.c:1476
void handle_endgame_report(const struct packet_endgame_report *packet)
Definition packhand.c:5236
void handle_early_chat_msg(const struct packet_early_chat_msg *packet)
Definition packhand.c:1550
void handle_ruleset_clause(const struct packet_ruleset_clause *p)
Definition packhand.c:4712
void handle_ruleset_road(const struct packet_ruleset_road *p)
Definition packhand.c:4338
void handle_unit_actions(const struct packet_unit_actions *packet)
Definition packhand.c:5105
void handle_ruleset_music(const struct packet_ruleset_music *packet)
Definition packhand.c:4761
void handle_ruleset_base(const struct packet_ruleset_base *p)
Definition packhand.c:4317
void notify_about_incoming_packet(struct connection *pc, int packet_type, int size)
Definition packhand.c:5318
void handle_freeze_client(void)
Definition packhand.c:5342
void handle_city_remove(int city_id)
Definition packhand.c:468
void handle_chat_msg(const struct packet_chat_msg *packet)
Definition packhand.c:1530
static void city_packet_common(struct city *pcity, struct tile *pcenter, struct player *powner, struct tile_list *worked_tiles, bool is_new, bool popup, bool investigate)
Definition packhand.c:1021
void handle_trade_route_info(const struct packet_trade_route_info *packet)
Definition packhand.c:1123
void handle_player_attribute_chunk(const struct packet_player_attribute_chunk *packet)
Definition packhand.c:5262
void handle_vote_new(const struct packet_vote_new *packet)
Definition packhand.c:5508
static void packhand_init(void)
Definition packhand.c:239
void handle_scenario_info(const struct packet_scenario_info *packet)
Definition packhand.c:3365
void handle_ruleset_extra_flag(const struct packet_ruleset_extra_flag *p)
Definition packhand.c:4291
char * lines
Definition packhand.c:131
void notify_about_outgoing_packet(struct connection *pc, int packet_type, int size, int request_id)
Definition packhand.c:5328
#define VALIDATE(_count, _maximum, _string)
const char forced_tileset_name[]
struct city_list * cities
Definition packhand.c:119
void handle_ruleset_tech_flag(const struct packet_ruleset_tech_flag *p)
Definition packhand.c:3852
void handle_nation_availability(int ncount, const bool *is_pickable, bool nationset_change)
Definition packhand.c:4682
void handle_spaceship_info(const struct packet_spaceship_info *p)
Definition packhand.c:3065
void handle_ruleset_specialist(const struct packet_ruleset_specialist *p)
Definition packhand.c:4829
void handle_unit_short_info(const struct packet_unit_short_info *packet)
Definition packhand.c:2151
void handle_diplomacy_accept_treaty(int counterpart, bool I_accepted, bool other_accepted)
Definition packhand.c:5568
void handle_ruleset_unit_flag(const struct packet_ruleset_unit_flag *p)
Definition packhand.c:3687
void handle_city_nationalities(const struct packet_city_nationalities *packet)
Definition packhand.c:987
void handle_server_shutdown(void)
Definition packhand.c:5371
void handle_ruleset_building(const struct packet_ruleset_building *p)
Definition packhand.c:3877
static bool update_improvement_from_packet(struct city *pcity, struct impr_type *pimprove, bool have_impr)
Definition packhand.c:628
void handle_ruleset_unit(const struct packet_ruleset_unit *p)
Definition packhand.c:3594
void handle_ruleset_terrain(const struct packet_ruleset_terrain *p)
Definition packhand.c:4026
static void action_decision_maybe_auto(struct unit *actor_unit, const struct act_prob *act_probs, struct unit *target_unit, struct city *target_city, struct tile *target_tile)
Definition packhand.c:5037
#define REQEST_BACKGROUND_FAST_AUTO_ATTACK
Definition packhand.c:142
void handle_city_sabotage_list(int actor_id, int city_id, bv_imprs improvements, action_id act_id, int request_kind)
Definition packhand.c:5175
void handle_ruleset_action_enabler(const struct packet_ruleset_action_enabler *p)
Definition packhand.c:4428
void handle_ruleset_achievement(const struct packet_ruleset_achievement *p)
Definition packhand.c:4506
void handle_game_info(const struct packet_game_info *pinfo)
Definition packhand.c:2262
struct player * placeholder
Definition packhand.c:120
void handle_vote_resolve(int vote_no, bool passed)
Definition packhand.c:5525
void handle_worker_task(const struct packet_worker_task *packet)
Definition packhand.c:1300
void handle_ruleset_description_part(const struct packet_ruleset_description_part *packet)
Definition packhand.c:3512
void handle_ruleset_trade(const struct packet_ruleset_trade *p)
Definition packhand.c:4522
int len
Definition packhand.c:127
void set_client_page(enum client_pages page)
enum client_pages get_client_page(void)
bool player_slot_is_used(const struct player_slot *pslot)
Definition player.c:448
struct unit * player_unit_by_number(const struct player *pplayer, int unit_id)
Definition player.c:1229
struct player * player_new(struct player_slot *pslot)
Definition player.c:493
struct player * player_by_number(const int player_id)
Definition player.c:849
int player_count(void)
Definition player.c:817
struct player_slot * player_slot_by_number(int player_id)
Definition player.c:463
int player_number(const struct player *pplayer)
Definition player.c:837
const char * player_name(const struct player *pplayer)
Definition player.c:895
void player_set_color(struct player *pplayer, const struct rgbcolor *prgbcolor)
Definition player.c:648
int player_index(const struct player *pplayer)
Definition player.c:829
bool player_set_nation(struct player *pplayer, struct nation_type *pnation)
Definition player.c:861
struct player_diplstate * player_diplstate_get(const struct player *plr1, const struct player *plr2)
Definition player.c:324
bool can_player_see_units_in_city(const struct player *pplayer, const struct city *pcity)
Definition player.c:1133
struct player * player_slot_get_player(const struct player_slot *pslot)
Definition player.c:437
bool can_player_see_city_internals(const struct player *pplayer, const struct city *pcity)
Definition player.c:1149
void player_destroy(struct player *pplayer)
Definition player.c:756
#define players_iterate_end
Definition player.h:537
#define players_iterate(_pplayer)
Definition player.h:532
#define ANON_USER_NAME
Definition player.h:48
#define is_ai(plr)
Definition player.h:230
#define ANON_PLAYER_NAME
Definition player.h:43
#define is_human(plr)
Definition player.h:229
void players_dialog_update(void)
#define fc_rand(_size)
Definition rand.h:56
void multipliers_dialog_update(void)
const struct packet_endgame_player *packet void science_report_dialog_update(void)
void economy_report_dialog_update(void)
void units_report_dialog_update(void)
endgame_report_dialog_player
Definition repodlgs_g.h:33
struct universal universal_by_number(const enum universals_n kind, const int value)
bool are_universals_equal(const struct universal *psource1, const struct universal *psource2)
enum tech_state research_invention_set(struct research *presearch, Tech_type_id tech, enum tech_state value)
Definition research.c:637
struct research * research_by_number(int number)
Definition research.c:118
struct research * research_get(const struct player *pplayer)
Definition research.c:128
void research_update(struct research *presearch)
Definition research.c:501
#define research_players_iterate(_presearch, _pplayer)
Definition research.h:166
#define research_players_iterate_end
Definition research.h:170
void rgbcolor_destroy(struct rgbcolor *prgbcolor)
Definition rgbcolor.c:74
struct rgbcolor * rgbcolor_new(int r, int g, int b)
Definition rgbcolor.c:34
void road_integrators_cache_init(void)
Definition road.c:111
struct road_type * road_by_number(Road_type_id id)
Definition road.c:58
void road_type_init(struct extra_type *pextra, int idx)
Definition road.c:93
void script_client_signal_emit(const char *signal_name,...)
static struct connection connections[MAX_NUM_CONNECTIONS]
Definition sernet.c:94
#define ARRAY_SIZE(x)
Definition shared.h:85
#define MIN(x, y)
Definition shared.h:55
#define MAX(x, y)
Definition shared.h:54
bool next_spaceship_component(struct player *pplayer, struct player_spaceship *ship, struct spaceship_component *fill)
Definition spaceship.c:130
struct specialist * specialist_by_number(const Specialist_type_id id)
Definition specialist.c:100
#define specialist_type_iterate_end
Definition specialist.h:79
#define specialist_type_iterate(sp)
Definition specialist.h:73
#define DEFAULT_SPECIALIST
Definition specialist.h:43
size_t size
Definition specvec.h:72
#define strvec_iterate(psv, str)
#define strvec_iterate_end
struct player * first
bool actor_consuming_always
Definition actions.h:395
int max_distance
Definition actions.h:378
bool quiet
Definition actions.h:385
enum action_sub_target_kind sub_target_kind
Definition actions.h:370
enum action_result result
Definition actions.h:365
char ui_name[MAX_LEN_NAME]
Definition actions.h:381
bv_action_sub_results sub_results
Definition actions.h:366
enum action_actor_kind actor_kind
Definition actions.h:368
bv_actions blocked_by
Definition actions.h:389
enum action_target_kind target_kind
Definition actions.h:369
int min_distance
Definition actions.h:378
struct requirement_vector research_reqs
Definition tech.h:137
struct tech_class * tclass
Definition tech.h:130
double cost
Definition tech.h:150
struct advance * require[AR_SIZE]
Definition tech.h:132
struct name_translation name
Definition tech.h:126
struct strvec * helptext
Definition tech.h:140
bv_tech_flags flags
Definition tech.h:139
int num_reqs
Definition tech.h:156
char graphic_str[MAX_LEN_NAME]
Definition tech.h:128
char graphic_alt[MAX_LEN_NAME]
Definition tech.h:129
int turn
Definition city.h:246
Definition city.h:320
struct worker_task_list * task_reqs
Definition city.h:412
int turn_last_built
Definition city.h:387
int surplus[O_LAST]
Definition city.h:355
enum city_wl_cancel_behavior wlcb
Definition city.h:404
int food_stock
Definition city.h:367
struct built_status built[B_LAST]
Definition city.h:394
struct player * original
Definition city.h:324
int history
Definition city.h:410
int * counter_values
Definition city.h:408
int pollution
Definition city.h:369
bool did_sell
Definition city.h:380
int id
Definition city.h:326
int last_turns_shield_surplus
Definition city.h:392
enum capital_type capital
Definition city.h:328
int disbanded_shields
Definition city.h:391
int waste[O_LAST]
Definition city.h:356
struct unit_list * info_units_present
Definition city.h:474
bv_city_options city_options
Definition city.h:403
int city_radius_sq
Definition city.h:375
bool was_happy
Definition city.h:381
struct player * owner
Definition city.h:323
enum city_acquire_type acquire_t
Definition city.h:329
int turn_founded
Definition city.h:386
int airlift
Definition city.h:378
int citizen_base[O_LAST]
Definition city.h:359
int caravan_shields
Definition city.h:390
bool did_buy
Definition city.h:379
struct unit_list * info_units_supported
Definition city.h:473
char * name
Definition city.h:321
struct trade_route_list * routes
Definition city.h:344
bool occupied
Definition city.h:460
int usage[O_LAST]
Definition city.h:360
struct worklist worklist
Definition city.h:401
struct universal production
Definition city.h:396
int walls
Definition city.h:461
bool happy
Definition city.h:462
struct unit_list * collecting_info_units_supported
Definition city.h:477
int steal
Definition city.h:414
int unhappy_penalty[O_LAST]
Definition city.h:357
unsigned char first_citizen_index
Definition city.h:483
int before_change_shields
Definition city.h:389
int culture
Definition city.h:465
int style
Definition city.h:327
bool had_famine
Definition city.h:382
struct unit_list * collecting_info_units_present
Definition city.h:478
int buy_cost
Definition city.h:466
citizens feel[CITIZEN_LAST][FEELING_LAST]
Definition city.h:333
citizens specialists[SP_MAX]
Definition city.h:336
struct tile * tile
Definition city.h:322
int shield_stock
Definition city.h:368
int prod[O_LAST]
Definition city.h:358
int city_image
Definition city.h:464
struct universal changed_from
Definition city.h:399
bool unhappy
Definition city.h:463
struct unit_list * units_supported
Definition city.h:406
int illness_trade
Definition city.h:370
struct city::@17::@20 client
bool fog_of_war
Definition game.h:121
struct rgbcolor * plr_bg_color
Definition game.h:103
struct packet_scenario_description scenario_desc
Definition game.h:88
struct packet_ruleset_control control
Definition game.h:83
char * ruleset_summary
Definition game.h:84
struct conn_list * est_connections
Definition game.h:97
int global_init_techs[MAX_NUM_TECH_LIST]
Definition game.h:110
struct packet_game_info info
Definition game.h:89
bool ruleset_ready
Definition game.h:119
int global_init_buildings[MAX_NUM_BUILDING_LIST]
Definition game.h:111
struct packet_scenario_info scenario
Definition game.h:87
char * ruleset_description
Definition game.h:85
struct conn_list * all_connections
Definition game.h:96
bool ruleset_init
Definition game.h:118
struct civ_game::@30 rgame
struct packet_timeout_info tinfo
Definition game.h:91
struct veteran_system * veteran
Definition game.h:101
struct packet_calendar_info calendar
Definition game.h:90
struct government * default_government
Definition game.h:93
struct civ_game::@31::@34 client
struct government * government_during_revolution
Definition game.h:94
int xsize
Definition map_types.h:78
int ysize
Definition map_types.h:78
int north_latitude
Definition map_types.h:79
Continent_id num_continents
Definition map_types.h:81
int south_latitude
Definition map_types.h:80
int topology_id
Definition map_types.h:72
int wrap_id
Definition map_types.h:73
struct connection conn
Definition client_main.h:96
struct requirement_vector receiver_reqs
Definition diptreaty.h:59
struct requirement_vector giver_reqs
Definition diptreaty.h:58
bool enabled
Definition diptreaty.h:57
bool sound_bell_at_new_turn
Definition options.h:150
bool autoaccept_tileset_suggestion
Definition options.h:183
bool autoaccept_musicset_suggestion
Definition options.h:185
bool draw_city_names
Definition options.h:196
bool draw_city_productions
Definition options.h:198
bool popup_new_cities
Definition options.h:167
bool draw_city_trade_routes
Definition options.h:200
bool wakeup_focus
Definition options.h:159
bool autoaccept_soundset_suggestion
Definition options.h:184
bool ask_city_name
Definition options.h:166
bool draw_city_growth
Definition options.h:197
bool ai_manual_turn_done
Definition options.h:154
int smooth_combat_step_msec
Definition options.h:153
bool draw_full_citybar
Definition options.h:216
bool auto_center_on_combat
Definition options.h:157
bool popup_attack_actions
Definition options.h:169
enum unit_type_flag_id flag
Definition unittype.h:467
enum combat_bonus_type type
Definition unittype.h:468
bool established
Definition connection.h:140
struct player * playing
Definition connection.h:151
int request_id_of_currently_handled_packet
Definition connection.h:193
struct connection::@58::@63 client
enum cmdlevel access_level
Definition connection.h:177
bool observer
Definition connection.h:147
char username[MAX_LEN_NAME]
Definition connection.h:164
char capability[MAX_LEN_CAPSTR]
Definition connection.h:171
int last_processed_request_id_seen
Definition connection.h:190
double ping_time
Definition connection.h:161
bv_unit_classes native_to
Definition extras.h:130
char rmact_gfx[MAX_LEN_NAME]
Definition extras.h:102
bv_extras conflicts
Definition extras.h:133
uint8_t rmcauses
Definition extras.h:95
char act_gfx_alt[MAX_LEN_NAME]
Definition extras.h:100
struct requirement_vector appearance_reqs
Definition extras.h:108
struct strvec * helptext
Definition extras.h:149
bv_extra_flags flags
Definition extras.h:132
char rmact_gfx_alt[MAX_LEN_NAME]
Definition extras.h:103
uint16_t causes
Definition extras.h:94
bv_extras bridged_over
Definition extras.h:135
struct extra_type::@25 data
int removal_time
Definition extras.h:120
char rmact_gfx_alt2[MAX_LEN_NAME]
Definition extras.h:104
int build_time_factor
Definition extras.h:119
struct requirement_vector disappearance_reqs
Definition extras.h:109
bool generated
Definition extras.h:117
int special_idx
Definition extras.h:153
struct requirement_vector rmreqs
Definition extras.h:107
Tech_type_id visibility_req
Definition extras.h:139
enum extra_category category
Definition extras.h:93
char graphic_alt[MAX_LEN_NAME]
Definition extras.h:98
char activity_gfx[MAX_LEN_NAME]
Definition extras.h:99
int disappearance_chance
Definition extras.h:126
int removal_time_factor
Definition extras.h:121
char act_gfx_alt2[MAX_LEN_NAME]
Definition extras.h:101
struct requirement_vector reqs
Definition extras.h:106
bool buildable
Definition extras.h:116
enum extra_unit_seen_type eus
Definition extras.h:128
int defense_bonus
Definition extras.h:124
int appearance_chance
Definition extras.h:125
char graphic_str[MAX_LEN_NAME]
Definition extras.h:97
int build_time
Definition extras.h:118
int infracost
Definition extras.h:122
int no_aggr_near_city
Definition extras.h:137
bv_extras hidden_by
Definition extras.h:134
struct name_translation name
Definition extras.h:90
struct strvec * helptext
Definition government.h:65
struct requirement_vector reqs
Definition government.h:62
char graphic_alt[MAX_LEN_NAME]
Definition government.h:58
Government_type_id item_number
Definition government.h:53
char sound_alt2[MAX_LEN_NAME]
Definition government.h:61
struct name_translation name
Definition government.h:54
char sound_str[MAX_LEN_NAME]
Definition government.h:59
char graphic_str[MAX_LEN_NAME]
Definition government.h:57
char sound_alt[MAX_LEN_NAME]
Definition government.h:60
int build_cost
Definition improvement.h:60
char graphic_str[MAX_LEN_NAME]
Definition improvement.h:55
char graphic_alt2[MAX_LEN_NAME]
Definition improvement.h:57
enum impr_genus_id genus
Definition improvement.h:63
char graphic_alt[MAX_LEN_NAME]
Definition improvement.h:56
struct requirement_vector obsolete_by
Definition improvement.h:59
char soundtag_alt[MAX_LEN_NAME]
Definition improvement.h:67
char soundtag_alt2[MAX_LEN_NAME]
Definition improvement.h:68
struct requirement_vector reqs
Definition improvement.h:58
struct strvec * helptext
Definition improvement.h:65
struct name_translation name
Definition improvement.h:52
bv_impr_flags flags
Definition improvement.h:64
char soundtag[MAX_LEN_NAME]
Definition improvement.h:66
struct requirement_vector reqs
Definition multipliers.h:42
struct strvec * helptext
Definition multipliers.h:43
int minimum_turns
Definition multipliers.h:41
struct name_translation name
Definition multipliers.h:33
int init_buildings[MAX_NUM_BUILDING_LIST]
Definition nation.h:123
struct nation_group_list * groups
Definition nation.h:116
struct name_translation noun_plural
Definition nation.h:102
struct nation_set_list * sets
Definition nation.h:113
char flag_graphic_str[MAX_LEN_NAME]
Definition nation.h:103
struct name_translation adjective
Definition nation.h:101
char flag_graphic_alt[MAX_LEN_NAME]
Definition nation.h:104
struct government * init_government
Definition nation.h:124
bool is_pickable
Definition nation.h:161
struct unit_type * init_units[MAX_NUM_UNIT_LIST]
Definition nation.h:125
char * legend
Definition nation.h:107
enum barbarian_type barb_type
Definition nation.h:110
struct nation_type::@51::@54 client
char * translation_domain
Definition nation.h:100
struct nation_style * style
Definition nation.h:106
int init_techs[MAX_NUM_TECH_LIST]
Definition nation.h:122
bool is_playable
Definition nation.h:109
char message[MAX_LEN_MSG]
enum event_type event
int last_turns_shield_surplus
int usage[O_LAST]
int ppl_content[FEELING_LAST]
bv_city_options city_options
enum capital_type capital
int surplus[O_LAST]
enum city_acquire_type acquire_type
int ppl_unhappy[FEELING_LAST]
int citizen_base[O_LAST]
enum city_wl_cancel_behavior wl_cb
int specialists[SP_MAX]
int ppl_angry[FEELING_LAST]
bv_imprs improvements
struct worklist worklist
char name[MAX_LEN_CITYNAME]
int ppl_happy[FEELING_LAST]
int prod[O_LAST]
int unhappy_penalty[O_LAST]
int waste[O_LAST]
int nation_id[MAX_CITY_NATIONALITIES]
int nation_citizens[MAX_CITY_NATIONALITIES]
enum capital_type capital
char name[MAX_LEN_CITYNAME]
int counters[MAX_COUNTERS]
enum event_type event
char message[MAX_LEN_MSG]
Government_type_id government_during_revolution_id
enum ai_level skill_level
enum phase_mode_type phase_mode
enum victory_condition_type victory_conditions
Government_type_id default_government_id
enum diplstate_type type
char inventions[A_LAST+1]
char rule_name[MAX_LEN_NAME]
enum achievement_type type
char name[MAX_LEN_NAME]
action_id alternatives[MAX_NUM_ACTIONS]
struct requirement reqs[MAX_NUM_REQS]
enum action_auto_perf_cause cause
struct requirement actor_reqs[MAX_NUM_REQS]
struct requirement target_reqs[MAX_NUM_REQS]
enum action_sub_target_kind sub_tgt_kind
enum action_actor_kind act_kind
bv_action_sub_results sub_results
char ui_name[MAX_LEN_NAME]
enum action_target_kind tgt_kind
enum action_result result
enum base_gui_type gui_type
char helptext[MAX_LEN_PACKET]
struct requirement obs_reqs[MAX_NUM_REQS]
char soundtag_alt[MAX_LEN_NAME]
struct requirement reqs[MAX_NUM_REQS]
enum impr_genus_id genus
char name[MAX_LEN_NAME]
char soundtag[MAX_LEN_NAME]
char soundtag_alt2[MAX_LEN_NAME]
char rule_name[MAX_LEN_NAME]
char graphic_alt2[MAX_LEN_NAME]
char graphic_str[MAX_LEN_NAME]
char graphic_alt[MAX_LEN_NAME]
char citizens_graphic[MAX_LEN_NAME]
char name[MAX_LEN_NAME]
char rule_name[MAX_LEN_NAME]
char graphic_alt[MAX_LEN_NAME]
char graphic[MAX_LEN_NAME]
struct requirement reqs[MAX_NUM_REQS]
enum clause_type type
struct requirement receiver_reqs[MAX_NUM_REQS]
struct requirement giver_reqs[MAX_NUM_REQS]
char preferred_soundset[MAX_LEN_NAME]
char preferred_tileset[MAX_LEN_NAME]
char preferred_musicset[MAX_LEN_NAME]
enum counter_behaviour behaviour
enum counter_target type
char name[MAX_LEN_NAME]
char rule_name[MAX_LEN_NAME]
char helptext[MAX_LEN_PACKET]
char text[MAX_LEN_CONTENT]
char rule_name[MAX_LEN_NAME]
struct requirement reqs[MAX_NUM_REQS]
bv_disaster_effects effects
char name[MAX_LEN_NAME]
char helptxt[MAX_LEN_PACKET]
char name[MAX_LEN_NAME]
bv_unit_classes native_to
char rmact_gfx_alt2[MAX_LEN_NAME]
struct requirement reqs[MAX_NUM_REQS]
char graphic_alt[MAX_LEN_NAME]
char act_gfx_alt2[MAX_LEN_NAME]
struct requirement disappearance_reqs[MAX_NUM_REQS]
bv_extra_flags flags
char act_gfx_alt[MAX_LEN_NAME]
char activity_gfx[MAX_LEN_NAME]
char rule_name[MAX_LEN_NAME]
enum extra_unit_seen_type eus
struct requirement appearance_reqs[MAX_NUM_REQS]
char name[MAX_LEN_NAME]
char graphic_str[MAX_LEN_NAME]
char rmact_gfx_alt[MAX_LEN_NAME]
char rmact_gfx[MAX_LEN_NAME]
struct requirement rmreqs[MAX_NUM_REQS]
char helptext[MAX_LEN_PACKET]
int work_raise_chance[MAX_VET_LEVELS]
int base_raise_chance[MAX_VET_LEVELS]
int global_init_techs[MAX_NUM_TECH_LIST]
int move_bonus[MAX_VET_LEVELS]
char veteran_name[MAX_VET_LEVELS][MAX_LEN_NAME]
Impr_type_id global_init_buildings[MAX_NUM_BUILDING_LIST]
int power_fact[MAX_VET_LEVELS]
char helptext[MAX_LEN_PACKET]
bv_goods_flags flags
char name[MAX_LEN_NAME]
char rule_name[MAX_LEN_NAME]
struct requirement reqs[MAX_NUM_REQS]
char sound_alt[MAX_LEN_NAME]
char graphic_alt[MAX_LEN_NAME]
char rule_name[MAX_LEN_NAME]
char name[MAX_LEN_NAME]
Government_type_id id
char sound_str[MAX_LEN_NAME]
char graphic_str[MAX_LEN_NAME]
struct requirement reqs[MAX_NUM_REQS]
char helptext[MAX_LEN_PACKET]
char sound_alt2[MAX_LEN_NAME]
char name[MAX_LEN_NAME]
char helptxt[MAX_LEN_PACKET]
char name[MAX_LEN_NAME]
Multiplier_type_id id
struct requirement reqs[MAX_NUM_REQS]
char rule_name[MAX_LEN_NAME]
char helptext[MAX_LEN_PACKET]
char music_combat[MAX_LEN_NAME]
struct requirement reqs[MAX_NUM_REQS]
char music_peaceful[MAX_LEN_NAME]
char groups[MAX_NUM_NATION_GROUPS][MAX_LEN_NAME]
bool hidden[MAX_NUM_NATION_GROUPS]
char rule_names[MAX_NUM_NATION_SETS][MAX_LEN_NAME]
char names[MAX_NUM_NATION_SETS][MAX_LEN_NAME]
char descriptions[MAX_NUM_NATION_SETS][MAX_LEN_MSG]
int init_techs[MAX_NUM_TECH_LIST]
char leader_name[MAX_NUM_LEADERS][MAX_LEN_NAME]
char noun_plural[MAX_LEN_NAME]
char adjective[MAX_LEN_NAME]
Impr_type_id init_buildings[MAX_NUM_BUILDING_LIST]
Unit_type_id init_units[MAX_NUM_UNIT_LIST]
bool leader_is_male[MAX_NUM_LEADERS]
char translation_domain[MAX_LEN_NAME]
char graphic_str[MAX_LEN_NAME]
Government_type_id init_government_id
int groups[MAX_NUM_NATION_GROUPS]
enum barbarian_type barbarian_type
int sets[MAX_NUM_NATION_SETS]
char graphic_alt[MAX_LEN_NAME]
char rule_name[MAX_LEN_NAME]
char legend[MAX_LEN_MSG]
bv_road_flags flags
int tile_incr_const[O_LAST]
enum road_gui_type gui_type
bv_max_extras integrates
enum road_compat compat
enum road_move_mode move_mode
int tile_bonus[O_LAST]
int tile_incr[O_LAST]
struct requirement first_reqs[MAX_NUM_REQS]
char rule_name[MAX_LEN_NAME]
char graphic_alt[MAX_LEN_NAME]
struct requirement reqs[MAX_NUM_REQS]
Specialist_type_id id
char helptext[MAX_LEN_PACKET]
char short_name[MAX_LEN_NAME]
char graphic_str[MAX_LEN_NAME]
char plural_name[MAX_LEN_NAME]
char name[MAX_LEN_NAME]
char rule_name[MAX_LEN_NAME]
char text[MAX_LEN_CONTENT]
char name[MAX_LEN_NAME]
char rule_name[MAX_LEN_NAME]
char name[MAX_LEN_NAME]
char helptxt[MAX_LEN_PACKET]
char name[MAX_LEN_NAME]
struct requirement research_reqs[MAX_NUM_REQS]
char graphic_str[MAX_LEN_NAME]
char rule_name[MAX_LEN_NAME]
char graphic_alt[MAX_LEN_NAME]
bv_tech_flags flags
char helptext[MAX_LEN_PACKET]
char name[MAX_LEN_NAME]
char helptxt[MAX_LEN_PACKET]
int extra_removal_times[MAX_EXTRA_TYPES]
Terrain_type_id transform_result
int resource_freq[MAX_EXTRA_TYPES]
char helptext[MAX_LEN_PACKET]
Resource_type_id resources[MAX_EXTRA_TYPES]
bv_terrain_flags flags
char graphic_str[MAX_LEN_NAME]
bv_unit_classes native_to
Terrain_type_id cultivate_result
Terrain_type_id plant_result
char name[MAX_LEN_NAME]
int road_output_incr_pct[O_LAST]
char graphic_alt[MAX_LEN_NAME]
char graphic_alt2[MAX_LEN_NAME]
char rule_name[MAX_LEN_NAME]
enum trade_route_illegal_cancelling cancelling
enum trade_route_bonus_type bonus_type
enum combat_bonus_type type
enum unit_type_flag_id flag
char helptxt[MAX_LEN_PACKET]
char rule_name[MAX_LEN_NAME]
bv_unit_class_flags flags
char name[MAX_LEN_NAME]
char helptext[MAX_LEN_PACKET]
char name[MAX_LEN_NAME]
char helptxt[MAX_LEN_PACKET]
char graphic_alt[MAX_LEN_NAME]
enum vision_layer vlayer
enum transp_def_type tp_defense
char rule_name[MAX_LEN_NAME]
int power_fact[MAX_VET_LEVELS]
char name[MAX_LEN_NAME]
char graphic_alt2[MAX_LEN_NAME]
char graphic_str[MAX_LEN_NAME]
char sound_fight_alt[MAX_LEN_NAME]
bv_unit_classes disembarks
bv_unit_classes cargo
bv_unit_type_flags flags
char sound_move_alt[MAX_LEN_NAME]
bv_unit_classes targets
struct requirement build_reqs[MAX_NUM_REQS]
int base_raise_chance[MAX_VET_LEVELS]
int work_raise_chance[MAX_VET_LEVELS]
char sound_fight[MAX_LEN_NAME]
bv_unit_classes embarks
char veteran_name[MAX_VET_LEVELS][MAX_LEN_NAME]
char sound_move[MAX_LEN_NAME]
char helptext[MAX_LEN_PACKET]
bv_unit_type_roles roles
int move_bonus[MAX_VET_LEVELS]
char description[MAX_LEN_CONTENT]
char authors[MAX_LEN_PACKET/3]
bv_spaceship_structure structure
Resource_type_id resource
enum known_type known
char label[MAX_LEN_MAP_LABEL]
Continent_id continent
Definition packets_gen.h:99
Terrain_type_id terrain
char spec_sprite[MAX_LEN_NAME]
enum route_direction direction
struct act_prob action_probabilities[MAX_NUM_ACTIONS]
int upkeep[O_LAST]
enum action_decision action_decision_want
struct unit_order orders[MAX_LEN_ROUTE]
enum unit_activity activity
Unit_type_id type
enum unit_activity changed_from
enum direction8 facing
enum server_side_agent ssa_controller
enum direction8 facing
char user[MAX_LEN_NAME]
enum unit_activity activity
enum ai_level skill_level
Definition player.h:114
enum barbarian_type barbarian_type
Definition player.h:120
int science_cost
Definition player.h:117
int love[MAX_NUM_PLAYER_SLOTS]
Definition player.h:122
int infra_points
Definition player.h:65
enum spaceship_state state
Definition spaceship.h:108
struct city_list * cities
Definition player.h:279
struct player_ai ai_common
Definition player.h:286
bv_plr_flags flags
Definition player.h:290
struct dbv tile_vision[V_COUNT]
Definition player.h:357
int primary_capital_id
Definition player.h:273
bool is_male
Definition player.h:255
int wonders[B_LAST]
Definition player.h:303
struct government * target_government
Definition player.h:257
int autoselect_weight
Definition player.h:297
char username[MAX_LEN_NAME]
Definition player.h:250
bool is_connected
Definition player.h:294
int revolution_finishes
Definition player.h:271
int nturns_idle
Definition player.h:263
struct government * government
Definition player.h:256
struct dbv tile_known
Definition player.h:308
int turns_alive
Definition player.h:264
bool was_created
Definition player.h:292
int tech_upkeep
Definition player.h:361
struct unit_list * units
Definition player.h:280
struct conn_list * connections
Definition player.h:296
bool is_alive
Definition player.h:266
bv_player real_embassy
Definition player.h:275
struct player::@70::@73 client
struct player_economic economic
Definition player.h:282
int culture
Definition player.h:365
struct player_spaceship spaceship
Definition player.h:284
char name[MAX_LEN_NAME]
Definition player.h:249
bv_player gives_shared_vision
Definition player.h:300
enum mood_type mood
Definition player.h:359
struct player_score score
Definition player.h:281
struct multiplier_value multipliers[MAX_NUM_MULTIPLIERS]
Definition player.h:312
bool color_changeable
Definition player.h:363
int music_style
Definition player.h:278
struct nation_style * style
Definition player.h:277
bool phase_done
Definition player.h:261
bv_player gives_shared_tiles
Definition player.h:302
bool is_ready
Definition player.h:260
int history
Definition player.h:314
struct rgbcolor * rgb
Definition player.h:310
bool unassigned_user
Definition player.h:251
int output[O_LAST]
Definition terrain.h:49
int g
Definition rgbcolor.h:34
int b
Definition rgbcolor.h:34
int r
Definition rgbcolor.h:34
struct requirement_vector reqs
Definition specialist.h:38
char graphic_alt[MAX_LEN_NAME]
Definition specialist.h:36
struct strvec * helptext
Definition specialist.h:40
char graphic_str[MAX_LEN_NAME]
Definition specialist.h:35
struct name_translation name
Definition specialist.h:31
struct name_translation abbreviation
Definition specialist.h:32
Definition map.c:41
struct terrain * cultivate_result
Definition terrain.h:215
int placing_time
Definition terrain.h:227
struct extra_type ** resources
Definition terrain.h:204
struct strvec * helptext
Definition terrain.h:263
char graphic_alt2[MAX_LEN_NAME]
Definition terrain.h:189
bv_terrain_flags flags
Definition terrain.h:259
int * resource_freq
Definition terrain.h:205
bv_unit_classes native_to
Definition terrain.h:257
int road_time
Definition terrain.h:213
struct name_translation name
Definition terrain.h:184
int plant_time
Definition terrain.h:219
struct terrain * plant_result
Definition terrain.h:218
int irrigation_food_incr
Definition terrain.h:221
int defense_bonus
Definition terrain.h:200
int cultivate_time
Definition terrain.h:216
int movement_cost
Definition terrain.h:199
const struct unit_type * animal
Definition terrain.h:237
int pillage_time
Definition terrain.h:232
int output[O_LAST]
Definition terrain.h:202
int transform_time
Definition terrain.h:231
char graphic_alt[MAX_LEN_NAME]
Definition terrain.h:188
int mining_time
Definition terrain.h:225
struct rgbcolor * rgb
Definition terrain.h:261
char graphic_str[MAX_LEN_NAME]
Definition terrain.h:187
enum terrain_class tclass
Definition terrain.h:197
int road_output_incr_pct[O_LAST]
Definition terrain.h:211
int extra_removal_times[MAX_EXTRA_TYPES]
Definition terrain.h:235
struct terrain * transform_result
Definition terrain.h:229
int irrigation_time
Definition terrain.h:222
int base_time
Definition terrain.h:212
int mining_shield_incr
Definition terrain.h:224
Definition tile.h:50
char * spec_sprite
Definition tile.h:66
char * label
Definition tile.h:65
bv_extras extras
Definition tile.h:55
struct unit_list * units
Definition tile.h:58
struct player * extras_owner
Definition tile.h:63
int infra_turns
Definition tile.h:62
struct extra_type * placing
Definition tile.h:61
Continent_id continent
Definition tile.h:54
int hp_loss_pct
Definition unittype.h:155
int non_native_def_pct
Definition unittype.h:156
int min_speed
Definition unittype.h:154
struct name_translation name
Definition unittype.h:151
struct strvec * helptext
Definition unittype.h:159
bv_unit_class_flags flags
Definition unittype.h:157
enum unit_orders order
Definition unit.h:93
int action
Definition unit.h:100
int transport_capacity
Definition unittype.h:523
struct unit_type::@87 adv
struct unit_class * uclass
Definition unittype.h:556
int pop_cost
Definition unittype.h:513
struct requirement_vector build_reqs
Definition unittype.h:520
int defense_strength
Definition unittype.h:516
bv_unit_classes cargo
Definition unittype.h:558
int firepower
Definition unittype.h:525
int paratroopers_range
Definition unittype.h:541
char graphic_alt[MAX_LEN_NAME]
Definition unittype.h:506
bool worker
Definition unittype.h:575
char sound_move_alt[MAX_LEN_NAME]
Definition unittype.h:509
int build_cost
Definition unittype.h:512
int convert_time
Definition unittype.h:531
int city_size
Definition unittype.h:550
struct veteran_system * veteran
Definition unittype.h:544
const struct unit_type * obsoleted_by
Definition unittype.h:529
int vision_radius_sq
Definition unittype.h:522
int move_rate
Definition unittype.h:517
bv_unit_classes targets
Definition unittype.h:561
enum vision_layer vlayer
Definition unittype.h:569
struct strvec * helptext
Definition unittype.h:571
int bombard_rate
Definition unittype.h:547
char graphic_str[MAX_LEN_NAME]
Definition unittype.h:505
int city_slots
Definition unittype.h:552
char sound_move[MAX_LEN_NAME]
Definition unittype.h:508
char sound_fight_alt[MAX_LEN_NAME]
Definition unittype.h:511
struct name_translation name
Definition unittype.h:502
bv_unit_type_roles roles
Definition unittype.h:535
enum transp_def_type tp_defense
Definition unittype.h:554
int upkeep[O_LAST]
Definition unittype.h:538
char graphic_alt2[MAX_LEN_NAME]
Definition unittype.h:507
bv_unit_classes disembarks
Definition unittype.h:567
const struct unit_type * converted_to
Definition unittype.h:530
bv_unit_type_flags flags
Definition unittype.h:534
char sound_fight[MAX_LEN_NAME]
Definition unittype.h:510
bv_unit_classes embarks
Definition unittype.h:564
int attack_strength
Definition unittype.h:515
int happy_cost
Definition unittype.h:537
struct combat_bonus_list * bonuses
Definition unittype.h:526
Definition unit.h:138
int length
Definition unit.h:195
int upkeep[O_LAST]
Definition unit.h:148
bool has_orders
Definition unit.h:193
struct unit::@80 orders
bool occupied
Definition unit.h:219
enum action_decision action_decision_want
Definition unit.h:202
int battlegroup
Definition unit.h:191
enum unit_activity activity
Definition unit.h:157
int moves_left
Definition unit.h:150
struct unit::@81::@83 client
int id
Definition unit.h:145
bool moved
Definition unit.h:173
int index
Definition unit.h:195
bool vigilant
Definition unit.h:197
int hp
Definition unit.h:151
int fuel
Definition unit.h:153
struct extra_type * changed_from_target
Definition unit.h:170
int current_form_turn
Definition unit.h:208
bool stay
Definition unit.h:205
bool colored
Definition unit.h:222
enum direction8 facing
Definition unit.h:142
bool asking_city_name
Definition unit.h:225
struct extra_type * activity_target
Definition unit.h:164
int activity_count
Definition unit.h:162
struct unit_order * list
Definition unit.h:198
enum unit_activity changed_from
Definition unit.h:168
struct player * nationality
Definition unit.h:144
int transported_by
Definition unit.h:216
bool repeat
Definition unit.h:196
int homecity
Definition unit.h:146
bool paradropped
Definition unit.h:174
bool done_moving
Definition unit.h:181
int birth_turn
Definition unit.h:207
struct goods_type * carrying
Definition unit.h:186
struct tile * goto_tile
Definition unit.h:155
struct tile * action_decision_tile
Definition unit.h:203
const struct unit_type * utype
Definition unit.h:139
int veteran
Definition unit.h:152
int changed_from_count
Definition unit.h:169
enum unit_focus_status focus_status
Definition unit.h:214
enum server_side_agent ssa_controller
Definition unit.h:172
enum universals_n kind
Definition fc_types.h:902
int yes
Definition voteinfo.h:36
int num_voters
Definition voteinfo.h:39
bool passed
Definition voteinfo.h:41
int abstain
Definition voteinfo.h:38
int vote_no
Definition voteinfo.h:31
int no
Definition voteinfo.h:37
struct civ_map map
struct nation_style * style_by_number(int id)
Definition style.c:88
void styles_alloc(int count)
Definition style.c:36
struct music_style * music_style_by_number(int id)
Definition style.c:171
void music_styles_alloc(int count)
Definition style.c:133
int fc_snprintf(char *str, size_t n, const char *format,...)
Definition support.c:974
size_t fc_strlcpy(char *dest, const char *src, size_t n)
Definition support.c:791
size_t fc_strlcat(char *dest, const char *src, size_t n)
Definition support.c:836
#define sz_strlcpy(dest, src)
Definition support.h:195
#define TRUE
Definition support.h:46
#define FALSE
Definition support.h:47
#define fc_strncmp(_s1_, _s2_, _len_)
Definition support.h:160
int team_count(void)
Definition team.c:375
struct team_slot * team_slot_by_number(int team_id)
Definition team.c:175
bool team_add_player(struct player *pplayer, struct team *pteam)
Definition team.c:467
struct team * team_new(struct team_slot *tslot)
Definition team.c:317
void team_slot_set_defined_name(struct team_slot *tslot, const char *team_name)
Definition team.c:288
struct advance * advance_by_number(const Tech_type_id atype)
Definition tech.c:107
void set_user_tech_flag_name(enum tech_flag_id id, const char *name, const char *helptxt)
Definition tech.c:394
struct tech_class * tech_class_by_number(const int idx)
Definition tech.c:320
Tech_type_id advance_number(const struct advance *padvance)
Definition tech.c:98
#define A_FUTURE
Definition tech.h:46
#define A_NEVER
Definition tech.h:51
#define advance_index_iterate_end
Definition tech.h:248
tech_req
Definition tech.h:110
@ AR_TWO
Definition tech.h:112
@ AR_ROOT
Definition tech.h:113
@ AR_ONE
Definition tech.h:111
static Tech_type_id advance_count(void)
Definition tech.h:170
#define A_NONE
Definition tech.h:43
#define A_UNKNOWN
Definition tech.h:49
#define A_LAST
Definition tech.h:45
#define advance_index_iterate(_start, _index)
Definition tech.h:244
Terrain_type_id terrain_count(void)
Definition terrain.c:118
struct terrain * terrain_by_number(const Terrain_type_id type)
Definition terrain.c:156
const char * terrain_rule_name(const struct terrain *pterrain)
Definition terrain.c:247
struct resource_type * resource_type_init(struct extra_type *pextra)
Definition terrain.c:272
void set_user_terrain_flag_name(enum terrain_flag_id id, const char *name, const char *helptxt)
Definition terrain.c:788
#define MAX_NUM_TERRAINS
Definition terrain.h:64
void tile_set_terrain(struct tile *ptile, struct terrain *pterrain)
Definition tile.c:124
void tile_set_owner(struct tile *ptile, struct player *pplayer, struct tile *claimer)
Definition tile.c:69
bool tile_set_label(struct tile *ptile, const char *label)
Definition tile.c:1095
void tile_set_resource(struct tile *ptile, struct extra_type *presource)
Definition tile.c:349
struct city * tile_city(const struct tile *ptile)
Definition tile.c:83
void tile_set_worked(struct tile *ptile, struct city *pcity)
Definition tile.c:106
#define tile_index(_pt_)
Definition tile.h:88
#define tile_worked(_tile)
Definition tile.h:114
#define tile_resource(_tile)
Definition tile.h:102
known_type
Definition tile.h:35
@ TILE_KNOWN_UNSEEN
Definition tile.h:37
@ TILE_UNKNOWN
Definition tile.h:36
@ TILE_KNOWN_SEEN
Definition tile.h:38
#define tile_list_iterate(tile_list, ptile)
Definition tile.h:73
#define tile_terrain(_tile)
Definition tile.h:110
#define TILE_XY(ptile)
Definition tile.h:43
#define tile_list_iterate_end
Definition tile.h:75
#define tile_owner(_tile)
Definition tile.h:96
void tileset_setup_unit_type(struct tileset *t, struct unit_type *ut)
Definition tilespec.c:3806
void tileset_setup_government(struct tileset *t, struct government *gov)
Definition tilespec.c:4419
void tileset_setup_specialist_type_default_set(struct tileset *t, Specialist_type_id id)
Definition tilespec.c:2891
void tileset_setup_tile_type(struct tileset *t, const struct terrain *pterrain)
Definition tilespec.c:4153
void tileset_player_init(struct tileset *t, struct player *pplayer)
Definition tilespec.c:7371
bool unit_drawn_with_city_outline(const struct unit *punit, bool check_focus)
Definition tilespec.c:5511
void tileset_setup_impr_type(struct tileset *t, struct impr_type *pimprove)
Definition tilespec.c:3840
void tileset_background_init(struct tileset *t)
Definition tilespec.c:7451
void tileset_setup_tech_type(struct tileset *t, struct advance *padvance)
Definition tilespec.c:3856
void tileset_setup_city_tiles(struct tileset *t, int style)
Definition tilespec.c:6454
void tilespec_reread_frozen_refresh(const char *tname)
Definition tilespec.c:1545
void tileset_setup_extra(struct tileset *t, struct extra_type *pextra)
Definition tilespec.c:3875
const char * tileset_basename(const struct tileset *t)
Definition tilespec.c:704
void finish_loading_sprites(struct tileset *t)
Definition tilespec.c:3612
const char * tileset_name_get(struct tileset *t)
Definition tilespec.c:7522
void tileset_error(enum log_level level, const char *tset_name, const char *format,...)
Definition tilespec.c:624
bool tilespec_reread(const char *new_tileset_name, bool game_fully_initialized, float scale)
Definition tilespec.c:1355
void tileset_setup_nation_flag(struct tileset *t, struct nation_type *nation)
Definition tilespec.c:4434
void tileset_ruleset_reset(struct tileset *t)
Definition tilespec.c:7486
#define MAX_NUM_CITIZEN_SPRITES
Definition tilespec.h:197
#define NUM_WALL_TYPES
Definition tilespec.h:359
int city_num_trade_routes(const struct city *pcity)
struct trade_route_settings * trade_route_settings_by_type(enum trade_route_type type)
struct goods_type * goods_by_number(Goods_type_id id)
bool unit_transport_load(struct unit *pcargo, struct unit *ptrans, bool force)
Definition unit.c:2370
struct unit * unit_transport_get(const struct unit *pcargo)
Definition unit.c:2441
bool unit_transport_unload(struct unit *pcargo)
Definition unit.c:2390
struct unit * unit_virtual_create(struct player *pplayer, struct city *pcity, const struct unit_type *punittype, int veteran_level)
Definition unit.c:1624
void unit_virtual_destroy(struct unit *punit)
Definition unit.c:1729
void unit_tile_set(struct unit *punit, struct tile *ptile)
Definition unit.c:1255
bool unit_transported(const struct unit *pcargo)
Definition unit.c:2425
struct unit_list * unit_transport_cargo(const struct unit *ptrans)
Definition unit.c:2451
#define unit_tile(_pu)
Definition unit.h:397
@ FOCUS_AVAIL
Definition unit.h:53
@ FOCUS_WAIT
Definition unit.h:53
@ ORDER_PERFORM_ACTION
Definition unit.h:47
#define unit_owner(_pu)
Definition unit.h:396
#define unit_list_iterate(unitlist, punit)
Definition unitlist.h:31
#define unit_list_iterate_end
Definition unitlist.h:33
void set_unit_class_caches(struct unit_class *pclass)
Definition unittype.c:2756
const struct unit_type * unit_type_get(const struct unit *punit)
Definition unittype.c:123
const char * unit_name_translation(const struct unit *punit)
Definition unittype.c:1569
const char * unit_rule_name(const struct unit *punit)
Definition unittype.c:1587
void set_unit_move_type(struct unit_class *puclass)
Definition unittype.c:2924
void set_unit_type_caches(struct unit_type *ptype)
Definition unittype.c:2815
struct unit_class * uclass_by_number(const Unit_Class_id id)
Definition unittype.c:2477
void veteran_system_definition(struct veteran_system *vsystem, int level, const char *vlist_name, int vlist_power, int vlist_move, int vlist_raise, int vlist_wraise)
Definition unittype.c:2685
struct unit_type * utype_by_number(const Unit_type_id id)
Definition unittype.c:112
void unit_type_action_cache_set(struct unit_type *ptype)
Definition unittype.c:915
void set_user_unit_class_flag_name(enum unit_class_flag_id id, const char *name, const char *helptxt)
Definition unittype.c:1812
struct veteran_system * veteran_system_new(int count)
Definition unittype.c:2654
bool utype_can_do_action(const struct unit_type *putype, const action_id act_id)
Definition unittype.c:371
void set_user_unit_type_flag_name(enum unit_type_flag_id id, const char *name, const char *helptxt)
Definition unittype.c:1876
#define UCF_LAST_USER_FLAG
Definition unittype.h:127
#define unit_class_iterate(_p)
Definition unittype.h:908
#define UTYF_LAST_USER_FLAG
Definition unittype.h:331
#define unit_type_iterate(_p)
Definition unittype.h:855
#define U_LAST
Definition unittype.h:40
#define unit_class_iterate_end
Definition unittype.h:915
#define unit_type_iterate_end
Definition unittype.h:862
void update_queue_processing_finished(int request_id)
void update_queue_processing_started(int request_id)
void unit_select_dialog_update(void)
#define vision_layer_iterate(v)
Definition vision.h:77
#define vision_layer_iterate_end
Definition vision.h:80
void voteinfo_queue_delayed_remove(int vote_no)
Definition voteinfo.c:53
struct voteinfo * voteinfo_queue_find(int vote_no)
Definition voteinfo.c:150
void voteinfo_queue_add(int vote_no, const char *user, const char *desc, int percent_required, int flags)
Definition voteinfo.c:123
bool worker_task_is_sane(struct worker_task *ptask)
Definition workertask.c:40
#define worker_task_list_iterate(tasklist, ptask)
Definition workertask.h:33
#define worker_task_list_iterate_end
Definition workertask.h:35
void worklist_copy(struct worklist *dst, const struct worklist *src)
Definition worklist.c:112
void worklist_init(struct worklist *pwl)
Definition worklist.c:38