PisqPipe.cs

/** functions that communicate with Piskvork manager through pipes */
/** don't modify this file */
using System;
using System.Threading;

abstract class GomocupInterface
{
    /* information about a game - you should use these variables */
    public int width, height; /* the board size */
    public int info_timeout_turn = 30000; /* time for one turn in milliseconds */
    public int info_timeout_match = 1000000000; /* total time for a game */
    public int info_time_left = 1000000000; /* left time for a game */
    public int info_max_memory = 0; /* maximum memory in bytes, zero if unlimited */
    public int info_game_type = 1; /* 0:human opponent, 1:AI opponent, 2:tournament, 3:network tournament */
    public bool info_exact5 = false; /* false:five or more stones win, true:exactly five stones win */
    public bool info_renju = false; /* false:gomoku, true:renju */
    public bool info_continuous = false; /* false:single game, true:continuous */
    public int terminate; /* return from brain_turn when terminate>0 */
    public int start_time; /* tick count at the beginning of turn */
    public string dataFolder; /* folder for persistent files, can be null */

    /* you have to implement these functions */
    abstract public string brain_about { get; } /* copyright, version, homepage */
    abstract public void brain_init(); /* create the board and call Console.WriteLine("OK"); or Console.WriteLine("ERROR Maximal board size is .."); */
    abstract public void brain_restart(); /* delete old board, create new board, call Console.WriteLine("OK"); */
    abstract public void brain_turn(); /* choose your move and call do_mymove(x,y); 0<=x<width, 0<=y<height */
    abstract public void brain_my(int x, int y); /* put your move to the board */
    abstract public void brain_opponents(int x, int y); /* put opponent's move to the board */
    abstract public void brain_block(int x, int y); /* square [x,y] belongs to a winning line (when info_continuous is 1) */
    abstract public int brain_takeback(int x, int y); /* clear one square; return value: 0:success, 1:not supported, 2:error */
    abstract public void brain_end();  /* delete temporary files, free resources */
    virtual public void brain_eval(int x, int y) { } /* display evaluation of square [x,y] */


    private string cmd;
    private AutoResetEvent event1;
    private ManualResetEvent event2;

    /** read a line from STDIN */
    private void get_line()
    {
        cmd = Console.ReadLine();
        if (cmd == null) Environment.Exit(0);
    }

    /** parse coordinates x,y */
    private bool parse_coord2(string param, out int x, out int y)
    {
        string[] p = param.Split(',');
        if (p.Length == 2 && int.TryParse(p[0], out x) && int.TryParse(p[1], out y) && x >= 0 && y >= 0)
            return true;
        x = y = 0;
        return false;
    }

    /** parse coordinates x,y */
    private bool parse_coord(string param, out int x, out int y)
    {
        return parse_coord2(param, out x, out y) && x < width && y < height;
    }

    /** parse coordinates x,y and player number z */
    private void parse_3int_chk(string param, out int x, out int y, out int z)
    {
        string[] p = param.Split(',');
        if (!(p.Length == 3 && int.TryParse(p[0], out x) && int.TryParse(p[1], out y) && int.TryParse(p[2], out z)
            && x >= 0 && y >= 0 && x < width && y < height))
            x = y = z = 0;
    }

    /** return pointer to word after command if input starts with command, otherwise return NULL */
    private static string get_cmd_param(string command, out string param)
    {
        param = "";
        int pos = command.IndexOf(' ');
        if (pos >= 0)
        {
            param = command.Substring(pos + 1).TrimStart(' ');
            command = command.Substring(0, pos);
        }
        return command.ToLower();
    }

    /** send suggest */
    protected void suggest(int x, int y)
    {
        Console.WriteLine("SUGGEST {0},{1}", x, y);
    }

    /** write move to the pipe and update internal data structures */
    protected void do_mymove(int x, int y)
    {
        brain_my(x, y);
        Console.WriteLine("{0},{1}", x, y);
    }

    /** main function for the working thread */
    private void threadLoop()
    {
        for (; ; )
        {
            event1.WaitOne();
            brain_turn();
            event2.Set();
        }
    }

    /** start thinking */
    private void turn()
    {
        terminate = 0;
        event2.Reset();
        event1.Set();
    }

    /** stop thinking */
    private void stop()
    {
        terminate = 1;
        event2.WaitOne();
    }

    private void start()
    {
        start_time = Environment.TickCount;
        stop();
        if (width == 0)
        {
            width = height = 20;
            brain_init();
        }
    }

    /** do command cmd */
    private void do_command()
    {
        string param, info;
        int x, y, who, e;

        switch (get_cmd_param(cmd, out param))
        {
            case "info":
                switch (get_cmd_param(param, out info))
                {
                    case "max_memory":
                        int.TryParse(info, out info_max_memory); break;
                    case "timeout_match":
                        int.TryParse(info, out info_timeout_match); break;
                    case "timeout_turn":
                        int.TryParse(info, out info_timeout_turn); break;
                    case "time_left":
                        int.TryParse(info, out info_time_left); break;
                    case "game_type":
                        int.TryParse(info, out info_game_type); break;
                    case "rule":
                        if (int.TryParse(info, out e))
                        {
                            info_exact5 = (e & 1) != 0;
                            info_continuous = (e & 2) != 0;
                            info_renju = (e & 4) != 0;
                        }
                        break;
                    case "folder":
                        dataFolder = info; break;
                    case "evaluate":
                        if (parse_coord(info, out x, out y)) brain_eval(x, y);
                        break;
                    /* unknown info is ignored */
                }
                break;
            case "start":
                if (!int.TryParse(param, out width) || width < 5)
                {
                    width = 0;
                    Console.WriteLine("ERROR bad START parameter");
                }
                else
                {
                    height = width;
                    start();
                    brain_init();
                }
                break;
            case "rectstart":
                if (!parse_coord2(param, out width, out height) || width < 5 || height < 5)
                {
                    width = height = 0;
                    Console.WriteLine("ERROR bad RECTSTART parameters");
                }
                else
                {
                    start();
                    brain_init();
                }
                break;
            case "restart":
                start();
                brain_restart();
                break;
            case "turn":
                start();
                if (!parse_coord(param, out x, out y))
                {
                    Console.WriteLine("ERROR bad coordinates");
                }
                else
                {
                    brain_opponents(x, y);
                    turn();
                }
                break;
            case "play":
                start();
                if (!parse_coord(param, out x, out y))
                {
                    Console.WriteLine("ERROR bad coordinates");
                }
                else
                {
                    do_mymove(x, y);
                }
                break;
            case "begin":
                start();
                turn();
                break;
            case "about":
                Console.WriteLine(brain_about);
                break;
            case "end":
                stop();
                brain_end();
                Environment.Exit(0);
                break;
            case "board":
                start();
                for (; ; ) /* fill the whole board */
                {
                    get_line();
                    parse_3int_chk(cmd, out x, out y, out who);
                    if (who == 1) brain_my(x, y);
                    else if (who == 2) brain_opponents(x, y);
                    else if (who == 3) brain_block(x, y);
                    else
                    {
                        if (!cmd.Equals("done", StringComparison.InvariantCultureIgnoreCase))
                            Console.WriteLine("ERROR x,y,who or DONE expected after BOARD");
                        break;
                    }
                }
                turn();
                break;
            case "takeback":
                start();
                string t = "ERROR bad coordinates";
                if (parse_coord(param, out x, out y))
                {
                    e = brain_takeback(x, y);
                    if (e == 0) t = "OK";
                    else if (e == 1) t = "UNKNOWN";
                }
                Console.WriteLine(t);
                break;
            default:
                Console.WriteLine("UNKNOWN command");
                break;
        }
    }


    /** main function for AI console application  */
    public void main()
    {
        try
        {
            int dummy = Console.WindowHeight;
            //ERROR, process started from the Explorer or command line
            Console.WriteLine("MESSAGE Gomoku AI should not be started directly. Please install gomoku manager (http://sourceforge.net/projects/piskvork). Then enter path to this exe file in players settings.");
        }
        catch (System.IO.IOException)
        {
            //OK, process started from the Piskvork manager
        }

        event1 = new AutoResetEvent(false);
        new Thread(threadLoop).Start();
        event2 = new ManualResetEvent(true);
        for (; ; )
        {
            get_line();
            do_command();
        }
    }

    static void Main(string[] args)
    {
        new GomocupEngine().main();
    }
}