def renderSelf(self, time, renderer, xMin, yMin): if (self.xPos + self.width - xMin < 0) or (self.yPos + self.height - yMin < 0): return elif (self.xPos > xMin + 800) or (self.yPos > yMin + 600): return if self.title is 'pizza' or self.title is 'heart' or self.title is 'carrot' or self.title is 'bombObject': time1 = ((int(time / 250)) % 4) #slowish spriteFrame = sdl.Rect((time1 * 50, 0, 50, 50)) sdl.renderCopy(renderer, self.texture, spriteFrame, self.getRect(xMin, yMin)) elif self.title is 'explosion': time1 = ((int(time / 250)) % 8) if time1 is not self.currentTime: self.currentFrame += 1 spriteFrame = sdl.Rect((self.currentFrame * 200, 0, 200, 200)) sdl.renderCopy(renderer, self.texture, spriteFrame, self.getRect(xMin, yMin)) if self.currentFrame is 8: self.used = True self.currentTime = time1 else: spriteFrame = sdl.Rect((self.currentFrame * 200, 0, 200, 200)) sdl.renderCopy(renderer, self.texture, spriteFrame, self.getRect(xMin, yMin)) elif self.title is 'blackScreen': self.updateAlpha(1) sdl.setTextureAlphaMod(self.texture, int(self.alpha)) sdl.renderCopy(renderer, self.texture, None, self.getRect(xMin, yMin)) else: sdl.renderCopy(renderer, self.texture, None, self.getRect(xMin, yMin))
def renderLight(self, renderer, xMin, yMin): mod = 1 texture = driver.lightTextures[7] # default red if self.attacking is 1: texture = driver.lightTextures[6] # change to green sdl.setTextureAlphaMod(texture, 64) mod = 10 elif self.attacking is 2: texture = driver.lightTextures[3] # change to orange sdl.setTextureAlphaMod(texture, 64) elif self.attacking is 3: texture = driver.lightTextures[4] # change to purple sdl.setTextureAlphaMod(texture, 64) if self.hurt: texture = driver.lightTextures[5] # change to blue sdl.setTextureAlphaMod(texture, 64) if self.dying: color = (self.currentFrame % 5) + 3 texture = driver.lightTextures[ color] # change to self.currentFrame % len(driver.lightTextures) sdl.setTextureAlphaMod(texture, 255) if color is 6: mod = 10 textureW, textureH = chef.textureSize(texture) textureW *= mod textureH *= mod lightRect = sdl.Rect((0, 0, textureW, textureH)) sdl.setTextureBlendMode(texture, sdl.BLENDMODE_ADD) posRect = sdl.Rect( (int(self.xPos) - int(xMin) + int(self.width / 2) - int(textureW / 2), int(self.yPos) - int(yMin) + int(self.height / 2) - int(textureH / 2), textureW, textureH)) sdl.renderCopy(renderer, texture, lightRect, posRect)
def renderSelf(self, time, xMin, yMin): if self.title is 'green': currentFrame = ((int(time / 125)) % 6) spriteFrame = sdl.Rect((currentFrame * 60, 0, 60, 60)) sdl.renderCopy(self.renderer, self.texture, spriteFrame, self.getRect(xMin, yMin)) elif self.title is 'purple': newTime = ((int(time / 400)) % 6) if newTime is not self.currentTime: self.currentFrame += 1 if self.currentFrame > 5: self.currentFrame = 5 spriteFrame = sdl.Rect((self.currentFrame * 400, 0, 400, 200)) sdl.renderCopy(self.renderer, self.texture, spriteFrame, self.getRect(xMin, yMin)) elif self.title is 'knife': tempRect = self.getRect(xMin, yMin) sdl.renderCopyEx(self.renderer, self.texture, None, tempRect, math.degrees(self.degree) + 90, sdl.Point((tempRect.w // 2, tempRect.h // 2)), sdl.FLIP_NONE) elif self.title is 'fire' or self.title is 'fireSlow': currentFrame = ((int(time / 125)) % 4) spriteFrame = sdl.Rect((currentFrame * 50, 0, 50, 150)) tempRect = self.getRect(xMin, yMin) sdl.renderCopyEx(self.renderer, self.texture, spriteFrame, tempRect, math.degrees(self.degree) - 90, sdl.Point((tempRect.w // 2, tempRect.h // 2)), sdl.FLIP_NONE)
def getRect(self, xMin, yMin, xVal, xdt, yVal, ydt): if self.identity is "bluePipe" or self.identity is "redPipe": return sdl.Rect((int(50 * self.xPos) - int(xMin), int(50 * self.yPos) - ydt - int(yMin), 50, yVal)) else: return sdl.Rect( (int(50 * self.xPos) - int(xMin) - xdt, int(50 * self.yPos) - 25 - int(yMin) - ydt, xVal, yVal))
def renderHealthPvp(self, renderer): if self.title is None: for i in range(self.health): spot = sdl.Rect((10 + i * 55, 10, 50, 50)) sdl.renderCopy(renderer, self.textures[1][0], None, spot) else: for i in range(self.health): spot = sdl.Rect(((16 * 50) - 65 - i * 55, 10, 50, 50)) sdl.renderCopy(renderer, self.textures[1][0], None, spot)
def getRect(self, xMin, yMin): if self.attacking is not 2: return sdl.Rect( (int(self.xPos) - int(xMin), int(self.yPos) - int(yMin), self.width, self.height)) else: return sdl.Rect((int(self.xPos - 200) - int(xMin), int(self.yPos - 200) - int(yMin), self.width + 400, self.height + 400))
def renderLight(self, renderer, xMin, yMin): if 'carrot' in driver.chef.items: textureW, textureH = chef.textureSize(driver.lightTextures[0]) lightRect = sdl.Rect((0, 0, textureW, textureH)) sdl.setTextureBlendMode(driver.lightTextures[0], sdl.BLENDMODE_ADD) sdl.setTextureAlphaMod(driver.lightTextures[0], 128) posRect = sdl.Rect( (int(self.xPos) - int(xMin) + int(self.width / 2) - int(textureW / 2), int(self.yPos) - int(yMin) + int(self.height / 2) - int(textureH / 2), textureW, textureH)) sdl.renderCopy(renderer, driver.lightTextures[0], lightRect, posRect)
def renderLight(self, renderer, xMin, yMin): for particle in self.particles: if self.type is "explosion": if not particle.isAlive(): self.particles.remove(particle) else: expRect = sdl.Rect((0, 0, 10, 10)) pixSize = particle.getTimeFraction() pixSize = (pixSize**3) // 2 sdl.renderCopy( renderer, self.expLight, None, sdl.Rect( (int(particle.xPos) - int(xMin) - int(pixSize / 2), int(particle.yPos) - int(yMin) - int(pixSize / 2), int(pixSize), int(pixSize))))
def overlayblack(self): if 'carrot' not in driver.chef.items: blackRect = sdl.Rect( (int(self.chef.xPos - 800) - int(self.xMin), (self.chef.yPos - 600) - int(self.yMin), 1600, 1200)) else: blackRect = sdl.Rect( (int(self.chef.xPos - 1200) - int(self.xMin), (self.chef.yPos - 900) - int(self.yMin), 2400, 1800)) if self.level is 5: blackRect = sdl.Rect( (int(self.chef.xPos - 1800) - int(self.xMin), (self.chef.yPos - 1350) - int(self.yMin), 3600, 2700)) sdl.renderCopy(driver.renderer, self.blackScreenTexture, None, blackRect)
def getRect(self, xMin, yMin): if self.title is 'green': return sdl.Rect((int(self.xPos) - int(xMin), int(self.yPos) - int(yMin), 60, 60)) elif self.title is 'purple': return sdl.Rect((int(self.xPos) - int(xMin), int(self.yPos) - int(yMin), 400, 200)) elif self.title is 'knife': return sdl.Rect( (int(self.xPos) - int(xMin), int(self.yPos) - int(yMin), self.height, self.width)) elif self.title is 'fire' or self.title is 'fireSlow': return sdl.Rect( (int(self.xPos) - int(xMin), int(self.yPos) - int(yMin), self.width, self.height))
def renderDamage(self, renderer, xMin, yMin): #if there has been any change in health if (self.changeInHp != 0): #create the string stringDamage = str(self.changeInHp) #make it red color = sdl.Color((255, 0, 0)).cdata[0] #but if the "damage" is positive (ie, healing) if (self.changeInHp > 0): #show that it is positive stringDamage = "+" + str(self.changeInHp) #and make it green color = sdl.Color((0, 255, 0)).cdata[0] dmgSurf = sdl.ttf.renderText_Solid(driver.scoreFont, stringDamage, color) dmgTexture = renderer.createTextureFromSurface(dmgSurf) textureW, textureH = chef.textureSize(dmgTexture) dmgRect = sdl.Rect() dmgRect.x = int(self.xPos + textureW // 6 - xMin) dmgRect.y = int(self.yPos - textureH - yMin) dmgRect.w = textureW dmgRect.h = textureH dmgRect.x = int(dmgRect.x) dmgRect.y = int(dmgRect.y) sdl.renderCopy(renderer, dmgTexture, None, dmgRect) sdl.freeSurface(dmgSurf) sdl.destroyTexture(dmgTexture)
def renderItems(self, renderer): for x in range(len(self.items)): spot = sdl.Rect((10 + x * 55, 65, 50, 50)) if self.items[x] is 'key': sdl.renderCopy(renderer, self.textures[1][1], None, spot) elif self.items[x] is 'carrot': sdl.renderCopy(renderer, self.textures[1][2], None, spot)
def __init__(self): self.window = None self.renderer = None self.background = None self.sprite = None self.sprite_rect = sdl.Rect() self.scale_direction = 0
def renderHealth(self, renderer, xMin, yMin): for i in range(self.health): spot = sdl.Rect( (int(self.xPos) - int(xMin) + 14 * i - int(14 * (self.health / 2)) + int(self.width / 2), int(self.yPos) - int(yMin) + int(self.height) - 10, 12, 12)) sdl.renderCopy(renderer, self.bossTextures[11], None, spot)
def renderLight(self, renderer, xMin, yMin): return textureW, textureH = chef.textureSize(driver.lightTextures[1]) lightRect = sdl.Rect((0, 0, textureW, textureH)) sdl.setTextureBlendMode(driver.lightTextures[1], sdl.BLENDMODE_ADD) if 'carrot' not in driver.chef.items: posRect = sdl.Rect( (int(self.xPos) - int(xMin) + int(self.width / 2) - int(textureW / 2), int(self.yPos) - int(yMin) + int(self.height / 2) - int(textureH / 2), textureW, textureH)) else: posRect = sdl.Rect( (int(self.xPos) - int(xMin) + int(self.width / 2) - int(textureW), int(self.yPos) - int(yMin) + int(self.height / 2) - int(textureH), textureW * 2, textureH * 2)) sdl.renderCopy(renderer, driver.lightTextures[1], lightRect, posRect)
def getRect5(self, xMin, yMin): #when a ball if self.ballWidth > 10: self.ballWidth = self.ballWidth - 5 if self.ballHeight > 10: self.ballHeight = self.ballHeight - (5 * (190.0 / 150.0)) return sdl.Rect((int(self.xPos - 37) + int( (150.0 - self.ballWidth) / 2) - int(xMin), int(self.yPos - 37) + int( (150.0 - self.ballHeight) / 2) - int(yMin), int(self.ballWidth), int(self.ballHeight)))
def renderLight(self, renderer, xMin, yMin): # textureW, textureH = chef.textureSize(driver.lightTextures[1]) # lightRect = sdl.Rect((0, 0, textureW, textureH)) # sdl.setTextureBlendMode(driver.lightTextures[1], sdl.BLENDMODE_ADD) # sdl.setTextureAlphaMod(driver.lightTextures[1], 128) # posRect = sdl.Rect((int(self.xPos) - int(xMin) + int(self.width/2) - int(textureW/2) ,int(self.yPos) - int(yMin) + int(self.height/2) - int(textureH/2), textureW, textureH)) # sdl.renderCopy(renderer, driver.lightTextures[1], lightRect, posRect) mod = 1 texture = driver.lightTextures[5] # default blue if self.hurt: texture = driver.lightTextures[7] # change to red sdl.setTextureAlphaMod(texture, 255) elif self.summoning: texture = driver.lightTextures[6] # change to green sdl.setTextureAlphaMod(texture, 64) mod = 10 elif self.transforming: texture = driver.lightTextures[3] # change to orange sdl.setTextureAlphaMod(texture, 64) elif self.transformed: texture = driver.lightTextures[7] # change to red sdl.setTextureAlphaMod(texture, 64) if self.dying: color = (self.currentFrame % 5) + 3 texture = driver.lightTextures[color] sdl.setTextureAlphaMod(texture, 255) if color is 6: mod = 10 textureW, textureH = chef.textureSize(texture) textureW *= mod textureH *= mod lightRect = sdl.Rect((0, 0, textureW, textureH)) sdl.setTextureBlendMode(texture, sdl.BLENDMODE_ADD) posRect = sdl.Rect( (int(self.xPos) - int(xMin) + int(self.width / 2) - int(textureW / 2), int(self.yPos) - int(yMin) + int(self.height / 2) - int(textureH / 2), textureW, textureH)) sdl.renderCopy(renderer, texture, lightRect, posRect)
def renderWeapons(self, renderer): for x in range(len(self.weapons)): spot = sdl.Rect((10 + x * 55, 120, 50, 50)) if self.weapons[x] is 'ladles': sdl.renderCopy(renderer, self.textures[1][3], None, spot) if self.weapons[x] is 'graters': sdl.renderCopy(renderer, self.textures[1][4], None, spot) if self.weapons[x] is 'bomb': sdl.renderCopy(renderer, self.textures[1][5], None, spot) if self.weapons[x] is 'knives': sdl.renderCopy(renderer, self.textures[1][9], None, spot)
def render(self, renderer): viewport = sdl.Rect() renderer.renderGetViewport(viewport) # Only render those tiles inside our viewport with a little overlap ranges = [] for (pos, tile_size, dimension, ceiling) in \ ((self.pos[0], self.tile_size[0], viewport.w, self.tmx.width), (self.pos[1], self.tile_size[1], viewport.h, self.tmx.height)): start = max(0, pos // tile_size) end = min(start + dimension // tile_size + 2, ceiling) ranges.append(xrange(start, end)) dest_rect = sdl.Rect((0, 0, 16, 16)) for x, y in itertools.product(*ranges): for layer in self.tmx.visible_tile_layers: image = self.tmx.get_tile_image(x, y, layer) if not image: continue ts, bounds, flags = image dest_rect.x = (x * 16) - self.pos[0] dest_rect.y = (y * 16) - self.pos[1] rot = 90 if (flags & TRANS_ROT) else 0 renderer.renderCopyEx( ts.texture, (bounds[0][0], bounds[0][1], bounds[1][0], bounds[1][1]), dest_rect, rot, None, (flags & (TRANS_FLIPX ^ (rot and TRANS_FLIPX)) and sdl.FLIP_HORIZONTAL) | (flags & (TRANS_FLIPY) and sdl.FLIP_VERTICAL)) for ob in self.tmx.objects: ts, bounds, flags = self.tmx.get_tile_image_by_gid(ob.gid) renderer.renderCopyEx( ts.texture, (bounds[0][0], bounds[0][1], bounds[1][0], bounds[1][1]), (int(ob.x) - self.pos[0], int(ob.y) - self.pos[1], bounds[1][0], bounds[1][1]), 0, None, 0)
def renderSelf(self, renderer, xMin, yMin, dt): for particle in self.particles: if self.type is "rat": particle.update(dt) if not particle.isAlive(): self.particles.remove(particle) else: pixSize = particle.getTimeFraction() sdl.renderCopy( renderer, self.tex, None, sdl.Rect((int(particle.xPos) - int(xMin), int(particle.yPos) - int(yMin), pixSize, pixSize))) elif self.type is "explosion": particle.update(dt) if not particle.isAlive(): self.particles.remove(particle) else: pixSize = particle.getTimeFraction() if particle.life > 900: sdl.renderCopy( renderer, self.tex3, None, sdl.Rect((int(particle.xPos) - int(xMin), int(particle.yPos) - int(yMin), pixSize, pixSize))) elif particle.life > 800: sdl.renderCopy( renderer, self.tex2, None, sdl.Rect((int(particle.xPos) - int(xMin), int(particle.yPos) - int(yMin), pixSize, pixSize))) elif particle.life > 0: sdl.renderCopy( renderer, self.tex1, None, sdl.Rect((int(particle.xPos) - int(xMin), int(particle.yPos) - int(yMin), pixSize, pixSize)))
def renderLight(self, renderer, xMin, yMin): texture = driver.lightTextures[7] modX = 1 modY = 1 if self.title is 'green': texture = driver.lightTextures[6] # change to green elif self.title is 'purple': texture = driver.lightTextures[4] # change to purple modX = 1 modY = 1 elif self.title is 'knife': texture = driver.lightTextures[1] # change to green return textureW, textureH = chef.textureSize(texture) textureW = textureW / modX textureH = textureH / modY lightRect = sdl.Rect((0, 0, int(textureW), int(textureH))) sdl.setTextureBlendMode(texture, sdl.BLENDMODE_ADD) sdl.setTextureAlphaMod(texture, 128) posRect = sdl.Rect((int(self.xPos) - int(xMin) + int(self.width / 2) - int(textureW / 2), int(self.yPos) - int(yMin) + int(self.height / 2) - int(textureH / 2), int(textureW), int(textureH))) sdl.renderCopy(renderer, texture, None, posRect)
def draw_column(self, column, ray, angle, game_map): """ Check if a hit occurs in the ray. Then itterate through each step of the ray (in reverse). A hit will be rendered (including its shadow). Rain drops will be drawn for each step. """ texture = game_map.wall_texture left = int(math.floor(column * self.spacing)) width = int(math.ceil(self.spacing)) hit = 0 while hit < len(ray) and ray[hit].height <= 0: hit += 1 for ray_index in range(len(ray) - 1, -1, -1): step = ray[ray_index] if ray_index == hit: texture_x = int(math.floor(texture.width * step.offset)) wall = self.project(step.height, angle, step.distance) image_location = sdl.Rect((texture_x, 0, 1, texture.height)) scale_rect = sdl.Rect( tuple( int(x) for x in (left, wall.top, width, wall.height))) renderer.renderCopy(texture.image, image_location, scale_rect) self.draw_shadow(step, scale_rect, game_map.light) self.draw_rain(step, angle, left, ray_index)
def renderLight(self, renderer, xMin, yMin): if (self.identity is "redPipe" or self.identity is "bluePipe" ) and self.used is False and 'carrot' in driver.chef.items: if self.identity is "redPipe": texture = driver.lightTextures[7] else: texture = driver.lightTextures[5] textureW = 100 textureH = 100 sdl.setTextureBlendMode(texture, sdl.BLENDMODE_ADD) sdl.setTextureAlphaMod(texture, 128) xP = int(self.xPos * 50) - int(xMin) + 25 - int(textureW / 2) yP = int(self.yPos * 50) - int(yMin) + 25 - int(textureH / 2) posRect = sdl.Rect((xP, yP, textureW, textureH)) sdl.renderCopy(renderer, texture, None, posRect) else: return
def renderSelf(self, time, renderer, xMin, yMin, ratTextures): if (self.xPos + self.width - xMin < 0) or (self.yPos + self.height - yMin < 0): return elif (self.xPos > xMin + 800) or (self.yPos > yMin + 600): return time = ((int(time / 125)) % 4) spriteFrame = sdl.Rect((time * 50, 0, 50, 60)) if not self.hurt: # if not hurt if self.attacking is 0: # if not attacking if self.direction == 'n' or self.direction == 'ne' or self.direction == 'nw': sdl.renderCopy(renderer, ratTextures[1], spriteFrame, self.getRect(xMin, yMin)) elif self.direction == 's' or self.direction == 'se' or self.direction == 'sw': sdl.renderCopy(renderer, ratTextures[3], spriteFrame, self.getRect(xMin, yMin)) elif self.direction == 'e': sdl.renderCopy(renderer, ratTextures[2], spriteFrame, self.getRect(xMin, yMin)) elif self.direction == 'w': sdl.renderCopy(renderer, ratTextures[4], spriteFrame, self.getRect(xMin, yMin)) else: # if attacking if self.attacking == 1: sdl.renderCopy(renderer, ratTextures[5], spriteFrame, self.getRect(xMin, yMin)) if self.attacking == 2: sdl.renderCopy(renderer, ratTextures[6], spriteFrame, self.getRect(xMin, yMin)) if self.attacking == 3: sdl.renderCopy(renderer, ratTextures[7], spriteFrame, self.getRect(xMin, yMin)) if self.attacking == 4: sdl.renderCopy(renderer, ratTextures[8], spriteFrame, self.getRect(xMin, yMin)) elif self.hurt: # if hurt sdl.renderCopy(renderer, ratTextures[0], spriteFrame, self.getRect(xMin, yMin)) self.renderHealth(renderer, xMin, yMin, ratTextures)
def Draw(s): viewport = sdl.Rect() sdl.renderGetViewport(s.renderer, viewport) # Draw the background sdl.renderCopy(s.renderer, s.background, None, None) # Scale and draw the sprite s.sprite_rect.w += s.scale_direction s.sprite_rect.h += s.scale_direction if s.scale_direction > 0: if s.sprite_rect.w >= viewport.w or s.sprite_rect.h >= viewport.h: s.scale_direction = -1 else: if s.sprite_rect.w <= 1 or s.sprite_rect.h <= 1: s.scale_direction = 1 s.sprite_rect.x = (viewport.w - s.sprite_rect.w) // 2 s.sprite_rect.y = (viewport.h - s.sprite_rect.h) // 2 sdl.renderCopy(s.renderer, s.sprite, ffi.NULL, s.sprite_rect) # Update the screen! sdl.renderPresent(s.renderer)
def run(self): cursor1 = MC.Chef(220, 190, 50, 80, 'none', 0, 0, 0, 0.001, 0.001, cursorTexture, True, 0, 0, 100, True, 1) cursor2 = MC.Chef(535, 190, 50, 80, 'none', 0, 0, 0, 0.001, 0.001, cursorTexture, True, 0, 0, 100, True, 1) running = True currentTime = 0 lastTime = 0 time = 0 cursorPos = 0 brightnessPos = 10 volumePos = round((driver.volume - 8) / 12) event = sdl.Event() textureW, textureH = game.textureSize(optionsTexture) textureRect = game.centeredRect(game.width, game.height, textureW, textureH) sdl.renderClear(driver.renderer) sdl.renderCopy(driver.renderer, optionsTexture, None, textureRect) # render cursor in time1 = ((int(time / 125)) % 4) time2 = ((int(time / 500)) % 4) # the rectangle that defines which sprite part the sprites spriteFrame = sdl.Rect((time1 * 48, 0, 48, 80)) spriteFrame2 = sdl.Rect((time2 * 48, 0, 48, 80)) sdl.renderCopy(driver.renderer, cursorTexture, spriteFrame2, cursor1.getRect(0, 0)) sdl.renderCopy(driver.renderer, cursorTexture, spriteFrame2, cursor2.getRect(0, 0)) #render in brightness indicators for i in range(brightnessPos): spot = sdl.Rect((280 + 25 * i, 357, 18, 18)) sdl.renderCopy(driver.renderer, indTexture, None, spot) #render in volume indicators for i in range(volumePos): spot = sdl.Rect((280 + 25 * i, 242, 18, 18)) sdl.renderCopy(driver.renderer, indTexture, None, spot) sdl.renderPresent(driver.renderer) while running: hover = None clicked = None #### TIME MANAGEMENT #### currentTime = sdl.getTicks() dt = currentTime - lastTime time += dt lastTime = currentTime #### TEXTURE MEASUREMENTS #### textureW, textureH = game.textureSize(optionsTexture) textureRect = game.centeredRect(game.width, game.height, textureW, textureH) #### HANDLE INPUT #### while sdl.pollEvent(event): if event.type == sdl.QUIT: running = False game.turnOff() elif event.type == sdl.KEYUP: if event.key.keysym.sym in [sdl.K_q, sdl.K_ESCAPE]: running = False game.turnOff() elif event.type == sdl.MOUSEBUTTONDOWN: if event.button.button == sdl.BUTTON_LEFT: for i in range(len(boxes)): if clicked is None: sdl.mixer.playChannel(0, selectSound, 0) clicked = boxes[i].checkEvent( event.motion.x, event.motion.y) for i in range(len(volumeBoxes)): here = volumeBoxes[i].checkEvent( event.motion.x, event.motion.y) if here is not None: volumePos = here elif event.type == sdl.MOUSEMOTION: for i in range(len(boxes)): if (boxes[i].checkMotion(event.motion.x, event.motion.y)): hover = boxes[i].cursorPos if event.type == sdl.KEYDOWN: if event.key.keysym.sym == sdl.K_UP: sdl.mixer.playChannel(1, scrollSound, 0) cursorPos -= 1 if cursorPos <= -1: cursorPos = 2 elif event.key.keysym.sym == sdl.K_DOWN: sdl.mixer.playChannel(1, scrollSound, 0) cursorPos = (cursorPos + 1) % 3 elif event.key.keysym.sym == sdl.K_RIGHT: sdl.mixer.playChannel(1, scrollSound, 0) if cursorPos is 1: if sdl.getWindowBrightness(driver.window) < 1: brightnessPos += 1 sdl.setWindowBrightness( driver.window, sdl.getWindowBrightness(driver.window) + 0.05) elif cursorPos is 0: if volumePos < 10: volumePos += 1 sdl.mixer.volume(-1, volumePos * 12) driver.volume = volumePos * 12 elif event.key.keysym.sym == sdl.K_LEFT: sdl.mixer.playChannel(1, scrollSound, 0) if cursorPos is 1: if sdl.getWindowBrightness(driver.window) > .5: brightnessPos -= 1 sdl.setWindowBrightness( driver.window, sdl.getWindowBrightness(driver.window) - 0.05) elif cursorPos is 0: if volumePos > 1: volumePos -= 1 sdl.mixer.volume(-1, volumePos * 12) driver.volume = volumePos * 12 elif event.key.keysym.sym == sdl.K_RETURN: if (cursorPos == 0): # Call to play game sdl.mixer.playChannel(1, scrollSound, 0) elif (cursorPos == 1): #ADD IN OPTIONS sdl.mixer.playChannel(1, scrollSound, 0) elif (cursorPos == 2): #Call to controls screen sdl.mixer.playChannel(0, selectSound, 0) running = False self.next = "menu" while (sdl.getTicks() - currentTime < 300): pass if (hover is not None): cursorPos = hover if clicked is not None: if cursorPos is 2: sdl.mixer.playChannel(0, selectSound, 0) running = False self.next = "menu" cursor1.updateY(190 + 115 * cursorPos) cursor2.updateY(190 + 115 * cursorPos) #### RENDER #### sdl.renderClear(driver.renderer) sdl.renderCopy(driver.renderer, optionsTexture, None, textureRect) # render cursor in time1 = ((int(time / 125)) % 4) time2 = ((int(time / 500)) % 4) # the rectangle that defines which sprite part the sprites spriteFrame = sdl.Rect((time1 * 48, 0, 48, 80)) spriteFrame2 = sdl.Rect((time2 * 48, 0, 48, 80)) sdl.renderCopy(driver.renderer, cursorTexture, spriteFrame2, cursor1.getRect(0, 0)) sdl.renderCopy(driver.renderer, cursorTexture, spriteFrame2, cursor2.getRect(0, 0)) for i in range(brightnessPos): spot = sdl.Rect((280 + 25 * i, 357, 18, 18)) sdl.renderCopy(driver.renderer, indTexture, None, spot) for i in range(volumePos): spot = sdl.Rect((280 + 25 * i, 242, 18, 18)) sdl.renderCopy(driver.renderer, indTexture, None, spot) sdl.renderPresent(driver.renderer)
def renderHealth(self, renderer, xMin, yMin, texture): for i in range(self.health): spot = sdl.Rect( (int(self.xPos) - int(xMin) + 14 * i, int(self.yPos) - int(yMin) + int(self.height) - 30, 12, 12)) sdl.renderCopy(renderer, texture, None, spot)
def renderSelf(self, time, renderer, xMin, yMin, bossTextures): if (self.xPos + self.width - xMin < 0) or (self.yPos + self.height - yMin < 0): return elif (self.xPos > xMin + 800) or (self.yPos > yMin + 600): return frameTime = ((int(time / 125)) % 4) spriteFrame = sdl.Rect((frameTime * 300, 0, 300, 400)) if self.dead: return if self.dying: frameTime = ((int(time / 500)) % 4) if self.currentTime is not frameTime: self.currentFrame += 1 self.currentTime = frameTime spriteFrame = sdl.Rect((self.currentFrame * 300, 0, 300, 400)) sdl.renderCopy(renderer, bossTextures[9], spriteFrame, self.getRect(xMin, yMin)) # once the animation for attacking runs through, set him back to not attacking # and reset the current frame to -1 (so it starts at frame 0 next run) if self.currentFrame is 10: self.currentFrame = -1 self.attacking = 0 self.currentTime = -1 self.dead = True self.dying = False else: self.currentTime = frameTime spriteFrame = sdl.Rect((self.currentFrame * 300, 0, 300, 400)) sdl.renderCopy(renderer, bossTextures[9], spriteFrame, self.getRect(xMin, yMin)) elif not self.hurt: # if not hurt if self.attacking is 0: # if not attacking if self.direction == 'e': sdl.renderCopy(renderer, bossTextures[1], spriteFrame, self.getRect(xMin, yMin)) #right elif self.direction == 'w': sdl.renderCopy(renderer, bossTextures[2], spriteFrame, self.getRect(xMin, yMin)) #left elif self.direction == 's': sdl.renderCopy(renderer, bossTextures[8], spriteFrame, self.getRect(xMin, yMin)) #idle else: # if attacking if self.attacking == 1: # GREEN ATTACK frameTime = ((int(time / 125)) % 4) if self.currentTime is not frameTime: self.currentFrame += 1 self.currentTime = frameTime spriteFrame = sdl.Rect( (self.currentFrame * 300, 0, 300, 400)) sdl.renderCopy(renderer, bossTextures[3], spriteFrame, self.getRect(xMin, yMin)) if self.currentFrame is 4: self.projectiles.append( Projectile( int(self.xPos) + 100, int(self.yPos) + 400, 60, 60, 'green', bossTextures[4], renderer, 0, 0, 0)) # once the animation for attacking runs through, set him back to not attacking # and reset the current frame to -1 (so it starts at frame 0 next run) if self.currentFrame >= 6: self.currentFrame = -1 self.attacking = 0 self.currentTime = -1 else: self.currentTime = frameTime spriteFrame = sdl.Rect( (self.currentFrame * 300, 0, 300, 400)) sdl.renderCopy(renderer, bossTextures[3], spriteFrame, self.getRect(xMin, yMin)) elif self.attacking == 2: # ORANGE ATTACK frameTime = ((int(time / 125)) % 4) if self.currentTime is not frameTime: self.currentFrame += 1 self.currentTime = frameTime spriteFrame = sdl.Rect( (self.currentFrame * 700, 0, 700, 800)) sdl.renderCopy(renderer, bossTextures[5], spriteFrame, self.getRect(xMin, yMin)) # once the animation for attacking runs through, set him back to not attacking # and reset the current frame to -1 (so it starts at frame 0 next run) if self.currentFrame >= 8: self.currentFrame = -1 self.attacking = 0 self.currentTime = -1 self.endOfOrange = True else: self.currentTime = frameTime spriteFrame = sdl.Rect( (self.currentFrame * 700, 0, 700, 800)) sdl.renderCopy(renderer, bossTextures[5], spriteFrame, self.getRect(xMin, yMin)) elif self.attacking == 3: # PURPLE ATTACK frameTime = ((int(time / 125)) % 4) if self.currentTime is not frameTime: self.currentFrame += 1 self.currentTime = frameTime spriteFrame = sdl.Rect( (self.currentFrame * 300, 0, 300, 400)) sdl.renderCopy(renderer, bossTextures[6], spriteFrame, self.getRect(xMin, yMin)) if self.currentFrame is 4: self.projectiles.append( Projectile( int(self.xPos) - 100, int(self.yPos) + 400, 400, 200, 'purple', bossTextures[7], renderer, 0, 0, 0)) # once the animation for attacking runs through, set him back to not attacking # and reset the current frame to -1 (so it starts at frame 0 next run) if self.currentFrame >= 6: self.currentFrame = -1 self.attacking = 0 self.currentTime = -1 else: self.currentTime = frameTime spriteFrame = sdl.Rect( (self.currentFrame * 300, 0, 300, 400)) sdl.renderCopy(renderer, bossTextures[6], spriteFrame, self.getRect(xMin, yMin)) if self.attacking == 4: sdl.renderCopy(renderer, bossTextures[8], spriteFrame, self.getRect(xMin, yMin)) elif self.hurt: # if hurt sdl.renderCopy(renderer, bossTextures[0], spriteFrame, self.getRect(xMin, yMin)) self.renderHealth(renderer, xMin, yMin, bossTextures[10])
def run(): running = True lastTime = 0 time = 0 up = False down = False left = False right = False event = sdl.Event() xPos = 100 yPos = 100 size = 200 while running: currentTime = sdl.getTicks() dt = currentTime - lastTime time += dt / 1000.0 lastTime = currentTime textureW, textureH = textureSize(texture) textureRect = centeredRect(width, height, textureW, textureH) #Figure out what keys are being pressed while sdl.pollEvent(event): if event.type == sdl.QUIT: running = False elif event.type == sdl.KEYUP: if event.key.keysym.sym in [sdl.K_q, sdl.K_ESCAPE]: running = False if event.key.keysym.sym == sdl.K_UP: up = False elif event.key.keysym.sym == sdl.K_DOWN: down = False elif event.key.keysym.sym == sdl.K_LEFT: left = False elif event.key.keysym.sym == sdl.K_RIGHT: right = False if event.type == sdl.KEYDOWN: if event.key.keysym.sym == sdl.K_UP: up = True elif event.key.keysym.sym == sdl.K_DOWN: down = True elif event.key.keysym.sym == sdl.K_LEFT: left = True elif event.key.keysym.sym == sdl.K_RIGHT: right = True #movement based on what keys are being pressed down if up and left: yPos -= 10 xPos -= 10 elif up and right: yPos -= 10 xPos += 10 elif down and left: yPos += 10 xPos -= 10 elif down and right: yPos += 10 xPos += 10 elif up: yPos -= 10 elif down: yPos += 10 elif left: xPos -= 10 elif right: xPos += 10 testRect = sdl.Rect((xPos, yPos, size, size)) sdl.renderClear(renderer) sdl.renderCopy(renderer, texture, None, textureRect) sdl.renderCopy(renderer, chefTexture, None, testRect) testRect = sdl.Rect((xPos, yPos, 250, 250)) sdl.renderClear(renderer) sdl.renderCopy(renderer, texture, None, textureRect) sdl.renderCopy(renderer, chefTexture, None, testRect) sdl.renderPresent(renderer)
def getRect(self, xMin, yMin): return sdl.Rect((int(self.xPos) - int(xMin), int(self.yPos) - int(yMin), self.width, self.height))