def _main(self): def launch(pos, drawParam, num, baseSpeed): drawParam.dst = pos.makeRect( drawParam.dst.w, drawParam.dst.h, True) NWay.launchLinearCircle( pos, self.angle, num, int(drawParam.dst.w/4), drawParam, baseSpeed) drawParam = Auxs.createBulletRedDrawParam( self.pos, Std.Vector2DF(16, 16)) launch(self.pos, drawParam, self.regulation.circleBulletNum, self.regulation.circleBulletSpeed) rand = Ctrl.getRandom() drawParam = Auxs.createBulletRedDrawParam( self.pos, Std.Vector2DF(16, 8)) for _ in range(int(self.regulation.randomBulletLaunchFrameNum)): for _ in range(int(self.regulation.randomBulletLaunchNum)): posVariance = Std.Vector2DF( rand.getFloat(*self.regulation.randomBulletPosVariance), rand.getFloat(*self.regulation.randomBulletPosVariance)) pos = self.pos + posVariance launch(pos, drawParam, 1, self.regulation.randomBulletSpeed) yield
def __init__(self, core, pos, angle, toggle, radius, baseDamage, spAttack = False): if not spAttack: size = Std.Vector2DF(radius * 2, 96) else: size = Std.Vector2DF(radius * 2, 128) drawParam = Std.Sprite.DrawParam() super().__init__(core, pos, angle, radius, size, self.SPEED, baseDamage, self.DAMAGE_RATE_DEC, self.DAMAGE_RATE_MIN, self.LOCK_SPEED, drawParam, 90, core.resource.se_ShotHit) self.hp = Regulation.lockMainShotAttenuationResistance self.toggle = toggle self.particleSize = Std.Vector2DF(radius * 6, radius * 6) if not spAttack: drawParam.color.a = 0.8 if toggle: drawParam.texture = core.resource.lockMainShot_1 else: drawParam.texture = core.resource.lockMainShot_2 else: drawParam.alphaBlend = Std.Sprite.AlphaBlend.Add drawParam.color.a = 0.6 if Ctrl.getRandom().getBool(): drawParam.flipX() if toggle: drawParam.texture = core.resource.spLockMainShot_1 else: drawParam.texture = core.resource.spLockMainShot_2 drawParam.src = Std.RectF(0, 0, 128, 256) drawParam.dst = self.locator.position.makeRect(size, True) drawParam.priority = Ctrl.DrawPriority.myShot drawParam.rotDegree = angle + 90
def createParticle(self, num = 1, priority = Ctrl.DrawPriority.enemyBulletB1, sizeRate = 0.3, speed = 1): rand = Ctrl.getRandom() drawParam = Std.Sprite.DrawParam() drawParam.texture = self.drawParam.texture drawParam.src = Std.RectF(0, 0, 64, 64) drawParam.dst = self.locator.position.makeRect(self.size * sizeRate, True) drawParam.priority = priority drawParam.alphaBlend = Std.Sprite.AlphaBlend.Add drawParam.rotDegree = rand.getFloat(-180, 180) param = Auxs.Particle.Param() param.drawParameter = drawParam param.setPosition(self.locator.position) param.setSpeedRange(speed * 0.5, speed * 1.5) param.setZoomRateRange(0.8, 1) param.setZoomDecRateRange(0.015, 0.025) param.setRotSpeedRange(self.rotSpeed - 0.5, self.rotSpeed + 0.5) creator = Auxs.Particle.Creator(param) creator.create(num)
def updateDestruction(self): Auxs.eraseBullets() frameCount = 0 explosionInterval = Std.RepeatCounter(3) random = Ctrl.getRandom() self.locator.accel.setUnitVector(90) self.locator.accel *= 0.08 while frameCount < 60: explosionInterval.update() for _ in range(explosionInterval.repeatCount): offset = Std.Vector2DF( random.getFloat(-self.SIZE.x/2, self.SIZE.x/2), random.getFloat(-self.SIZE.y/2, self.SIZE.y/2)) Auxs.createExplosion( self.locator.position + offset, self.EXPLOSION_SIZE / 2.0) frameCount += 1 yield else: Std.Sprite.setShake(20, 0.3) Auxs.createExplosion( self.position, self.EXPLOSION_SIZE, 2) self.valid = False
def __init__(self, core, position, angle): super().__init__(position, self.RADIUS, self.BASE_DAMAGE) self.noDamage = True self.core = core self.prevValidArea = self.isHitRect(self.VALID_AREA) self.locator = Std.Locator.LinearF(position) self.locator.speed.setUnitVector(angle) self.locator.speed *= self.SPEED self.damageRateDec = self.DAMAGE_RATE_DEC self.damageRateMin = self.DAMAGE_RATE_MIN self.blast = PlasmaBlast(self.core, self.position) self.blasted = False drawParam = Std.Sprite.DrawParam() drawParam.src = Std.RectF(0, 0, 64, 64) drawParam.dst = position.makeRect(self.SIZE, True) drawParam.priority = Ctrl.DrawPriority.myShot self.animation = createSequenceAnimation( core.resource.plasmaBallTexList, drawParam) rand = Ctrl.getRandom() self.animation.play( rand.getInt(0, self.animation.frameHolder.frameNum - 1)) self.se_PlasmaBlast = core.resource.se_PlasmaBlast
def getVariantVector(self, baseVector, variantVector): rand = Ctrl.getRandom() vx = rand.getFloat( baseVector.x - variantVector.x, baseVector.x + variantVector.x) vy = rand.getFloat( baseVector.y - variantVector.y, baseVector.y + variantVector.y) return Std.Vector2DF(vx, vy)
def createSpNormalShot(core, pos, angle, damage, paDamage, damageToBullet, shotHp, damageKickbackRateToBullet = 1.0): speed = Regulation.spNormalShotSpeed radius = 32 damageRateDec = Regulation.spNormalShotDamageRateDecrease damageRateMin = Regulation.spNormalShotDamageRateMin rand = Ctrl.getRandom() drawParam = Std.Sprite.DrawParam() drawParam.texture = core.resource.spNormalShot drawParam.src = Std.RectF(0, 0, 128, 256) drawParam.dst = pos.makeRect(radius*2, 96, True) drawParam.priority = Ctrl.DrawPriority.myShot drawParam.rotDegree = angle + 90 drawParam.alphaBlend = Std.Sprite.AlphaBlend.Add drawParam.color.a = 0.6 if rand.getBool(): drawParam.flipX() particleSize = Std.Vector2DF(radius*6, radius*6) vanishDrawParam = Std.Sprite.DrawParam() vanishDrawParam.src = Std.RectF(0, 0, 128, 128) vanishDrawParam.dst = pos.makeRect(particleSize, True) vanishDrawParam.priority = Ctrl.DrawPriority.myShot vanishDrawParam.alphaBlend = Std.Sprite.AlphaBlend.Add vanishDrawParam.color.a = 0.3 if rand.getBool(): vanishDrawParam.flipX() vanishAnimation = createSequenceAnimation( core.resource.spNormalParticleTexList, vanishDrawParam) vanishAnimation.frameInterval = 0.4 shot = createSimpleShot( pos, angle, speed, radius, damage, damageRateDec, damageRateMin, paDamage, drawParam, 90, vanishAnimation, core.resource.se_ShotHit) shot.hp = shotHp shot.damageToBullet = damageToBullet shot.damageKickbackRateToBullet = damageKickbackRateToBullet def damageToBulletCallback(locator): drawParam = Std.Sprite.DrawParam(vanishDrawParam) drawParam.rotDegree = locator.speed.getAngle() + 90 drawParam.alphaBlend = Std.Sprite.AlphaBlend.Add drawParam.color.a = 0.3 if rand.getBool(): drawParam.flipX() animation = createSequenceAnimation( core.resource.spNormalParticleTexList, drawParam) animation.frameInterval = 0.4 rect = Std.Hit.RectI(locator.position, particleSize, True) animeObj = Auxs.Animation(rect, animation) Ctrl.Actor.registerActor(animeObj) shot.setDamageToBulletCallback(damageToBulletCallback)
def onUpdate(self):
self.locator.update()
rand = Ctrl.getRandom()
vibration = Std.Vector2DF(rand.getFloat(*self.POS_VARIANCE), rand.getFloat(*self.POS_VARIANCE))
self.pos = self.locator.position + vibration
if self.task.alive:
self.task.resume()
self.drawParam.dst = self.position.makeRect(self.SIZE, True)
def _createTree(self): rand = Ctrl.getRandom() pos = Std.Vector2DF() pos.x = rand.getFloat( -_Tree.VALID_SIZE.x/2, Std.Consts.ScreenSize.x - Std.Consts.StgInfAreaSize.x + _Tree.VALID_SIZE.x/2) pos.y = -_Tree.VALID_SIZE.y / 2 tree = _Tree(pos, self.stageSet) Ctrl.Actor.registerActor(tree) self.treeList.insert(0, tree)
def wait(self): random = Ctrl.getRandom() waitCount = 60 * 10 while waitCount > 0: if waitCount % 20 == 0: idiot01 = Idiot01( Std.Vector2DF(random.getFloat(0, 440), -32), self.stage.resource, self.stageSetRef().scoreManager) Ctrl.Actor.registerEnemy(idiot01) waitCount -= 1 yield
def task(self, bit):
rotSpeed = 15
if not self.clockwise:
rotSpeed *= -1
rotSum = 0
while abs(rotSum) < 360:
bit.angle += rotSpeed
rotSum += rotSpeed
yield
bit.circling.circling = True
bit.circling.circlingAngle = 15
wait = createWait(self.regulation.aimingFrameNum)
rand = Ctrl.getRandom()
angleError = rand.getFloat(*self.regulation.angleError)
while wait():
targetAngle = bit.locator.position.getAngle(Ctrl.Actor.myShip.position) + angleError
bit.circling.targetAngle = targetAngle
yield
bit.circling.circling = False
bit.circling.circlingAngle = bit.CIRCLING_ANGLE
if self.clockwise:
crossLaunchAngle = bit.angle - 90
else:
crossLaunchAngle = bit.angle + 90
cross = _TracingCross(self.core.resource, bit.nozzlePos, crossLaunchAngle, self.rank, self.clockwise)
Ctrl.Actor.registerBullet(cross)
drawParam = Auxs.createBulletRedDrawParam(bit.nozzlePos, Std.Vector2DF(16, 8))
for i in range(int(self.regulation.launchRepeat)):
NWay.launchLinear(
bit.nozzlePos,
bit.angle,
self.regulation.angleInterval,
self.regulation.wayNum,
int(drawParam.dst.w / 2),
drawParam,
self.regulation.speed(i),
self.regulation.accel(i),
)
wait = createWait(self.regulation.launchInterval)
while wait():
yield
wait = createWait(self.regulation.endWait)
while wait():
yield
def __init__(self, locator, size, relPos, drawParam): self.locator = locator self.stdSize = size self.size = size * 6 self.relPos = relPos self.appeared = False self.drawParam = drawParam self.drawParam.color.a = 0 self.drawParam.rotDegree = Ctrl.getRandom().getFloat(-180, 180) self.taskList = [] self.taskList.append(Coroutine(self._alphaTask)) self.taskList.append(Coroutine(self._sizeTask)) self.taskList.append(Coroutine(self._rotateTask))
def launch(): rand = Ctrl.getRandom() while True: drawParam = Auxs.createBulletRedDrawParam( bit.nozzlePos, Std.Vector2DF(16, 8)) NWay.launchLinear( bit.nozzlePos, bit.circling.angle, self.regulation.angleInterval, self.regulation.wayNum, int(drawParam.dst.w/2), drawParam, self.regulation.speed) launchWait = createWait( rand.getFloat(*self.regulation.launchInterval)) while launchWait(): yield
def __init__(self, core, position): super().__init__(position, self.RADIUS, self.BASE_DAMAGE) self.noDamage = True self.locator = Std.Locator.LinearF(position) self.paBaseDamage = self.PA_BASE_DAMAGE self.forcibleForPA = True self.frameCounnt = self.LONGEVITY drawParam = Std.Sprite.DrawParam() drawParam.src = Std.RectF(0, 0, 128, 128) drawParam.dst = position.makeRect(self.SIZE, True) drawParam.priority = Ctrl.DrawPriority.myShot self.animation = createSequenceAnimation( core.resource.plasmaBlastTexList, drawParam) rand = Ctrl.getRandom() self.animation.play( rand.getInt(0, self.animation.frameHolder.frameNum - 1))
def onErase(self): dst = self.position.makeRect(self.particleSize, True) drawParam = Std.Sprite.DrawParam() drawParam.src = Std.RectF(0, 0, 128, 128) drawParam.dst = dst drawParam.priority = Ctrl.DrawPriority.myShot drawParam.rotDegree = self.drawParam.rotDegree if Ctrl.getRandom().getBool(): drawParam.flipX() if self.toggle: texList = self.core.resource.lockMainParticleTexList_1 else: texList = self.core.resource.lockMainParticleTexList_2 animation = createSequenceAnimation(texList, drawParam) animation.frameInterval = 0.6 animeObj = Auxs.Animation(Std.Hit.RectI(dst), animation) Ctrl.Actor.registerActor(animeObj)
def update(self): if self.controlFlag: targetDistance = self.core.locator.position.getDistance( self.core.locator.targetPosition) if(self.changeTargetCount == self.CHANGE_TARGET_FREQUENCY or targetDistance <= self.baseSpeed): random = Ctrl.getRandom() nextTargetPos = Std.Vector2DF() while True: randX = random.getFloat(0, self.MOVE_AREA_SIZE.x) randX -= self.MOVE_AREA_SIZE.x / 2 randY = random.getFloat(0, self.MOVE_AREA_SIZE.y) randY -= self.MOVE_AREA_SIZE.y / 2 nextTargetPos = Std.Vector2DF( self.basePos.x + randX, self.basePos.y + randY) nextTargetDistance = self.core.locator.position.getDistance(nextTargetPos) if nextTargetDistance > self.baseSpeed: break self.core.locator.targetPosition = nextTargetPos self.changeTargetCount = 0 else: self.changeTargetCount += 1 self.core.locator.update() if self.controlFlag: currentSpeed = self.core.locator.speed.getAbs() speedDir = self.core.locator.speed.getAngle() self.core.locator.speed.setUnitVector(speedDir) if currentSpeed > self.baseSpeed: if currentSpeed - self.SPEED_CORRECTION_AMOUNT < self.baseSpeed: self.core.locator.speed *= self.baseSpeed else: self.core.locator.speed *= currentSpeed - self.SPEED_CORRECTION_AMOUNT elif currentSpeed < self.baseSpeed: if currentSpeed + self.SPEED_CORRECTION_AMOUNT > self.baseSpeed: self.core.locator.speed *= self.baseSpeed else: self.core.locator.speed *= currentSpeed + self.SPEED_CORRECTION_AMOUNT
def update(self): self.repCounter.update() rand = Ctrl.getRandom() for _ in range(self.repCounter.repeatCount): pos = self._getPos() baseAngle = 90 + rand.getFloat(-45, 45) drawParam = Auxs.createBulletBlueDrawParam( pos, Std.Vector2DF(16, 16)) drawParam.dst = pos.makeRect( drawParam.dst.w, drawParam.dst.h, True) NWay.launchLinear( pos, baseAngle, self.regulation.angleInterval, self.regulation.wayNum, int(drawParam.dst.w/4), drawParam, self.regulation.speed)
def _destruct(self): self.core.destructBullets() self.core.move.controlFlag = False self.core.locator.tracing = False self.core.locator.accel *= 0 self.core.locator.speed = Std.Vector2DF(0, 0.2) self.core.primalArmor.enabled = False self.core.resource.se_BossDestruction1_1.play() for i in range(60 * 4 + 52): if i % 2 == 0: expObjList = self.core.drawing.createExplosion( Ctrl.DrawPriority.enemy4, 1, self.core.locator.position, 96, 0.7, Std.Vector2DF(100, 80), 0.3) for expObj in expObjList: angle = self.core.locator.position.getAngle( expObj.position) rand = Ctrl.getRandom() speed = rand.getFloat(0, 3) expObj.locator.speed.setUnitVector(angle) expObj.locator.speed *= speed yield self.core.resource.se_BossDestruction1_1.stop() self.core.resource.se_BossDestruction1_2.play() self.core.drawing.createExplosion( Ctrl.DrawPriority.enemy4, 50, self.core.locator.position, 384, 4, Std.Vector2DF(200, 150), 0.3) Std.Sprite.setShake(20, 0.2) self.core.valid = False
def createParticle(self): num = 20 size = Std.Vector2DF(self.size, self.size) speed = 2 rotSpeed = 6 drawParam = Std.Sprite.DrawParam(self.drawParam) drawParam.dst = self.position.makeRect(size, True) drawParam.priority = Ctrl.DrawPriority.scoreRate2 drawParam.color.a = 1 drawParam.rotDegree = Ctrl.getRandom().getFloat(-180, 180) param = Auxs.Particle.Param() param.drawParameter = drawParam param.setPosition(self.position) param.setSpeedRange(speed * 0.5, speed * 1.5) param.setZoomRateRange(0.8, 1.2) param.setZoomDecRateRange(0.015, 0.025) param.setRotSpeedRange(rotSpeed * 0.5, rotSpeed * 1.5) creator = Auxs.Particle.Creator(param) creator.create(num)
def createExplosion(self, drawPri, num, pos, size, frameItv = 1, posVariance = Std.Vector2DF(), sizeVarianceRate = 0, frameItvVarianceRate = 0): rand = Ctrl.getRandom() expObjList = [] for _ in range(num): sizeRate = rand.getFloat( -sizeVarianceRate, sizeVarianceRate) correctedSize = size + size*sizeRate itv = rand.getFloat( frameItv - frameItv*frameItvVarianceRate, frameItv + frameItv*frameItvVarianceRate) expObjList.append(Auxs.createExplosion2( self.getVariantVector(pos, posVariance), Std.Vector2DF(correctedSize, correctedSize), itv, drawPri)) return expObjList
def createSmoke(left): rand = Ctrl.getRandom() for _ in range(self.smokeRepCounter.repeatCount): pos = self.getVariantVector( self.core.locator.position, Std.Vector2DF(6, 24)) if left: pos.x += 150 - 76/2 else: pos.x -= 150 - 76/2 pos.y += 40 baseSize = Std.Vector2DF(48, 48) sizeRate = rand.getFloat(-0.5, 0.5) correctedSize = baseSize + baseSize*sizeRate smoke = Auxs.createSmoke( pos, correctedSize, 1, Ctrl.DrawPriority.enemy2, 0.2) smoke.locator.speed.y = 2
def _main(self): angleList = NWay.getAngleList( self.regulation.bitCreationBaseAngle, self.regulation.bitCreationAngleInterval, self.num) angleList.sort(reverse = True) while len(self.bitPairList) < self.num: bit = Bit(self.core.locator.position, angleList[len(self.bitPairList)], self.core.resource, self.core.scoreManager, self.rank) Ctrl.Actor.registerEnemy(bit) self.core.subEnemyObjList.append(bit) def initialControl(bit): bit.locator.tracing = False bit.circling.circling = False bit.locator.speed.setUnitVector(bit.angle) bit.locator.speed *= 6 bit.locator.accel.setUnitVector(bit.angle) bit.locator.accel *= -0.1 while bit.locator.speed.getAbs() > 1: yield bit.locator.speed *= 0 bit.locator.accel *= 0 bit.drawPriority = Ctrl.DrawPriority.enemy4 bitPair = [bit, Coroutine(initialControl)] self.bitPairList.append(bitPair) wait = createWait(self.regulation.bitCreationInterval) while wait(): yield def allTaskFinished(): finished = True for bitPair in self.bitPairList: if bitPair[1].alive: finished = False break if self.chainGun and self.chainGun.alive: finished = False return finished while not allTaskFinished(): yield self._initialized = True charging = False firstChoice = True prevTaskNum = None while self.bitPairList: if len(self.bitPairList) <= self.regulation.forceChargeBitNum and not charging: self.chainGun = None for bitPair in self.bitPairList: charge = Charge(self.rank) bitPair[1] = Coroutine(charge.task) charging = True if allTaskFinished(): self.chainGun = None for bitPair in self.bitPairList: bit = bitPair[0] bit.drawPriority = Ctrl.DrawPriority.enemy4 bit.locator.tracing = False bit.locator.speed *= 0 bit.locator.accel *= 0 bit.circling.circling = False bitTaskList = self.regulation.bitTaskList if not bitTaskList: rand = Ctrl.getRandom() if firstChoice: taskNum = rand.getInt(0, 1) else: while True: taskNum = rand.getInt(0, 3) if taskNum != prevTaskNum: break else: global taskListIndex if taskListIndex is None or taskListIndex == len(bitTaskList): taskListIndex = 0 taskNum = bitTaskList[taskListIndex] taskListIndex += 1 if taskNum == 0: for i in range(len(self.bitPairList)): if i < self.num / 2: aiming = Aiming(self.core, self.rank, False) else: aiming = Aiming(self.core, self.rank, True) self.bitPairList[i][1] = Coroutine(aiming.task) self.chainGun = ChainGun(self.core, self.rank) elif taskNum == 1: for i in range(len(self.bitPairList)): circle = CircleForm(self.core, self.num, i, self.rank) self.bitPairList[i][1] = Coroutine(circle.task) elif taskNum == 2: for i in range(len(self.bitPairList)): if i < len(self.bitPairList) / 2: clockwise = False else: clockwise = True tracingCross = LaunchTracingCross( self.core, clockwise, self.rank) self.bitPairList[i][1] = Coroutine(tracingCross.task) elif taskNum == 3: for bitPair in self.bitPairList: charge = Charge(self.rank) bitPair[1] = Coroutine(charge.task) charging = True firstChoice = False prevTaskNum = taskNum yield
def task(self, bit): wait = createWait(self.regulation.firstWait) while wait(): yield for _ in range(int(self.regulation.repeatNum)): if self.left: center = self.core.locator.position + Std.Vector2DF( *self.regulation.moveCenterPosOffset) else: offset = Std.Vector2DF(*self.regulation.moveCenterPosOffset) offset.x *= -1 center = self.core.locator.position + offset areaSizeX = self.regulation.moveAreaSize[0] / 2 areaSizeY = self.regulation.moveAreaSize[1] / 2 rand = Ctrl.getRandom() bitPos = center + Std.Vector2DF( rand.getFloat(-areaSizeX, areaSizeX), rand.getFloat(-areaSizeY, areaSizeY)) bit.locator.tracing = True bit.locator.maxCirclingAngle = 180 bit.locator.targetPosition = bitPos bit.locator.speed = Std.Vector2DF(1, 0) * 4 bit.locator.accel *= 0 wait = createWait( self.regulation.launchFrameNum + rand.getFloat(*self.regulation.launchFrameNumVariance)) launcher = None while wait(): if bit.locator.speed.getAbs() > 0.1: speedAngle = bit.locator.speed.getAngle() accel = Std.Vector2DF() accel.setUnitVector(speedAngle + 180) accel *= 0.1 bit.locator.accel = accel else: bit.locator.speed *= 0 bit.locator.accel *= 0 def launch(): for _ in range(int(self.regulation.launchRepeat)): drawParam = Auxs.createBulletRedDrawParam( bit.nozzlePos, Std.Vector2DF(16, 8)) NWay.launchLinear( bit.nozzlePos, bit.circling.angle, self.regulation.angleInterval, self.regulation.wayNum, int(drawParam.dst.w/2), drawParam, self.regulation.speed) launchWait = createWait(self.regulation.launchRepeatInterval) while launchWait(): yield if launcher is None: launcher = Coroutine(launch) if launcher.alive: launcher.resume() if not launcher is None and launcher.alive: bit.circling.circling = False else: targetAngle = bit.locator.position.getAngle( Ctrl.Actor.myShip.position) bit.circling.circling = True bit.circling.targetAngle = targetAngle yield
