Jam/polyomino.py

import math
import sys
from kivy.graphics import Color,Line,Rectangle

from point import Point,l_infinity
from tools import isint_nonzero,sgn,in_interval

# parent class of all polyominos
class Polyomino():
    def __init__(self,**kwargs):
        # square elements that maje up the polyomino 
        self.squares=kwargs.get("squares",[])

        self.color=kwargs.get("color",(0,0,1))
        self.selected=False

    # draw function
    def draw(self):
        # set color
        if not self.selected:
            Color(*self.color)
        else:
            (r,g,b)=self.color
            # darken selected
            Color(r/2,g/2,b/2)

        for square in self.squares:
            Rectangle(pos=((square.pos.x-0.5)*square.size,(square.pos.y-0.5)*square.size),size=(square.size,square.size))

        # draw boundary
        self.stroke()

    # draw boundary (override for connected polyominos)
    def stroke(self):
        # white
        Color(1,1,1)
        for square in self.squares:
            Line(points=(
            *((square.pos.x-0.5)*square.size,(square.pos.y-0.5)*square.size),
            *((square.pos.x-0.5)*square.size,(square.pos.y+0.5)*square.size),
            *((square.pos.x+0.5)*square.size,(square.pos.y+0.5)*square.size),
            *((square.pos.x+0.5)*square.size,(square.pos.y-0.5)*square.size)
            ))

    # whether x is in the support of the polyomino
    def in_support(self,x):
        for square in self.squares:
            if l_infinity(square.pos-x)<=1/2:
                return True
        return False

    # check whether self interacts with candidate if candidate were moved by offset
    def check_interaction(self,candidate,offset):
        for square1 in self.squares:
            for square2 in candidate.squares:
                if square1.check_interaction(square2.pos+offset):
                    return True
        return False

    # check whether self touches candidate
    def check_touch(self,candidate):
        for square1 in self.squares:
            for square2 in candidate.squares:
                if square1.check_touch(square2.pos):
                    return True
        return False
        

# square
class Square(Polyomino):
    def __init__(self,x,y,**kwargs):
        super(Square,self).__init__(kwargs,squares=[Square_element(x,y)])



# square building block of polyominos
class Square_element():
    # size
    size=50

    def __init__(self,x,y,**kwargs):
        self.pos=Point(x,y)

    # set position
    def setpos(self,x,y):
        self.pos.x=x
        self.pos.y=y


    # check whether a square at pos interacts with square
    def check_interaction(self,pos):
        return l_infinity(pos-self.pos)<1

    # check whether a square at position pos is touching self
    def check_touch(self,pos):
        # allow for error
        if in_interval(l_infinity(pos-solf.pos),1-1e-11,1+1e-11):
                return True
        return False

    # find position along a line that comes in contact with the line going through pos in direction v
    def move_on_line_to_stick(self,pos,v):
        # compute intersections with four lines making up square
        intersections=[\
        Point(self.pos.x+1/2,pos.y+v.y/v.x*(self.pos.x+1/2-pos.x)),\
        Point(self.pos.x-1/2,pos.y+v.y/v.x*(self.pos.x-1/2-pos.x)),\
        Point(pos.x+v.x/v.y*(self.pos.y+1/2-pos.y),self.pos.y+1/2),\
        Point(pos.x+v.x/v.y*(self.pos.y-1/2-pos.y),self.pos.y-1/2)\
        ]

        # compute closest one, on square
        closest=None
        dist=math.inf
        for i in range(0,4):
            # check that it is on square
            if abs(intersections[i].x-self.pos.x)<=1/2+1e-11 and abs(intersections[i].y-self.pos.y)<=1/2+1e-11:
                if (intersections[i]-pos)**2<dist:
                    closest=intersections[i]
                    dist=(intersections[i]-pos)**2

        if closest==None:
            print("error: cannot move particle at (",pos.x,",",pos.y,") to the boundary of (",self.pos.x,",",self.pos.y,")",file=sys.stderr)
            exit(-1)

        return closest

    # move along edge of square
    def move_along(self,delta,pos):
        rel=pos-self.pos
        # check if the particle is stuck in the x direction
        if isint_nonzero(rel.x):
            # check y direction
            if isint_nonzero(rel.y):
                # in corner
                if sgn(delta.y)==-sgn(rel.y):
                    # stuck in x direction
                    return self.move_stuck_x(delta,pos)
                elif sgn(delta.x)==-sgn(rel.x):
                    # stuck in y direction
                    return self.move_stuck_y(delta,pos)
                # stuck in both directions
                return pos
            else:
                # stuck in x direction
                return self.move_stuck_x(delta,pos)
        elif isint_nonzero(rel.y):
            # stuck in y direction
            return self.move_stuck_y(delta,pos)
        # this should never happen
        else:
            print("error: stuck particle has non-integer relative position: (",rel.x,",",rel.y,")",file=sys.stderr)
            exit(-1)
    # move when stuck in the x direction
    def move_stuck_x(self,delta,pos):
        # only move in y direction
        candidate=Point(pos.x,pos.x+delta.y)
        # do not move past corners
        rel=pos.y-self.pos.y
        if delta.y>0:
            if rel<math.ceil(rel)-1e-11 and delta.y+rel>math.ceil(rel)+1e-11 and math.ceil(rel)!=0:
                # stick to corner
                candidate.y=math.ceil(rel)+self.pos.y
        else:
            if rel>math.floor(rel)+1e-11 and delta.y+rel<math.floor(rel)-1e-11 and math.floor(rel)!=0:
                # stick to corner
                candidate.y=math.floor(rel)+self.pos.y
        return candidate
    # move when stuck in the y direction
    def move_stuck_y(self,delta,pos):
        # onlx move in x direction
        candidate=Point(pos.x,newpos.x)
        # do not move past corners
        rel=pos.x-self.pos.x
        if delta.x>0:
            if rel<math.ceil(rel)-1e-11 and delta.x+rel>math.ceil(rel)+1e-11 and math.ceil(rel)!=0:
                # stick to corner
                candidate.x=math.ceil(rel)+self.pos.x
        else:
            if rel>math.floor(rel)+1e-11 and delta.x+rel<math.floor(rel)-1e-11 and math.floor(rel)!=0:
                # stick to corner
                candidate.x=math.floor(rel)+self.pos.x
        return candidate