main.vala 3.74 KB
Newer Older
1 2 3 4 5 6 7
/*
 * A sample bot.
 * Currently it is dummy code only to develop the API. It doesn't compile and
 * it probably don't use the better API ever. Let's see.
 */


8
public class Bot
9
{
10
  private MainLoop          loop   = null;
11 12
  private OVCC.Player       player = null;
  private OVCCClient.Client client = null;
13 14
  private OVCCClient.Game   game   = null;
  public  OVCC.Network.SignalHandle signal_handle = null;
15 16
  
  public bool join (OVCCClient.Server server)
17
    throws Error
18
  {
19
    uint            player_suffix = 7;
20

21
    /* connect to the server */
22
    debug ("Trying to connect to server...");
23 24 25 26 27
    server.connect_to (); /* may throw a rejection */
    debug ("Connected");

    /* login to the server, choosing an available nickname */
    debug ("Trying to login...");
28 29
    do {
      /* Create our player instance */
30
      player = new OVCC.Player ("""Clever bot %03u""".printf (player_suffix));
31
      
32
      try {
33
        client = new OVCCClient.Client (player);
34
        server.login_to (player);
35
        break;
36
      } catch (OVCCClient.ServerError.NICKNAME_IN_USE e) {
37
        player_suffix++;
38
      } catch (OVCCClient.ServerError.MISSING_AUTHENTICATION e) {
39
        server.disconnect_from ();
40
        throw e; /* avoid infinite loop */
41 42 43
      } catch (Error e) {
        server.disconnect_from ();
        throw e;
44 45
      }
    }
46
    while (true);
47 48 49
    debug ("Logged in with player_suffix = %u", player_suffix);

    Thread.usleep (2*1000*1000);
50

51
    /* join any open table */
52
    debug ("Trying to join a table...");
53 54
    try {
      game = server.join_table (-1);
55
    } catch (Error e) {
56
      server.disconnect_from ();
57
      throw e;
58 59
    }
    debug ("Joined");
60 61 62

    /* start listening to the server */
    server.start_listening (game, player);
63
    
64 65 66 67 68 69 70 71 72 73 74 75 76
    /* react on game state changes */
    game.notify["state"].connect ((s, p) => {
      switch (((OVCC.Game)s).state)
      {
        case OVCC.GameState.FINISHED:
          loop.quit ();
          debug ("We're done, bye!");
          break;
        case OVCC.GameState.ABORTED:
          loop.quit ();
          debug ("Abnormal game termination!");
          break;
      }
77 78
    });
    /* we should place a tile? OK, why not */
79
    client.place_tile.connect ((tile) => {
80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103
      debug ("Seems we should place a tile...");
      game.board.foreach ((b, p, t) => {
        for (var i = 0; i < 4; i++) {
          var npos = p;
          
          switch (i) {
            case 0: npos.y--; break; /* top */
            case 1: npos.x++; break; /* right */
            case 2: npos.y++; break; /* bottom */
            case 3: npos.x--; break; /* left */
          }
          for (var j = 0; j < 4; j++) {
            /* FIXME: this should probably be asynchronous... */
            if (game.place_tile (player, npos)) {
              return false;
            } else {
              tile.rotate (1);
            }
          }
        }
        return true;
      });
    });
    /* we should place a pawn? let's do so */
104
    client.place_pawn.connect ((game, tile) => {
105 106 107 108 109
      debug ("We're asked to place a pawn!");
      foreach (var o in tile.objects) {
        /* we guess all pawns can go anywhere another can -- which isn't true
         * using some extensions, but it doesn't matter that much. */
        /* FIXME: this should probably also be asynchronous... */
110 111 112
//         if (game.place_pawn (player.pawns.nth_data (0), o)) {
//           break;
//         }
113 114
      }
    });
115 116

    return true;
117
  }
118 119 120 121 122
  
  public Bot (MainLoop l)
  {
    loop = l;
  }
123 124
}

125
public int main (string[] args)
126
{
127 128
  var loop = new MainLoop ();
  var bot = new Bot (loop);
129
  var server = new OVCCClient.Server ("localhost", 0xdead);
130
  
131
  try {
132 133
    bot.join (server);
    loop.run ();
134 135 136
  } catch (Error e) {
    warning ("Failed to join on the server: %s", e.message);
  }
137 138

  return 0;
139
}