def draw(self):
x, y = self.pos
checkbox = Rect(x - 8, y - 8, 16, 16)
rounded_rect(WHITE_KEY, checkbox)
if self.selected:
pygame.draw.circle(screen, pygame.Color('#006600'), self.pos, 5)
textbox = text(self.label, (checkbox.right + 8, self.rect.top + 1))
self.rect = checkbox.union(textbox)
def update_rect(self):
rect = Rect(0, 0, 0, 0)
for k in self.objects:
o = self.objects[k]
rect = rect.union(o.rect)
self.rect.w = rect.w + self.canvas.style["d_space"] * 2
self.rect.h = rect.h + self.canvas.style["d_space"] * 2
self.offset_x = self.canvas.style["d_space"]
self.offset_y = self.canvas.style["d_space"]
if len(self.inputs) > 1:
self.rect.w += self.parent.canvas.style["d_input"]
self.offset_x += self.parent.canvas.style["d_input"]
if len(self.outputs) > 1:
self.rect.w += self.parent.canvas.style["d_output"]
self.rect_rel = Rect(self.rect)
self.rect_rel.x = 0
self.rect_rel.y = 0
self.update_io_xy()
class Monster(object):
id = None # type: UUID
direction = Direction.UP
speed = 0
is_freeze = False
position = None # type: Rect
old_position = None # type: Rect
parent = None # type: Monster
SIZE = 8
def __init__(self, x: int, y: int, direction: Direction = None):
self.id = uuid4()
size = self.SIZE
self.position = Rect(x, y, size, size)
self.set_old_position()
if direction:
self.direction = direction
def set_old_position(self):
self.old_position = self.position.copy()
def set_position(self, x: int, y: int):
self.position.x = x
self.position.y = y
def set_speed(self, speed: int):
self.speed = speed
def set_freeze(self):
self.is_freeze = True
def unset_freeze(self):
self.is_freeze = False
def set_direction(self, direction: Direction):
self.direction = direction
def get_type(self):
return self.__class__.__name__.lower()
def get_grid_position(self):
position = self.position
return Rect(
# (x >> 4) << 4 is faster than floor(x / 16) * 16
(position.x >> 4) << 4,
(position.y >> 4) << 4,
32,
32,
)
def check_collision_with_group(self, group, rect=None, callback=None):
callback = callback or (lambda m: m.position)
rect = rect or self.position
if isinstance(group, SlicedArray):
group = group.find_nearest(rect)
rect_group = list(map(callback, group))
indices = rect.collidelistall(rect_group)
return [group[index] for index in indices]
def check_collision_with_old_position(self, monster):
return self.old_position.colliderect(monster.position)
def union_new_position_with_old(self):
return self.position.union(self.old_position)
def set_parent(self, parent):
self.parent = parent
def get_position(self):
return dict(
x=self.position.x,
y=self.position.y,
)
def move(self):
if self.is_freeze:
return
self.move_with_speed(self.speed)
def move_with_speed(self, speed):
position = self.position
direction = self.direction
if direction is Direction.UP:
position.y -= speed
elif direction is Direction.DOWN:
position.y += speed
elif direction is Direction.LEFT:
position.x -= speed
elif direction is Direction.RIGHT:
position.x += speed
def test_union__with_identical_Rect(self):
r1 = Rect(1, 2, 3, 4)
self.assertEqual(r1, r1.union(Rect(r1)))
def test_union(self):
r1 = Rect(1, 1, 1, 2)
r2 = Rect(-2, -2, 1, 2)
self.assertEqual(Rect(-2, -2, 4, 5), r1.union(r2))
def test_union__with_identical_Rect( self ):
r1 = Rect( 1, 2, 3, 4 )
self.assertEqual( r1, r1.union( Rect(r1) ) )
def test_union( self ):
r1 = Rect( 1, 1, 1, 2 )
r2 = Rect( -2, -2, 1, 2 )
self.assertEqual( Rect( -2, -2, 4, 5 ), r1.union(r2) )
def testUnionWithIdenticalRect( self ):
r1 = Rect( 1, 2, 3, 4 )
self.assertEqual( r1, r1.union( Rect(r1) ) )
class AnimationState():
def __init__(self, obj, pos=(0,0)):
self.object = obj
self.dir = 0
self.startTime = 0
self.animName = 'stopped'
self.x = pos[0]
self.y = pos[1]
self.newX = pos[0]
self.newY = pos[1]
# dirty dirty dirty
self.stashPos=pos
self.deleted = False
# functions for play once animations
# dirty animation
self.stash = Rect(0,0,0,0)
self.stashFrame = None
self.dirty = False
self.dirtyRegions = list()
self.old = None
self.oldOffset = None
# event
self.eventStash = None
self.invalidated = False
def invalidate(self):
self.invalidated = True
def setAnimation(self,animName):
# if you're busy, set what happens next after
#if self.busy:
# self.playOnceBackToAnim = animName
#else:
if self.animName!=animName:
#if self.animName == 'shoot':
# print "######## Cancel Shooting"
# print animName
self.animName = animName
self.startTime = 0
#self.startTime = startTime
def setAnimationOnce(self, animName):
# if you're not already busy
if self.old==None:
self.old = self.animName
self.setAnimation(animName)
nframe = self.getFrameByNumber(0)
if self.stashFrame!=None:
if nframe.surface.get_rect().height!=self.stashFrame.surface.get_rect().height:
self.oldOffset = nframe.surface.get_rect().height-self.stashFrame.surface.get_rect().height
self.y = self.y - self.oldOffset
def setDirection(self,dir):
self.dir = dir
def setPosVec(self, vect):
self.x = vect[0]
self.y = vect[1]
def setPos(self,x,y):
self.x = x
self.y = y
#def setNewPos(self,(x,y)):
# self.newX = x
# self.newY = y
def getDirection(self):
return self.dir
def getX(self):
return self.x
def setX(self,x):
self.x = x
def getY(self):
return self.y
def setY(self,y):
self.y = y
def getPos(self):
return (self.x,self.y)
#def movePos(self):
# self.x = self.newX
# self.y = self.newY
def getFrameByNumber(self,frameNum):
anim = self.object.animations[self.animName].directions[self.dir]
frame = anim.frames[frameNum]
return frame
def getFrameNumber(self,gameTime):
if self.startTime == 0:
self.startTime = gameTime
timediff = gameTime - self.startTime
fps = self.object.animations[self.animName].fps
frames = self.object.animations[self.animName].frames
msf = 1000 / fps
frame = int((timediff / msf))
if self.old!=None and frame>frames:
self.setAnimation(self.old)
self.old = None
if self.oldOffset!=None:
self.y = self.y + self.oldOffset
self.stashPos = (self.stashPos[0],self.stashPos[1]+ self.oldOffset)
self.oldOffset = None
return self.getFrameNumber(gameTime)
return frame%frames
def getFrame(self,gameTime):
anim = self.object.animations[self.animName].directions[self.dir]
frame = anim.frames[self.getFrameNumber(gameTime)]
return frame
def getFrameEvent(self,gameTime):
frame = self.getFrame(gameTime)
if self.eventStash != frame:
self.eventStash = frame
return frame.event
return ''
def getColAABB(self,time):
framenum = self.getFrameNumber(time)
anim = self.object.animations[self.animName].directions[self.dir]
return anim.frames[framenum].collisionArea
def requiresDraw(self):
frame = self.getFrame(game.Game.universal.time.time())
major = frame==self.stashFrame and self.stashPos==(self.x,self.y) and self.invalidated==False
return not (major and self.dirty==False)
def draw(self,target,time):
if self.deleted == True: return
frame = self.getFrame(time.time())
major = frame==self.stashFrame and self.stashPos==(self.x,self.y) and self.invalidated==False
if major and self.dirty==False:
return
self.stash = frame.drawArea.move(self.x,self.y)
self.stashFrame = frame
self.stashPos = (self.x,self.y)
if major:
for region in self.dirtyRegions:
target.blit(frame.surface,region[0],region[0].move(-region[1][0],-region[1][1]))
else:
target.blit(frame.surface,self.stash,frame.drawArea)
self.dirty = False
self.dirtyRegions = list()
self.invalidated = False
def undraw(self,source,target,time):
if self.deleted == True: return
frame = self.getFrame(time.time())
if frame==self.stashFrame and self.stashPos==(self.x,self.y) and self.invalidated==False:
if self.dirty==False:
return
else:
for region in self.dirtyRegions:
target.blit(source,region[0],region[0])
return
target.blit(source,self.stash.topleft,self.stash)
if self.dirty:
for region in self.dirtyRegions:
for yolo in region[2].dirtyRegions:
if yolo[2]==self:
yolo[0] = self.stash.union(yolo[0])
#if frame!=self.stashFrame or self.stashPos!=(self.x,self.y) or self.dirty!=False:
# target.blit(source,self.stash.topleft,self.stash)
def visualDelete(self,source,target):
self.deleted = True
target.blit(source,self.stash.topleft,self.stash)
for region in self.dirtyRegions:
region[2].invalidate()
def testUnionWithIdenticalRect(self):
r1 = Rect(1, 2, 3, 4)
self.assertEqual(r1, r1.union(Rect(r1)))
class AnimationState():
def __init__(self, obj, pos=(0, 0)):
self.object = obj
self.dir = 0
self.startTime = 0
self.animName = 'stopped'
self.x = pos[0]
self.y = pos[1]
self.newX = pos[0]
self.newY = pos[1]
# dirty dirty dirty
self.stashPos = pos
self.deleted = False
# functions for play once animations
# dirty animation
self.stash = Rect(0, 0, 0, 0)
self.stashFrame = None
self.dirty = False
self.dirtyRegions = list()
self.old = None
self.oldOffset = None
# event
self.eventStash = None
self.invalidated = False
def invalidate(self):
self.invalidated = True
def setAnimation(self, animName):
# if you're busy, set what happens next after
#if self.busy:
# self.playOnceBackToAnim = animName
#else:
if self.animName != animName:
#if self.animName == 'shoot':
# print "######## Cancel Shooting"
# print animName
self.animName = animName
self.startTime = 0
#self.startTime = startTime
def setAnimationOnce(self, animName):
# if you're not already busy
if self.old == None:
self.old = self.animName
self.setAnimation(animName)
nframe = self.getFrameByNumber(0)
if self.stashFrame != None:
if nframe.surface.get_rect(
).height != self.stashFrame.surface.get_rect().height:
self.oldOffset = nframe.surface.get_rect(
).height - self.stashFrame.surface.get_rect().height
self.y = self.y - self.oldOffset
def setDirection(self, dir):
self.dir = dir
def setPosVec(self, vect):
self.x = vect[0]
self.y = vect[1]
def setPos(self, x, y):
self.x = x
self.y = y
#def setNewPos(self,(x,y)):
# self.newX = x
# self.newY = y
def getDirection(self):
return self.dir
def getX(self):
return self.x
def setX(self, x):
self.x = x
def getY(self):
return self.y
def setY(self, y):
self.y = y
def getPos(self):
return (self.x, self.y)
#def movePos(self):
# self.x = self.newX
# self.y = self.newY
def getFrameByNumber(self, frameNum):
anim = self.object.animations[self.animName].directions[self.dir]
frame = anim.frames[frameNum]
return frame
def getFrameNumber(self, gameTime):
if self.startTime == 0:
self.startTime = gameTime
timediff = gameTime - self.startTime
fps = self.object.animations[self.animName].fps
frames = self.object.animations[self.animName].frames
msf = 1000 / fps
frame = int((timediff / msf))
if self.old != None and frame > frames:
self.setAnimation(self.old)
self.old = None
if self.oldOffset != None:
self.y = self.y + self.oldOffset
self.stashPos = (self.stashPos[0],
self.stashPos[1] + self.oldOffset)
self.oldOffset = None
return self.getFrameNumber(gameTime)
return frame % frames
def getFrame(self, gameTime):
anim = self.object.animations[self.animName].directions[self.dir]
frame = anim.frames[self.getFrameNumber(gameTime)]
return frame
def getFrameEvent(self, gameTime):
frame = self.getFrame(gameTime)
if self.eventStash != frame:
self.eventStash = frame
return frame.event
return ''
def getColAABB(self, time):
framenum = self.getFrameNumber(time)
anim = self.object.animations[self.animName].directions[self.dir]
return anim.frames[framenum].collisionArea
def requiresDraw(self):
frame = self.getFrame(game.Game.universal.time.time())
major = frame == self.stashFrame and self.stashPos == (
self.x, self.y) and self.invalidated == False
return not (major and self.dirty == False)
def draw(self, target, time):
if self.deleted == True: return
frame = self.getFrame(time.time())
major = frame == self.stashFrame and self.stashPos == (
self.x, self.y) and self.invalidated == False
if major and self.dirty == False:
return
self.stash = frame.drawArea.move(self.x, self.y)
self.stashFrame = frame
self.stashPos = (self.x, self.y)
if major:
for region in self.dirtyRegions:
target.blit(frame.surface, region[0],
region[0].move(-region[1][0], -region[1][1]))
else:
target.blit(frame.surface, self.stash, frame.drawArea)
self.dirty = False
self.dirtyRegions = list()
self.invalidated = False
def undraw(self, source, target, time):
if self.deleted == True: return
frame = self.getFrame(time.time())
if frame == self.stashFrame and self.stashPos == (
self.x, self.y) and self.invalidated == False:
if self.dirty == False:
return
else:
for region in self.dirtyRegions:
target.blit(source, region[0], region[0])
return
target.blit(source, self.stash.topleft, self.stash)
if self.dirty:
for region in self.dirtyRegions:
for yolo in region[2].dirtyRegions:
if yolo[2] == self:
yolo[0] = self.stash.union(yolo[0])
#if frame!=self.stashFrame or self.stashPos!=(self.x,self.y) or self.dirty!=False:
# target.blit(source,self.stash.topleft,self.stash)
def visualDelete(self, source, target):
self.deleted = True
target.blit(source, self.stash.topleft, self.stash)
for region in self.dirtyRegions:
region[2].invalidate()
def _clearPath(first, second, color, offset=0):
start = Rect(coordinateOffset(first[0]) + offset, coordinateOffset(first[1]) + offset, side - 2 * offset, side - 2 * offset)
end = Rect(coordinateOffset(second[0]) + offset, coordinateOffset(second[1]) + offset, side - 2 * offset, side - 2 * offset)
pygame.draw.rect(console, color, start.union(end))
