Пример #1
0
	def __init__(self, ship):
		self.ship = ship
		
		self.shipDrawParam = Std.Sprite.DrawParam()
		self.shipDrawParam.texture = self.ship.resource.shipTexture
		self.shipDrawParam.src = Std.RectF(0, 0, 64, 64)
		self.shipDrawParam.dst = ship.position.makeRect(ship.SHIP_SIZE, True)
		self.shipDrawParam.priority = Ctrl.DrawPriority.myShip
		
		self.hitMarkDrawParam = Std.Sprite.DrawParam()
		self.hitMarkDrawParam.texture = CommonResource.get("bulletRed")
		self.hitMarkDrawParam.src = Std.RectF(0, 0, 64, 64)
		self.hitMarkDrawParam.dst = ship.position.makeRect(self.HIT_MARK_SIZE, True)
		self.hitMarkDrawParam.priority = Ctrl.DrawPriority.myShipHitMark
		self.hitMarkDrawParam.alphaBlend = Std.Sprite.AlphaBlend.Add
		
		self.barrierDrawParam = Std.Sprite.DrawParam()
		self.barrierDrawParam.texture = CommonResource.get("bulletBlue")
		self.barrierDrawParam.src = Std.RectF(0, 0, 64, 64)
		self.barrierDrawParam.dst = ship.position.makeRect(self.BARRIER_SIZE, True)
		self.barrierDrawParam.priority = Ctrl.DrawPriority.myBarrier
		self.barrierDrawParam.alphaBlend = Std.Sprite.AlphaBlend.Add
		
		spBeginDrawParam = Std.Sprite.DrawParam()
		spBeginDrawParam.src = Std.RectF(0, 0, 200, 200)
		spBeginDrawParam.dst = ship.position.makeRect(self.SPBEGIN_ANIME_SIZE, True)
		spBeginDrawParam.priority = Ctrl.DrawPriority.myShip2
		self.spBeginAnimation = createSequenceAnimation(
			ship.resource.spBeginTextureList, spBeginDrawParam)
		
		spFinishDrawParam = Std.Sprite.DrawParam()
		spFinishDrawParam.src = Std.RectF(0, 0, 200, 200)
		spFinishDrawParam.dst = ship.position.makeRect(
			self.SPFINISH_ANIME_SIZE, True)
		spFinishDrawParam.priority = Ctrl.DrawPriority.myShip2
		self.spFinishAnimation = createSequenceAnimation(
			ship.resource.spFinishTextureList, spFinishDrawParam)
		
		spFinishingDrawParam = Std.Sprite.DrawParam()
		spFinishingDrawParam.src = Std.RectF(0, 0, 200, 200)
		spFinishingDrawParam.dst = ship.position.makeRect(
			self.SPFINISHING_ANIME_SIZE, True)
		spFinishingDrawParam.priority = Ctrl.DrawPriority.myShip2
		self.spFinishingAnimation = createSequenceAnimation(
			ship.resource.spFinishingTextureList, spFinishingDrawParam)
		
		spGaugeDrawParam = Std.Sprite.DrawParam()
		spGaugeDrawParam.src = Std.RectF(0, 0, 64, 64)
		spGaugeDrawParam.dst = ship.position.makeRect(
			self.SPGAUGE_ANIME_SIZE, True)
		spGaugeDrawParam.priority = Ctrl.DrawPriority.myShip2
		self.spGaugeAnimation = createSequenceAnimation(
			ship.resource.spGaugeTextureList, spGaugeDrawParam)
Пример #2
0
	def drawInfArea(self, basePos):
		font = CommonResource.getFont("font32", 
			Ctrl.DrawPriority.infAreaStr, False, 24)
		rect = Std.RectF(basePos.x, basePos.y, 
			Std.Consts.StgInfAreaSize.x, 32)
		offset = Std.Point2DF()
		color = Std.ColorF()
		
		def repeatStr(count):
			string = "*" * count
			font.drawLeft(rect, offset, color, string)
		
		font.drawLeft(rect, offset, color, "Player:")
		rect.y += 32
		if self.ship.remainder > 0:
			repeatStr(self.ship.remainder - 1)
		
		rect.y += 32
		font.drawLeft(rect, offset, color, "Power:")
		rect.y += 32
		repeatStr(self.ship.powerCount)
		
		rect.y += 32
		font.drawLeft(rect, offset, color, "SpAttack:")
		rect.y += 32
		repeatStr(self.ship.spAttackCount)
Пример #3
0
							def dirConfigDrawTask():
								color = Std.ColorF()
								dst = Std.Point2DF(120, 220)
								while True:
									font = Resource.getFont(
										"font32", drawPriority.str, False, 32)
									font.draw(dst, color, message)
									yield
Пример #4
0
	def __init__(self, core, size = Std.Vector2DF(86, 86)):
		self.core = core
		self.size = size
		
		self.drawParam = Std.Sprite.DrawParam()
		self.drawParam.texture = CommonResource.get("bulletBlue")
		self.drawParam.src = Std.RectF(0, 0, 64, 64)
		self.drawParam.dst = core.locator.position.makeRect(size, True)
		self.drawParam.priority = Ctrl.DrawPriority.myBarrier
		self.drawParam.alphaBlend = Std.Sprite.AlphaBlend.Add
Пример #5
0
	def drawInfArea(self, drawRect):
		font = Resource.getFont(
			"font32", Ctrl.DrawPriority.infAreaStr, False, 24)
		offset = Std.Point2DF()
		color = Std.ColorF()
		
		font.drawLeft(drawRect, offset, color, "HighScore:")
		drawRect.y += 32
		font.drawRight(drawRect, offset, color, str(self.highScore))
		
		drawRect.y += 32
		font.drawLeft(drawRect, offset, color, "Score:")
		drawRect.y += 32
		font.drawRight(drawRect, offset, color, str(self.score))
		
		font = Resource.getFont(
			"font16", Ctrl.DrawPriority.infAreaStr, False, 16)
		drawRect.y += 24
		rateStr = "Rate: %.2f" % self.rate
		font.drawRight(drawRect, offset, color, rateStr)
Пример #6
0
	def __init__(self, basicScoreManager = None):
		self.scoreManager = basicScoreManager
		
		self.drawParam = Std.Sprite.DrawParam()
		self.drawParam.texture = Resource.get("infAreaBack")
		self.drawParam.src = Std.RectF(0, 0, 200, 480)
		self.drawParam.dst = Std.RectF(
			Std.Consts.ScreenSize.x - Std.Consts.StgInfAreaSize.x, 
			0, 
			Std.Consts.StgInfAreaSize.x, 
			Std.Consts.StgInfAreaSize.y)
		self.drawParam.priority = Ctrl.DrawPriority.infAreaBack
		self.drawParam.shakable = False
Пример #7
0
			def drawTask():
				basePos = Std.Point2DF(420, 260)
				color = Std.ColorF()
				while True:
					font = Resource.getFont(
						"font32", drawPriority.str, False, 32)
					for i in range(len(infoList)):
						dst = Std.Point2DF(basePos.x, basePos.y + font.size*i)
						font.draw(dst, color, infoList[i][1])
					dst = Std.Point2DF(
						basePos.x - font.size, 
						basePos.y + font.size*arrow.position)
					font.draw(dst, color, "→")
					yield
Пример #8
0
	def __init__(self, position, angle):
		super().__init__(position, self.RADIUS, self.BASE_DAMAGE)
		
		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.drawParam = Std.Sprite.DrawParam()
		self.drawParam.texture = CommonResource.get("bulletGreen")
		self.drawParam.src = Std.RectF(0, 0, 64, 64)
		self.drawParam.dst = self.locator.position.makeRect(self.SIZE, True)
		self.drawParam.priority = Ctrl.DrawPriority.myShot
		self.drawParam.rotDegree = angle
		self.drawParam.color = Std.ColorF(1, 1, 1, 0.8)
Пример #9
0
			def drawTask():
				basePos = Std.Point2DF(380, 260)
				color = Std.ColorF()
				while True:
					font = Resource.getFont(
						"font32", drawPriority.str, False, 32)
					for i in range(enum.window + 1):
						dst = Std.Point2DF(basePos.x, basePos.y + font.size*i)
						if i == enum.full:
							font.draw(dst, color, "FullScreen")
						elif i == enum.window:
							font.draw(dst, color, "Window")
					dst = Std.Point2DF(
						basePos.x - font.size, 
						basePos.y + font.size*arrow.position)
					font.draw(dst, color, "→")
					yield
Пример #10
0
 def confDrawTask():
     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 * (confArrow.position + 1)
         )
         font.draw(dst, color, "→")
         yield
Пример #11
0
	def __init__(self, pos, radius):
		super().__init__(
			Std.Hit.RectI(pos, radius*2, radius*2, True))
		self.hitCircle = Std.Hit.CircleI(pos, radius)
		self.hitRect = Std.Hit.RectI(pos, radius*2, radius*2, True)
		self.hp = self.INIT_HP
		self.damagedEffectScale = 2
		
		self.damagedDrawParam = Std.Sprite.DrawParam()
		self.damagedDrawParam.texture = CommonResource.get("bulletDamagedEffect")
		self.damagedDrawParam.src = Std.RectF(0, 0, 64, 64)
		self.damagedDrawParam.dst = pos.makeRect(
			radius*2 * self.damagedEffectScale, 
			radius*2 * self.damagedEffectScale, 
			True)
		self.damagedDrawParam.priority = Ctrl.DrawPriority.enemyBulletDamaged
		self.damagedDrawParam.color = Std.ColorF(1, 1, 1, 0)
		self.damagedDrawParam.alphaBlend = Std.Sprite.AlphaBlend.Add
Пример #12
0
				def drawValue(name, dst, value, selected):
					font = Resource.getFont(
						"font32", Ctrl.DrawPriority.pauseStr, False, 32)
					color = Std.ColorF()
					if not selected:
						color.a = 0.5
					dst = Std.Point2DF(dst)
					
					font.draw(dst, color, name)
					dst.y += 32
					if value < 100:
						font.draw(dst, color, "↑")
					dst.y += 32
					if value > 0:
						font.draw(dst, color, "↓")
					dst.x += 32
					dst.y -= 32 / 2
					font.draw(dst, color, str(int(value)))
Пример #13
0
 def drawTask():
     basePos = Std.Point2DF(100, 200)
     color = Std.ColorF()
     while True:
         font = Resource.getFont("font32", Ctrl.DrawPriority.pauseStr, False, 32)
         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
Пример #14
0
			def drawTask():
				basePos = Std.Point2DF(420, 260)
				color = Std.ColorF()
				while True:
					font = Resource.getFont(
						"font32", drawPriority.str, False, 32)
					for i in range(enum.exit + 1):
						dst = Std.Point2DF(basePos.x, basePos.y + font.size*i)
						if i == enum.gameStart:
							font.draw(dst, color, "GameStart")
						elif i == enum.option:
							font.draw(dst, color, "Option")
						elif i == enum.exit:
							font.draw(dst, color, "Exit")
					dst = Std.Point2DF(
						basePos.x - font.size, 
						basePos.y + font.size*arrow.position)
					font.draw(dst, color, "→")
					yield
Пример #15
0
	def onDestructed(self):
		drawParam = Std.Sprite.DrawParam()
		drawParam.texture = CommonResource.get("bulletGreen")
		drawParam.src = Std.RectF(0, 0, 64, 64)
		drawParam.dst = self.locator.position.makeRect(12, 12, True)
		drawParam.priority = Ctrl.DrawPriority.myShot
		drawParam.alphaBlend = Std.Sprite.AlphaBlend.Add
		param = Auxs.Particle.Param()
		param.drawParameter = drawParam
		
		angle = self.locator.speed.getAngle()
		direction = Std.Vector2DF()
		direction.setUnitVector(angle)
		param.setPosition(self.locator.position + direction*10)
		param.setAngleRange(angle+180 - 20, angle+180 + 20)
		param.setSpeedRange(8, 12)
		param.setZoomRateRange(0.8, 1)
		param.setZoomDecRateRange(0.06, 0.08)
		
		creator = Auxs.Particle.Creator(param)
		creator.create(2)
Пример #16
0
			def drawTask():
				basePos = Std.Point2DF(380, 260)
				color = Std.ColorF()
				while True:
					font = Resource.getFont(
						"font32", drawPriority.str, False, 32)
					for i in range(enum.default + 1):
						dst = Std.Point2DF(basePos.x, basePos.y + font.size*i)
						if i == enum.screenMode:
							font.draw(dst, color, "ScreenMode")
						elif i == enum.volume:
							font.draw(dst, color, "Volume")
						elif i == enum.gamePad:
							font.draw(dst, color, "GamePad")
						elif i == enum.default:
							font.draw(dst, color, "Default")
					dst = Std.Point2DF(
						basePos.x - font.size, 
						basePos.y + font.size*arrow.position)
					font.draw(dst, color, "→")
					yield
Пример #17
0
			def drawTask():
				basePos = Std.Point2DF(320, 230)
				color = Std.ColorF()
				while True:
					font = Resource.getFont(
						"font32", drawPriority.str, False, 32)
					for i in range(enum.returnTop + 1):
						dst = Std.Point2DF(
							basePos.x, basePos.y + font.size*i)
						dstVKey = Std.Point2DF(
							basePos.x + 260, basePos.y + font.size*i)
						if i == enum.shot:
							font.draw(dst, color, "決定/ショット")
							font.draw(dstVKey, color, 
								str(Ctrl.Conf.getButtonVirtualKey(Std.Input.KeyId.Z)))
						elif i == enum.special:
							font.draw(dst, color, "取消/特殊攻撃")
							font.draw(dstVKey, color, 
								str(Ctrl.Conf.getButtonVirtualKey(Std.Input.KeyId.X)))
						elif i == enum.spare:
							font.draw(dst, color, "KEY_C(予備)")
							font.draw(dstVKey, color, 
								str(Ctrl.Conf.getButtonVirtualKey(Std.Input.KeyId.C)))
						elif i == enum.slow:
							font.draw(dst, color, "低速移動")
							font.draw(dstVKey, color, 
								str(Ctrl.Conf.getButtonVirtualKey(Std.Input.KeyId.LShift)))
						elif i == enum.pause:
							font.draw(dst, color, "ポーズ")
							font.draw(dstVKey, color, 
								str(Ctrl.Conf.getButtonVirtualKey(Std.Input.KeyId.Space)))
						elif i == enum.direction:
							font.draw(dst, color, "方向入力設定")
						elif i == enum.returnTop:
							font.draw(dst, color, "戻る")
					dst = Std.Point2DF(
						basePos.x - font.size, 
						basePos.y + font.size*arrow.position)
					font.draw(dst, color, "→")
					yield