Added some AIs!

Also added collision blocks.

dub.sdl

@@ -3,3 +3,4 @@ description "An AI for CosmicBlocks"
 authors "dhasenan"
 copyright "Copyright © 2018, dhasenan"
 license "MS-PL"
+dependency "vectorflow" version="1.0.0"

dub.selections.json

@@ -0,0 +1,6 @@
+{
+	"fileVersion": 1,
+	"versions": {
+		"vectorflow": "1.0.0"
+	}
+}

source/app.d

@@ -1,18 +1,113 @@
 module app;
 
+import cosmic.ai;
 import cosmic.base;
 import cosmic.blocks;
 import cosmic.drawing;
+import cosmic.random;
+import cosmic.simple;
+
 import std.stdio;
 
 void main()
 {
     auto board = new Board;
-    foreach (i, type; BlockType.playable)
-    {
-        board[Pos(cast(int)i, 0)].type = type;
-    }
+    board.runGame(new Simple, new Simple);
+    //mockup(board);
     auto svg = new SvgSink();
     board.draw(svg);
     svg.write("board.svg");
 }
+
+void mockup(Board board)
+{
+    auto y = board.startA.y;
+    for (int i = board.startA.x + 2; i <= board.startB.x - 2; i++)
+    {
+        board[Pos(i, y)].type = BlockType.plus;
+    }
+    board[Pos(board.startA.x + 1, y)].type = BlockType.arrowR;
+    board[Pos(board.startB.x - 1, y)].type = BlockType.arrowL;
+    board.recalculateAccessibility;
+}
+
+void runGame(Board board, AI aia, AI aib)
+{
+    board.recalculateAccessibility;
+    foreach (block; board.blocks)
+    {
+        if (block.access != Player.none)
+        {
+            writefln("block %s accessible to %s", block.pos, block.access);
+        }
+    }
+    aia.init(board, Player.a);
+    aib.init(board, Player.b);
+    uint moves = 0;
+    uint collisions = 0;
+    while (true)
+    {
+        moves++;
+        if (moves > 300 || collisions > 10)
+        {
+            writefln("draw due to too many moves");
+            break;
+        }
+        auto ma = aia.nextMove();
+        writefln("Player A plays: %s", ma);
+        if (ma.forfeit)
+        {
+            writeln("Player A forfeits");
+            break;
+        }
+        assert(board[ma.pos].type is null, "tried to overwrite existing");
+        if (board.winners != Player.none)
+        {
+            writefln("winner: %s", board.winners);
+            break;
+        }
+
+        auto mb = aib.nextMove();
+        writefln("Player B plays: %s", mb);
+        if (mb.forfeit)
+        {
+            writeln("Player B forfeits");
+            break;
+        }
+        assert(board[mb.pos].type is null, "tried to overwrite existing");
+
+        if (mb.pos == ma.pos)
+        {
+            writefln("collision!");
+            board[ma.pos].type = BlockType.collision5;
+            collisions++;
+        }
+        else
+        {
+            collisions = 0;
+            board[ma.pos].play(Player.a, ma.type, moves);
+            board[mb.pos].play(Player.b, mb.type, moves);
+        }
+        board.tick;
+        if (board.winners != Player.none)
+        {
+            writefln("winner: %s", board.winners);
+            break;
+        }
+    }
+}
+
+Player winners(Board board)
+{
+    board.recalculateAccessibility;
+    Player w = Player.none;
+    if (board[board.startA].access & Player.b)
+    {
+        w |= Player.b;
+    }
+    if (board[board.startB].access & Player.a)
+    {
+        w |= Player.a;
+    }
+    return w;
+}

source/cosmic/ai.d

@@ -1 +1,41 @@
 module cosmic.ai;
+
+import cosmic.base;
+import cosmic.blocks;
+import std.experimental.logger;
+
+struct Move
+{
+    static Move doForfeit = {forfeit: true};
+    Pos pos;
+    BlockType type;
+    bool forfeit = false;
+}
+
+abstract class AI
+{
+    Board board;
+    Player player;
+    Pos start, goal;
+    BlockType[] inventory;  // TODO make multiset
+
+    void init(Board board, Player player)
+    {
+        this.board = board;
+        this.player = player;
+        if (player == Player.a)
+        {
+            start = board.startA;
+            goal = board.startB;
+        }
+        else
+        {
+            start = board.startB;
+            goal = board.startA;
+        }
+        // Close enough?
+        this.inventory = BlockType.playable ~ BlockType.playable;
+    }
+
+    abstract Move nextMove();
+}

source/cosmic/base.d

@@ -21,6 +21,11 @@ struct Pos
                 mixin("this.x " ~ op ~ " other.x"),
                 mixin("this.y " ~ op ~ " other.y"));
     }
+
+    int dist(Pos other)
+    {
+        return (y - other.y) ^^ 2 + (x - other.x) ^^ 2;
+    }
 }
 
 struct Point

source/cosmic/blocks.d

@@ -2,11 +2,13 @@ module cosmic.blocks;
 
 import cosmic.base;
 import cosmic.drawing;
-
 import std.math, std.format;
+import std.experimental.logger;
 
 final class Board
 {
+    immutable width = WIDTH;
+    immutable height = HEIGHT;
     Block[HEIGHT][WIDTH] grid;
     Pos startA, startB;
 
@@ -16,7 +18,7 @@ final class Board
         {
             foreach (y; 0..HEIGHT)
             {
-                grid[x][y] = Block(null, Access.none, Pos(x, y));
+                grid[x][y] = Block(null, Pos(x, y));
             }
         }
 
@@ -31,25 +33,56 @@ final class Board
 
     string colorA = "red", colorB = "yellow", colorBoth = "orange", colorBg = "#E3EAEA";
 
+    void tick()
+    {
+        recalculateAccessibility;
+        foreach (x; 0..WIDTH)
+        {
+            foreach (y; 0..HEIGHT)
+            {
+                grid[x][y].tick;
+            }
+        }
+        /*
+        foreach (ref block; blocks)
+        {
+            block.tick;
+        }
+        */
+    }
+
+    void decayCollisions()
+    {
+        foreach (x; 0..width)
+        {
+            foreach (y; 0..height)
+            {
+                auto p = Pos(x, y);
+                //this[p].type.tick(this, p);
+            }
+        }
+    }
+
     void recalculateAccessibility()
     {
         foreach (x; 0..WIDTH)
         {
             foreach (y; 0..HEIGHT)
             {
-                grid[x][y].access = Access.none;
+                grid[x][y].access = Player.none;
             }
         }
-        accessFrom(startA, Access.a);
-        accessFrom(startB, Access.b);
+        accessFrom(startA, Player.a);
+        accessFrom(startB, Player.b);
     }
 
-    void accessFrom(Pos start, Access access)
+    void accessFrom(Pos start, Player access)
     {
         import std.container.rbtree;
         auto queue = new RedBlackTree!Pos;
         queue.insert(start);
         bool[Pos] seen;
+        this[start].access |= access;
 
         while (!queue.empty)
         {
@@ -58,20 +91,30 @@ final class Board
             foreach (offset; p.type.downstreamOffsets)
             {
                 auto t = p.pos + offset;
+                if (!inBounds(t))
+                {
+                    continue;
+                }
                 if (t in seen)
                 {
                     continue;
                 }
                 seen[t] = true;
                 auto bt = this[t];
-                if (bt.type !is null && (bt.access & access) == Access.none)
+                if (bt.type !is null && (bt.access & access) == Player.none)
                 {
                     queue.insert(t);
                 }
+                this[t].access |= access;
             }
         }
     }
 
+    bool inBounds(Pos pos)
+    {
+        return pos.x >= 0 && pos.y >= 0 && pos.x < width && pos.y < height;
+    }
+
     ref Block opIndex(Pos pos)
     {
         return grid[pos.x][pos.y];
@@ -87,33 +130,43 @@ final class Board
             }
         }
     }
+
+    auto blocks()
+    {
+        import std.range, std.algorithm;
+        return cartesianProduct(iota(width), iota(height))
+            .map!(x => grid[x[0]][x[1]]);
+    }
 }
 
-@("Access for a fresh board")
+@("Player for a fresh board")
 unittest
 {
     auto board = new Board;
-    assert(board[board.startA].access == Access.a);
-    assert(board[board.startB].access == Access.b);
+    assert(board[board.startA].access == Player.a);
+    assert(board[board.startB].access == Player.b);
 
     // Some random points around that should be empty
-    assert(board[Pos(1, 1)].access == Access.none);
-    assert(board[Pos(20, 10)].access == Access.none);
-    assert(board[Pos(0, 0)].access == Access.none);
+    assert(board[Pos(1, 1)].access == Player.none);
+    assert(board[Pos(20, 10)].access == Player.none);
+    assert(board[Pos(0, 0)].access == Player.none);
 
     // The neighborhood near the start positions
     foreach (dx; -1 .. 2)
     {
         foreach (dy; -1 .. 2)
         {
-            assert(board[Pos(board.startA.x + dx, board.startA.y + dy)].access == Access.a);
-            assert(board[Pos(board.startB.x + dx, board.startB.y + dy)].access == Access.b);
+            auto pa = board.startA + Pos(dx, dy);
+            auto pb = board.startB + Pos(dx, dy);
+            assert(board[pa].access == Player.a, format("%s should have had access for player a", pa));
+            assert(board[pb].access == Player.b, format("%s should have had access for player b", pb));
+            assert(board[Pos(board.startB.x + dx, board.startB.y + dy)].access == Player.b);
         }
     }
-    assert(board[Pos(0, 0)].access == Access.none);
+    assert(board[Pos(0, 0)].access == Player.none);
 }
 
-enum Access
+enum Player
 {
     none = 0,
     a = 0b01,
@@ -124,13 +177,29 @@ enum Access
 struct Block
 {
     BlockType type;
-    Access access;
     Pos pos;
+    Player access;
+    Player placed;
+    uint turn;
+
+    void play(Player player, BlockType type, uint turn)
+    {
+        this.placed |= player;
+        this.type = type;
+        this.turn = turn;
+    }
+
+    void tick()
+    {
+        if (type !is null) type.tick(this);
+    }
 
     void draw(SvgSink sink)
     {
-        string color;
-        final switch (access) with (Access)
+        string color = sink.colorBg;
+        string strokeColor = sink.colorGrid;
+        double strokeWidth = sink.thinStroke;
+        final switch (access) with (Player)
         {
             case none:
                 color = sink.colorBg;
@@ -145,12 +214,37 @@ struct Block
                 color = sink.colorB;
                 break;
         }
+        switch (placed) with (Player)
+        {
+            case a:
+                strokeColor = sink.colorBoldA;
+                strokeWidth = sink.mediumStroke;
+                break;
+            case b:
+                strokeColor = sink.colorBoldB;
+                strokeWidth = sink.mediumStroke;
+                break;
+            default:
+                strokeColor = sink.colorGrid;
+                strokeWidth = sink.thinStroke;
+                break;
+        }
         auto center = sink.center(pos);
         auto scale = Point(sink.halfScale, sink.halfScale);
         auto left = center - Point(sink.halfScale, sink.halfScale);
-        sink.put(format(`<rect x="%s" y="%s" width="%s" height="%s" fill="%s" stroke="#CAD0D1" stroke-width="%s" />`,
-                    left.x, left.y, sink.scale, sink.scale, color, sink.thinStroke));
+        if (placed != Player.none && placed != Player.both)
+        {
+            strokeWidth = sink.mediumStroke;
+        }
+        sink.put(format(`<rect x="%s" y="%s" width="%s" height="%s" fill="%s" stroke="%s" stroke-width="%s" />`,
+            left.x, left.y, sink.scale, sink.scale, color, strokeColor, strokeWidth));
         if (type !is null) type.draw(sink, pos);
+        if (turn > 0)
+        {
+            sink.put(format(`<text x="%s" y="%s" font-size="%s" font-family="%s">%s</text>`,
+                left.x + 5, left.y + 20, sink.textSize, sink.font, turn));
+            
+        }
     }
 }
 
@@ -161,6 +255,11 @@ abstract class BlockType
     bool canCircle() @property { return circled != this; }
     abstract const(Pos[]) downstreamOffsets();
 
+    void tick(ref Block block)
+    {
+        // Do nothing by default
+    }
+
     static BlockType x;
     static BlockType ox;
     static BlockType plus;
@@ -168,6 +267,12 @@ abstract class BlockType
     static BlockType star;
     static BlockType ostar;
     static BlockType source;
+    static BlockType collision1;
+    static BlockType collision2;
+    static BlockType collision3;
+    static BlockType collision4;
+    static BlockType collision5;
+    mixin Arrows!();
 
     static BlockType[] playable;
 
@@ -180,18 +285,60 @@ abstract class BlockType
         star = new BlockStar();
         ostar = new BlockOStar();
         source = new BlockSource;
+        collision1 = new Collision(1, null);
+        collision2 = new Collision(2, collision1);
+        collision3 = new Collision(3, collision2);
+        collision4 = new Collision(4, collision3);
+        collision5 = new Collision(5, collision4);
+
+        import std.string : startsWith;
 
-        playable = [
-            x, ox, plus, oplus, star, ostar,
-            new Arrow(Pos(-1, -1)),
-            new Arrow(Pos(-1,  0)),
-            new Arrow(Pos(-1,  1)),
-            new Arrow(Pos( 1, -1)),
-            new Arrow(Pos( 1,  0)),
-            new Arrow(Pos( 1,  1)),
-            new Arrow(Pos( 0,  1)),
-            new Arrow(Pos( 0, -1)),
-        ];
+        static foreach (member; __traits(allMembers, BlockType))
+        {
+            static if (!member.startsWith("collision") && is(typeof(__traits(getMember, BlockType, member)) : BlockType))
+            {
+                static if (__traits(compiles, () { auto a = __traits(getMember, BlockType, member); }))
+                {
+                    pragma(msg, "have type " ~ member);
+                    playable ~= __traits(getMember, BlockType, member);
+                }
+            }
+        }
+    }
+}
+
+mixin template Arrows()
+{
+    import std.conv : to;
+    template name(int x, int y)
+    {
+        enum name = "arrow" ~ (["L", "", "R"][x + 1]) ~ (["U", "", "D"][y + 1]);
+    }
+
+    static foreach (dx; -1..2)
+    {
+        static foreach (dy; -1..2)
+        {
+            static if (dx != 0 || dy != 0)
+            {
+                mixin("static BlockType " ~ name!(dx, dy) ~ ";");
+            }
+        }
+    }
+
+    static this()
+    {
+        static foreach (dx; -1..2)
+        {
+            static foreach (dy; -1..2)
+            {
+                static if (dx != dy)
+                {
+                    mixin(name!(dx, dy) ~ " = new Arrow(Pos(" ~
+                            dx.to!string ~ ", " ~ dy.to!string ~ "));");
+                }
+            }
+        }
     }
 }
 
@@ -370,6 +517,54 @@ class Arrow : BlockType
     }
 }
 
+class Collision : BlockType
+{
+    uint stage;
+    BlockType next;
+    this(uint stage, BlockType next = null)
+    {
+        this.stage = stage;
+        this.next = next;
+        if (stage == 1)
+        {
+            assert(next is null);
+        }
+        else
+        {
+            assert(next !is null);
+        }
+    }
+
+    override void tick(ref Block block)
+    {
+        infof("Collision tick: %s -> %s", this, next);
+        block.type = next;
+        block.placed = Player.none;
+        block.turn = 0;
+    }
+
+    override string toString()
+    {
+        return format("Collision(%s)", stage);
+    }
+
+    override void draw(SvgSink sink, Pos pos)
+    {
+        // A half-sized square?
+        auto center = sink.center(pos);
+        auto scale = sink.halfScale * 0.3;
+        sink.put(format(
+                `<rect x="%s" y="%s" width="%s" height="%s" stroke="black" stroke-width="%s" />`,
+                center.x - scale, center.y - scale, scale * 2,
+                scale * 2, sink.strokeWidth));
+        sink.put(format(
+                `<text x="%s" y="%s" fill="white" font-size="%s" font-family="%s">%s</text>`,
+                center.x - 5, center.y + 5, sink.textSize, sink.font, stage));
+    }
+
+    override const(Pos[]) downstreamOffsets() { return null; }
+}
+
 class BlockSource : BlockType
 {
     override void draw(SvgSink sink, Pos pos)
@@ -382,7 +577,7 @@ class BlockSource : BlockType
     }
     override const(Pos[]) downstreamOffsets()
     {
-        return BlockOStar.offsets;
+        return BlockStar.offsets;
     }
 }
 

source/cosmic/drawing.d

@@ -53,18 +53,26 @@ class SvgSink
 
 class Theme
 {
-    double scale = 40;
+    double scale = 80;
     double halfScale() @property pure { return scale / 2; }
     double angleScale() @property pure { return (scale / 2) / (2 ^^ 0.5); }
 
     double drawablePortion = 0.8;
 
-    double strokeWidth = 4;
-    double thinStroke = 1;
-
-    string colorA = "#ff0000",
-           colorB = "#0000ff",
-           colorBoth = "#ff00ff",
-           colorBg = "#E3EAEA",
-           colorGrid = "#CAD0D1";
+    double strokeWidth = 8;
+    double thinStroke = 3;
+    double mediumStroke = 5;
+
+    double textSize = 20;
+    string font = "sans-serif";
+
+    // these HSV values are from some weird scale from 0 to 343
+    string colorA = "#e58f7b"  // HSV(11, 46, 90)
+         , colorB = "#7baee5"  // HSV(211, 46, 90)
+         , colorBoth = "#e57be5"  // HSV(300, 46, 90)
+         , colorBg = "#efe6d0"
+         , colorGrid = "#cad0d1"
+         , colorBoldA = "#e53c16" // HSV(11, 90, 90)
+         , colorBoldB = "#167ae5"  // HSV(211, 90, 90)
+           ;
 }

source/cosmic/greedy.d

@@ -0,0 +1,30 @@
+module cosmic.greedy;
+
+import cosmic.ai;
+import cosmic.base;
+import cosmic.blocks;
+import std.random;
+
+class Greedy : AI
+{
+    private static Mt19937 rnd;
+
+    static this()
+    {
+        rnd.seed(1);
+    }
+
+    private Board board;
+
+    override void init(Board board, Player player)
+    {
+        this.board = board;
+    }
+
+    override Move nextMove()
+    {
+        // The value of a position is how valuable it is to get there.
+        //
+        assert(false);
+    }
+}

source/cosmic/random.d

@@ -1 +1,38 @@
 module cosmic.random;
+
+import cosmic.ai;
+import cosmic.base;
+import cosmic.blocks;
+import std.random;
+
+class Random : AI
+{
+    private static Mt19937 rnd;
+
+    static this()
+    {
+        rnd.seed(1);
+    }
+
+    private Board board;
+
+    override void init(Board board, Player player)
+    {
+        this.board = board;
+    }
+
+    override Move nextMove()
+    {
+        foreach (attempt; 0..10)
+        {
+            auto x = uniform(0, board.width, rnd);
+            auto y = uniform(0, board.height, rnd);
+            auto p = Pos(x, y);
+            if (board[p].type is null)
+            {
+                return Move(p, choice(BlockType.playable, rnd), false);
+            }
+        }
+        return Move(Pos(0, 0), null, true);
+    }
+}

source/cosmic/simple.d

@@ -0,0 +1,88 @@
+module cosmic.simple;
+
+import cosmic.ai;
+import cosmic.base;
+import cosmic.blocks;
+import std.experimental.logger;
+import std.random;
+
+/**
+  * A simple AI that tries to make moves that directly contribute to victory.
+  * It is unsubtle and relatively obvious.
+  */
+class Simple : AI
+{
+    private static Mt19937 rnd;
+
+    static this()
+    {
+        rnd.seed(1);
+    }
+
+    override Move nextMove()
+    {
+        // There are two types of moves in a single-player mindset:
+        // 1. Closing a gap
+        // 2. Increasing the options
+        // We can often do both at once. However, we might sometimes do only one or the other.
+        if (rnd.dice(0.8, 0.2) == 0)
+        {
+            return closeGap;
+        }
+        else
+        {
+            return increaseOptions;
+        }
+    }
+
+    Move increaseOptions()
+    {
+        // Don't know how
+        return closeGap;
+    }
+
+    Move closeGap()
+    in
+    {
+        assert(player != Player.none, "AI must have a player");
+    }
+    do
+    {
+        // Find the open position closest to your opponent's position
+        import std.algorithm, std.array;
+        infof("close gap for player %s", player);
+        auto options = board.blocks
+            .filter!(x => (x.access & player) == player)
+            .filter!(x => x.type is null)
+            .array
+            .sort!((a, b) => a.pos.dist(goal) < b.pos.dist(goal));
+        if (options.length == 0)
+        {
+            // TODO try to use a remove
+            info("failed to find a move: no open spaces");
+            return Move.doForfeit;
+        }
+        foreach (option; options)
+        {
+            foreach (type; inventory)
+            {
+                bool getsCloser = false;
+                foreach (offset; type.downstreamOffsets)
+                {
+                    if (goal.dist(option.pos + offset) < goal.dist(option.pos))
+                    {
+                        getsCloser = true;
+                        break;
+                    }
+                }
+                if (!getsCloser) continue;
+                // Let's just take the first.
+                Move m = {pos: option.pos, type: type};
+                return m;
+            }
+        }
+        info("nothing gets us closer; doing something random");
+        Move m = {pos: options[0].pos, type: inventory[0]};
+        return m;
+    }
+}