server.hpp

本程序是主要是扫雷

/*     Copyright(c) Ben Bear 2003-2004  */

//  This program is free software; you can redistribute it and/or
//  modify it under the terms of the GNU General Public License as
//  published by the Free Software Foundation; either version 2 of the
//  License, or (at your option) any later version.
//  
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//  General Public License for more details.
//  
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
//  02111-1307, USA.

/*  This file provide a final server, which can run at background.
 *  Once the server has been build, it waits for players to join.
 */

#ifndef __server_hpp
#define __server_hpp

#include "info.hpp"
#include "checkers_server.hpp"
#include "server_connector.hpp"

class server: public checkers_server, public server_con
{
protected:
  // join a new player[p]
  void new_player (int p);
  
  // quit a player[p]
  void quit_player (int p);

  void game_over ();
public:
  server(const setting& set);

  bool run ();
};

server::server (const setting& set)
  : checkers_server (set)
{
  start_net ();
}

bool
server::run ()
{
  //fprintf (stderr, long_jump ? "long" : "short");
  do
    {
      char player_name[PLAYER_NAME_LEN];
      try
	{
	  wait_player (player_name);
	}
      catch (char* err)
	{
	  //fprintf (stderr, "%s\n", err);
	  continue;
	}
      int p = join (player_name);
      if (p == -1)
	{
	  waiter_close (GAME_OVER);
	  continue;
	}
      new_player (p);
    }
  while (!checkers_server::full());

  checkers_server::restart ();

  // send game started message
  for (int i = 0; i < 6; ++i)
    {
      if (player[i].end == -1)
	continue;

      send_int (i, GAME_START);
      if (recv_int (i) == PLAYER_QUIT)
	{
	  // now, don't support quit at this time
	}
    }

  do
    {
      int p = cur_player;
      cur_player = order[cur_player];

      //fprintf (stderr, "order move: %d\n", p);
      send_int (p, ORDER_MOVE);
      int s, e;
      int r = recv_int (p);
      if (r == MOVE_FAILED)
	continue;
      else if (r == PLAYER_QUIT)
	{
	  server_con::delete_sock (p);
	  checkers_server::quit (p);
	  game_over ();
	  return false;
	}

      //fprintf (stderr, "recv move chess from: %d\n", p);
      s = recv_int (p);
      e = recv_int (p);
      
      if (move (p, s, e))
	{
	  send_int (p, ALL_OK);
	  // send the move message to other players
	  for (int i = 0; i < 6; ++i)
	    {
	      if ((i == p) || (player[i].end == -1))
		continue;
	      //fprintf (stderr, "send move chess to: %d\n", i);
	      send_int (i, MOVE_CHESS);
	      send_int (i, s);
	      send_int (i, e);

	      // a player quit
	      if (recv_int (i) == PLAYER_QUIT)
		{
		  server_con::delete_sock (i);
		  checkers_server::quit (i);
		  game_over ();
		  return false;
		}
	    }
	}
      else  // move failed
	{
	  send_int (p, MOVE_FAILED);
	  // but without move again
	}
      if (win (p) && group_win(p))
	{
	  //fprintf (stderr, "player win: %d\n", p);
	  // send the win message
	  for (int i = 0; i < 6; ++i)
	    {
	      if (player[i].end == -1)
		continue;
	      
	      send_int (i, PLAYER_WIN);
	      send_int (i, p);
	    }
	  /*
	  // receive the response
	  for (int i = 0; i < 6; ++i)
	    {
	      if (player[i].end == -1)
		continue;

	      if (recv_int (i) == PLAYER_QUIT)
		{
		  quit_player (i);
		}
	    }
	  */
	  // has win, quit
	  break;
	}
    }
  while (true);
  return true;
}

void
server::new_player (int p)
{
  //fprintf (stderr, "new player: %d\n", p);
  save_sock (p);

  send_int (p, JOINED_GAME);
  send_int (p, floor);
  send_int (p, num_player);
  send_bool (p, long_jump);
  send_int (p, group);
  send_bool (p, stay_limit);

  send_int (p, p);

  int r = recv_int (p);
  if (r == PLAYER_QUIT)
    {
      checkers_server::quit (p);
      delete_sock (p);
      return;
    }
  // send new player name to other players
  for (int i = 0; i < 6; ++i)
    {
      if ((i == p) || (player[i].end == -1))
	continue;
      
      send_int (i, NEW_PLAYER);
      send_int (i, p);
      send_name (i, player[p].name.c_str());
      // get the responses of the player
      int r = recv_int (i);
      if (r == PLAYER_QUIT)
	{
	  quit_player (i);
	  continue;
	}
      
      send_int (p, NEW_PLAYER);
      send_int (p, i);
      send_name (p, player[i].name.c_str());
      // get the responses of the player
      r = recv_int (p);
      if (r == PLAYER_QUIT)
	{
	  quit_player (p);
	  break;
	}
    }
}

void
server::quit_player (int p)
{
  //fprintf (stderr, "delete player: %d\n", p);
  server_con::delete_sock (p);
  checkers_server::quit (p);

  for (int i = 0; i < 6; ++i)
    {
      if (player[i].end == -1)
	continue;

      send_int (i, PLAYER_QUIT);
      send_int (i, p);
      int r = recv_int (i);
      if (r == PLAYER_QUIT)
	quit_player (i);
    }
}

void
server::game_over ()
{
  for (int i = 0; i < 6; ++i)
    {
      if (player[i].end == -1)
	continue;
      send_int (i, GAME_OVER);
      server_con::delete_sock (i);
      checkers_server::quit (i);
    }
}

#endif