class MiniGrill:
def __init__(self):
self.image = image.load(data_file('grill.png'))
self.rect = Rect(500, 250, self.image)
window.game_window.push_handlers(self.on_mouse_press)
window.game_window.push_handlers(self.on_mouse_motion)
self.highlighted = False
self.active = False
def on_mouse_motion(self, x, y, dx, dy):
if self.rect.collide_point(x, y):
self.highlighted = True
else:
self.highlighted = False
def on_mouse_press(self, x, y, button, modifiers):
if self.rect.collide_point(x, y):
self.active = True
def draw(self):
if self.highlighted:
glColor4f(0.5, 0.1, 1, 1)
else:
glColor4f(1, 1, 1, 1)
self.image.blit(*self.rect.bottomleft)
glColor4f(1, 1, 1, 1)
def _drawKeys(self, dc):
blackPen = wx.Pen('black')
whiteBrush = wx.Brush('white')
# set the font
self.font = wx.Font(self._fontSize, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL,
wx.FONTWEIGHT_BOLD, False, 'Arial Rounded MT Bold')
dc.SetFont(self.font)
for displayKey in self._displayKeys.values():
# draw key shadow
shadowRect = Rect(*displayKey.scaled)
shadowRect.OffsetXY(1, 1)
dc.SetPen(wx.Pen('light grey', 3.5))
dc.DrawRoundedRectangleRect(shadowRect.Get(), -.075)
# handle selections
if self._isKeySelected(displayKey.handle):
if self.FindFocus() == self:
# TODO: Generalize this magic number from system settings.
# Currently is Mac selection blue.
dc.SetPen(wx.Pen('#3e75d6', 2))
else:
dc.SetPen(wx.Pen('dark grey', 2))
dc.SetBrush(wx.Brush('light grey'))
else:
dc.SetPen(blackPen)
dc.SetBrush(whiteBrush)
# draw key outline
dc.DrawRoundedRectangleRect(displayKey.scaled.Get(), -.075)
# draw label
self._drawLabels(dc, displayKey.labelRect, displayKey)
def _refreshKey(self, displayKey):
"""
Calculate the appropriate region of the screen to refresh based
on the given displayKey.
"""
refreshRect = Rect(*displayKey.scaled)
refreshRect.Inflate(2, 2)
self.RefreshRect(refreshRect.Get())
def _getDrawingArea(self):
"""
Return a Rect encompassing the allowable drawing area of the current client window,
in device units.
"""
drawingArea = Rect(*self.GetClientRect())
drawingArea.Deflate(self._border, self._border)
return drawingArea
def to_pygame(self, blitable):
"""Converts object coordinates into pygame coordinates, given lower left coordinates of an
object and the object's height."""
# Get top left corner, and convert to pygame coordinates
rect = Rect(blitable.image.get_rect())
rect.offset(blitable.position)
new_position = self.to_pygame_coords(rect.bottom_left)
new_position = new_position + Vector(0, -blitable.image.get_height())
return new_position
def _getContentArea(self):
"""
Based on the content size, in logical units, return, in device units,
the rectangle encompassing the extents of the content to be drawn.
"""
drawingArea = self._getDrawingArea()
scale = self._getScale(drawingArea)
contentSize = self._getContentSize() * scale
contentArea = Rect(drawingArea.x, drawingArea.y, contentSize.width, contentSize.height)
contentArea = contentArea.CenterIn(drawingArea)
return contentArea
def attack(self, pos, gap, orientation,team):
if self.nextAttackTimer != 0.0 or self.knivesAvailable == 0:
#print 'cooldown: ', self.nextAttackTimer, self.knivesAvailable
return False
self.knivesAvailable -= 1
self.nextAttackTimer += self.attackCooldown
#create a knife just outside the spawn location
knifeShape = Rect.createAtOrigin(10,10)
#TODO: how to handle diagonal movement and firing?
# spawn outside rect, or inside?
knifePos = pos + orientation.getNormalized()*gap
#print orientation.getNormalized() * gap
#proj = BasicProjectile(knifePos,knifeShape,team,orientation)
proj = MagicKnife(knifePos,knifeShape,self.owner,orientation)
proj.owner = self.owner #Set owner so it can return and keep track of unit
self.knives.append(proj)
glad.world.objectList.append(proj)
#play sound effect
proj.sound.play(self.owner.pos)
return True
def __init__(self):
self.image_opened = image.load(data_file('garbagecan-open.png'))
self.image_closed = image.load(data_file('garbagecan-closed.png'))
self.image_lid = image.load(data_file('garbagecan-lid.png'))
self.image_opened.anchor_x = self.image_opened.width/2
self.image_opened.anchor_y = self.image_opened.height/2
self.image_closed.anchor_x = self.image_opened.width/2
self.image_closed.anchor_y = self.image_opened.height/2
self.candidateLeaves = {}
self.opened = True
self.lid_active = False
self.can_active = False
self.fallen = False
self.can_highlighted = False
self.lid_highlighted = True
self.can_rect = Rect(0, 0, self.image_closed)
self.can_rect.center = (80, 90)
self.can_sprite = Sprite(self.image_opened)
self.can_sprite.set_position(self.can_rect.x, self.can_rect.y)
self.lid_rect = Rect(20, 40, self.image_lid)
window.game_window.push_handlers(self.on_mouse_release)
window.game_window.push_handlers(self.on_mouse_press)
window.game_window.push_handlers(self.on_mouse_drag)
window.game_window.push_handlers(self.on_mouse_motion)
events.AddListener(self)
def __init__(self, parent, displayMode, border):
wx.ScrolledWindow.__init__(self, parent)
self._displayKeys = {}
self._orderedHeyHandles = []
self._keySize = wx.Size(4, 4)
self._keySpacing = wx.Size(1, 1)
self._border = border
self._selectedKeyHandle = None
self._contentSize = Size(200, 200)
self._displayMode = displayMode
self._scroll = wx.Size(0, 0)
self._scrollUnit = wx.Size(0, 0)
self._tooltip = wx.ToolTip("")
self._zoom = 1
if displayMode == DISPLAY_MODE_DYNAMIC_RESIZE:
self._zoom = 10 # 25
self._dragStart = None
self._dragMode = DRAG_MODE_NONE
self.Bind(wx.EVT_PAINT, self.OnPaint)
self.Bind(wx.EVT_SIZE, self.OnSize)
self.Bind(wx.EVT_MOUSE_EVENTS, self.OnMouse)
self.Bind(wx.EVT_CHAR, self.OnChar)
self.Bind(wx.EVT_KILL_FOCUS, self.OnKillFocus)
self.Bind(wx.EVT_SET_FOCUS, self.OnSetFocus)
self.SetToolTip(self._tooltip)
self.SetScrollRate(1, 1)
displayRect = self._getDisplayRect()
print "displayRect: %s" % displayRect
# dc.SetMapMode(wx.MM_TEXT)
dc.SetMapMode(wx.MM_METRIC)
contentRect = Rect(dc.DeviceToLogicalX(displayRect.x),
dc.DeviceToLogicalY(displayRect.y),
dc.DeviceToLogicalXRel(displayRect.width),
dc.DeviceToLogicalYRel(displayRect.height))
def __init__(self, parent, sourceKey):
KeyDisplayPane.__init__(self,
parent,
border=10,
displayMode=DISPLAY_MODE_WRAPPED)
self._displayKeys = {}
KeyDisplayPane._initKeys(self)
self.Bind(wx.EVT_PAINT, self.OnPaint)
self._keySize = Size(6.0, 2.5)
self._keySpacing = Size(0.2, 0.2)
keyRect = Rect(0, 0, *self._keySize)
handle = None
if sourceKey.usage:
handle = sourceKey.usage.MakeHandle()
elif sourceKey.mode:
handle = "mode:%s" % sourceKey.mode
elif len(sourceKey.macro) > 0:
for (i, macroKey) in enumerate(sourceKey.macro):
handle = macroKey.MakeHandle(i)
self._displayKeys[handle] = DisplayKey(handle, keyRect)
self._orderedKeyHandles.append(handle)
handle = None
if handle is not None:
dispKey = DisplayKey(handle, keyRect)
self._displayKeys[handle] = dispKey
self._orderedKeyHandles.append(handle)
self._updateKeys()
def update(self, dt):
# print(1 / dt)
for obj in self._objects:
obj.pos += obj.velocity * dt
x1, y1 = obj.rect.topleft
x2, y2 = obj.rect.bottomright
x1 = round(x1)
x2 = round(x2)
y1 = round(y1)
y2 = round(y2)
points = [(x, y) for x in range(x1 - 2, x2 + 2) for y in range(y1 - 2, y2 + 2)]
obj.one_ground = False
for r in list(obj.rect.collidelistall([tuple(self.get_block(p).rect) for p in points if self.get_block(p).has_collision])):
r: Rect = Rect(r)
n = obj.pos - r.center
n = n.unit
if n.x > 0.5:
obj.rect.left = r.right + 0.05
obj.velocity.x = 0
obj.one_wall = True
elif n.x < -0.5:
obj.rect.right = r.left - 0.05
obj.velocity.x = 0
obj.one_wall = True
else:
if n.y > 0:
obj.rect.top = r.bottom
obj.velocity.y = 0
obj.one_ground = True
elif n.y < 0:
obj.rect.bottom = r.top
obj.velocity.y = 0
obj.one_ground = False
obj.velocity += self.gravity * dt
def attack(self, pos, gap, orientation,team):
if self.nextAttackTimer != 0.0:
return False
self.nextAttackTimer += self.attackCooldown
#create a knife just outside the spawn location
projectileShape = Rect.createAtOrigin(self.size[0], self.size[1])
#TODO: how to handle diagonal movement and firing?
# spawn outside rect, or inside?
projectilePos = pos + orientation.getNormalized()*gap
proj = SlimeBall(projectilePos,projectileShape,self.owner,orientation,self.hue)
#proj = Rock(projectilePos,projectileShape,team,orientation)
glad.world.objectList.append(proj)
#play sound effect
proj.sound.play(self.owner.pos)
return True
def rect_iter(self):
for ind in xrange(len(self.bbox_array)):
rect = Rect(self.bbox_array[ind][0],
self.bbox_array[ind][1],
self.bbox_array[ind][2],
self.bbox_array[ind][3],
label = self.label_array[ind])
yield rect
def __init__(self, pos, **kwargs): shape = Rect.createAtOrigin(64, 64) AbstractObject.__init__(self, pos, shape, **kwargs) self.collisionType = 'UNIT' self.orientation = Vector(1,0)
def __init__(self):
GrillObject.__init__(self)
self.image = image.load(data_file('beef.png'))
self.rect = Rect(520, 230, self.image)
self.cooking = False
self.reset()
def __init__(self, pos, **kwargs): shape = Rect.createAtOrigin(64, 64) BasicUnit.__init__(self, pos, shape, name='BIG_SLIME', slime=True, **kwargs) self.rangedWeapon = SlimeAttack(self) self.alwaysMove = True
def __init__(self, pos, **kwargs): shape = Rect.createAtOrigin(26, 28) BasicUnit.__init__(self, pos, shape, name='GHOST', **kwargs) self.rangedWeapon = KnifeThrower(self) self.alwaysMove = True
def __init__(self, pos, **kwargs): shape = Rect.createAtOrigin(16, 16) BasicUnit.__init__(self, pos, shape, name='FAERIE', **kwargs) self.rangedWeapon = BasicRangedAttack(self, 'sparkle') self.alwaysMove = True
def _updateKeys(self):
"""
Adjust position and scale of each display key based on current display rect.
"""
drawingArea = self._getDrawingArea()
self._scroll.width = self._scroll.height = 0
self._scrollUnit = drawingArea.size
scale = self._getScale(drawingArea)
if self._displayMode == DISPLAY_MODE_DYNAMIC_RESIZE:
contentArea = self._getContentArea()
for displayKey in self._displayKeys.values():
displayKey.scaled = displayKey.unscaled * scale
displayKey.scaled.Offset(contentArea.origin)
displayKey.labelRect = Rect(*displayKey.unscaled)
displayKey.labelRect.Deflate(0.2, 0.2)
displayKey.labelRect *= scale
displayKey.labelRect.Offset(contentArea.origin)
self._fontSize = scale * 0.37
else:
maxWidth = drawingArea.width / scale
origin = Point(0, 0)
for displayKeyHandle in self._orderedKeyHandles:
displayKey = self._displayKeys[displayKeyHandle]
if origin.x + self._keySize.width > maxWidth:
origin.x = 0
origin.y += self._keySize.height + self._keySpacing.height
displayKey.unscaled.x = origin.x
displayKey.unscaled.y = origin.y
displayKey.scaled = displayKey.unscaled * scale
self._scroll.width = max(self._scroll.width, displayKey.scaled.x + displayKey.scaled.width)
self._scroll.height = max(self._scroll.height, displayKey.scaled.y + displayKey.scaled.height)
displayKey.scaled.Offset(drawingArea.origin)
displayKey.labelRect = Rect(*displayKey.unscaled)
displayKey.labelRect.Deflate(0.2, 0.2)
displayKey.labelRect *= scale
displayKey.labelRect.Offset(drawingArea.origin)
origin.x += self._keySize.width + self._keySpacing.width
self._scrollUnit.width = min(self._scrollUnit.width, displayKey.scaled.width)
self._scrollUnit.height = min(self._scrollUnit.height, displayKey.scaled.height)
self._scroll.width += self._border * 2
self._scroll.height += self._border * 2
self._scrollUnit.width += self._keySpacing.width * scale
self._scrollUnit.height += self._keySpacing.height * scale
def generate_goal_area(*, snake: Snake, field: Field) -> Rect:
collision = True
possible_goal: Rect = Rect(x=0, y=0, w=0, h=0)
while collision:
possible_goal = random_rect(size=9, area=field.client_area())
collision = False
for point in snake:
if rect_contains_point(possible_goal, point):
collision = True
return possible_goal
def __init__(self, parent, sourceKey):
KeyDisplayPane.__init__(self,
parent,
border=10,
displayMode=DISPLAY_MODE_DYNAMIC_RESIZE)
self._sourceKey = sourceKey
self._dispKey = DisplayKey(sourceKey.handle, Rect(0, 0, 1.8, 1.8))
self._displayKeys = {sourceKey.handle: self._dispKey}
self._updateKeys()
KeyDisplayPane._initKeys(self)
def __init__(self, pos, **kwargs):
#For now, just use BasicUnit Defaults
#default soldier size
shape = Rect.createAtOrigin(32, 32)
BasicUnit.__init__(self, pos, shape, name='SOLDIER', **kwargs)
#self.rangedWeapon = BasicRangedAttack('knife',size=(12,12))
self.rangedWeapon = KnifeThrower(self)
def __init__(self):
self.image = image.load(data_file('grill.png'))
self.rect = Rect(500, 250, self.image)
window.game_window.push_handlers(self.on_mouse_press)
window.game_window.push_handlers(self.on_mouse_motion)
self.highlighted = False
self.active = False
def __init__(self, pos, owner, **kwargs): shape = Rect.createAtOrigin(32, 32) AbstractObject.__init__(self, pos, shape, **kwargs) self.owner = self #keep a copy of who the corpse belongs to self.collisionType = 'OBJ' #should add collision type for corpses, keys, and other stuff you can walk over self.currentAnimation = 'ANIM_BLOOD_'+str(random.randint(0,3)) self.animationPlayer = animation.AnimationPlayer(glad.resource.resourceDict[self.currentAnimation], 0.2, True)
def _initKeys(self):
KeyDisplayPane._initKeys(self)
self._displayKeys = {
'left_shift': DisplayKey('left_shift', Rect(0.0, 0.0, 2.8, 1.8)),
'left_ctrl': DisplayKey('left_ctrl', Rect(0.0, 2.0, 2.8, 1.8)),
'left_alt': DisplayKey('left_alt', Rect(0.0, 4.0, 2.8, 1.8)),
'left_gui': DisplayKey('left_gui', Rect(0.0, 6.0, 2.8, 1.8)),
'right_shift': DisplayKey('right_shift', Rect(3.0, 0.0, 2.8, 1.8)),
'right_ctrl': DisplayKey('right_ctrl', Rect(3.0, 2.0, 2.8, 1.8)),
'right_alt': DisplayKey('right_alt', Rect(3.0, 4.0, 2.8, 1.8)),
'right_gui': DisplayKey('right_gui', Rect(3.0, 6.0, 2.8, 1.8))
}
self._updateKeys()
def __init__(self, pos, **kwargs):
shape = Rect.createAtOrigin(32, 32)
BasicUnit.__init__(self, pos, shape, name='FIRE_ELEM', **kwargs)
#self.rangedWeapon = KnifeThrower()
self.rangedWeapon = BasicRangedAttack(self, 'meteor')
self.alwaysMove = True
self.animationPlayer.timer = 0.1
def __init__(self, pos, shape = Rect.createAtOrigin(32, 32), hue=180, name='SOLDIER', slime=False, **kwargs):
AbstractObject.__init__(self, pos, shape, **kwargs)
self.collisionType = 'UNIT'
#Default statistics
self.strength = 10
self.dexterity = 10
self.constitution = 10
self.intelligence = 10
self.armor = 10
self.level = 1
self.life = 100
self.mana = 100
self.rangedWeapon = None
self.meleeWeapon = None
self.rangedDamage = 10
self.meleeDamage = 10
self.range = 400 #range for ranged weapon (in pixels)
self.moveSpeed = 200
#By default, have units face 'right'
self.orientation = Vector(1,0)
self.directionString = self.orientationToString() #may not be needed
#self.name = "SOLDIER" #might as well be soldier by default, name used to load animations with current name format
self.name=name
self.slime=slime
if self.slime:
self.currentAnimation = 'ANIM_' + self.name + '_TEAM_' + str(self.team) +'_MOVE'
else:
self.currentAnimation = 'ANIM_' + self.name + '_TEAM_' + str(self.team) +'_MOVE' + self.orientationToString()
self.animationTime = 0.2
self.animationPlayer = animation.AnimationPlayer(glad.resource.resourceDict[self.currentAnimation], self.animationTime , True)
self.alwaysMove = False
#turning
self.turnTime = 0.08
#Attacking
self.attacking = False
#attack animation
self.attackTime = 0.1 #time attack frame is up
self.attackTimer = 0
self.animateAttack = False
self.hue = hue #I thnk this is from my old method of team coloring - can probably be removed
def attack(self, pos, gap, orientation,team):
if self.nextAttackTimer != 0.0:
return False
self.nextAttackTimer += self.attackCooldown
#create a knife just outside the spawn location
projectileShape = Rect.createAtOrigin(self.size[0], self.size[1])
#TODO: how to handle diagonal movement and firing?
# spawn outside rect, or inside?
projectilePos = pos + orientation.getNormalized()*gap
dict = {'rock': Rock(projectilePos,projectileShape,self.owner,orientation),
'arrow': Arrow(projectilePos,projectileShape,self.owner,orientation),
'firearrow': FireArrow(projectilePos,projectileShape,self.owner,orientation),
'fireball': Fireball(projectilePos,projectileShape,self.owner,orientation),
'hammer': Hammer(projectilePos,projectileShape,self.owner,orientation),
'lightning': Lightning(projectilePos,projectileShape,self.owner,orientation),
'meteor': Meteor(projectilePos,projectileShape,self.owner,orientation),
'bone' : Bone(projectilePos,projectileShape,self.owner,orientation),
'knife' : Knife(projectilePos,projectileShape,self.owner,orientation),
'sparkle' : Sparkle(projectilePos,projectileShape,self.owner,orientation),
'boulder' : Boulder(projectilePos,projectileShape,self.owner,orientation)}
proj = dict[self.type]
proj.owner = self.owner
#play sound - if I do this when the projectile is created, it plays it for each entry in the above dict
#need to play sound for each attack, right now just this, knifeThrower, and slimeAttack
proj.sound.play(self.owner.pos)
#if self.type == "arrow":
# glad.resource.resourceDict['twang'].play(self.owner.pos)
#elif self.type == "sparkle":
# glad.resource.resourceDict['faerie1'].play(self.owner.pos)
#elif self.type == "lightning":
# glad.resource.resourceDict['bolt1'].play(self.owner.pos)
#elif self.type == "meteor":
# glad.resource.resourceDict['blast1'].play(self.owner.pos)
#else:
# glad.resource.resourceDict['fwip'].play(self.owner.pos) #Just testing sound, should be for only stuff on screen or nearby,
#proj = BasicProjectile(projectilePos, projectileShape, team, orientation) #basic projectile should be default
#proj = Fireball(projectilePos,projectileShape,team,orientation)
##proj = Knife(projectilePos,projectileShape,team,orientation)
glad.world.objectList.append(proj)
return True
def __init_rect_list(self, ind, min_prob=0.5):
"""
Returns list of Rect instances from output of neural network for a single image.
Args
bottom_height (int): height of image (bottom layer)
bottom_width (int): width of image
bbox_label_pred (ndarray): spatial map of predicted bounding
box coordinates at the top of neural network
label_pred (ndaray): spatial map of probabilities of the
different labels
"""
#bbox_label_pred = self.net.tops['bbox_label'].data[ind]
#binary_pred = self.net.tops['binary_label'].data[ind]
bottom_height = self.image_height
bottom_width = self.image_width
bbox_label_pred = self.net.tops['bbox_pred'].data[ind]
binary_pred = self.net.tops['binary_softmax'].data[ind]
label_pred = self.net.tops['label_softmax'].data[ind]
(_, top_height, top_width) = bbox_label_pred.shape
y_mul = bottom_height * 1. / top_height
x_mul = bottom_width * 1. / top_width
rect_list = []
for y in xrange(top_height):
for x in xrange(top_width):
# corresponds to indices in original image
cx_orig = x_mul * (x + 0.5)
cy_orig = y_mul * (y + 0.5)
# we predict a symbol here if p(no label) < x
if binary_pred[0, y, x] < 0.5:
k = np.argmax(label_pred[:, y, x])
#if label_pred[k, y, x] < 0.2: continue
# apply offsets to get positions in original image
cx = cx_orig + bbox_label_pred[0, y, x]
cy = cy_orig + bbox_label_pred[1, y, x]
w = bbox_label_pred[2, y, x]
h = bbox_label_pred[3, y, x]
xmin = cx - w / 2.0
ymin = cy - h / 2.0
rect = Rect(xmin,
ymin,
xmin + w,
ymin + h,
label=k,
prob=label_pred[k, y, x])
rect_list.append(rect)
return rect_list
def rect_list(self):
"""
List[Rect] - instances corresponding to labelled image.
"""
rect_list_ = []
for ind in xrange(len(self.bbox_array)):
rect = Rect(self.bbox_array[ind][0],
self.bbox_array[ind][1],
self.bbox_array[ind][2],
self.bbox_array[ind][3],
label = self.label_array[ind])
rect_list_.append(rect)
return rect_list_
def _initKeys(self):
KeyDisplayPane._initKeys(self)
self._displayKeys.clear()
self._orderedKeyHandles = self._category.keyHandles
for keyHandle in self._category.keyHandles:
if not Model.sourcekeys.has_key(keyHandle):
raise RuntimeError("Unknown key '%s' in category '%s'" %
(keyHandle, self._category.name))
sourceKey = Model.sourcekeys[keyHandle]
rect = Rect(0, 0, self._keySize.width, self._keySize.height)
self._displayKeys[keyHandle] = DisplayKey(keyHandle, rect)
self._updateKeys()
self._selectKey(self._orderedKeyHandles[0])
self._updateScrollbars()
def chunkify(m):
direction = WallDirection.horizontal
start_chunk = Rect(0, 0, m.width, m.height)
TowerMapGenerator.mark_room(m, start_chunk, 0)
chunks = [start_chunk]
minsize = 13
minlength = 6
while TowerMapGenerator.free_area(m) < TowerMapGenerator.total_size(m) * 0.2:
curr = TowerMapGenerator.pop_largest(chunks)
if direction == WallDirection.vertical and curr.width > minsize:
start = curr.x + max(minlength, int(curr.width * 0.2))
end = curr.x + curr.width - max(minlength, int(curr.width * 0.2))
hallway = random.randint(start, end)
first = Rect(curr.x, curr.y, hallway - curr.x, curr.height)
second = Rect(hallway + 1, curr.y, curr.x + curr.width - hallway - 1, curr.height)
new_direction = WallDirection.horizontal
elif direction == WallDirection.horizontal and curr.height > minsize: # horizontal
start = curr.y + max(minlength, int(curr.height * 0.2))
end = curr.y + curr.height - max(minlength, int(curr.height * 0.2))
hallway = random.randint(start, end)
first = Rect(curr.x, curr.y, curr.width, hallway - curr.y)
second = Rect(curr.x, hallway + 1, curr.width, curr.y + curr.height - hallway - 1)
new_direction = WallDirection.vertical
else: # chunk too small, done. just re-add the chunk
chunks.append(curr)
break
TowerMapGenerator.mark_room(m, first, TowerMapGenerator.first_unused_room_id(m))
chunks.append(first)
TowerMapGenerator.mark_room(m, second, TowerMapGenerator.first_unused_room_id(m))
chunks.append(second)
TowerMapGenerator.mark_hallway(m, curr, hallway, direction)
direction = new_direction
return chunks
def __init__(self):
self.rect = Rect(0,0,70,80) #this is the *logical* rect
self.facing = Facing.right
self.yFacing = Facing.up
self.velocity = [0,0]
self.xFriction = 1
self.yFriction = 2
self.xAccel = 1
self.yAccel = 1
self.xMax = 8
self.xMin = -8
self.yMax = 4
self.yMin = -4
self.walkMask = None #level will set this
self.triggerZones = None #level will set this
def batch_data(self, image_mean):
"""
Prepares data for ingestion by Apollo.
Returns:
ndarray (trans_img): transposed image in N-C-H-W caffe blob format
ndarray (bbox_label): target bounding boxes corresponding to image,
bbox_label[0]: cx (center x) offset at each position
bbox_label[1]: cy (center y) offset at each position
bbox_label[2]: w (width) of bounding box of object at each position
bbox_label[3]: h (height) of bounding box of object at each position
ndarray (conf_label): target indices corresponding to different points in image
"""
# zero label means nothing is there
conf_label = np.zeros((1, TOP_HEIGHT, TOP_WIDTH), dtype = np.float)
bbox_label = np.zeros((4, TOP_HEIGHT, TOP_WIDTH), dtype = np.float)
y_mul = IMG_HEIGHT * 1. / TOP_HEIGHT
x_mul = IMG_WIDTH * 1. / TOP_WIDTH
# iterate over all pixels
for y in range(TOP_HEIGHT):
for x in range(TOP_WIDTH):
# current distance to closest object center at coordinate
best_dist = np.Inf
# find object closest to coordinate (if one exists)
for rect in self.rect_iter():
# makes box smaller to prevent label ambiguity
# at downsampled resolution (detections get centered)
rect.scale_wh(0.5, 0.5)
x_orig = x_mul * x
y_orig = y_mul * y
obs_rect = Rect(x_orig, y_orig, x_orig + x_mul, y_orig + y_mul)
if rect.intersects(obs_rect):
center_dist = (rect.cx - obs_rect.cx) ** 2 + (rect.cy - obs_rect.cy) ** 2
if center_dist < best_dist:
best_dist = center_dist
conf_label[0, y, x] = rect.label
bbox_label[0, y, x] = rect.cx - obs_rect.cx
bbox_label[1, y, x] = rect.cy - obs_rect.cy
bbox_label[2, y, x] = rect.w
bbox_label[3, y, x] = rect.h
image = self.image.copy()
image = image.reshape(1, IMG_HEIGHT, IMG_WIDTH)
return (image, bbox_label, conf_label)
def __init__(self, pos, data=None):
self.base_images = {}
for n, p in self.image_paths.items():
self.base_images[n] = pygame.image.load(p)
self._velocity: Vec2d = Vec2d((0, 0))
self.images: Dict[str, BodyPart] = {}
for n, v in self.image_parts.items():
self.images[n] = BodyPart(self.base_images[v[0]].subsurface(v[1]),
v[2])
self._data: Dict[str, Any] = None
self._hash = None
self._image = None
self._rect = Rect(pos, self.size)
self._draw_offset = None
self.data = data or {}
self.one_ground = False
self.setup()
def main():
pygame.init()
screen = pygame.display.set_mode(SIZE)
clock = pygame.time.Clock()
noto_sans = pygame.font.Font('NotoSans-Regular.ttf', 12)
field = Field(area=Rect(x=10, y=50, w=WIDTH - 20, h=HEIGHT - 60))
snake = Snake(
starting_point=random_point(offset=100, area=field.client_area()))
score = Score(font=noto_sans, position=Point(x=10, y=10))
goal = Goal(area=generate_goal_area(snake=snake, field=field))
controller = KeyboardController(
snake=snake,
start_direction=random_direction(),
key_map=KeyMap(
up=pygame.K_UP,
down=pygame.K_DOWN,
left=pygame.K_LEFT,
right=pygame.K_RIGHT
# up=pygame.K_w, down=pygame.K_s, left=pygame.K_a, right=pygame.K_d
))
running = True
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
controller.handle_event(event)
if not running:
break
score.update(score=len(snake))
screen.fill(BLACK)
for go in [field, snake, score, goal]:
go.draw_to(screen)
pygame.display.flip()
controller.update()
running = check_collisions(snake, screen, goal, field)
clock.tick(120)
print(f'Game over! Your score: {len(snake)}')
pygame.quit()
def __init__(self, pos, tileNum, type = None, shape=Rect.createAtOrigin(32,32), **kwargs):
AbstractObject.__init__(self, pos, shape, team=None, moveDir=None, **kwargs)
self.collisionType = 'LAND'
if tileNum in Tile.water:
self.collisionType = 'WATER'
elif tileNum in Tile.tree:
self.collisionType = 'TREE'
elif tileNum in Tile.wall:
self.collisionType = 'WALL'
elif tileNum in Tile.barrier:
self.CollisionType = 'BARRIER'
#set appropriate tile to be drawn
self.tileNum = tileNum
tileName = Tile.tileDict[self.tileNum]
anim = [glad.resource.get(tileName)]
self.currentAnimation = animation.Animation(anim)
self.animationPlayer = animation.AnimationPlayer(self.currentAnimation, 0.2, True)
def __init__(self):
self.image = image.load(data_file('biggrill.png'))
self.beef = Beef()
self.spritzer = Spritzer()
self.table = Table()
self.exit = Exit()
self.rect = Rect(150, 300, 300, 200)
self.flareups = []
self.flareup_range = (10, 50)
self.flareup_counter = randint(*self.flareup_range) / 10.0
window.game_window.push_handlers(self.on_mouse_press)
window.game_window.push_handlers(self.on_mouse_release)
window.game_window.push_handlers(self.on_mouse_motion)
#events.AddListener(self)
self.active = False
self.beef_hint_done = False
self.flareup_hint_done = False
def _initKeys(self):
self._keySpacing = wx.Size(self._kb.layout.spacing, self._kb.layout.spacing)
self._displayKeys = {}
selectedKey = None
rows = self._kb.layout.rows
for row in rows:
if row is None:
continue
for keydef in row.keydefs:
if keydef.isNullKey:
continue
keyRect = Rect(keydef.origin.x, keydef.origin.y, keydef.size.width, keydef.size.height)
location = keydef.location
keyHandle = None
if self._keymap and self._keymap.keys.has_key(location):
keyHandle = self._keymap.keys[location].keyHandle
self._displayKeys[location] = DestDisplayKey(location, keyHandle, keyRect)
if selectedKey == None:
selectedKey = location
self._updateKeys()
self._selectKey(selectedKey)
def chunkify(m):
direction = Dir.horizontal
start_chunk = Rect(0, 0, m.width, m.height)
start_chunk.room = -1
chunks = [start_chunk]
minsize = 13
minlength = 6
while m.free_area < m.total_size * 0.2:
curr = pop_largest(chunks)
if direction == Dir.vertical and curr.width > minsize:
start = curr.x + max(minlength, int(curr.width * 0.2))
end = curr.x + curr.width - max(minlength, int(curr.width * 0.2))
hallway = random.randint(start, end)
first = Rect(curr.x, curr.y, hallway - curr.x, curr.height)
second = Rect(hallway + 1, curr.y, curr.x + curr.width - hallway - 1, curr.height)
new_direction = Dir.horizontal
elif direction == Dir.horizontal and curr.height > minsize: # horizontal
start = curr.y + max(minlength, int(curr.height * 0.2))
end = curr.y + curr.height - max(minlength, int(curr.height * 0.2))
hallway = random.randint(start, end)
first = Rect(curr.x, curr.y, curr.width, hallway - curr.y)
second = Rect(curr.x, hallway + 1, curr.width, curr.y + curr.height - hallway - 1)
new_direction = Dir.vertical
else: # chunk too small, done. just re-add the chunk
chunks.append(curr)
break
mark_room(m, first, m.first_unused_room_id)
chunks.append(first)
mark_room(m, second, m.first_unused_room_id)
chunks.append(second)
mark_hallway(m, curr, hallway, direction)
direction = new_direction
# print_map(m)
return chunks
class Beef(GrillObject):
def __init__(self):
GrillObject.__init__(self)
self.image = image.load(data_file('beef.png'))
self.rect = Rect(520, 230, self.image)
self.cooking = False
self.reset()
def reset(self):
GrillObject.reset(self)
self.cooking_time = 15
self.red = 1
self.brown_time = 3
self.cooked = False
self.burnt = False
self.rect.bottomleft = (580, 230)
def handler(self, pos):
if self.rect.collide_point(*pos):
self.set_active()
self.cooking = False
self.highlighted = False
return True
return False
def set_active(self):
GrillObject.set_active(self)
events.Fire('BeefTaken')
#print "beef taken"
def set_inactive(self, pos):
GrillObject.set_inactive(self, pos)
events.Fire('BeefDropped')
#print "beef dropped"
def update(self, tick):
if self.cooking:
self.brown_time -= tick
if self.brown_time < 0:
self.brown_time = 3
self.red -= 0.1
self.cooking_time -= tick
if self.cooking_time < 0:
if not self.cooked:
self.cooked = True
events.Fire('BeefCooked')
events.Fire('NewHint', random.choice(COOKED_PHRASES))
elif self.cooking_time < -15 and not self.burnt:
events.Fire('BeefBurnt')
events.Fire('NewHint', random.choice(BURN_PHRASES))
self.burnt = True
def draw(self):
if self.highlighted:
glColor4f(0.5, 0.1, 1, 1)
else:
glColor4f(self.red, self.red, self.red, 1)
self.image.blit(*self.rect.bottomleft)
glColor4f(1, 1, 1, 1)
def on_mouse_drag(self, x, y, dx, dy, buttons, modifiers):
if self.active:
self.rect.center = (x, y)
class Grill:
def __init__(self):
self.image = image.load(data_file('biggrill.png'))
self.beef = Beef()
self.spritzer = Spritzer()
self.table = Table()
self.exit = Exit()
self.rect = Rect(150, 300, 300, 200)
self.flareups = []
self.flareup_range = (10, 50)
self.flareup_counter = randint(*self.flareup_range) / 10.0
window.game_window.push_handlers(self.on_mouse_press)
window.game_window.push_handlers(self.on_mouse_release)
window.game_window.push_handlers(self.on_mouse_motion)
#events.AddListener(self)
self.active = False
self.beef_hint_done = False
self.flareup_hint_done = False
def update(self, tick):
self.beef.update(tick)
if self.beef.cooking:
self.flareup_counter -= tick
#print self.flareup_counter
if self.flareup_counter <= 0:
if len(self.flareups) < 2:
if not self.flareup_hint_done:
events.Fire('NewHint',
'I can put out flare ups with the spritzer')
self.flareup_hint_done = True
#print "flare ups hint"
self.flareups.append(FlareUp())
self.flareup_counter = randint(*self.flareup_range) / 10.0
#print "flareup"
events.Fire('FlareUp')
if self.beef.burnt:
self.active = False
self.spritzer.update(tick)
for fire in self.flareups:
fire.update(tick)
def draw(self):
self.image.blit(120, 100)
self.exit.draw()
self.table.draw()
#self.draw_rect()
self.beef.draw()
for fire in self.flareups:
fire.draw()
self.spritzer.draw()
def check_flareups(self, x, y):
for fire in self.flareups:
#x += self.spritzer.rect.width/2
#y += self.spritzer.rect.height/2
rect_x = x - fire.rect.x - fire.rect.width/2
rect_y = y + self.spritzer.rect.height/2 - fire.rect.y
if rect_x < 100 and abs(rect_y) < 40:
#print "hit fire"
fire.lives -= 1
if fire.lives <= 0:
self.flareups.remove(fire)
break
def on_mouse_press(self, x, y, button, modifiers):
if not self.active:
return
if self.spritzer.active:
if self.table.rect.collide_point(x, y):
self.spritzer.set_inactive((x, y))
return
#print "spritz"
self.spritzer.spritz((x, y))
events.Fire('Spritz')
self.check_flareups(x, y)
return
if self.exit.rect.collide_point(x, y):
self.active = False
if self.spritzer.handler((x, y)):
return
if self.beef.handler((x, y)):
return
def on_mouse_release(self, x, y, button, modifiers):
if self.beef.active:
self.beef.set_inactive((x, y))
if self.rect.collide_point(self.beef.rect.center):
events.Fire('BeefCooking')
self.beef.cooking = True
#print "cookin'!"
def on_mouse_motion(self, x, y, dx, dy):
if not self.beef_hint_done and self.active:
events.Fire('NewHint', 'I need to put the steak on the grill.')
self.beef_hint_done = True
def draw_rect(self):
glColor4f(0, 0, 1, .5)
glBegin(GL_POLYGON)
glVertex2d(*self.rect.bottomleft)
glVertex2d(*self.rect.topleft)
glVertex2d(*self.rect.topright)
glVertex2d(*self.rect.bottomright)
glEnd()
glColor4f(1, 1, 1, 1)
class GarbageCan:
def __init__(self):
self.image_opened = image.load(data_file('garbagecan-open.png'))
self.image_closed = image.load(data_file('garbagecan-closed.png'))
self.image_lid = image.load(data_file('garbagecan-lid.png'))
self.image_opened.anchor_x = self.image_opened.width/2
self.image_opened.anchor_y = self.image_opened.height/2
self.image_closed.anchor_x = self.image_opened.width/2
self.image_closed.anchor_y = self.image_opened.height/2
self.candidateLeaves = {}
self.opened = True
self.lid_active = False
self.can_active = False
self.fallen = False
self.can_highlighted = False
self.lid_highlighted = True
self.can_rect = Rect(0, 0, self.image_closed)
self.can_rect.center = (80, 90)
self.can_sprite = Sprite(self.image_opened)
self.can_sprite.set_position(self.can_rect.x, self.can_rect.y)
self.lid_rect = Rect(20, 40, self.image_lid)
window.game_window.push_handlers(self.on_mouse_release)
window.game_window.push_handlers(self.on_mouse_press)
window.game_window.push_handlers(self.on_mouse_drag)
window.game_window.push_handlers(self.on_mouse_motion)
events.AddListener(self)
def update(self, timechange):
pass
def draw(self):
if not self.can_active:
if self.can_highlighted:
self.can_sprite.color = (255, 20, 25)
else:
self.can_sprite.color = (255, 255, 255)
else:
self.can_sprite.color = (255, 255, 255)
self.can_sprite.draw()
glColor4f(1, 1, 1, 1)
if not self.lid_active:
if self.lid_highlighted:
glColor4f(1, 0.1, 0.1, 1)
else:
glColor4f(1, 1, 1, 1)
if self.opened:
self.image_lid.blit(*self.lid_rect.bottomleft)
glColor4f(1, 1, 1, 1)
def on_mouse_press(self, x, y, button, modifiers):
if self.opened and self.lid_rect.collide_point(x, y):
self.set_lid_active()
elif self.collides(x, y):
self.fallen = False
self.set_can_active()
self.can_sprite.rotation = 0
if self.opened:
self.can_sprite.image = self.image_opened
else:
self.can_sprite.image = self.image_closed
def set_can_active(self):
window.game_window.set_mouse_visible(False)
self.can_active = True
events.Fire('CanTaken')
def set_lid_active(self):
window.game_window.set_mouse_visible(False)
self.lid_active = True
events.Fire('LidTaken')
def collides(self, x,y):
cs = self.can_sprite
return (x > cs.x - cs.image.width/2
and x < cs.x + cs.image.width/2
and y > cs.y - cs.image.height/2
and y < cs.y + cs.image.height/2 )
def on_mouse_release(self, x, y, button, modifiers):
window.game_window.set_mouse_visible(True)
#print "x=%d y=%d" % (x, y)
if self.lid_active:
if self.collides(x, y):
self.can_sprite.image = self.image_closed
self.opened = False
events.Fire('LidClosed')
else:
self.lid_rect.x = x
self.lid_rect.y = y
events.Fire('LidDropped')
self.lid_active = False
elif self.can_active:
self.can_sprite.rotation = 0
#self.can_sprite.set_position(x,y)
self.can_active = False
events.Fire('CanDropped')
def on_mouse_motion(self, x, y, dx, dy):
if self.collides(x, y):
self.can_highlighted = True
else:
self.can_highlighted = False
if self.lid_rect.collide_point(x, y):
self.lid_highlighted = True
else:
self.lid_highlighted = False
def on_mouse_drag(self, x, y, dx, dy, buttons, modifiers):
if self.can_active:
self.can_sprite.x = x
self.can_sprite.y = y
#self.can_rect.centerx = x
#self.can_rect.centery = y
#self.can_sprite.set_position(self.can_rect.x, self.can_rect.y)
dist = math.sqrt(abs(dx*dx + dy*dy))
self.can_sprite.rotation = dx / 10.0 * 45
if dist > 10:
self.fallen = True
self.can_active = False
if dx > 0:
self.can_sprite.rotation = 90
else:
self.can_sprite.rotation = -90
events.Fire('CanTipped')
if not self.opened:
self.opened = True
self.can_sprite.image = self.image_opened
self.lid_rect.bottomleft = self.can_rect.bottomleft
self.lid_rect.x += dx * 5
self.lid_rect.y += dy * 5
for leaf in self.candidateLeaves:
if self.collides(leaf.x, leaf.y):
leaf.die()
elif self.lid_active:
self.lid_rect.center = (x, y)
def On_LeafSweptOff(self, leaf):
self.candidateLeaves[leaf] = 1
def On_LeafDeath(self, leaf):
if leaf in self.candidateLeaves:
del self.candidateLeaves[leaf]
def __init__(self, pos, **kwargs): shape = Rect.createAtOrigin(96, 72) BasicUnit.__init__(self, pos, shape, name='GOLEM', **kwargs) self.rangedWeapon = BasicRangedAttack(self, 'boulder', size=(26,26))
def generateNeighborDict(self, time):
"""Generate dict of neighbors. A neighbor is any object
within the bounding box of an objects trajectory during time.
Objects must be able to collide to be considered neighbors"""
#first, calculate bounding box for each object
boundDict = {}
for i in range(len(self.objectList)):
p1 = self.objectList[i].pos
p2 = self.objectList[i].getPosInTime(time)
shape = self.objectList[i].shape
#Get bounding boxes at the 2 positions
box1 = shape.getBoundingBox().translate(p1)
box2 = shape.getBoundingBox().translate(p2)
#generate the union between them and store it
bbox = Rect.union(box1, box2)
boundDict[i] = bbox
d = {}
#TODO: improve, this is O(n^2) for testing
#TODO: is this only necessary for objects that can stop each other?
for i in range(len(self.objectList)):
iObj = self.objectList[i]
iRect = boundDict[i]
#Check nearby tiles
tl = [int(floor(iRect.x1/32)), int(floor(iRect.y1/32))] #top left tile indices
br = [int(ceil(iRect.x2/32)), int(ceil(iRect.y2/32))] #bottom right tile indices
for x in range(tl[0], br[0]+1):
for y in range(tl[1], br[1]+1):
jObj = self.tileGrid[x][y]
#Following Code copied from below
#this is only applicable for objects which can create
# collision events
if not CollisionFilter.canCollide(iObj,jObj):
continue
#iRect = boundDict[i]
jRect = jObj.shape.getBoundingBox().translate(jObj.pos)
if Rect.touches(iRect, jRect):
if iObj in d:
d[iObj].add(jObj)
else:
d[iObj] = set([jObj])
if jObj in d:
d[jObj].add(iObj)
else:
d[jObj] = set([iObj])
#End of copied code
#Check other objects
for j in range(i+1, len(self.objectList)):
#iObj = self.objectList[i]
jObj = self.objectList[j]
#this is only applicable for objects which can create
# collision events
if not CollisionFilter.canCollide(iObj,jObj):
continue
#iRect = boundDict[i]
jRect = boundDict[j]
if Rect.touches(iRect, jRect):
if iObj in d:
d[iObj].add(jObj)
else:
d[iObj] = set([jObj])
if jObj in d:
d[jObj].add(iObj)
else:
d[jObj] = set([iObj])
return d
def _drawKeys(self, dc):
blackPen = wx.Pen('black')
whiteBrush = wx.Brush('white')
font = wx.Font(10, wx.FONTFAMILY_SWISS, wx.FONTSTYLE_NORMAL,
wx.FONTWEIGHT_NORMAL, False, 'Arial Rounded MT Bold')
dc.SetFont(font)
scale = 1
if self._displayMode == DISPLAY_MODE_DYNAMIC_RESIZE:
displayRect = self._getDisplayRect()
print "displayRect: %s" % displayRect
# dc.SetMapMode(wx.MM_TEXT)
dc.SetMapMode(wx.MM_METRIC)
contentRect = Rect(dc.DeviceToLogicalX(displayRect.x),
dc.DeviceToLogicalY(displayRect.y),
dc.DeviceToLogicalXRel(displayRect.width),
dc.DeviceToLogicalYRel(displayRect.height))
print "contentRect: %s" % contentRect
scale = self._getScale(contentRect)
# dc.SetPen(wx.Pen('black', 1*scale))
dc.SetMapMode(wx.MM_TEXT)
for displayKey in self._displayKeys.values():
# if self._isKeySelected(displayKey.handle):
# if self.FindFocus() == self:
# # TODO: Generalize this magic number from system
# # settings. Currently is Mac selection blue.
# dc.SetPen(wx.Pen('#3e75d6', 2))
# else:
# dc.SetPen(wx.Pen('dark grey', 2))
# dc.SetBrush(wx.Brush('light grey'))
# else:
# dc.SetPen(blackPen)
# dc.SetBrush(whiteBrush)
label_rect = deepcopy(displayKey.scaled)
key_rect = deepcopy(displayKey.scaled)
# make any necessary adjustments
if self._displayMode == DISPLAY_MODE_DYNAMIC_RESIZE:
key_rect = key_rect * scale
# draw key rectangle
dc.DrawRoundedRectangleRect(key_rect.Get(), -.075)
# draw label
if False:
label_rect.Deflate(5, 2)
label = self._getLabel(displayKey)
if label:
dc.SetUserScale(scale, scale)
(width, height) = dc.GetTextExtent(label)
if width > label_rect.width:
# TODO: better wrapping
# extents = dc.GetPartialTextExtents(label)
label = fill(label, 5)
dc.DrawLabel(label, label_rect.Get(),
wx.ALIGN_LEFT | wx.ALIGN_BOTTOM)
if self._isKeySelected(displayKey.handle):
dc.SetPen(blackPen)
dc.SetBrush(whiteBrush)
dc.SetUserScale(1, 1)
def _render_rect(self):
self._rect = Rect(
tuple(self.pos),
(self._image.get_size()[0] / 16, self._image.get_size()[1] / 16))
def gen_sweep_plane(src_Hs, src_frames):
max_poly = None # the bound of the blended image
bldIm = None # the blended plane image
cost_info = None # An array structure to collect pixel colors of
# blended frames
nframes = len(src_frames)
o = np.array([[0], [0], [1]]) # origin = zero
# Get max polygon
for k in range(nframes):
cpoly = Rect(Point(0, 0),
Point(src_frames[k].shape[1],
src_frames[k].shape[0])).get_trans_regpoly(src_Hs[k], 10)
if(k == 0):
max_poly = cpoly
else:
max_poly = max_poly | cpoly
#end if
#end for
(xmin, xmax, ymin, ymax) = max_poly.boundingBox(0)
max_rec = Rect(Point(xmin, ymin), Point(xmax, ymax))
#print "Max: " , max_rec, "W: ", max_rec.width(), " H: ", max_rec.height()
#alocate costs and count matrixes
cost_info = np.zeros([int(max_rec.height()),
int(max_rec.width()),
nframes, 3], dtype=np.int)
counts = np.zeros([int(max_rec.height()),
int(max_rec.width())], dtype=np.int)
bldIm = cv.CreateMat(int(np.round(max_rec.height())),
int(np.round(max_rec.width())), cv.CV_32FC3)
cv.Zero(bldIm)
for k in range(nframes):
cur_H = src_Hs[k]
cur_o = np.dot(cur_H, o)
# translate the warped frame to origin from topleft corner
disp = np.array([[1, 0, (0 - cur_o[0, 0]) / cur_o[2, 0]],
[0, 1, (0 - cur_o[1, 0]) / cur_o[2, 0]],
[0, 0, 1]])
o_H = np.dot(disp, cur_H)
tpoly = Rect(Point(0, 0),
Point(src_frames[k].shape[1],
src_frames[k].shape[0])).get_trans_poly(cur_H)
cpoly = Rect(Point(0, 0),
Point(src_frames[k].shape[1],
src_frames[k].shape[0])).get_trans_regpoly(cur_H, 10)
(xmin, xmax, ymin, ymax) = cpoly.boundingBox(0)
frec = Rect(Point(xmin, ymin), Point(xmax, ymax))
mask = gen_mask(frec, tpoly)
#print "Rec: ", frec, "W: ", frec.width(), " H: ", frec.height()
if k == 0:
fwarp = cv2.warpPerspective(src_frames[k], o_H,
(int(frec.width()), int(frec.height())))
# get blended image
blend_views(bldIm, fwarp, mask,
frec, max_rec)
# determine costs
collect_costs_info(cost_info, counts, fwarp, mask,
frec, max_rec, k)
else:
fwarp = cv2.warpPerspective(src_frames[k], o_H,
(int(frec.width()), int(frec.height())))
# get blended image
blend_views(bldIm, fwarp, mask,
frec, max_rec)
# determine costs
collect_costs_info(cost_info, counts, fwarp, mask,
frec, max_rec, k)
#end if
#end for
bldIm = np.asarray(bldIm)
# Scale blended image to 8U
bldIm8U = scaleTo8U(bldIm, counts)
## Measure Cost
costs = None
costs = calculate_costs(cost_info, counts)
##return blended image and costs
return (bldIm8U, costs, max_rec)
def get_body_rect(self): dy = settings.player_body_adjustment if self.default_angle == 0 else -settings.player_body_adjustment return Rect(self.pos[0], self.pos[1] + dy, settings.player_body_width, settings.player_body_height, self.angle)
def get_stick_head(self):
stick_ball_offset = pygame.Vector2(settings.ball_radius, 0)
offset_rotated = stick_ball_offset.rotate(-self.angle)
ball_pos = self.get_ball_pos()
return Rect(ball_pos[0] + offset_rotated[0], ball_pos[1] + offset_rotated[1], settings.stick_head_width, settings.stick_head_height, self.angle)
def client_area(self) -> Rect:
return Rect(self._area.x + 1, self._area.y + 1, self._area.w - 2, self._area.h - 2)
def __init__(self, pos, **kwargs): shape = Rect.createAtOrigin(32, 28) BasicUnit.__init__(self, pos, shape, name='MAGE', **kwargs) self.rangedWeapon = BasicRangedAttack(self, 'fireball')
def gen_sweep_plane(src_Hs, src_frames):
max_poly = None # the bound of the blended image
bldIm = None # the blended plane image
cost_info = None # An array structure to collect pixel colors of
# blended frames
nframes = len(src_frames)
o = np.array([[0], [0], [1]]) # origin = zero
# Get max polygon
for k in range(nframes):
cpoly = Rect(Point(0, 0),
Point(src_frames[k].shape[1],
src_frames[k].shape[0])).get_trans_regpoly(
src_Hs[k], 10)
if (k == 0):
max_poly = cpoly
else:
max_poly = max_poly | cpoly
#end if
#end for
(xmin, xmax, ymin, ymax) = max_poly.boundingBox(0)
max_rec = Rect(Point(xmin, ymin), Point(xmax, ymax))
#print "Max: " , max_rec, "W: ", max_rec.width(), " H: ", max_rec.height()
#alocate costs and count matrixes
cost_info = np.zeros(
[int(max_rec.height()),
int(max_rec.width()), nframes, 3],
dtype=np.int)
counts = np.zeros(
[int(max_rec.height()), int(max_rec.width())], dtype=np.int)
bldIm = cv.CreateMat(int(np.round(max_rec.height())),
int(np.round(max_rec.width())), cv.CV_32FC3)
cv.Zero(bldIm)
for k in range(nframes):
cur_H = src_Hs[k]
cur_o = np.dot(cur_H, o)
# translate the warped frame to origin from topleft corner
disp = np.array([[1, 0, (0 - cur_o[0, 0]) / cur_o[2, 0]],
[0, 1, (0 - cur_o[1, 0]) / cur_o[2, 0]], [0, 0, 1]])
o_H = np.dot(disp, cur_H)
tpoly = Rect(Point(0, 0),
Point(src_frames[k].shape[1],
src_frames[k].shape[0])).get_trans_poly(cur_H)
cpoly = Rect(Point(0, 0),
Point(src_frames[k].shape[1],
src_frames[k].shape[0])).get_trans_regpoly(
cur_H, 10)
(xmin, xmax, ymin, ymax) = cpoly.boundingBox(0)
frec = Rect(Point(xmin, ymin), Point(xmax, ymax))
mask = gen_mask(frec, tpoly)
#print "Rec: ", frec, "W: ", frec.width(), " H: ", frec.height()
if k == 0:
fwarp = cv2.warpPerspective(
src_frames[k], o_H, (int(frec.width()), int(frec.height())))
# get blended image
blend_views(bldIm, fwarp, mask, frec, max_rec)
# determine costs
collect_costs_info(cost_info, counts, fwarp, mask, frec, max_rec,
k)
else:
fwarp = cv2.warpPerspective(
src_frames[k], o_H, (int(frec.width()), int(frec.height())))
# get blended image
blend_views(bldIm, fwarp, mask, frec, max_rec)
# determine costs
collect_costs_info(cost_info, counts, fwarp, mask, frec, max_rec,
k)
#end if
#end for
bldIm = np.asarray(bldIm)
# Scale blended image to 8U
bldIm8U = scaleTo8U(bldIm, counts)
## Measure Cost
costs = None
costs = calculate_costs(cost_info, counts)
##return blended image and costs
return (bldIm8U, costs, max_rec)
def __init__(self, pos, **kwargs): shape = Rect.createAtOrigin(32, 26) BasicUnit.__init__(self, pos, shape, name='THIEF', **kwargs) self.rangedWeapon = BasicRangedAttack(self, 'knife', size=(12,12))
def generateCollisionList(self, time):
"""Generate a dictionary of collisions between object
that are allowed to generate collision events
TODO: FINISH DOC HERE
only considers collisions that happen <= time"""
#d = {}
l = []
#TODO: improve, this is O(n^2) for testing
for i in range(len(self.objectList)):
objI = self.objectList[i]
#create bounding box of trajectory and test for collision with appropriate tiles
p1 = objI.pos
p2 = objI.getPosInTime(time)
shape = self.objectList[i].shape
#Get bounding boxes at the 2 positions
box1 = shape.getBoundingBox().translate(p1)
box2 = shape.getBoundingBox().translate(p2)
#generate the union between them and store it
bbox = Rect.union(box1, box2)
tl = [int(floor(bbox.x1/32)), int(floor(bbox.y1/32))] #top left tile indices
br = [int(ceil(bbox.x2/32)), int(ceil(bbox.y2/32))] #bottom right tile indices
#print tl[0], br[0]
for x in range(tl[0], br[0]+1):
for y in range(tl[1], br[1]+1):
objJ = self.tileGrid[x][y]
#the following is copied from below
if not CollisionFilter.canCollide(objI, objJ):
continue
#Note, the shapes are at the origin, so we have to translate them
# to the objects current position
s1 = objI.shape.translate(objI.getPos())
s1vel = objI.vel
s2 = objJ.shape.translate(objJ.getPos())
s2vel = objJ.vel
#TODO: this will always return none!!!
colInfo = getCollisionInfo(s1,s1vel,s2,s2vel)
if colInfo is not None:
#only consider events <= time
colTime, objIStops, objJStops = colInfo
if colTime <= time:
#print colInfo
#if objI not in d:
# d[objI] = set([()])
l.append((colTime, objI, objIStops,objJ,objJStops))
####end of copied code
#check collision with other objects
for j in range(i+1, len(self.objectList)):
#objI = self.objectList[i]
objJ = self.objectList[j]
#If the objects can't collide, don't even bother
# comparing them
if not CollisionFilter.canCollide(objI, objJ):
continue
#Note, the shapes are at the origin, so we have to translate them
# to the objects current position
s1 = objI.shape.translate(objI.getPos())
s1vel = objI.vel
s2 = objJ.shape.translate(objJ.getPos())
s2vel = objJ.vel
#TODO: this will always return none!!!
colInfo = getCollisionInfo(s1,s1vel,s2,s2vel)
if colInfo is not None:
#only consider events <= time
colTime, objIStops, objJStops = colInfo
if colTime <= time:
#print colInfo
#if objI not in d:
# d[objI] = set([()])
l.append((colTime, objI, objIStops,objJ,objJStops))
return l
def __init__(self, pos, **kwargs): shape = Rect.createAtOrigin(30, 26) BasicUnit.__init__(self, pos, shape, name='SKELETON', **kwargs) self.rangedWeapon = BasicRangedAttack(self, 'bone', size=(14,14))
def __init__(self, pos, **kwargs): shape = Rect.createAtOrigin(20, 20) BasicUnit.__init__(self, pos, shape, name='ELF', **kwargs) self.rangedWeapon = BasicRangedAttack(self, 'rock',size=(12,12))
def __init__(self, pos, **kwargs): shape = Rect.createAtOrigin(32, 32) BasicUnit.__init__(self, pos, shape, name='ORC', **kwargs) self.rangedWeapon = KnifeThrower(self)
def get_rect(self):
return Rect(self.x, self.y, settings.goalie_width,
settings.goalie_height)
def helper(name):
room = Rect(2, 2, 10, 10)
return get_monster(0, 0, game_map, room, name, [])[0]
