home *** CD-ROM | disk | FTP | other *** search
/ Amiga Times / AmigaTimes.iso / spiele / FreeCiv / src / freeciv-1.7.0 / server / civserver.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-10-06  |  37.1 KB  |  1,291 lines
  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. #include <stdio.h>
  14. #include <stdlib.h>
  15. #include <ctype.h>
  16. #include <unistd.h>
  17. #include <sys/types.h>
  18. #include <string.h>
  19.  
  20. #ifdef __EMX__
  21. #include <netdb.h>
  22. #include <sys/ioctl.h>
  23. #include <sys/termio.h>
  24. #include <termios.h>
  25. #endif
  26.  
  27. #include <time.h>
  28. #include <game.h>
  29. #include <gamehand.h>
  30. #include <civserver.h>
  31. #include <map.h>
  32. #include <shared.h>
  33. #include <city.h>
  34. #include <tech.h>
  35. #include <sernet.h>
  36. #include <log.h>
  37. #include <packets.h>
  38. #include <unithand.h>
  39. #include <unitfunc.h>
  40. #include <cityhand.h>
  41. #include <cityturn.h>
  42. #include <handchat.h>
  43. #include <maphand.h>
  44. #include <player.h>
  45. #include <plrhand.h>
  46. #include <mapgen.h>
  47. #include <diplhand.h>
  48. #include <packets.h>
  49. #include <stdinhand.h>
  50. #include <meta.h>
  51. #include <advmilitary.h>
  52. #include <aihand.h>
  53. #include <capability.h>
  54. #include <settlers.h>
  55.  
  56. void show_ending();
  57. void end_game();
  58. int end_turn();
  59. void start_new_game(void);
  60. void init_new_game(void);
  61. void send_game_state(struct player *dest, int state);
  62. int find_highest_used_id(void);
  63. void send_all_info(struct player *dest);
  64. void shuffle_players(void);
  65. void ai_start_turn(void);
  66. int is_game_over();
  67.  
  68. extern struct connection connections[];
  69.  
  70. enum server_states server_state;
  71.  
  72. /* this global is checked deep down the netcode. 
  73.    packets handling functions can set it to none-zero, to
  74.    force end-of-tick asap
  75. */
  76. int force_end_of_sniff;
  77. char metaserver_info_line[256];
  78. /* server name for metaserver to use for us */
  79. char metaserver_servername[64]="";
  80.  
  81. struct player *shuffled[MAX_PLAYERS];
  82.  
  83. /* this counter creates all the id numbers used */
  84. /* use get_next_id_number()                     */
  85. unsigned short global_id_counter=100;
  86. unsigned char used_ids[8192]={0};
  87.  
  88. int is_new_game=1;
  89.  
  90. char usage[] = 
  91. "Usage: %s [-fhlpv] [--file] [--help] [--log] [--port]\n\t[--version]\n";
  92.  
  93. int port=DEFAULT_SOCK_PORT;
  94. int nocity_send=0;
  95.  
  96. /* These are the capability strings for the client and the server. */
  97. char c_capability[MSG_SIZE]="";
  98. char s_capability[MSG_SIZE]="";
  99.  
  100. /* The next three variables make selecting races for AI players cleaner */
  101. int races_avail[R_LAST];
  102. int races_used[R_LAST];
  103. int num_races_avail=R_LAST;
  104.  
  105. /**************************************************************************
  106. ...
  107. **************************************************************************/
  108. int main(int argc, char *argv[])
  109. {
  110.   int h=0, v=0, n=0;
  111.   char *log_filename=NULL;
  112.   char *load_filename=NULL;
  113.   int i;
  114.   int save_counter;
  115.  
  116.   strcpy(metaserver_info_line, DEFAULT_META_SERVER_INFO_STRING);
  117.  
  118.   /* no  we don't use GNU's getopt or even the "standard" getopt */
  119.   /* yes we do have reasons ;)                                   */
  120.   i=1;
  121.   while(i<argc) {
  122.     if(!strcmp("-f", argv[i]) || !strcmp("--file", argv[i])) { 
  123.       if(++i<argc) 
  124.     load_filename=argv[i];
  125.       else {
  126.     fprintf(stderr, "Error: filename not specified.\n");
  127.     h=1;
  128.     break;
  129.       }
  130.     }
  131.     else if(!strcmp("-h", argv[i]) || !strcmp("--help", argv[i])) { 
  132.       h=1;
  133.       break;
  134.     }
  135.     else if(!strcmp("-l", argv[i]) || !strcmp("--log", argv[i])) { 
  136.       if(++i<argc) 
  137.     log_filename=argv[i];
  138.       else {
  139.     fprintf(stderr, "Error: filename not specified.\n");
  140.     h=1;
  141.     break;
  142.       }
  143.     }
  144.     else if(!strcmp("-n", argv[i]) || !strcmp("--nometa", argv[i])) { 
  145.       n=1;
  146.     }
  147.     else if(!strcmp("-p", argv[i]) || !strcmp("--port", argv[i])) { 
  148.       if(++i<argc) 
  149.     port=atoi(argv[i]);
  150.       else {
  151.     fprintf(stderr, "Error: port not specified.\n");
  152.     h=1;
  153.     break;
  154.       }
  155.     }
  156.     else if(!strcmp("-s", argv[i]) || !strcmp("--server", argv[i])) { 
  157.       if(++i<argc) 
  158.           strcpy(metaserver_servername,argv[i]);
  159.       else {
  160.     fprintf(stderr, "Error: no name specified.\n");
  161.     h=1;
  162.     break;
  163.       }
  164.     }
  165.     else if(!strcmp("-v", argv[i]) || !strcmp("--version", argv[i])) { 
  166.       v=1;
  167.     }
  168.     else {
  169.       fprintf(stderr, "Error: unknown option '%s'\n", argv[i]);
  170.       h=1;
  171.       break;
  172.     }
  173.     i++;
  174.   }
  175.     
  176.   if(h) {
  177.     fprintf(stderr, "This is the Freeciv server\n");
  178.     fprintf(stderr, "  -f, --file F\t\t\tLoad saved game F\n");
  179.     fprintf(stderr, "  -h, --help\t\t\tPrint a summary of the options\n");
  180.     fprintf(stderr, "  -l, --log F\t\t\tUse F as logfile\n");
  181.     fprintf(stderr, "  -n, --nometa\t\t\tDon't send info to Metaserver\n");
  182.     fprintf(stderr, "  -p, --port N\t\t\tconnect to port N\n");
  183.     fprintf(stderr, "  -s, --server H\t\tList this server as host H\n");
  184.     fprintf(stderr, "  -v, --version\t\t\tPrint the version number\n");
  185.     exit(0);
  186.   }
  187.  
  188.   if(v) {
  189.     fprintf(stderr, FREECIV_NAME_VERSION "\n");
  190.     exit(0);
  191.   }
  192.  
  193.   log_init(log_filename);
  194.   log_set_level(LOG_NORMAL);
  195.   
  196.   printf(FREECIV_NAME_VERSION " server\n> ");
  197. #if MINOR_VERSION < 7
  198.   printf("Freeciv 1.7 will be released on August 5 from http://www.freeciv.org\n");
  199. #endif
  200.   fflush(stdout);
  201.  
  202.   strcpy(s_capability, CAPABILITY);
  203.   if (getenv("FREECIV_CAPS"))
  204.     strcpy(s_capability, getenv("FREECIV_CAPS"));
  205.  
  206.   game_init();
  207.  
  208.   /* load a saved game */
  209.   
  210.   if(load_filename) {
  211.     struct section_file file;
  212.     printf("loading game: %s\n", load_filename);
  213.     if(!section_file_load(&file, load_filename)) { 
  214.       log(LOG_FATAL, "couldn't load savefile: %s", load_filename);
  215.       exit(1);
  216.     }
  217.     if (game_load(&file)) {
  218.       section_file_free(&file);
  219.       if(game.nplayers)
  220.     is_new_game=0;
  221.       else
  222.     game.scenario=1;
  223.       while(is_id_allocated(global_id_counter++));
  224.     } else 
  225.       section_file_free(&file);
  226.   }
  227.   
  228.   /* init network */  
  229.   init_connections(); 
  230.   server_open_socket();
  231.   if(n==0) {
  232.     log(LOG_NORMAL, "Sending info to metaserver[%s %d]", METASERVER_ADDR, METASERVER_PORT);
  233.     server_open_udp(); /* open socket for meta server */ 
  234.   }
  235.  
  236.   send_server_info_to_metaserver(1);
  237.   
  238.   /* accept new players, wait for serverop to start..*/
  239.   log(LOG_NORMAL, "Now accepting new client connections");
  240.   server_state=PRE_GAME_STATE;
  241.   while(server_state==PRE_GAME_STATE)
  242.     sniff_packets();
  243.  
  244.   send_server_info_to_metaserver(1);
  245.   
  246.   for(i=0; i<R_LAST;i++) {
  247.       races_avail[i]=i;
  248.       races_used[i]=i;
  249.   }
  250.  
  251.   /* allow players to select a race(case new game} */
  252. /* come on, this can't be right!
  253.   for(i=0; i<game.nplayers && game.players[i].race!=R_LAST
  254.       && !game.players[i].ai.control; i++); */
  255.   for(i=0; i<game.nplayers && game.players[i].race!=R_LAST; i++);
  256.   
  257.   /* at least one player is missing a race */
  258.   if(i<game.nplayers) { 
  259. /* this is bizarre!  Who wrote this and how long has it been this way?? -- Syela */
  260.     send_select_race(&game.players[i]);
  261.     for(i=0; i<game.nplayers; i++)
  262.       send_select_race(&game.players[i]);
  263.  
  264.     while(server_state==SELECT_RACES_STATE) {
  265.       sniff_packets();
  266.       for(i=0; i<game.nplayers; i++)
  267.     if((game.players[i].race==R_LAST) && !game.players[i].ai.control)
  268.       break;
  269.       if(i==game.nplayers)
  270.     server_state=RUN_GAME_STATE;
  271.     }
  272.   }
  273.  
  274.   generate_ai_players();
  275.    
  276.   if(map_is_empty())
  277.     map_fractal_generate();
  278.   else 
  279.     flood_it(1);
  280.   /* start the game */
  281.  
  282.   set_civ_style(game.civstyle);
  283.  
  284.   server_state=RUN_GAME_STATE;
  285.   send_server_info_to_metaserver(1);
  286.  
  287.   if(is_new_game) {
  288.     int i;
  289.     for(i=0; i<game.nplayers; i++) {
  290.       init_tech(&game.players[i], game.tech); 
  291.       game.players[i].economic.gold=game.gold;
  292.     }
  293.     game.max_players=game.nplayers;
  294.     flood_it(game.scenario);
  295.     choose_start_positions();
  296.   }
  297.  
  298.   initialize_move_costs(); /* this may be the wrong place to do this */
  299.   initialize_city_cache(); /* probably not needed, better to be safe */
  300.   generate_minimap(); /* for city_desire; saves a lot of calculations */
  301.  
  302.   if (!is_new_game) {
  303.     for (i=0;i<game.nplayers;i++) {
  304.       civ_score(&game.players[i]);  /* if we don't, the AI gets really confused */
  305.       if (game.players[i].ai.control) {
  306.         city_list_iterate(game.players[i].cities, pcity)
  307.           assess_danger(pcity); /* a slowdown, but a necessary one */
  308.         city_list_iterate_end;
  309.       }
  310.     }
  311.   }
  312.   
  313.   send_all_info(0);
  314.  
  315.   if(is_new_game) 
  316.     init_new_game();
  317.     
  318.   send_game_state(0, CLIENT_GAME_RUNNING_STATE);
  319.   
  320.   save_counter=game.save_nturns;
  321.   
  322.   while(server_state==RUN_GAME_STATE) {
  323.     force_end_of_sniff=0;
  324. /* printf("Shuffleplayers\n"); */
  325.     shuffle_players();
  326. /* printf("Aistartturn\n"); */
  327.     ai_start_turn();
  328. /* printf("sniffingpackets\n"); */
  329.     while(sniff_packets()==1);
  330.     for(i=0;i<game.nplayers;i++)
  331.       connection_do_buffer(game.players[i].conn);
  332. /* printf("Autosettlers\n"); */
  333.     auto_settlers(); /* moved this after ai_start_turn for efficiency -- Syela */
  334. /* moved after sniff_packets for even more efficiency.  What a guy I am. -- Syela */
  335. /* and now, we must manage our remaining units BEFORE the cities that are
  336. empty get to refresh and defend themselves.  How totally stupid. */
  337.     ai_start_turn(); /* Misleading name for manage_units -- Syela */
  338. /* printf("Endturn\n"); */
  339.     end_turn();
  340. /* printf("Gamenextyear\n"); */
  341.     game_next_year();
  342. /* printf("Sendplayerinfo\n"); */
  343.     send_player_info(0, 0);
  344. /* printf("Sendgameinfo\n"); */
  345.     send_game_info(0);
  346. /* printf("Sendyeartoclients\n"); */
  347.     send_year_to_clients(game.year);
  348. /* printf("Sendinfotometaserver\n"); */
  349.     send_server_info_to_metaserver(0);
  350.     for(i=0;i<game.nplayers;i++)
  351.       connection_do_unbuffer(game.players[i].conn);
  352.       
  353.     if(--save_counter==0) {
  354.       save_counter=game.save_nturns;
  355.       save_game();
  356.     }
  357.     if (game.year>game.end_year || is_game_over()) 
  358.       server_state=GAME_OVER_STATE;
  359.   }
  360.  
  361.   show_ending();
  362.   
  363.   notify_player(0, "Game: The game is over..");
  364.  
  365.   while(server_state==GAME_OVER_STATE) {
  366.     force_end_of_sniff=0;
  367.     sniff_packets();
  368.   }
  369.  
  370.   server_close_udp();
  371.  
  372.   return 0;
  373. }
  374.  
  375. int is_game_over()
  376. {
  377.   int alive = 0;
  378.   int i;
  379.   if (game.nplayers == 1)
  380.     return 0;
  381.   for (i=0;i<game.nplayers; i++) {
  382.     if (game.players[i].is_alive)
  383.       alive ++;
  384.   }
  385.   return (alive <= 1);
  386. }
  387.  
  388. /**************************************************************************
  389. ...
  390. **************************************************************************/
  391. void send_server_info_to_metaserver(int do_send)
  392. {
  393.   static int time_last_send;
  394.   int time_now;
  395.   
  396.   time_now=time(NULL);
  397.   
  398.   if(do_send || time_now-time_last_send>METASERVER_UPDATE_INTERVAL) {
  399.     char desc[4096], info[4096];
  400.     int i;
  401.   
  402.     /* build description block */
  403.     desc[0]='\0';
  404.   
  405.     sprintf(desc+strlen(desc), "Freeciv\n");
  406.     sprintf(desc+strlen(desc), VERSION_STRING"\n");
  407.     switch(server_state) {
  408.      case PRE_GAME_STATE:
  409.       sprintf(desc+strlen(desc), "Pregame\n");
  410.       break;
  411.      case RUN_GAME_STATE:
  412.       sprintf(desc+strlen(desc), "Running\n");
  413.       break;
  414.      case GAME_OVER_STATE:
  415.       sprintf(desc+strlen(desc), "Game over\n");
  416.       break;
  417.    default:
  418.       sprintf(desc+strlen(desc), "Waiting\n");
  419.     }
  420.     sprintf(desc+strlen(desc), "%s\n",metaserver_servername);
  421.     sprintf(desc+strlen(desc), "%d\n", port);
  422.     sprintf(desc+strlen(desc), "%d\n", game.nplayers);
  423.     sprintf(desc+strlen(desc), "%s", metaserver_info_line);
  424.     
  425.   /* now build the info block */
  426.     info[0]='\0';
  427.     sprintf(info+strlen(info), 
  428.         "Players:%d  Min players:%d  Max players:%d\n",
  429.         game.nplayers, game.min_players, game.max_players);
  430.     sprintf(info+strlen(info), 
  431.         "Timeout:%d  Year: %s\n",
  432.         game.timeout, textyear(game.year));
  433.     
  434.     
  435.     sprintf(info+strlen(info), "NO:  NAME:               HOST:\n");
  436.     sprintf(info+strlen(info), "----------------------------------------\n");
  437.     for(i=0; i<game.nplayers; ++i) {
  438.       sprintf(info+strlen(info), "%2d   %-20s %s\n", 
  439.           i, game.players[i].name, game.players[i].addr);
  440.     }
  441.  
  442.     time_last_send=time_now;
  443.     send_to_metaserver(desc, info);
  444.   }
  445.     
  446. }
  447.  
  448. /**************************************************************************
  449. dest can be NULL meaning all players
  450. **************************************************************************/
  451. void send_all_info(struct player *dest)
  452. {
  453.   send_game_info(dest);
  454.   send_map_info(dest);
  455.   send_player_info(0, dest);
  456.   send_all_known_tiles(dest);
  457. }
  458.  
  459. /**************************************************************************
  460. ...
  461. **************************************************************************/
  462. int find_highest_used_id(void)
  463. {
  464.   int i, max_id;
  465.   struct genlist_iterator myiter;
  466.  
  467.   max_id=0;
  468.   for(i=0; i<game.nplayers; i++) {
  469.     genlist_iterator_init(&myiter, &game.players[i].cities.list, 0);
  470.     for(; ITERATOR_PTR(myiter); ITERATOR_NEXT(myiter))
  471.       max_id=MAX(max_id, ((struct city *)ITERATOR_PTR(myiter))->id);
  472.     genlist_iterator_init(&myiter, &game.players[i].units.list, 0);
  473.     for(; ITERATOR_PTR(myiter); ITERATOR_NEXT(myiter))
  474.       max_id=MAX(max_id, ((struct unit *)ITERATOR_PTR(myiter))->id);
  475.   }
  476.  
  477.   return max_id;
  478. }
  479. /**************************************************************************
  480. ...
  481. **************************************************************************/
  482. void do_apollo_program()
  483. {
  484.   int cityid;
  485.   int i;
  486.   struct player *pplayer;
  487.   struct city *pcity;
  488.   if ((cityid=game.global_wonders[B_APOLLO]) && 
  489.       (pcity=find_city_by_id(cityid))) {
  490.     pplayer=city_owner(pcity);
  491.     
  492.     for(i=0; i<game.nplayers; i++) {
  493.       city_list_iterate(game.players[i].cities, pcity)
  494.     
  495.     light_square(pplayer, pcity->x, pcity->y, 0);
  496.       city_list_iterate_end;
  497.     }
  498.   }
  499. }
  500.  
  501. /**************************************************************************
  502. ...
  503. **************************************************************************/
  504. void update_pollution()
  505. {
  506.   int x,y,count=0;
  507.   
  508.   for (x=0;x<map.xsize;x++) 
  509.     for (y=0;y<map.ysize;y++) 
  510.       if (map_get_special(x,y)&S_POLLUTION) {
  511.     count++;
  512.       }
  513.   game.heating=count;
  514.   game.globalwarming+=count;
  515.   if (game.globalwarming<game.warminglevel) 
  516.     game.globalwarming=0;
  517.   else {
  518.     game.globalwarming-=game.warminglevel;
  519.     if (myrand(200)<=game.globalwarming) {
  520.       fprintf(stderr, "Global warming:%d\n", count);
  521.       global_warming(map.xsize/10+map.ysize/10+game.globalwarming*5);
  522.       game.globalwarming=0;
  523.       send_all_known_tiles(0);
  524.       notify_player(0, "Game: Global warming has occurred! Coastlines have been flooded\nand vast ranges of grassland have become deserts.");
  525.       game.warminglevel+=4;
  526.     }
  527.   }
  528. }
  529.  
  530. /**************************************************************************
  531. ...
  532. **************************************************************************/
  533. void before_end_year()
  534. {
  535.   int i;
  536.   for (i=0; i<game.nplayers; i++) {
  537.     send_packet_before_end_year(game.players[i].conn);
  538.   }
  539. }
  540.  
  541. /**************************************************************************
  542. ...
  543. **************************************************************************/
  544. void shuffle_players()
  545. {
  546.   int i, pos;
  547.   struct player *tmpplr;
  548.   /* shuffle players */
  549.  
  550.   for(i=0; i<game.nplayers; i++) {
  551.     shuffled[i] = &game.players[i];
  552.   }
  553.  
  554.   for(i=0; i<game.nplayers; i++) {
  555.     pos = myrand(game.nplayers);
  556.     tmpplr = shuffled[i]; 
  557.     shuffled[i] = shuffled[pos];
  558.     shuffled[pos] = tmpplr;
  559.   }
  560. }
  561.  
  562. void ai_start_turn()
  563. {
  564.   int i;
  565.   for (i = 0; i < game.nplayers; i++) {
  566.     if (shuffled[i]->ai.control) ai_do_first_activities(shuffled[i]);
  567.   }
  568. }
  569.  
  570. int end_turn()
  571. {
  572.   int i;
  573.   before_end_year();
  574.   nocity_send = 1;
  575.  
  576.   for(i=0; i<game.nplayers; i++) {
  577. /*    printf("updating player activities for #%d\n", i); */
  578.     update_player_activities(shuffled[i]); /* ai unit activity has been moved UP -- Syela */
  579.     shuffled[i]->turn_done=0;
  580.   }
  581.   nocity_send = 0;
  582.   for (i=0; i<game.nplayers;i++) {
  583.     send_player_cities(&game.players[i]);
  584.   }
  585.   update_pollution();
  586.   do_apollo_program();
  587.   make_history_report();
  588. /*  printf("Turn ended.\n"); */
  589.   return 1;
  590. }
  591.  
  592.  
  593. /**************************************************************************
  594. ...
  595. **************************************************************************/
  596.  
  597. void end_game()
  598. {
  599. }
  600.  
  601. /**************************************************************************
  602. ...
  603. **************************************************************************/
  604.  
  605. void save_game(void)
  606. {
  607.   char filename[512];
  608.   struct section_file file;
  609.   
  610.   sprintf(filename, "%s%d.sav", game.save_name, game.year);
  611.   
  612.   section_file_init(&file);
  613.   
  614.   game_save(&file);
  615.   
  616.   if(!section_file_save(&file, filename))
  617.     printf("Failed saving game as %s\n", filename);
  618.   else
  619.     printf("Game saved as %s\n", filename);
  620.  
  621.   section_file_free(&file);
  622. }
  623.  
  624. /**************************************************************************
  625. ...
  626. **************************************************************************/
  627.  
  628. void start_game(void)
  629. {
  630.   if(server_state!=PRE_GAME_STATE) {
  631.     puts("the game is already running.");
  632.     return;
  633.   }
  634.  
  635.   puts("starting game.");
  636.  
  637.   server_state=SELECT_RACES_STATE; /* loaded ??? */
  638.   force_end_of_sniff=1;
  639. }
  640.  
  641.  
  642. /**************************************************************************
  643. ...
  644. **************************************************************************/
  645. void handle_report_request(struct player *pplayer, enum report_type type)
  646. {
  647.   switch(type) {
  648.    case REPORT_WONDERS_OF_THE_WORLD:
  649.     wonders_of_the_world(pplayer);
  650.     break;
  651.    case REPORT_TOP_5_CITIES:
  652.     top_five_cities(pplayer);
  653.     break;
  654.    case REPORT_DEMOGRAPHIC:
  655.     demographics_report(pplayer);
  656.     break;
  657.   case REPORT_SERVER_OPTIONS:
  658.     report_server_options(pplayer);
  659.   }
  660.   
  661. }
  662.  
  663.  
  664. /**************************************************************************
  665. ...
  666. **************************************************************************/
  667. void handle_packet_input(struct connection *pconn, char *packet, int type)
  668. {
  669.   int i;
  670.   struct player *pplayer=NULL;
  671.  
  672.   switch(type) {
  673.   case PACKET_REQUEST_JOIN_GAME:
  674.     handle_request_join_game(pconn, (struct packet_req_join_game *)packet);
  675.     free(packet);
  676.     return;
  677.     break;
  678.   }
  679.  
  680.   for(i=0; i<game.nplayers; i++)
  681.     if(game.players[i].conn==pconn) {
  682.       pplayer=&game.players[i];
  683.       break;
  684.     }
  685.  
  686.   if(i==game.nplayers) {
  687.     log(LOG_DEBUG, "got game packet from unaccepted connection");
  688.     free(packet);
  689.     return;
  690.   }
  691.  
  692.   pplayer->nturns_idle=0;
  693.  
  694.   if(!pplayer->is_alive && type!=PACKET_CHAT_MSG)
  695.     return;
  696.   
  697.   switch(type) {
  698.     
  699.   case PACKET_TURN_DONE:
  700.     handle_turn_done(i);
  701.     break;
  702.  
  703.   case PACKET_ALLOC_RACE:
  704.     handle_alloc_race(i, (struct packet_alloc_race *)packet);
  705.     break;
  706.  
  707.   case PACKET_UNIT_INFO:
  708.     handle_unit_info(pplayer, (struct packet_unit_info *)packet);
  709.     break;
  710.  
  711.   case PACKET_MOVE_UNIT:
  712.     handle_move_unit(pplayer, (struct packet_move_unit *)packet);
  713.     break;
  714.  
  715.   case PACKET_CHAT_MSG:
  716.     handle_chat_msg(pplayer, (struct packet_generic_message *)packet);
  717.     break;
  718.  
  719.   case PACKET_CITY_SELL:
  720.     handle_city_sell(pplayer, (struct packet_city_request *)packet);
  721.     break;
  722.  
  723.   case PACKET_CITY_BUY:
  724.     handle_city_buy(pplayer, (struct packet_city_request *)packet);
  725.     break;
  726.    
  727.   case PACKET_CITY_CHANGE:
  728.     handle_city_change(pplayer, (struct packet_city_request *)packet);
  729.     break;
  730.  
  731.   case PACKET_CITY_MAKE_SPECIALIST:
  732.     handle_city_make_specialist(pplayer, (struct packet_city_request *)packet);
  733.     break;
  734.  
  735.   case PACKET_CITY_MAKE_WORKER:
  736.     handle_city_make_worker(pplayer, (struct packet_city_request *)packet);
  737.     break;
  738.  
  739.   case PACKET_CITY_CHANGE_SPECIALIST:
  740.     handle_city_change_specialist(pplayer, (struct packet_city_request *)packet);
  741.     break;
  742.  
  743.   case PACKET_CITY_RENAME:
  744.     handle_city_rename(pplayer, (struct packet_city_request *)packet);
  745.     break;
  746.  
  747.   case PACKET_PLAYER_RATES:
  748.     handle_player_rates(pplayer, (struct packet_player_request *)packet);
  749.     break;
  750.  
  751.   case PACKET_PLAYER_REVOLUTION:
  752.     handle_player_revolution(pplayer);
  753.     break;
  754.  
  755.   case PACKET_PLAYER_GOVERNMENT:
  756.     handle_player_government(pplayer, (struct packet_player_request *)packet);
  757.     break;
  758.  
  759.   case PACKET_PLAYER_RESEARCH:
  760.     handle_player_research(pplayer, (struct packet_player_request *)packet);
  761.     break;
  762.  
  763.   case PACKET_PLAYER_TECH_GOAL:
  764.     handle_player_tech_goal(pplayer, (struct packet_player_request *)packet);
  765.     break;
  766.  
  767.   case PACKET_UNIT_BUILD_CITY:
  768.     handle_unit_build_city(pplayer, (struct packet_unit_request *)packet);
  769.     break;
  770.  
  771.   case PACKET_UNIT_DISBAND:
  772.     handle_unit_disband(pplayer, (struct packet_unit_request *)packet);
  773.     break;
  774.  
  775.   case PACKET_UNIT_CHANGE_HOMECITY:
  776.     handle_unit_change_homecity(pplayer, (struct packet_unit_request *)packet);
  777.     break;
  778.  
  779.   case PACKET_UNIT_AUTO:
  780.     handle_unit_auto_request(pplayer, (struct packet_unit_request *)packet);
  781.     break;
  782.  
  783.   case PACKET_UNIT_UNLOAD:
  784.     handle_unit_unload_request(pplayer, (struct packet_unit_request *)packet);
  785.     break;
  786.  
  787.   case PACKET_UNIT_UPGRADE:
  788.     handle_upgrade_unit_request(pplayer, (struct packet_unittype_info *)packet);
  789.     break;
  790.  
  791.   case PACKET_UNIT_ESTABLISH_TRADE:
  792.     handle_unit_establish_trade(pplayer, (struct packet_unit_request *)packet);
  793.     break;
  794.  
  795.   case PACKET_UNIT_HELP_BUILD_WONDER:
  796.     handle_unit_help_build_wonder(pplayer, (struct packet_unit_request *)packet);
  797.     break;
  798.  
  799.   case PACKET_UNIT_GOTO_TILE:
  800.     handle_unit_goto_tile(pplayer, (struct packet_unit_request *)packet);
  801.     break;
  802.     
  803.   case PACKET_DIPLOMAT_ACTION:
  804.     handle_diplomat_action(pplayer, (struct packet_diplomat_action *)packet);
  805.     break;
  806.   case PACKET_REPORT_REQUEST:
  807.     handle_report_request(pplayer, 
  808.      ((struct packet_generic_integer *)packet)->value);
  809.     break;
  810.   case PACKET_DIPLOMACY_INIT_MEETING:
  811.     handle_diplomacy_init(pplayer, (struct packet_diplomacy_info *)packet);
  812.     break;
  813.   case PACKET_DIPLOMACY_CANCEL_MEETING:
  814.     handle_diplomacy_cancel_meeting(pplayer, (struct packet_diplomacy_info *)packet);  
  815.     break;
  816.   case PACKET_DIPLOMACY_CREATE_CLAUSE:
  817.     handle_diplomacy_create_clause(pplayer, (struct packet_diplomacy_info *)packet);  
  818.     break;
  819.   case PACKET_DIPLOMACY_REMOVE_CLAUSE:
  820.     handle_diplomacy_remove_clause(pplayer, (struct packet_diplomacy_info *)packet);  
  821.     break;
  822.   case PACKET_DIPLOMACY_ACCEPT_TREATY:
  823.     handle_diplomacy_accept_treaty(pplayer, (struct packet_diplomacy_info *)packet);  
  824.     break;
  825.   case PACKET_CITY_REFRESH:
  826.     handle_city_refresh(pplayer, (struct packet_generic_integer *)packet);
  827.     break;
  828.   case PACKET_INCITE_INQ:
  829.     handle_incite_inq(pplayer, (struct packet_generic_integer *)packet);
  830.     break;
  831.   default:
  832.     log(LOG_NORMAL, "uh got an unknown packet from %s", game.players[i].name);
  833.   }
  834.  
  835.   free(packet);
  836. }
  837.  
  838. /**************************************************************************
  839. ...
  840. **************************************************************************/
  841. void dealloc_id(int id)
  842. {
  843.   used_ids[id/8]&= 0xff ^ (1<<(id%8));
  844. }
  845.  
  846. /**************************************************************************
  847. ...
  848. **************************************************************************/
  849. int is_id_allocated(int id)
  850. {
  851.   return (used_ids[id/8])&(1<<(id%8));
  852. }
  853.  
  854. /**************************************************************************
  855. ...
  856. **************************************************************************/
  857. void alloc_id(int id)
  858. {
  859.   used_ids[id/8]|= (1<<(id%8));
  860. }
  861.  
  862. /**************************************************************************
  863. ...
  864. **************************************************************************/
  865.  
  866. int get_next_id_number(void)
  867. {
  868.   while(is_id_allocated(++global_id_counter)) ;
  869.   return global_id_counter;
  870. }
  871.  
  872. /**************************************************************************
  873. ...
  874. **************************************************************************/
  875. int check_for_full_turn_done(void)
  876. {
  877.   int i;
  878.  
  879.   for(i=0; i<game.nplayers; i++)
  880.     if(game.players[i].conn && game.players[i].is_alive && 
  881.        !game.players[i].turn_done) {
  882.       return 0;
  883.     }
  884.   force_end_of_sniff=1;
  885.   return 1;
  886. }
  887.  
  888. /**************************************************************************
  889. ...
  890. **************************************************************************/
  891. void handle_turn_done(int player_no)
  892. {
  893.   game.players[player_no].turn_done=1;
  894.   
  895.   /* if someone is still moving, then let the other know that this play moved */ 
  896.   if(!check_for_full_turn_done())
  897.     send_player_info(&game.players[player_no], 0);
  898. }
  899.  
  900. /**************************************************************************
  901. ...
  902. **************************************************************************/
  903. void handle_alloc_race(int player_no, struct packet_alloc_race *packet)
  904. {
  905.   int i;
  906.   struct packet_generic_integer retpacket;
  907.  
  908.   for(i=0; i<game.nplayers; i++)
  909.     if(game.players[i].race==packet->race_no) {
  910.        send_select_race(&game.players[player_no]); /* it failed - race taken */
  911.        return;
  912.     } else /* check to see if name has been taken */
  913.        if (!strcmp(game.players[i].name,packet->name) && 
  914.             game.players[i].race != R_LAST) { 
  915.        notify_player(&game.players[player_no],
  916.              "Another player named '%s' has already joined the game.  "
  917.              "Please choose another name.", packet->name);
  918.        send_select_race(&game.players[player_no]);
  919.        return;
  920.     }
  921.  
  922.   log(LOG_NORMAL, "%s is the %s ruler %s", game.players[player_no].name, 
  923.       get_race_name(packet->race_no), packet->name);
  924.  
  925.   /* inform player his choice was ok */
  926.   retpacket.value=-1;
  927.   send_packet_generic_integer(game.players[player_no].conn,
  928.                   PACKET_SELECT_RACE, &retpacket);
  929.  
  930.   game.players[player_no].race=packet->race_no;
  931.   strcpy(game.players[player_no].name, packet->name);
  932.  
  933.   /* tell the other players, that the race is now unavailable */
  934.   for(i=0; i<game.nplayers; i++)
  935.     if(game.players[i].race==R_LAST)
  936.       send_select_race(&game.players[i]);
  937.  
  938.   mark_race_as_used(packet->race_no);
  939. }
  940.  
  941. /**************************************************************************
  942. ...
  943. **************************************************************************/
  944. void send_select_race(struct player *pplayer)
  945. {
  946.   int i;
  947.   struct packet_generic_integer genint;
  948.  
  949.   genint.value=0;
  950.  
  951.   for(i=0; i<game.nplayers; i++)
  952.     if(game.players[i].race!=R_LAST)
  953.       genint.value|=1<<game.players[i].race;
  954.  
  955.   send_packet_generic_integer(pplayer->conn, PACKET_SELECT_RACE, &genint);
  956. }
  957.  
  958.  
  959. /**************************************************************************
  960. ...
  961. **************************************************************************/
  962.  
  963. void accept_new_player(char *name, struct connection *pconn)
  964. {
  965.   int i;
  966.   struct packet_join_game_reply packet;
  967.   char hostname[512];
  968.  
  969.   packet.you_can_join=1;
  970.   strcpy(packet.capability, CAPABILITY);
  971.  
  972.   strcpy(game.players[game.nplayers].name, name);
  973.   game.players[game.nplayers].conn=pconn;
  974.   game.players[game.nplayers].is_connected=1;
  975.   if (pconn) {
  976.     strcpy(game.players[game.nplayers].addr, pconn->addr); 
  977.     sprintf(packet.message, "Welcome %s.", name);
  978.     send_packet_join_game_reply(pconn, &packet);
  979.     log(LOG_NORMAL, "%s[%s] has joined the game.", name, pconn->addr);
  980.     for(i=0; i<game.nplayers; ++i)
  981.       notify_player(&game.players[i],
  982.               "Game: Player %s[%s] has connected.", name, pconn->addr);
  983.   } else {
  984.      log(LOG_NORMAL, "%s[ai-player] has joined the game.", name, pconn->addr);
  985.      for(i=0; i<game.nplayers; ++i)
  986.        notify_player(&game.players[i],
  987.              "Game: Player %s[ai-player] has connected.", name, pconn->addr);
  988.   }
  989.   game.nplayers++;
  990.   if(server_state==PRE_GAME_STATE && game.max_players==game.nplayers)
  991.     server_state=SELECT_RACES_STATE;
  992.  
  993.   /* now notify the player about the server etc */
  994.   if (pconn && (gethostname(hostname, 512)==0)) {
  995.      notify_player(&game.players[game.nplayers-1],
  996.            "Welcome to the %s Server running at %s", 
  997.            FREECIV_NAME_VERSION, hostname);
  998.      notify_player(&game.players[game.nplayers-1],
  999.            "There's currently %d player%s connected:", game.nplayers,
  1000.            game.nplayers>1 ? "s" : "");
  1001.      
  1002.      for(i=0; i<game.nplayers; ++i)
  1003.        notify_player(&game.players[game.nplayers-1], "%s[%s]", 
  1004.              game.players[i].name, game.players[i].addr);
  1005.   }
  1006.   send_server_info_to_metaserver(1);
  1007. }
  1008.   
  1009. /**************************************************************************
  1010. ...
  1011. **************************************************************************/
  1012.  
  1013. void reject_new_player(char *msg, struct connection *pconn)
  1014. {
  1015.   struct packet_join_game_reply packet;
  1016.   
  1017.   packet.you_can_join=0;
  1018.   strcpy(packet.capability, s_capability);
  1019.   strcpy(packet.message, msg);
  1020.   send_packet_join_game_reply(pconn, &packet);
  1021. }
  1022.   
  1023. /**************************************************************************
  1024. ...
  1025. **************************************************************************/
  1026.  
  1027. void handle_request_join_game(struct connection *pconn, 
  1028.                   struct packet_req_join_game *req)
  1029. {
  1030.   struct player *pplayer;
  1031.   char msg[MSG_SIZE];
  1032.   
  1033.   log(LOG_NORMAL, "Connection from %s with client version %d.%d.%d", req->name,
  1034.       req->major_version, req->minor_version, req->patch_version);
  1035. #if 0
  1036.   log(LOG_NORMAL, "Client caps: %s Server Caps: %s", req->capability, s_capability);
  1037. #endif
  1038.   /* Make sure the server has every capability the client needs */
  1039.   if (!has_capabilities(s_capability, req->capability)) {
  1040.     sprintf(msg, "The server is missing a capability that this client needs.\n"
  1041.         "Server version: %d.%d.%d Client version: %d.%d.%d.  Upgrading may help!",
  1042.         MAJOR_VERSION, MINOR_VERSION, PATCH_VERSION,
  1043.         req->major_version, req->minor_version, req->patch_version);
  1044.     reject_new_player(msg, pconn);
  1045.     log(LOG_NORMAL, "%s was rejected: mismatched capabilities", req->name);
  1046.     close_connection(pconn);
  1047.     return;
  1048.   }
  1049.  
  1050.   /* Make sure the client has every capability the server needs */
  1051.   if (!has_capabilities(req->capability, s_capability)) {
  1052.     sprintf(msg, "The client is missing a capability that the server needs.\n"
  1053.         "Server version: %d.%d.%d Client version: %d.%d.%d.  Upgrading may help!",
  1054.         MAJOR_VERSION, MINOR_VERSION, PATCH_VERSION,
  1055.         req->major_version, req->minor_version, req->patch_version);
  1056.     reject_new_player(msg, pconn);
  1057.     log(LOG_NORMAL, "%s was rejected: mismatched capabilities", req->name);
  1058.     close_connection(pconn);
  1059.     return;
  1060.   }
  1061.  
  1062.   if((pplayer=find_player_by_name(req->name))) {
  1063.     if(!pplayer->conn) {
  1064.       /* can I use accept_new_player here?? mjd */
  1065.       struct packet_join_game_reply packet;
  1066.  
  1067.       pplayer->conn=pconn;
  1068.       pplayer->is_connected=1;
  1069.       strcpy(pplayer->addr, pconn->addr); 
  1070.       sprintf(packet.message, "Welcome back %s.", pplayer->name);
  1071.       packet.you_can_join=1;
  1072.       strcpy(packet.capability, s_capability);
  1073.       send_packet_join_game_reply(pconn, &packet);
  1074.       log(LOG_NORMAL, "%s has reconnected.", pplayer->name);
  1075.       if(server_state==RUN_GAME_STATE) {
  1076.     send_all_info(pplayer);
  1077.         send_game_state(pplayer, CLIENT_GAME_RUNNING_STATE);
  1078.       }
  1079.  
  1080.       return;
  1081.     }
  1082.  
  1083.     if(server_state==PRE_GAME_STATE) {
  1084.       if(game.nplayers==game.max_players) {
  1085.     reject_new_player("Sorry you can't join. The game is full.", pconn);
  1086.     log(LOG_NORMAL, "game full - %s was rejected.", req->name);    
  1087.     close_connection(pconn);
  1088.  
  1089.         return;
  1090.       }
  1091.       accept_new_player(req->name, pconn);
  1092.  
  1093.       return;
  1094.     }
  1095.  
  1096.     sprintf(msg, "You can't join the game. %s is already connected.", 
  1097.         pplayer->name);
  1098.     reject_new_player(msg, pconn);
  1099.     log(LOG_NORMAL, "%s was rejected.", pplayer->name);
  1100.     close_connection(pconn);
  1101.  
  1102.     return;
  1103.   }
  1104.  
  1105.   /* unknown name */
  1106.  
  1107.   if(server_state!=PRE_GAME_STATE) {
  1108.     reject_new_player("Sorry you can't join. The game is already running.",
  1109.               pconn);
  1110.     log(LOG_NORMAL, "game running - %s was rejected.", req->name);
  1111.     lost_connection_to_player(pconn);
  1112.     close_connection(pconn);
  1113.  
  1114.     return;
  1115.   }
  1116.  
  1117.   if(game.nplayers==game.max_players) {
  1118.     reject_new_player("Sorry you can't join. The game is full.", pconn);
  1119.     log(LOG_NORMAL, "game full - %s was rejected.", req->name);    
  1120.     close_connection(pconn);
  1121.  
  1122.     return;
  1123.   }
  1124.  
  1125.   accept_new_player(req->name, pconn);    
  1126. }
  1127.  
  1128. /**************************************************************************
  1129. ...
  1130. **************************************************************************/
  1131.  
  1132. void lost_connection_to_player(struct connection *pconn)
  1133. {
  1134.   int i;
  1135.  
  1136.   for(i=0; i<game.nplayers; i++)
  1137.     if(game.players[i].conn==pconn) {
  1138.       game.players[i].conn=NULL;
  1139.       game.players[i].is_connected=0;
  1140.       strcpy(game.players[i].addr, "---.---.---.---");
  1141.       log(LOG_NORMAL, "lost connection to %s", game.players[i].name);
  1142.       send_player_info(&game.players[i], 0);
  1143.       notify_player(0, "Game: Lost connection to %s", game.players[i].name);
  1144.  
  1145.       if(is_new_game && (server_state==PRE_GAME_STATE ||
  1146.              server_state==SELECT_RACES_STATE))
  1147.      server_remove_player(&game.players[i]);
  1148.       check_for_full_turn_done();
  1149.       return;
  1150.     }
  1151.  
  1152.   log(LOG_FATAL, "lost connection to unknown");
  1153. }
  1154.  
  1155. /**************************************************************************
  1156. generate_ai_players() - Selects a race for players created with server's
  1157.    "create <PlayerName>" command.  If <PlayerName> is the default leader
  1158.    name for some race, we choose the corresponding race for that name
  1159.    (i.e. if we issue "create Shaka" then we will make that AI player's
  1160.    race the Zulus if the Zulus have not been chosen by anyone else.  If they
  1161.    have, then we pick an available race at random.
  1162.  
  1163.    After that, we check to see if the
  1164.    server option "aifill" is greater than the number of players currently
  1165.    connected.  If so, we create the appropriate number of players
  1166.    (game.aifill - game.nplayers) from scratch, choosing a random race
  1167.    and appropriate name for each.
  1168. **************************************************************************/
  1169.  
  1170. void generate_ai_players()
  1171. {
  1172.   int i,j,player,race;
  1173.   char player_name[MAX_LENGTH_NAME];
  1174.  
  1175.   /* My attempt to randomly seed the PRNG.
  1176.      Without this we get the same AI players in every game -- at least
  1177.      under Linux. Maybe this should be near the beginning of main()? 
  1178.      - Cedric */
  1179.  
  1180.   j=time(NULL)%60;
  1181.   for(i=0;i<j;i++)
  1182.       myrand(1);
  1183.  
  1184. /* Editorial comment: Seeding the PRNG hinders development in many cases,
  1185. but since this only happens at the start of a brand-new game, I don't
  1186. see it as particularly harmful and am therefore leaving it intact. -- Syela */
  1187.  
  1188.   /* Select races for AI players generated with server 'create <name>' command */
  1189.  
  1190.   for(player=0;player<game.nplayers;player++) {
  1191.     if(game.players[player].race != R_LAST)
  1192.        continue;
  1193.  
  1194.     for (race = 0; race < R_LAST; race++) {
  1195.       if (!strcmp(game.players[player].name, default_race_leader_names[race]))
  1196.         if(races_used[race] != -1) {
  1197.            game.players[player].race=mark_race_as_used(race);
  1198.             break;
  1199.         }
  1200.     }
  1201.  
  1202.     if(race == R_LAST)
  1203.            game.players[player].race=
  1204.               mark_race_as_used(races_avail[myrand(num_races_avail)]);
  1205.  
  1206.     announce_ai_player(&game.players[player]);
  1207.  
  1208.   }
  1209.  
  1210.   /* Create and pick race and name for AI players needed to bring the
  1211.      total number of players == game.aifill */
  1212.  
  1213.   for(;game.nplayers < game.aifill;) {
  1214.      race = mark_race_as_used(races_avail[myrand(num_races_avail)]);
  1215.      pick_ai_player_name(race,player_name);
  1216.      i=game.nplayers;
  1217.      accept_new_player(player_name, NULL);
  1218.      if ((game.nplayers == i+1) && 
  1219.          !strcmp(player_name,game.players[i].name)) {
  1220.            game.players[i].race=race;
  1221.        game.players[i].ai.control = !game.players[i].ai.control;
  1222.        game.players[i].is_connected=0;
  1223.            announce_ai_player(&game.players[i]);
  1224.         } else
  1225.       printf ("Error creating new ai player: %s\n", player_name);
  1226.    }
  1227.  
  1228.   send_server_info_to_metaserver(1);
  1229.  
  1230. }
  1231.  
  1232.  
  1233.  
  1234. /*************************************************************************
  1235.  pick_ai_player_name() - Returns the default ruler name for a given race
  1236.      given that race's number.  If that player name is already taken,
  1237.      iterates through "Player 1", "Player 2", ... until an unused name
  1238.      is found.
  1239. *************************************************************************/
  1240. void pick_ai_player_name (enum race_type race, char *newname) 
  1241. {
  1242.    int playernumber=1;
  1243.    char tempname[50];
  1244.  
  1245.    strcpy(tempname,default_race_leader_names[race]);
  1246.  
  1247.    while(find_player_by_name(tempname)) {
  1248.        sprintf(tempname,"Player %d",playernumber++);
  1249.    }
  1250.  
  1251.    strcpy(newname,tempname);
  1252. }
  1253.  
  1254. /*************************************************************************
  1255.  mark_race_as_used() - shuffles the appropriate arrays to indicate that
  1256.  the specified race number has been allocated to some player and is
  1257.  therefore no longer available to any other player.  We do things this way
  1258.  so that the process of determining which races are available to AI players
  1259.  is more efficient.
  1260. *************************************************************************/
  1261. int mark_race_as_used (int race) {
  1262.  
  1263.   if(num_races_avail <= 0) {/* no more unused races */
  1264.       log(LOG_FATAL, "Argh! ran out of races!");
  1265.       exit(1);
  1266.   }
  1267.  
  1268.    races_used[races_avail[num_races_avail-1]]=races_used[race];
  1269.    races_avail[races_used[race]]=races_avail[--num_races_avail];
  1270.    races_used[race]=-1;
  1271.  
  1272.    return race;
  1273. }
  1274.  
  1275. /*************************************************************************
  1276. ...
  1277. *************************************************************************/
  1278. void announce_ai_player (struct player *pplayer) {
  1279.    int i;
  1280.  
  1281.    log(LOG_NORMAL, "AI is controlling the %s ruled by %s",
  1282.                     races[pplayer->race].name_plural,
  1283.                     pplayer->name);
  1284.  
  1285.    for(i=0; i<game.nplayers; ++i)
  1286.      notify_player(&game.players[i],
  1287.            "Option: %s rules the %s.", pplayer->name,
  1288.                     races[pplayer->race].name_plural);
  1289.  
  1290. }
  1291.