示例#1
0
 def __init__(self, game, playMusic=True):
     self.mGame = game
     Pgl.app.setUpdaterate(int(Updaterate.FAST))
     pygame.mouse.set_visible(False)
             
     if playMusic: SoundManager.getInstance().playMenuMusic()
 
     #set input & camera
     self.mGame.input = MenuInput(self)
     self.mCamera = Camera(Pgl.width, Pgl.height)
     self.modelsize = self.mCamera.getModelCoords(b2Vec2(Pgl.width, Pgl.height))
     
     #fonts
     self.screenFont = Resources.getInstance().getScaledFont(self.mCamera.scale.x / 3.0)
     self.titleFont = Resources.getInstance().getScaledFont(self.mCamera.scale.x * 2.0)
     self.infoFont = Resources.getInstance().getScaledFont(self.mCamera.scale.x / 2)
     
     #graphics
     self.arrow = Sprite(Resources.getInstance().mArrow) 
     self.arrow.setSize(self.mCamera.getScaledSize((self.arrow.getWidth()/float(self.arrow.getHeight())) * 0.5, 0.5))
     self.menubutton = Animation(Resources.getInstance().mMenuButton, 2, 1, 0, self.mCamera.getScaledSize(1, 1), False, False)
     self.levelbutton = Animation(Resources.getInstance().mLevelButton, 2, 1, 0, self.mCamera.getScaledSize(1, 1), False, False)
     self.checkbutton = Animation(Resources.getInstance().mCheckButton, 2, 1, 0, self.mCamera.getScaledSize(1, 1), False, False)
     self.lock = Sprite(Resources.getInstance().mLock)
     self.lock.setSize(self.mCamera.getScaledSize((self.lock.getWidth()/float(self.lock.getHeight())) * 0.2, 0.2))
示例#2
0
class IntroFadeSequence(object):
	def __init__(self, main):
		self.main = main
		self.dead = False

		self.stage = -1
		self.fade = 0

		self.intro_delay = 120
		self.fadein_length = 60
		self.hold_length = 180
		self.fadeout_length = 60
		self.end_delay = 120

		self.is_covering_screen = True

		self.sprite = Sprite(self.main, "imgs/sprites/raubana", 3, False)

	def update(self):
		if not self.dead:
			if self.stage == -1:
				self.fade += 1
				if self.fade >= self.intro_delay:
					self.fade = 0
					self.stage = 0
			elif self.stage < 2:
				if self.stage == 0:
					self.sprite.set_frame("raubana")
				elif self.stage == 1:
					self.sprite.set_frame("pyweek")

				self.fade += 1
				if self.fade >= self.fadein_length + self.hold_length + self.fadeout_length:
					self.fade = 0
					self.stage += 1
			else:
				self.fade += 1
				if self.fade >= self.end_delay:
					self.dead = True

	def render(self):
		self.main.screen.fill((0,0,0))
		if self.stage >= 0 and self.stage <= 1:
			img = self.sprite.get_img()
			rect = img.get_rect(center = (self.main.screen_size[0]/2, self.main.screen_size[1]/2))

			fade = self.fade
			if fade < self.fadein_length:
				img = img.copy()
				p = fade / float(self.fadein_length)
				img.fill((255,255,255,int(255*p)),None,special_flags=BLEND_RGBA_MULT)
			elif fade >= self.fadein_length + self.hold_length:
				img = img.copy()
				p = min((fade-self.fadein_length-self.hold_length) / float(self.fadein_length),1.0)
				img.fill((255,255,255,int(255*(1-p))),None,special_flags=BLEND_RGBA_MULT)

			self.main.screen.blit(img, rect)
示例#3
0
	def __init__(self, main):
		self.main = main
		self.dead = False

		self.stage = -1
		self.fade = 0

		self.intro_delay = 120
		self.fadein_length = 60
		self.hold_length = 180
		self.fadeout_length = 60
		self.end_delay = 120

		self.is_covering_screen = True

		self.sprite = Sprite(self.main, "imgs/sprites/raubana", 3, False)
示例#4
0
    def __init__(self, camera, world):
        self.mCamera = camera
        self.mWorld = world
        
        self.mUI = Sprite(Resources.getInstance().mUI, self.mCamera.getScaledSize(4,1))

        self.timefont = Resources.getInstance().getScaledFont(self.mCamera.scale.x)
        self.timesize = self.timefont.size("00:00:00")
示例#5
0
 def draw(self, delta, position):
     if self.__mRunning:
         self.__mElapsedTime += delta
     
         if self.__mElapsedTime > self.__mMaxTime:
             
             self.__mCurrentFrame += 1
             
             if self.__mCurrentFrame >= self.__mFramesX:
                 self.__mCurrentFrame = 0
                 
                 if not self.__mLooping:
                     self.__mIsDone = True
                     self.__mRunning = False
         
             self.__mElapsedTime = 0.0
     
     Sprite.draw(self, position, self.__mDrawRect.move(self.__mCurrentFrame * self.__mFrameWidth, self.__mCurrentRow * self.__mFrameHeight))
示例#6
0
 def __init__(self, sprite, framesX, framesY, animationtime, size, looping = True, running = True):
     super(Animation, self).__init__(sprite)
     
     self.__mElapsedTime = 0.0
     self.__mLooping = looping
     self.__mRunning = running
     self.__mIsDone = False
     self.__mCurrentFrame = 0
     self.__mCurrentRow = 0
     self.__mDrawRect = None
     
     Sprite.setSize(self, size)
     self.__mFramesX = framesX
     self.__mFramesY = framesY
     self.__mFrameHeight = Sprite.getHeight(self) / framesY
     self.__mFrameWidth = Sprite.getWidth(self) / framesX
     self.__mMaxTime = animationtime / self.__mFramesX
     self.__mDrawRect = Rect(self.__mCurrentFrame * self.__mFrameWidth, self.__mCurrentRow * self.__mFrameHeight, self.__mFrameWidth, self.__mFrameHeight)
示例#7
0
class UIRender(object):
    
    mCamera = None
    mWorld = None
    mUI = None
    mTimeFont = None
    
    def __init__(self, camera, world):
        self.mCamera = camera
        self.mWorld = world
        
        self.mUI = Sprite(Resources.getInstance().mUI, self.mCamera.getScaledSize(4,1))

        self.timefont = Resources.getInstance().getScaledFont(self.mCamera.scale.x)
        self.timesize = self.timefont.size("00:00:00")
        
    def render(self, delta):
        uipos =  self.mCamera.getScaledSize(Camera.CAMERA_WIDTH / 2.0 - 2, Camera.CAMERA_HEIGHT - 1)
        self.mUI.draw(uipos)
        
        self.time = self.timefont.render(Time.convertToTimeString(self.mWorld.mTimer), 0, (255, 255, 255))
        Pgl.app.surface.blit(self.time,
                             (self.mCamera.getScaledSize(Camera.CAMERA_WIDTH / 2.0 - (self.timesize[0] / 2.0) / self.mCamera.scale.x, 
                                                         Camera.CAMERA_HEIGHT - ((Camera.CAMERA_HEIGHT +self.timesize[1]) / self.mCamera.scale.y))))