Jam/main.py

import math
from kivy.app import App
from kivy.uix.widget import Widget
from kivy.graphics import Color,Line,Rectangle
from kivy.config import Config

# App class
class Jam_app(App):
    # name of .kv file for main interface
    #kv_file="jam.kv"

    def build(self):
        parent=Widget()
        self.cross_painter=Cross_painter()
        parent.add_widget(self.cross_painter)
        return parent

# cross painter
class Cross_painter(Widget):

    def __init__(self,**kwargs):

        # list of crosses
        self.crosses=[]

        # selected cross
        self.selected=None

        # init Widget
        super(Cross_painter,self).__init__(**kwargs)


    # draw all crosses
    def draw(self):
        with self.canvas:
            for cross in self.crosses:
                cross.draw()


    # respond to mouse down
    def on_touch_down(self,touch):
        # create new cross
        if touch.button=="right":
            if self.check_add(Point(touch.x,touch.y)):
                new=Cross(touch.x,touch.y)
                with self.canvas:
                    new.draw()
                # add to list
                self.crosses.append(new)

        # select cross
        if touch.button=="left":
            # unselect
            if self.selected!=None:
                self.selected.selected=False

            # find cross under touch
            self.selected=self.find_cross((touch.x,touch.y))
            # select
            if self.selected!=None:
                self.selected.selected=True


    # respond to drag
    def on_touch_move(self,touch):
        # only move on left click
        if touch.button=="left" and self.selected!=None:
            #self.selected.pos=self.check_move((touch.x,touch.y),self.selected)
            self.selected.setpos(touch.x,touch.y)
            # redraw
            self.canvas.clear()
            self.draw()


    # find the cross at position pos
    def find_cross(self,pos):
        for cross in self.crosses:
            if cross_distx(pos,cross.pos)<=cross.size/2 or cross_disty(pos,cross.pos)<=cross.size/2:
                return cross
        # none found
        return None

    # check that a cross can move to new position
    def check_move(self,newpos,cross):
        for other in self.crosses:
            # do not compare a cross to itself
            if other!=cross:
                return newpos
        return newpos

    # check that a cross can be added at position
    def check_add(self,pos):
        for cross in self.crosses:
            if cross.check_interaction(pos)==False:
                return False
        return True

# cross
class Cross():
    # size of central square
    size=50

    def __init__(self,x,y,**kwargs):
        self.pos=Point(x,y)
        self.color=kwargs.get("color",(0,0,1))
        self.selected=False

    def draw(self):
        # fill
        #if not self.selected:
        #    Color(*(self.color))
        #else:
        #    Color(1,0,0)
        Color(*(self.color))
        Rectangle(pos=(self.pos.x-self.size*1.5,self.pos.y-self.size*0.5),size=(3*self.size,self.size))
        Rectangle(pos=(self.pos.x-self.size*0.5,self.pos.y-self.size*1.5),size=(self.size,3*self.size))

        # stroke
        Color(1,1,1)
        Line(points=(
        *(self.pos.x-self.size*0.5,self.pos.y-self.size*0.5),
        *(self.pos.x-self.size*0.5,self.pos.y-self.size*1.5),
        *(self.pos.x+self.size*0.5,self.pos.y-self.size*1.5),
        *(self.pos.x+self.size*0.5,self.pos.y-self.size*0.5),
        *(self.pos.x+self.size*1.5,self.pos.y-self.size*0.5),
        *(self.pos.x+self.size*1.5,self.pos.y+self.size*0.5),
        *(self.pos.x+self.size*0.5,self.pos.y+self.size*0.5),
        *(self.pos.x+self.size*0.5,self.pos.y+self.size*1.5),
        *(self.pos.x-self.size*0.5,self.pos.y+self.size*1.5),
        *(self.pos.x-self.size*0.5,self.pos.y+self.size*0.5),
        *(self.pos.x-self.size*1.5,self.pos.y+self.size*0.5),
        *(self.pos.x-self.size*1.5,self.pos.y-self.size*0.5),
        *(self.pos.x-self.size*0.5,self.pos.y-self.size*0.5),
        ))

    # check whether a cross at pos interacts with cross
    def check_interaction(self,pos):
        return ((pos-self.pos)/self.size).int()**2>=5

    # find position along a line that comes in contact with the line
    #def move_on_line_to_stick(self,x,v):

class Point:
    def __init__(self,x,y):
        self.x=x
        self.y=y

    def __add__(self,point):
        return Point(self.x+point.x,self.y+point.y)

    def __sub__(self,point):
        return Point(self.x-point.x,self.y-point.y)

    def __neg__(self):
        return Point(-self.x,-self.y)

    def __mul__(self,a):
        return Point(a*self.x,a*self.y)

    def __truediv__(self,a):
        return Point(self.x/a,self.y/a)

    def __pow__(self,a):
        if a==2:
            return self.dot(self)

    # dot product
    def dot(self,x):
        return self.x*x.x+self.y*x.y

    # integer part
    def int(self):
        return Point(int(self.x),int(self.y))

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

# L_infinity distance rescalled by 3 in the x direction
def cross_distx(x,y):
    return max(abs(x.x-y.x)/3,abs(x.y-y.y))
# L_infinity distance rescalled by 3 in the y direction
def cross_disty(x,y):
    return max(abs(x.x-y.x),abs(x.y-y.y)/3)

# polar description of touching cross
def cross_polar(t):
    # by symmetry, put angle in interval (-pi/4,pi/4), and take absolute value
    tt=abs((t+math.pi/4)%(math.pi/2)-math.pi/4)
    if tt<math.atan(1/3):
        return 3/math.cos(tt)
    elif tt<math.atan(1/2):
        return 1/math.sin(tt)
    else:
        return 2/math.cos(tt)


# sign function
def sgn(x):
    if x>=0:
        return 1
    return -1


# disable red circles on right click
Config.set('input', 'mouse', 'mouse,disable_multitouch')

# run
if __name__ == '__main__':
    Jam_app().run()