Starting work on Galcon engine.

Author: cameron.jp

Diff for: galcon/Makefile

@@ -0,0 +1,32 @@
+# Copyright 2010 owners of the AI Challenge project
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not
+# use this file except in compliance with the License. You may obtain a copy
+# of the License at http:#www.apache.org/licenses/LICENSE-2.0 . Unless
+# required by applicable law or agreed to in writing, software distributed
+# under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+# CONDITIONS OF ANY KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations under the License.
+#
+# Author: Jeff Cameron ([email protected])
+#
+# Makefile for the entire AI contest project.
+
+CC=g++
+CPPFLAGS += -Wall -I.. -I../third_party/googletest/include
+VPATH = third_party/googletest/make:cpp_util:sandbox
+SUBDIRS = engine
+
+all: subdirs
+
+clean:
+	for dir in $(SUBDIRS); \
+	do \
+		$(MAKE) -C $$dir clean; \
+	done
+
+.PHONY: subdirs $(SUBDIRS)
+subdirs: $(SUBDIRS)
+
+$(SUBDIRS):
+	$(MAKE) -C $@

Diff for: galcon/engine/Makefile

@@ -0,0 +1,30 @@
+# Copyright 2010 owners of the AI Challenge project
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not
+# use this file except in compliance with the License. You may obtain a copy
+# of the License at http:#www.apache.org/licenses/LICENSE-2.0 . Unless
+# required by applicable law or agreed to in writing, software distributed
+# under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+# CONDITIONS OF ANY KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations under the License.
+#
+# Author: Jeff Cameron ([email protected])
+#
+# Makefile for the Tic-Tac-Toe contest engine.
+
+CC=g++
+CPPFLAGS += -Wall -I../.. -I../../third_party/googletest/include
+VPATH = ../../third_party/googletest/make:../../cpp_util:../../sandbox
+TARGETS = engine random_bot unit_tests
+
+all: $(TARGETS)
+
+clean:
+	rm -f *.o $(TARGETS) *_test
+
+engine: engine.o grid.o sandbox.a cpp_util.a
+
+random_bot: random_bot.o cpp_util.a
+
+unit_tests: grid.o grid_test.o gtest_main.a
+	$(CC) $(CPPFLAGS) -o $@ $^ -lpthread

Diff for: galcon/engine/engine.cc

@@ -0,0 +1,63 @@
+// Copyright 2010 owners of the AI Challenge project
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not
+// use this file except in compliance with the License. You may obtain a copy
+// of the License at http://www.apache.org/licenses/LICENSE-2.0 . Unless
+// required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+//
+// Author: Jeff Cameron ([email protected])
+//
+// Runs a game of Tic-Tac-Toe between two computer programs.
+
+#include <iostream>
+#include <stdlib.h>
+#include "cpp_util/string_util.h"
+#include "sandbox/sandbox.h"
+#include "tic_tac_toe/engine/grid.h"
+
+int main(int argc, char *argv[]) {
+  Sandbox player_one("./random_bot");
+  Sandbox player_two("./random_bot");
+  player_one.Init();
+  player_two.Init();
+  int blame = 0;
+  Grid grid(3, 3, 3);
+  while (!grid.GameOver()) {
+    std::cout << "grid.GameOver(): " << grid.GameOver() << std::endl;
+    Sandbox& player = grid.WhoseTurn() == 1 ? player_one : player_two;
+    player.Write(grid.ToString());
+    std::cout << grid.ToString();
+    std::string line;
+    int result = player.ReadLine(line, 1000);
+    if (result <= 0) {
+      blame = grid.WhoseTurn();
+      std::cout << "Didn't receive a response from player " << blame
+		<< std::endl;
+      break;
+    }
+    std::cout << "Received from player " << grid.WhoseTurn() << " ("
+	      << result << "): " << line << std::endl;
+    std::vector<std::string> tokens = StringUtil::Tokenize(line);
+    if (tokens.size() != 2) {
+      blame = grid.WhoseTurn();
+      break;
+    }
+    int x = atoi(tokens[0].c_str());
+    int y = atoi(tokens[1].c_str());
+    grid.MakeMove(x, y);
+  }
+  if (blame != 0) {
+    std::cout << "Player " << blame << " did something bad." << std::endl;
+    return 0;
+  }
+  std::cout << grid.ToString();
+  if (grid.Winner() == 0) {
+    std::cout << "Draw!" << std::endl;
+  } else {
+    std::cout << "Player " << grid.Winner() << " Wins!" << std::endl;
+  }
+  return 0;
+}

Diff for: galcon/engine/game.cc

@@ -0,0 +1,14 @@
+// Copyright 2010 owners of the AI Challenge project
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not
+// use this file except in compliance with the License. You may obtain a copy
+// of the License at http://www.apache.org/licenses/LICENSE-2.0 . Unless
+// required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+//
+// Author: Jeff Cameron ([email protected])
+
+#include "galcon/engine/game.h"
+

Diff for: galcon/engine/game.h

@@ -0,0 +1,57 @@
+// Copyright 2010 owners of the AI Challenge project
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not
+// use this file except in compliance with the License. You may obtain a copy
+// of the License at http://www.apache.org/licenses/LICENSE-2.0 . Unless
+// required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+//
+// Author: Jeff Cameron ([email protected])
+//
+// Stores the game state.
+
+#ifndef GALCON_ENGINE_GAME_H_
+#define GALCON_ENGINE_GAME_H_
+
+#include <string>
+
+class Game {
+ public:
+  // Initializes a game using a description of a map from a text file. See the
+  // LoadMapFromFile function for a description of the map file format.
+  Game(const std::string& map_filename);
+
+  // Returns the number of planets in the map.
+  int NumPlanets() const;
+
+  // Returns the owner of the planet with the given number.
+  int Owner(int planet_id) const;
+
+  // Returns the number of ships in the given planet.
+  int NumShips(int planet_id) const;
+
+  // Returns the x- and y-coordinate of a given planet.
+  int PlanetX(int planet_id) const;
+  int PlanetY(int planet_id) const;
+
+ private:
+  // Loads a map from a test file. The text file contains a description of the
+  // starting state of a game. One planet is specified per line. Each line
+  // contains the x- and y-coordinate of one planet, the player number that
+  // starts off owning the planet, and the number of ships originally in the
+  // planet. Any characters on a line beyond a '#' character should be
+  // ignored. The coordinates are real numbers, and need not be integers.
+  // The player number and number of ships must be integers. Fields are
+  // separated by space characters. Lines that do not appear to match the
+  // specified line format should be ignored. For example:
+  //
+  // # This is a sample map file, for the purpose of illustration.
+  // 0 0 1 34 # Player one home planet
+  // 7 7 2 34 # Player two home planet
+  // 3.14 2.71 0 15 # Neutral planet with real-numbere coordinates.
+  void LoadMapFromFile(const std::string& map_filename);
+};
+
+#endif

Diff for: galcon/engine/game_test.cc

@@ -0,0 +1,136 @@
+// Copyright 2010 owners of the AI Challenge project
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not
+// use this file except in compliance with the License. You may obtain a copy
+// of the License at http://www.apache.org/licenses/LICENSE-2.0 . Unless
+// required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+//
+// Author: Jeff Cameron ([email protected])
+//
+// Unit tests for the Sandbox class.
+
+#include "tic_tac_toe/engine/grid.h"
+#include <sstream>
+#include "gtest/gtest.h"
+
+// Tests the default constructor. It's supposed to make a standard 3x3 Tic Tac
+// Toe board.
+TEST(GridTest, DefaultConstructor) {
+  Grid g;
+  ASSERT_EQ(g.Width(), 3) << "Board width is suppsed to be 3.";
+  ASSERT_EQ(g.Height(), 3) << "Board height is suppsed to be 3.";
+  ASSERT_EQ(g.WinLength(), 3) << "Board win length is suppsed to be 3.";
+  ASSERT_EQ(g.GameOver(), false) << "Game should not be over right after "
+                                 << "initialization.";
+}
+// Tests the custom constructor, which creates boards with arbitrary
+// dimensions.
+TEST(GridTest, CustomConstructor) {
+  Grid g(2, 4, 3);
+  ASSERT_EQ(g.Width(), 2) << "Wrong board width.";
+  ASSERT_EQ(g.Height(), 4) << "Wrong board height.";
+  ASSERT_EQ(g.WinLength(), 3) << "Wrong win length.";
+  ASSERT_EQ(g.GameOver(), false) << "Game should not be over right after "
+                                 << "initialization.";  
+}
+
+// Runs a full game on a small, simple board, testing the state of the grid
+// after each move.
+TEST(GridTest, SmallGame) {
+  Grid g(2, 2, 2);
+  ASSERT_EQ(g.Width(), 2);
+  ASSERT_EQ(g.Height(), 2);
+  ASSERT_EQ(g.WinLength(), 2);
+  ASSERT_EQ(g.GameOver(), false);
+  ASSERT_EQ(g.WhoseTurn(), 1);
+  std::stringstream grid_string;
+  grid_string << "2 2 2" << std::endl
+	      << "00" << std::endl
+	      << "00" << std::endl;
+  ASSERT_EQ(g.ToString(), grid_string.str());
+  ASSERT_EQ(g.Winner(), 0);
+  ASSERT_EQ(g.Loser(), 0);
+  ASSERT_EQ(g.MakeMove(0, 0), 0);
+  ASSERT_EQ(g.GameOver(), false);
+  ASSERT_EQ(g.WhoseTurn(), 2);
+  grid_string.str("");
+  grid_string << "2 2 2" << std::endl
+	      << "10" << std::endl
+	      << "00" << std::endl;
+  ASSERT_EQ(g.ToString(), grid_string.str());
+  ASSERT_EQ(g.Winner(), 0);
+  ASSERT_EQ(g.Loser(), 0);
+  ASSERT_EQ(g.MakeMove(1, 0), 0);
+  ASSERT_EQ(g.GameOver(), false);
+  ASSERT_EQ(g.WhoseTurn(), 1);
+  grid_string.str("");
+  grid_string << "2 2 2" << std::endl
+	      << "12" << std::endl
+	      << "00" << std::endl;
+  ASSERT_EQ(g.ToString(), grid_string.str());
+  ASSERT_EQ(g.Winner(), 0);
+  ASSERT_EQ(g.Loser(), 0);
+  ASSERT_EQ(g.MakeMove(1, 1), 0);
+  ASSERT_EQ(g.GameOver(), true);
+  ASSERT_EQ(g.WhoseTurn(), 2);
+  grid_string.str("");
+  grid_string << "2 2 2" << std::endl
+	      << "12" << std::endl
+	      << "01" << std::endl;
+  ASSERT_EQ(g.ToString(), grid_string.str());
+  ASSERT_EQ(g.Winner(), 1);
+  ASSERT_EQ(g.Loser(), 2);
+}
+
+// Tries to move onto a square which has already been filled.
+TEST(GridTest, IllegalMove) {
+  Grid g;
+  ASSERT_EQ(g.WhoseTurn(), 1);
+  ASSERT_EQ(g.MakeMove(1, 1), 0);
+  ASSERT_EQ(g.WhoseTurn(), 2);
+  ASSERT_EQ(g.MakeMove(1, 1), -1);
+  ASSERT_EQ(g.WhoseTurn(), 2);
+}
+
+// Tries to move onto a square which is out of bounds.
+TEST(GridTest, OutOfBounds) {
+  Grid g;
+  ASSERT_EQ(g.MakeMove(3, 2), -1);
+}
+
+// Makes sure that draws are detected okay. Plays the following game:
+//   122
+//   211
+//   112
+// where the moves are made in the following order:
+//   984
+//   615
+//   372
+// then checks to make sure that the draw is detected.
+TEST(GridTest, DrawDetection) {
+  Grid g;
+  ASSERT_EQ(g.GameOver(), false);
+  ASSERT_EQ(g.MakeMove(1, 1), 0);
+  ASSERT_EQ(g.GameOver(), false);
+  ASSERT_EQ(g.MakeMove(2, 2), 0);
+  ASSERT_EQ(g.GameOver(), false);
+  ASSERT_EQ(g.MakeMove(0, 2), 0);
+  ASSERT_EQ(g.GameOver(), false);
+  ASSERT_EQ(g.MakeMove(2, 0), 0);
+  ASSERT_EQ(g.GameOver(), false);
+  ASSERT_EQ(g.MakeMove(2, 1), 0);
+  ASSERT_EQ(g.GameOver(), false);
+  ASSERT_EQ(g.MakeMove(0, 1), 0);
+  ASSERT_EQ(g.GameOver(), false);
+  ASSERT_EQ(g.MakeMove(1, 2), 0);
+  ASSERT_EQ(g.GameOver(), false);
+  ASSERT_EQ(g.MakeMove(1, 0), 0);
+  ASSERT_EQ(g.GameOver(), false);
+  ASSERT_EQ(g.MakeMove(0, 0), 0);
+  ASSERT_EQ(g.GameOver(), true);
+  ASSERT_EQ(g.Winner(), 0);
+  ASSERT_EQ(g.Loser(), 0);
+}