Jam/src/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 make up the polyomino 
        self.squares=kwargs.get("squares",[])

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

        # mesh of background grid (no grid for mesh size 0)
        self.grid=kwargs.get("grid",0)

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

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

        # draw boundary
        self.stroke(painter)

    # draw boundary (override for connected polyominos)
    def stroke(self,painter):
        # convert to graphical coordinates
        coordx=painter.pos_tocoord_x(square.pos.x)
        coordy=painter.pos_tocoord_y(square.pos.y)

        # white
        Color(1,1,1)
        for square in self.squares:
            Line(points=(
            *(coordx-0.5*square.size*painter.base_size,coordy-0.5*square.size*painter.base_size),
            *(coordx-0.5*square.size*painter.base_size,coordy+0.5*square.size*painter.base_size),
            *(coordx+0.5*square.size*painter.base_size,coordy+0.5*square.size*painter.base_size),
            *(coordx+0.5*square.size*painter.base_size,coordy-0.5*square.size*painter.base_size),
            *(coordx-0.5*square.size*painter.base_size,coordy-0.5*square.size*painter.base_size)
            ))

    # move by delta
    def move(self,delta):
        for square in self.squares:
            square.pos+=delta

    # 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

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

# cross
class Cross(Polyomino):
    def __init__(self,x,y,**kwargs):
        super(Cross,self).__init__(**kwargs,squares=[\
        Square_element(x,y,1),\
        Square_element(x+1,y,1),\
        Square_element(x-1,y,1),\
        Square_element(x,y+1,1),\
        Square_element(x,y-1,1)\
        ])

    # redefine stroke to avoid lines between touching squares
    def stroke(self,painter):
        # convert to graphical coordinates
        coordx=painter.pos_tocoord_x(self.squares[0].pos.x)
        coordy=painter.pos_tocoord_y(self.squares[0].pos.y)

        Color(1,1,1)
        Line(points=(
        *(coordx-0.5*painter.base_size,coordy-0.5*painter.base_size),
        *(coordx-0.5*painter.base_size,coordy-1.5*painter.base_size),
        *(coordx+0.5*painter.base_size,coordy-1.5*painter.base_size),
        *(coordx+0.5*painter.base_size,coordy-0.5*painter.base_size),
        *(coordx+1.5*painter.base_size,coordy-0.5*painter.base_size),
        *(coordx+1.5*painter.base_size,coordy+0.5*painter.base_size),
        *(coordx+0.5*painter.base_size,coordy+0.5*painter.base_size),
        *(coordx+0.5*painter.base_size,coordy+1.5*painter.base_size),
        *(coordx-0.5*painter.base_size,coordy+1.5*painter.base_size),
        *(coordx-0.5*painter.base_size,coordy+0.5*painter.base_size),
        *(coordx-1.5*painter.base_size,coordy+0.5*painter.base_size),
        *(coordx-1.5*painter.base_size,coordy-0.5*painter.base_size),
        *(coordx-0.5*painter.base_size,coordy-0.5*painter.base_size),
        ))



# square building block of polyominos
class Square_element():

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

    # 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)<self.size

    # check whether a square at position pos is touching self
    def check_touch(self,pos):
        # allow for error
        if in_interval(l_infinity(pos-self.pos),self.size-1e-11,self.size+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
        if v.x!=0:
            if v.y!=0:
                intersections=[\
                Point(self.pos.x+self.size,pos.y+v.y/v.x*(self.pos.x+self.size-pos.x)),\
                Point(self.pos.x-self.size,pos.y+v.y/v.x*(self.pos.x-self.size-pos.x)),\
                Point(pos.x+v.x/v.y*(self.pos.y+self.size-pos.y),self.pos.y+self.size),\
                Point(pos.x+v.x/v.y*(self.pos.y-self.size-pos.y),self.pos.y-self.size)\
                ]
            else:
                intersections=[\
                Point(self.pos.x+self.size,pos.y+v.y/v.x*(self.pos.x+self.size-pos.x)),\
                Point(self.pos.x-self.size,pos.y+v.y/v.x*(self.pos.x-self.size-pos.x))
                ]
        else:
            if v.y!=0:
                intersections=[\
                Point(pos.x+v.x/v.y*(self.pos.y+self.size-pos.y),self.pos.y+self.size),\
                Point(pos.x+v.x/v.y*(self.pos.y-self.size-pos.y),self.pos.y-self.size)\
                ]
            else:
                print("error: move_on_line_to_stick called with v=0, please file a bug report with the developer",file=sys.stderr)
                exit(-1)

        # compute closest one, on square
        closest=None
        dist=math.inf
        for i in range(0,len(intersections)):
            # check that it is on square
            if abs(intersections[i].x-self.pos.x)<=self.size+1e-11 and abs(intersections[i].y-self.pos.y)<=self.size+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,") in direction (",v.x,",",v.y,")",file=sys.stderr)
            exit(-1)

        # return difference to pos
        return closest-pos

    # 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/self.size):
            # check y direction
            if isint_nonzero(rel.y/self.size):
                # 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/self.size):
            # 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(0,delta.y)
        # do not move past corners
        rel=pos.y-self.pos.y
        if delta.y>0:
            if rel<math.ceil(rel/self.size)*self.size-1e-11 and delta.y+rel>math.ceil(rel/self.size)*self.size+1e-11 and math.ceil(rel/self.size)*self.size!=0:
                # stick to corner
                candidate.y=math.ceil(rel/self.size)*self.size+self.pos.y-pos.y
        else:
            if rel>math.floor(rel/self.size)*self.size+1e-11 and delta.y+rel<math.floor(rel/self.size)*self.size-1e-11 and math.floor(rel/self.size)*self.size!=0:
                # stick to corner
                candidate.y=math.floor(rel)+self.pos.y-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(delta.x,0)
        # do not move past corners
        rel=pos.x-self.pos.x
        if delta.x>0:
            if rel<math.ceil(rel/self.size)*self.size-1e-11 and delta.x+rel>math.ceil(rel/self.size)*self.size+1e-11 and math.ceil(rel/self.size)*self.size!=0:
                # stick to corner
                candidate.x=math.ceil(rel/self.size)*self.size+self.pos.x-pos.x
        else:
            if rel>math.floor(rel/self.size)*self.size+1e-11 and delta.x+rel<math.floor(rel/self.size)*self.size-1e-11 and math.floor(rel/self.size)*self.size!=0:
                # stick to corner
                candidate.x=math.floor(rel/self.size)*self.size+self.pos.x-pos.x
        return candidate