add files

gen.py

@@ -0,0 +1,147 @@
+from functools import reduce
+import random
+import visual
+
+
+######## Width and height #######
+N = 3
+#M = 3
+#################################
+
+
+
+EMPTY = -1
+WIRE = 0
+SOURCE = 1
+SINK = 2
+types = ["Wire","Source","Sink"]
+
+NORTH,EAST,SOUTH,WEST = range(4)
+edges = ["North","East","South","West"]
+
+directions = [(0,1),(1,0),(0,-1),(-1,0)]
+
+def isWireConnected(puzzle,x,y):
+    _,ds = puzzle[y][x]
+    drs= [directions[d] for d in ds]
+    for d in ds:
+        dx,dy = directions[d]
+        if 0 <= y+dy < len(puzzle) and 0 <= x+dx < len(puzzle[y+dy]):
+            t2,ds2 = puzzle[y+dy][x+dx]
+            if t2 == EMPTY:
+                continue
+            if (d+2)%4 not in ds2:
+                return False
+        else:
+            return False
+    return True
+
+def gettile():
+    return (WIRE, [i for i in range(4) if random.random() < 0.4])
+
+def consistent(puzzle,x,y):
+    if not isWireConnected(puzzle,x,y):
+        return False
+    if y > 0:
+        if not isWireConnected(puzzle,x,y-1):
+            return False
+    if x > 0:
+        if not isWireConnected(puzzle,x-1,y):
+            return False
+    return True
+
+def joined(puzzle,x1,y1,x2,y2):
+    # is there a wire connecting the tiles at x1,y1 and x2,y2
+    _,ds = puzzle[y1][x1]
+    _,ds2 = puzzle[y2][x2]
+    diff = (x2-x1,y2-y1)
+    if diff not in [(0,1),(1,0),(0,-1),(-1,0)]: return False
+    d = directions.index(diff)
+    return (d+2)%4 in ds2 and d in ds
+
+def neighbours(puzzle,x,y):
+    _,ds = puzzle[y][x]
+    for d in ds:
+        dx,dy = directions[d]
+        if 0 <= y+dy < len(puzzle) and 0 <= x+dx < len(puzzle[y+dy]):
+            yield (x+dx,y+dy)
+
+def reachable(puzzle,x,y):
+    ttype,_ = puzzle[y][x]
+    found = [(x,y)]
+    ttype2 = SINK if ttype == SOURCE else SOURCE
+    assert ttype in [SOURCE,SINK]
+    
+    flag = True
+    while flag:
+        flag = False
+        for (x1,y1) in found.copy():
+            for (x2,y2) in neighbours(puzzle,x1,y1):
+                if (x2,y2) in found:
+                    continue
+                found.append((x2,y2))
+                flag = True
+                if puzzle[y2][x2][0] == ttype2:
+                    return (x2,y2)
+    return random.choice(found[1:])
+
+seed1=0
+def genpuzzle(w,h=None,seed=0):
+    global seed1
+    if h is None:
+        h = w
+    if seed == 0:
+        seed = random.randint(0,9223372036854775807)
+    random.seed(seed)
+    seed1 = seed
+    puzzle = [[(EMPTY,[]) for _ in range(w)] for _ in range(h)]
+    for y in range(h):
+        for x in range(w):
+            puzzle[y][x] = gettile()
+            while not consistent(puzzle,x,y):
+                puzzle[y][x] = gettile()
+    
+    numsinks = (w*h//10) + 1
+    for _ in range(numsinks):
+        x = random.randint(0,w-1)
+        y = random.randint(0,h-1)
+        if puzzle[y][x][1] != []:
+            t1,t2 = random.choice([(SOURCE,SINK),(SINK,SOURCE)])
+            puzzle[y][x] = (t1,puzzle[y][x][1])
+            x2,y2 = reachable(puzzle,x,y)
+            puzzle[y2][x2] = (t2,puzzle[y2][x2][1])
+    
+    return puzzle
+
+def h(puzzle):
+    output = "["
+    for row in reversed(puzzle):
+        ss = []
+        for t in row:
+            s = types[t[0]]# + " "
+            s += "[" + ",".join(map(lambda x: edges[x], t[1])) + "]"
+            ss.append(s)
+        output += "[" + ",".join(ss) + "],"
+    output = output[:-1] + "]"
+    return output
+
+def shuf(puzzle):
+    def rot(rs,x):
+        return (x[0], list(map(lambda y: (y+rs)%4, x[1])))
+    return [[rot(random.randint(0,3),t) for t in ln] for ln in puzzle]
+
+
+if __name__ == '__main__':
+    try:
+        p = genpuzzle(N,M)
+    except NameError:
+        p = genpuzzle(N)
+
+    p_ = shuf(p)
+
+    print(h(p))
+    print('=======================================')
+    print(h(p_))
+
+    p2 = visual.join(p,p_)
+    visual.show(p2)

visual.py

@@ -0,0 +1,182 @@
+from re import match
+import matplotlib.pyplot as plt
+from matplotlib.patches import Arc
+
+EMPTY = -1
+WIRE = 0
+SOURCE = 1
+SINK = 2
+
+NORTH = 0
+EAST = 1
+SOUTH = 2
+WEST = 3
+
+############
+SCALE = 1
+WIDTH = .25
+CIRCRAD = .25
+############
+
+HLF = WIDTH/2
+LW = 50 * WIDTH * SCALE
+
+def parseDirs(dirs):
+    if dirs == '': return []
+    return list(map(["North","East","South","West"].index,dirs.split(',')))
+
+def parse(s:str):
+    s = ''.join(s.split())
+    s = match(r'\[(.*)\]',s).group(1)
+    lines = s.split(']],')
+    #objs = [l.split('],') for l in lines]
+    tiles = []
+    
+    for l in lines:
+        currline= []
+        ts = l.split('],')
+        for t in ts:
+            t = t.strip('[]')
+            if r:=match(r'Wire\[?(.*)',t):
+                currline.append((WIRE,parseDirs(r.group(1))))
+            elif r:=match(r'Source\[?(.*)',t):
+                currline.append((SOURCE,parseDirs(r.group(1))))
+            elif r:=match(r'Sink\[?(.*)',t):
+                currline.append((SINK,parseDirs(r.group(1))))
+            else:
+                raise Exception("didnt work :/")
+        tiles.append(currline)
+    tiles.reverse()
+    print(tiles)
+    return tiles
+
+def join(xs,ys):
+    return [x + [(EMPTY,[])] + y for x,y in zip(xs,ys)]
+
+
+def rectpos(x, y, d):
+    return [((x - HLF, y), WIDTH, .5), ((x, y - HLF), .5, WIDTH), ((x - HLF, y - .5), WIDTH, .5), ((x - .5, y - HLF), .5, WIDTH)][d]
+
+def mktile(tile, pos, wirevalid=True, circlevalid=True, 
+           wirevalidcolor='green', wireinvalidcolor='red', 
+           circlevalidcolor='green', circleinvalidcolor='red'
+           ):
+    
+    wirecolor = wirevalidcolor if wirevalid else wireinvalidcolor
+    circlecolor = circlevalidcolor if circlevalid else circleinvalidcolor
+    tiletype,ds = tile
+    x,y = pos
+    
+    if tiletype == EMPTY: return
+    
+    box = plt.Rectangle((x-.5,y-.5),1,1,color='grey',fill=False, zorder=2)
+    plt.gca().add_patch(box)
+    
+    if not (wirevalid and circlevalid):
+        plt.gca().add_patch(plt.Rectangle((x-.5,y-.5),1,1,color='red',fill=False, zorder=3, lw=1))
+    
+    # if line is a right angle draw an arc
+    if tiletype == WIRE and len(ds) == 2 and (ds[0] - ds[1]) % 2 == 1:
+        ds = sorted(ds)
+        if ds == [0,3]:
+            plt.gca().add_patch(Arc((x-.5,y+.5),1,1,theta1=270,theta2=360,color=wirecolor, lw=LW))
+        elif ds[0] == 0:
+            plt.gca().add_patch(Arc((x+.5,y+.5),1,1,theta1=180,theta2=270,color=wirecolor, lw=LW))
+        elif ds[0] == 1:
+            plt.gca().add_patch(Arc((x+.5,y-.5),1,1,theta1=90,theta2=180,color=wirecolor, lw=LW))
+        elif ds[0] == 2:
+            plt.gca().add_patch(Arc((x-.5,y-.5),1,1,theta1=0,theta2=90,color=wirecolor, lw=LW))
+        
+    else:
+        if len(ds) == 1:
+            circ = plt.Circle((x,y),HLF,color=wirecolor)
+            plt.gca().add_patch(circ)
+    
+        for d in ds:
+            rect = plt.Rectangle(*rectpos(x,y,d),color=wirecolor)
+            plt.gca().add_patch(rect)
+        
+        if tiletype > 0:
+            circ = plt.Circle((x,y),CIRCRAD,color=circlecolor)
+            plt.gca().add_patch(circ)
+        if tiletype == 2:
+            circ = plt.Circle((x,y),CIRCRAD/2,color='white')
+            plt.gca().add_patch(circ)
+
+def mkgrid(grid):
+    for y,l in enumerate(grid):
+        for x,t in enumerate(l):
+            if t[0] > WIRE:
+                mktile(t,(x,y), isWireConnected(grid,x,y), sinksource(grid,x,y))
+            else:
+                mktile(t,(x,y), isWireConnected(grid,x,y))
+
+directions = [(0,1),(1,0),(0,-1),(-1,0)]
+
+def isWireConnected(puzzle,x,y):
+    _,ds = puzzle[y][x]
+    drs= [directions[d] for d in ds]
+    return all(0 <= y+dy < len(puzzle) and 0 <= x+dx < len(puzzle[y+dy]) and (d+2)%4 in puzzle[y+dy][x+dx][1] for d,(dx,dy) in zip(ds, drs))
+
+def neighbours(puzzle,x,y):
+    _,ds = puzzle[y][x]
+    for d in ds:
+        dx,dy = directions[d]
+        if 0 <= y+dy < len(puzzle) and 0 <= x+dx < len(puzzle[y+dy]):
+            yield (x+dx,y+dy)
+
+def sinksource(puzzle,x,y):
+    ttype,_ = puzzle[y][x]
+    found = [(x,y)]
+    ttype2 = SINK if ttype == SOURCE else SOURCE
+    assert ttype in [SOURCE,SINK]
+    
+    flag = True
+    while flag:
+        flag = False
+        for (x1,y1) in found.copy():
+            for (x2,y2) in neighbours(puzzle,x1,y1):
+                if (x2,y2) in found:
+                    continue
+                found.append((x2,y2))
+                flag = True
+                if puzzle[y2][x2][0] == ttype2:
+                    return True
+    return False
+
+def joined(puzzle,x1,y1,x2,y2):
+    # is there a wire connecting the tiles at x1,y1 and x2,y2
+    _,ds = puzzle[y1][x1]
+    _,ds2 = puzzle[y2][x2]
+    diff = (x2-x1,y2-y1)
+    if diff not in [(0,1),(1,0),(0,-1),(-1,0)]: return False
+    d = directions.index(diff)
+    return (d+2)%4 in ds2 and d in ds
+
+def setup(p, show_axes=False):
+    plt.figure(figsize=(len(p[0])*SCALE,len(p)*SCALE))
+    plt.axes().set_aspect('equal')
+    plt.gca().xaxis.set_major_locator(plt.MultipleLocator(1))
+    plt.gca().yaxis.set_major_locator(plt.MultipleLocator(1))
+    plt.gca().get_xaxis().set_visible(show_axes)
+    plt.gca().get_yaxis().set_visible(show_axes)
+    mkgrid(p)
+    plt.axis('scaled')
+
+def fig(p):
+    setup(p)
+    return plt
+
+def show(p, show_axes=False):
+    setup(p, show_axes)
+    plt.show()
+
+def main():
+    inp = input(">>>")
+
+    while inp != "":
+        show(parse(inp))
+        inp = input(">>>")
+
+if __name__ == '__main__':
+    main()

webui.py

@@ -0,0 +1,52 @@
+import gradio as gr
+import visual
+import gen
+import subprocess
+import sys
+
+def showpuzzle(encoding):
+    p1 = visual.parse(encoding)
+    return visual.fig(p1)
+
+showpuzzint = gr.Interface(fn=showpuzzle, inputs=gr.Text(label="Puzzle encoding"), outputs=gr.Plot())
+
+
+def genpuzzle(width,height,is_square,shuffle,seed):
+    if is_square:
+        height=width
+    p = gen.genpuzzle(width,height,seed)
+    if seed==0:
+        seed=gen.seed1
+    if not shuffle:
+        return visual.fig(p),seed,gen.h(p),''
+    p_ = gen.shuf(p)
+    p2 = visual.join(p,p_)
+    return visual.fig(p2),seed,gen.h(p),gen.h(p_)
+
+genint = gr.Interface(fn=genpuzzle, inputs=[gr.Slider(label="Width",step=1,minimum=1,maximum=40,value=3),gr.Slider(label="Height",step=1,minimum=1,maximum=40,value=3),gr.Checkbox(label="Square",value=True),gr.Checkbox(label="Shuffle"),gr.Number(label="Seed",value=0)], outputs=[gr.Plot(label="Puzzle"),gr.Number(label="Seed"),gr.Text(label="Puzzle encoding"),gr.Text(label="Shuffled encoding")])
+
+def shuffle(encoding,show):
+    p = visual.parse(encoding)
+    p_ = gen.shuf(p)
+    if show:
+        return visual.fig(p_),gen.h(p_)
+    return None,gen.h(p_)
+
+shufint = gr.Interface(fn=shuffle, inputs=[gr.Text(label="Puzzle encoding"),gr.Checkbox(label="Visualise")], outputs=[gr.Plot(label="Visualisation"),gr.Text(label="Shuffled encoding")])
+
+def sendcommand(function,args):
+    process = subprocess.run(["ghc", "Challenges.hs", "-e", f'{function} {args}' ], check=True, capture_output=True)
+    return process.stdout.decode(sys.stdout.encoding).strip()
+
+commandint = gr.Interface(fn=sendcommand, inputs=['text','text'], outputs='text', description="sends a function call to Challenges.hs")
+
+def runtests():
+    output = subprocess.run(["runghc", "../Tests.hs"],check=True,capture_output=True).stderr.decode(sys.stdout.encoding).strip()
+    if output == "":
+        return "All tests passed"
+    return output
+    
+testint = gr.Interface(fn=runtests, inputs=None, outputs='text', description="runs automated tests from Tests.hs")
+
+demo = gr.TabbedInterface([showpuzzint,genint,shufint,commandint,testint],["visualise","generate","shuffle","run","test"],title="comp2209 Tools")
+demo.launch()