def _initPhysic(self, position, angle):
self._body = physic.BaseBody(self, None,None)
self._body.position = position
self._body.angle = angle
points = [(0,0), (self.size[0],0), self.size, (0,self.size[1])]
points = map(lambda p: util.vectorSub(p, util.vectorMult(self.size, 0.5)),
points)
shape = pymunk.Poly(self._body, points)
shape.collision_type = physic.CannonCollisionType
shape.elasticity = 1
self._addShape(shape)
sensorPoints = map(lambda p: util.vectorMult(p, 0.9), points)
self._sensorShape = pymunk.Poly(self._body, sensorPoints)
self._sensorShape.sensor = True
self._addShape(self._sensorShape)
self._addLaunchAreaDivider()
def __init__(
self,
space,
parent,
position,
size=None,
angle=0,
rotationSpeed=0,
rotationEnabled=False,
theme=themes.DefaultTheme,
owner=None,
helpSystem=None,
):
AnnotatedObject.__init__(self, helpSystem)
self._size = size
assert size is None or len(size) == 2
self._space = space
self._parent = parent
self._theme = theme
self._owner = owner
self._rootParent = parent
self._hidden = False
self._hideLock = threading.Lock()
self._shapes = []
self._body = None
self._initPhysic(position, angle)
assert self._body is not None
self._root = avg.DivNode(parent=parent)
self._root.pivot = (0, 0)
if self.size is not None:
self._interactionDiv = avg.DivNode(parent=self._root)
self._interactionDiv.pos = util.vectorMult(self.size, -0.5)
self._interactionDiv.size = self.size
self._setInfoHandler(self._interactionDiv)
if __debug__:
self._interactionDiv.elementoutlinecolor = "FFFFFF"
else:
avg.Logger.get().trace(avg.Logger.WARNING, "{0} has no size".format(self))
self._initLibavg(parent)
self._setPosition(position)
self.angle = angle
self.alive = True
self._rotationSpeed = rotationSpeed
self._rotationEnabled = rotationEnabled
if rotationEnabled:
self._body.angular_velocity = rotationSpeed
def __init__(self, href, size, *args, **kwargs):
avg.DivNode.__init__(self, *args, **kwargs)
self.pivot = 0, 0
self.opacity = 1
self.sensitive = False
imageNode = avg.ImageNode(parent=self, opacity=1, href=href, size=size)
imageNode.pos = util.vectorMult(size, -0.5)
self.image = imageNode
if __debug__:
self.elementoutlinecolor = "FFFFFF"
def __init__(self, space, pos, size):
self.points = []
self.points.append(tuple(pos))
self.points.append((pos[0], pos[1] + size[1]))
self.points.append((pos[0]+ size[0], pos[1]+size[1]))
self.points.append((pos[0]+ size[0], pos[1]))
inertia = pymunk.moment_for_box(1, size[0], size[1])
pymunk.Body.__init__(self, 1, inertia)
self.shape = pymunk.Poly(self, self.points, util.vectorMult(size, -0.5))
space.add(self, self.shape)
def _placeInfoElements(self, button, box):
angle = math.pi/2
baseDisplacement = math.sqrt(2*(self.size[0]**2)) /2.0
infoBoxElementAdjustemnt = util.getVectotInDirection(angle,
-baseDisplacement - box.size[1]/2)
buttonPos = (-self.size[0]*0.23, self.size[1]*0.27)
button.size = util.vectorMult(self.size, 0.20)
util.centerNodeOnPosition(button, buttonPos)
util.centerNodeOnPosition(box, infoBoxElementAdjustemnt)
util.centerNodeOnPosition(box, infoBoxElementAdjustemnt)
def shoot(self):
elementToShoot = self.getAggressionElement()
if elementToShoot is None:
return
spots = self.checkForSpace(elementToShoot)
if spots:
from geneacrystal.gameElements import items
spot = self.toAbsPos(random.choice(spots))
c = items.BulletCrystal(self._space, self._root.getParent(), spot, helpSystem=self._helpSystem)
impuls = util.vectorSub(c.position, self.toAbsPos(elementToShoot.position))
impuls = util.vectorMult(impuls, 10)
c._body.apply_impulse(impuls)
def __init__(self, layers, size, *args, **kwargs):
avg.DivNode.__init__(self, *args, **kwargs)
self.pivot = 0, 0
self.opacity = 1
self.sensitive = False
childPos = util.vectorMult(size, -0.5)
self._layer = []
self._topImage = None
for image in layers:
node = avg.ImageNode(parent=self, opacity=1, href=image, size=size, pos=childPos, sensitive=False)
self._layer.append(node)
node.sensitive = True
self._topImage = self._layer[-1]
def _addImpulseForDrag(self, event, offset):
if not self.alive:
return
managers = list(self._helpSystem.getPlayerManagersForEvent(event))
if managers:
self._takeOwner(managers[0])
impuls = util.vectorLength(event.speed) * 100
impuls = max(300, impuls)
impuls = min(impuls, 1000)
direction = util.vectorNormalize(offset)
self._body.apply_impulse(util.vectorMult(direction, impuls))
def _initGameElements(self, parent):
gameElement = CenterNodeStructure(radius=50,
space=self.space,
rotationSpeed=self._structureStartRotationSpeed,
framesToGrowth= self._structureFramesToGrowth,
startCrystals=self._structureStartSize,
position=util.vectorMult(util.WINDOW_SIZE, 0.5),
parent=parent,
helpSystem=self._helpSystem,
crystalManager=self._generator,
)
gameElement.depletedCallback = lambda: self._winCB(showKeyboards=False)
gameElement.gameOverCallback = lambda: self._winCB(showKeyboards=False)
self.structures.append(gameElement)
def getOffscreenPosForElement(self, pos):
return util.vectorAdd(pos, util.vectorMult(self._canvasRoot.size, 0.5))
def _makeExitButton(self):
pos = self.size[0]*0.125, self.size[1] *0.165
self._exitButton = StaticOverlayNode(self.delete, parent=self._root,
size=util.vectorMult(self.size, 0.2),
pos=pos)
def _makeExitButton(self):
pos = -self.size[0]*0.29, -self.size[1] *0.29
self._exitButton = StaticOverlayNode(self.delete, parent=self._root,
size=util.vectorMult(self.size, 0.25),
pos=pos,
angle=math.pi/4)
def _getSpawnPos(self):
spawnPos = util.vectorMult((self.size[0], -self.size[1]), 0.5)
spawnPos = util.vectorSub(spawnPos, (util.CRYSTAL_SIZE,-util.CRYSTAL_SIZE))
spawnPos = self._root.getAbsPos(spawnPos)
return spawnPos
