示例#1
0
    def onDestructed(self):
        self.onErase()
        self.scoreManager.addScore(self.maxHp)

        itemNum = Regulation.itemNum
        angleList = NWay.getAngleList(Regulation.itemLaunchAngle, Regulation.itemLaunchAngleInterval, itemNum)

        def effectCallback(result):
            if not result:
                self.scoreManager.addScore(1000)

        for angle in angleList:
            item = Auxs.Item.SpAttack(self.position, angle)
            item.setEffectCallback(effectCallback)
            Ctrl.Actor.registerItem(item)
示例#2
0
	def _main(self):
		self.shooting = True
		
		speed = self.regulation.speed
		for i in range(int(self.regulation.launchSetNum)):
			targetAngle = self._getPos().getAngle(
				Ctrl.Actor.myShip.position)
			
			for _ in range(i + 1):
				drawParam = Auxs.createBulletBlueDrawParam(
					self._getPos(), Std.Vector2DF(16, 16))
				NWay.launchLinear(
					self._getPos(), 
					targetAngle, 
					self.regulation.firstAngleInterval, 
					self.regulation.firstWayNum, 
					int(drawParam.dst.w/2), 
					drawParam, 
					speed)
					
				wait = createWait(self.regulation.launchInterval)
				while wait(): yield
				
				angleList = NWay.getAngleList(
					targetAngle, 
					self.regulation.secondAngleInterval, 
					self.regulation.secondWayNum)
				drawParam = Auxs.createBulletBlueDrawParam(
					self._getPos(), Std.Vector2DF(14, 14))
				for angle in angleList:
					NWay.launchLinear(
						self._getPos(), 
						angle, 
						self.regulation.secondAngleIntervalPerWay, 
						self.regulation.secondWayNumPerWay, 
						int(drawParam.dst.w/2), 
						drawParam, 
						speed)
				
				wait = createWait(self.regulation.launchInterval)
				while wait(): yield
			
			wait = createWait(self.regulation.setInterval)
			while wait(): yield
		
		self.shooting = False
示例#3
0
	def onDestruction(self):
		Misc.createExplosion(
			Ctrl.DrawPriority.myShip, 
			5, 
			self.locator.position, 
			self.SHIP_SIZE.getAbs() * 2, 
			1.5, 
			Std.Vector2DF(16, 16)
			)
		self.resource.se_Destruction.play()
		
		if self.power <= 2:
			itemNum = 2
		elif self.power <= 4:
			itemNum = self.power
		angleList = NWay.getAngleList(-90, 20, itemNum)
		for angle in angleList:
			item = Auxs.Item.PowerUp(self.position, angle)
			Ctrl.Actor.registerItem(item)
		
		self.power = 0
示例#4
0
	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