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 update(self): dirX = Ctrl.getController().direction.x if dirX > 0 and not self.core.moveForbidFlag: self.rollAmount += self.ROLL_SPEED elif dirX < 0 and not self.core.moveForbidFlag: self.rollAmount -= self.ROLL_SPEED else: if self.rollAmount < 0: self.rollAmount += self.ROLL_SPEED if self.rollAmount > 0: self.rollAmount = 0 elif self.rollAmount > 0: self.rollAmount -= self.ROLL_SPEED if self.rollAmount < 0: self.rollAmount = 0 self._setDrawParam() if not self.hitMarkerAnimation.playing: self.hitMarkerAnimation.play() else: self.hitMarkerAnimation.update() updateDst(self.hitMarkerAnimation, self.core.position, self.HIT_MARKER_SIZE) if not self.backFireAnimation.playing: self.backFireAnimation.play() else: self.backFireAnimation.update() updateDst(self.backFireAnimation, self.backFirePos, self.BACK_FIRE_SIZE)
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 _input(self): controller = Ctrl.getController() if not self.disappeared: if not self.moveForbidFlag: self.locator.speed = controller.direction * self.moveSpeed self.locator.update() pos = self.locator.position size = self.shipSize rightBorder = Std.Consts.ScreenSize.x - Std.Consts.StgInfAreaSize.x bottomBorder = Std.Consts.ScreenSize.y if pos.x - size.x/2 < 0: pos.x = size.x/2 elif pos.x + size.x/2 > rightBorder: pos.x = rightBorder - size.x/2 if pos.y - size.y/2 < 0: pos.y = size.y/2 elif pos.y + size.y/2 > bottomBorder: pos.y = bottomBorder - size.y/2 self.locator.position = pos if(not self.shotForbidFlag and controller.isHold(Std.Input.KeyId.Z)): self.shot() if(not self.specialAttackForbidFlag and controller.isPush(Std.Input.KeyId.X)): self.specialAttack()
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 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, validRect): self.valid = True self.setValidAreaMargin(self.INIT_VALID_AREA_MARGIN) self.validRect = validRect self.validFrameNum = self.INIT_VALID_FRAME_NUM self.frameCount = 0 self.frameCounting = True self._objectId = Ctrl.genObjectId()
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 update(self): self.onUpdate() if not self.finish: if not self._currentStage is None: self._currentStage.update() if self._currentStage is None: self._currentStage = Ctrl.getNextStage() self._currentStage._internalPyObject.stageSetRef = weakref.ref(self) elif self._currentStage.end: nextStage = Ctrl.getNextStage() if nextStage is None: self.finish = True self.onFinish() else: nextStage._internalPyObject.stageSetRef = weakref.ref(self) self._currentStage = nextStage self.infArea.update()
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 onUpdate(self): if self.levelChangeWaitCount > 0: self.levelChangeWaitCount -= 1 controller = Ctrl.getController() if(controller.isHold(Std.Input.KeyId.C) and self.levelChangeWaitCount == 0): def change(level): self.level += level self.levelChangeWaitCount = 60 self.core.lockManager.adjust() self.core.resource.se_ChangeOption.play() dirY = controller.direction.y if dirY < -0.3 and self.level < self.maxLevel: change(1) elif dirY > 0.3 and self.level > 1: change(-1)
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 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 onUpdate(self): self.slow = Ctrl.getController().isHold(Std.Input.KeyId.LShift) self.drawing.update() self.shipLauncher.update() self.optionManager.update() if self.spFrameCount > 0: self.spFrameCount -= 1 if self.spFrameCount <= 0: self.spFinished() elif self.spFrameCount == 60: self.drawing.spFinishingAnimation.play() if self.spFinishedForceFrameCount > 0: self.applySpFinishedForce() self.spFinishedForceFrameCount -= 1
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 __init__(self, core):
controller = Ctrl.getController()
def task():
yes = 0
no = 1
arrow = Std.ArrowLocator(yes, yes, no)
arrow.controller = controller
arrow.setMoveCallback(lambda: core.resource.se_Select1.play())
def drawTask():
basePos = Std.Point2DF(100, 200)
color = Std.ColorF()
while True:
font = core.resource.font_Common32
font.setPriority(Ctrl.DrawPriority.pauseStr)
font.shakable = False
font.draw(basePos, color, "コンティニューしますか？")
for i in range(no + 1):
dst = Std.Point2DF(basePos.x, basePos.y + font.size * (i + 1))
if i == yes:
font.draw(dst, color, "はい")
elif i == no:
font.draw(dst, color, "いいえ")
dst = Std.Point2DF(basePos.x - font.size, basePos.y + font.size * (arrow.position + 1))
font.draw(dst, color, "→")
yield
self.drawTask = Coroutine(drawTask)
while True:
arrow.update()
if controller.isPush(Std.Input.KeyId.Z):
core.resource.se_Select3.play()
if arrow.position == yes:
core.end = True
self.drawTask = None
elif arrow.position == no:
core.fadeOut(30, lambda: Std.Scene.changeScene(GameOverScene()))
yield
self.task = Coroutine(task)
self.drawTask = None
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 __init__(self, core): controller = Ctrl.getController() def task(): yes = 0; no = 1 arrow = Std.ArrowLocator(yes, yes, no) arrow.controller = controller def drawTask(): basePos = Std.Point2DF(100, 200) color = Std.ColorF() while True: font = Resource.getFont( "font32", Ctrl.DrawPriority.pauseStr, False, 32) font.draw(basePos, color, "コンティニューしますか？") for i in range(no + 1): dst = Std.Point2DF( basePos.x, basePos.y + font.size*(i + 1)) if i == yes: font.draw(dst, color, "はい") elif i == no: font.draw(dst, color, "いいえ") dst = Std.Point2DF( basePos.x - font.size, basePos.y + font.size*(arrow.position + 1)) font.draw(dst, color, "→") yield self.drawTask = Coroutine(drawTask) while True: arrow.update() if controller.isPush(Std.Input.KeyId.Z): if arrow.position == yes: core.end = True self.drawTask = None elif arrow.position == no: core.fadeOut( 30, lambda : Std.Scene.changeToSTGTitle()) yield self.task = Coroutine(task) self.drawTask = None
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 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 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 selectTask(): arrow = Std.ArrowLocator( initPos, enum.returnToGame, enum.option) arrow.setMoveCallback(lambda: core.resource.se_Select1.play()) def drawTask(): basePos = Std.Point2DF(100, 200) color = Std.ColorF() while True: font = core.resource.font_Common32 font.setPriority(Ctrl.DrawPriority.pauseStr) font.shakable = False for i in range(enum.option + 1): dst = Std.Point2DF(basePos.x, basePos.y + font.size*i) if i == enum.returnToGame: font.draw(dst, color, "ゲームに戻る") elif i == enum.restart: font.draw(dst, color, "最初から始める") elif i == enum.returnToTitle: font.draw(dst, color, "タイトル画面へ") elif i == enum.option: font.draw(dst, color, "オプション") dst = Std.Point2DF( basePos.x - font.size, basePos.y + font.size*arrow.position) font.draw(dst, color, "→") yield self.drawTask = Coroutine(drawTask) while True: arrow.update() if(controller.isPush(Std.Input.KeyId.Space) or controller.isPush(Std.Input.KeyId.X)): core.resource.se_Cancel.play() core.end = True self.drawTask = None elif controller.isPush(Std.Input.KeyId.Z): def confirmTask(action): yes = 0; no = 1 confArrow = Std.ArrowLocator(no, yes, no) confArrow.setMoveCallback(lambda: core.resource.se_Select1.play()) def confDrawTask(): basePos = Std.Point2DF(100, 200) color = Std.ColorF() while True: font = core.resource.font_Common32 font.setPriority(Ctrl.DrawPriority.pauseStr) font.shakable = False font.draw(basePos, color, "本当に？") for i in range(no + 1): dst = Std.Point2DF( basePos.x, basePos.y + font.size*(i + 1)) if i == yes: font.draw(dst, color, "はい") elif i == no: font.draw(dst, color, "いいえ") dst = Std.Point2DF( basePos.x - font.size, basePos.y + font.size*(confArrow.position + 1)) font.draw(dst, color, "→") yield self.drawTask = Coroutine(confDrawTask) while True: confArrow.update() if controller.isPush(Std.Input.KeyId.X): core.resource.se_Cancel.play() break elif controller.isPush(Std.Input.KeyId.Z): if confArrow.position == yes: core.resource.se_Select3.play() core.fadeOut(30, action) elif confArrow.position == no: core.resource.se_Cancel.play() break yield self.drawTask = Coroutine(drawTask) if arrow.position == enum.returnToGame: core.resource.se_Cancel.play() core.end = True self.drawTask = None elif arrow.position == enum.restart: core.resource.se_Select2.play() confTask = Coroutine(confirmTask) yield while confTask.alive: confTask.resume(lambda : Ctrl.restart()) yield elif arrow.position == enum.returnToTitle: core.resource.se_Select2.play() confTask = Coroutine(confirmTask) yield while confTask.alive: confTask.resume(lambda : Std.Scene.changeToSTGTitle()) yield elif arrow.position == enum.option: core.resource.se_Select2.play() core.view = OptionTop(core) yield
