class Screen:
def __init__(self, window, scene, menu):
self.u = (2./3, -1./3.5)
self.v = (-2./3, -1./3.5)
self.w = (0, -15)
self._window = window
self._scene = scene
self._hud = HUD(self)
self._grid = Grid(self)
self._players = pygame.sprite.Group()
player1 = PlayerSprite(scene.getPlayer(0), menu)
self._playerG1 = pygame.sprite.Group()
self._playerG1.add(player1)
player2 = PlayerSprite(scene.getPlayer(1), menu)
self._playerG2 = pygame.sprite.Group()
self._playerG2.add(player2)
self._players.add(player1)
self._players.add(player2)
self._shadows = pygame.sprite.Group()
self._shadows.add(ShadowSprite(scene.getPlayer(0)))
self._shadows.add(ShadowSprite(scene.getPlayer(1)))
self._weaponGroup = pygame.sprite.Group()
self._weaponList = [WeaponSprite(scene.getPlayer(0).weapon()),
WeaponSprite(scene.getPlayer(1).weapon())]
def calcPos(self, vector):
return (
vector[0]*self.u[0] + vector[1]*self.v[0] + vector[2]*self.w[0] +
self._window.get_width()/2,
vector[0]*self.u[1] + vector[1]*self.v[1] + vector[2]*self.w[1] +
self._window.get_height()/2
)
def calcPosZ(self, vector):
return vector[0] + vector[1]
def calcVec(self, vector):
return (
vector[0]*self.u[0] + vector[1]*self.v[0],
vector[0]*self.u[1] + vector[1]*self.v[1]
)
def draw(self):
self._players.update(self._scene, self)
self._shadows.update(self._scene, self)
self._window.fill(pygame.Color(255,255,255))
for w in self._weaponList:
if w.weapon().active():
self._weaponGroup.add(w)
else:
self._weaponGroup.remove(w)
self._weaponGroup.update()
self._grid.draw()
self._shadows.draw(self._window)
if self.calcPosZ(self._scene.getPlayer(0).position()) > self.calcPosZ(self._scene.getPlayer(1).position()):
self._playerG1.draw(self._window);
self._playerG2.draw(self._window);
else:
self._playerG2.draw(self._window);
self._playerG1.draw(self._window);
self._weaponGroup.draw(self._window)
self._grid.afterDraw()
self._hud.draw()
pygame.display.flip()
class MapState:
global amountOfLevels
global highestLevelComplete
global currentLevel
amountOfLevels = 5
highestLevelComplete = 0
currentLevel = 4
def __init__(self, gsm):
self.gsm = gsm
self.HUD = HUD(self.gsm)
global currentLevel
global highestLevelComplete
# If you beat all the levels
if highestLevelComplete == 5:
self.gsm.setState(self.gsm.VICTORYSTATE)
# Level Images
self.levelImgRed = pygame.image.load(
os.path.join("res", "MapState", "map level red.png"))
self.levelImgRed = pygame.transform.scale(self.levelImgRed, (50, 50))
self.levelImgBlue = pygame.image.load(
os.path.join("res", "MapState", "map level blue.png"))
self.levelImgBlue = pygame.transform.scale(self.levelImgBlue, (50, 50))
self.levelImgGray = pygame.image.load(
os.path.join("res", "MapState", "map level gray.png"))
self.levelImgGray = pygame.transform.scale(self.levelImgGray, (50, 50))
# Level Locations
# Level1
self.level1X = 100
self.level1Y = 500
# Level2
self.level2X = 450
self.level2Y = 425
# Level 3
self.level3X = 275
self.level3Y = 325
# Level 4
self.level4X = 600
self.level4Y = 250
# Level 5
self.level5X = 350
self.level5Y = 125
# Player boat (navigator)
self.player = pygame.image.load(
os.path.join("res", "MapState", "menu boat.png"))
self.playerX = 90
self.playerY = 450
def update(self):
if currentLevel == 1:
self.playerX = self.level1X
self.playerY = self.level1Y
elif currentLevel == 2:
self.playerX = self.level2X
self.playerY = self.level2Y
elif currentLevel == 3:
self.playerX = self.level3X
self.playerY = self.level3Y
elif currentLevel == 4:
self.playerX = self.level4X
self.playerY = self.level4Y
elif currentLevel == 5:
self.playerX = self.level5X
self.playerY = self.level5Y
def draw(self, window):
window.fill(Color.TEAL)
# Levels
# Level 1
if highestLevelComplete == 0: # if you have not completed any level
window.blit(self.levelImgRed, (self.level1X, self.level1Y))
elif highestLevelComplete > 0: # if you have the level
window.blit(self.levelImgBlue, (self.level1X, self.level1Y))
else:
window.blit(self.levelImgGray, (self.level1X, self.level1Y))
# Level 2
if highestLevelComplete == 1: # if you have beat level 1
window.blit(self.levelImgRed, (self.level2X, self.level2Y))
elif highestLevelComplete > 1: # if you have beat the level
window.blit(self.levelImgBlue, (self.level2X, self.level2Y))
else:
window.blit(self.levelImgGray, (self.level2X, self.level2Y))
# Level 3
if highestLevelComplete == 2: # if you have beat level 2
window.blit(self.levelImgRed, (self.level3X, self.level3Y))
elif highestLevelComplete > 2: # if you have beat the level
window.blit(self.levelImgBlue, (self.level3X, self.level3Y))
else:
window.blit(self.levelImgGray, (self.level3X, self.level3Y))
# Level 4
if highestLevelComplete == 3: # if you have beat level 3
window.blit(self.levelImgRed, (self.level4X, self.level4Y))
elif highestLevelComplete > 2: # if you have beat the level
window.blit(self.levelImgBlue, (self.level4X, self.level4Y))
else:
window.blit(self.levelImgGray, (self.level4X, self.level4Y))
# Level 5
if highestLevelComplete == 4: # if you have beat level 4
window.blit(self.levelImgRed, (self.level5X, self.level5Y))
elif highestLevelComplete > 3: # if you have beat the level
window.blit(self.levelImgBlue, (self.level5X, self.level5Y))
else:
window.blit(self.levelImgGray, (self.level5X, self.level5Y))
# Draw Lines
pygame.draw.line(window, Color.RED,
(self.level1X + 50, self.level1Y + 25),
(self.level2X, self.level2Y + 25))
pygame.draw.line(window, Color.RED, (self.level2X, self.level2Y + 25),
(self.level3X + 50, self.level3Y + 25))
pygame.draw.line(window, Color.RED,
(self.level3X + 50, self.level3Y + 25),
(self.level4X, self.level4Y + 25))
pygame.draw.line(window, Color.RED, (self.level4X, self.level4Y + 25),
(self.level5X + 50, self.level5Y + 25))
# Player
window.blit(self.player, (self.playerX, self.playerY))
self.HUD.draw(window)
def keyHandler(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
quit()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
self.gsm.setState(self.gsm.MENUSTATE)
if event.key == pygame.K_UP:
self.moveUp()
if event.key == pygame.K_DOWN:
self.moveDown()
if event.key == pygame.K_RETURN:
self.gsm.setState(self.gsm.PLAYSTATE)
def moveUp(self):
global currentLevel
if currentLevel <= highestLevelComplete:
currentLevel += 1
def moveDown(self):
global currentLevel
if currentLevel > 1:
currentLevel -= 1
def nextLevel(self):
global highestLevelComplete
highestLevelComplete += 1
class PlayState():
def __init__(self, gsm):
self.gsm = gsm
self.background = Background(
os.path.join("res", "PlayState", "background.png"))
self.camera = Camera(self)
self.HUD = HUD(self.gsm)
# Key handling
self.leftKeyDown = False
self.rightKeyDown = False
self.upKeyDown = False
self.spriteSheet = SpriteSheet(
os.path.join("res", "PlayState", "Spritesheet.png"), 1)
# Holds all the objects in the game
self.allObjectList = pygame.sprite.Group()
self.activeObjectList = pygame.sprite.Group()
self.terrainList = pygame.sprite.Group()
self.interactableList = pygame.sprite.Group()
self.enemyList = pygame.sprite.Group()
self.enemyAIList = pygame.sprite.Group()
self.player = None
self.level = currentLevel # Sets the current level
self.loadLevel(self.level) # Loads the level
def update(self):
# Fixes the bug where if you instantly switch directions you will stop moving
if self.leftKeyDown:
self.player.moveLeft()
if self.rightKeyDown:
self.player.moveRight()
self.camera.update(self.player)
self.HUD.update()
# PERFORMANCE FIX
# This block makes it so that only the objects that are within a certain range of the player will it update it and draw it.
# Runs through all the objects in the game and if it is within the range of the camera then add it to the active objects list.
for object in self.allObjectList:
if object.rect.right > -160 and object.rect.left < 960:
self.activeObjectList.add(object)
else:
self.activeObjectList.remove(object)
self.activeObjectList.update() # Updates all the active objects
self.background.update()
def draw(self, window):
window.fill(Color.CYAN)
self.background.draw(window)
self.activeObjectList.draw(window) # Draws all the active objects
self.HUD.draw(window)
def keyHandler(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
quit()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT:
self.leftKeyDown = True
if event.key == pygame.K_RIGHT:
self.rightKeyDown = True
if event.key == pygame.K_UP:
self.player.jump(9.5)
if event.type == pygame.KEYUP:
if event.key == pygame.K_LEFT:
self.player.stopMoving()
self.leftKeyDown = False
if event.key == pygame.K_RIGHT:
self.player.stopMoving()
self.rightKeyDown = False
def loadLevel(
self, level
): # Reads the pixels of an image for their RGB Values and depending on these values, create a object at that position
if level == 1:
mapData = Image.open(
os.path.join("res", "PlayState",
"Level1Map(sand).png")) # Loads level1
elif level == 2:
mapData = Image.open(
os.path.join("res", "PlayState", "Level2Map(sand).png"))
elif level == 3:
mapData = Image.open(
os.path.join("res", "PlayState", "Level3Map.png"))
elif level == 4:
mapData = Image.open(
os.path.join("res", "PlayState", "Level4Map.png"))
elif level == 5:
mapData = Image.open(
os.path.join("res", "PlayState", "Level5Map.png"))
mapWidth, mapHeight = mapData.size # Gets the width and height of the image
print("WIDTH: " + str(mapWidth) + " HEIGHT: " +
str(mapHeight)) # For debugging
for x in range(mapWidth): # Runs through all the colomns
for y in range(mapHeight): # Runs through all the rows
currentPixel = mapData.getpixel((x, y))
red = currentPixel[0] # RED VALUE
green = currentPixel[1] # GREEN VALUE
blue = currentPixel[2] # BLUE VALUE
alpha = currentPixel[3] # ALPHA VALUE
# Checks for player spawner
if red == 255 and green == 0 and blue == 255 and alpha == 255:
self.player = Player(
x * 32,
y * 32,
self,
self.gsm,
self.spriteSheet,
)
self.allObjectList.add(self.player)
# Check for Grass blocks
if red == 0 and green == 255 and blue == 0 and alpha == 255:
self.terrainList.add(
Grass(x * 32, y * 32, self.spriteSheet))
# Checks for dirt blocks
if red == 222 and green == 144 and blue == 61 and alpha == 255:
self.terrainList.add(Dirt(x * 32, y * 32,
self.spriteSheet))
# Checks for sand blocks
if red == 243 and green == 225 and blue == 179 and alpha == 255:
self.terrainList.add(Sand(x * 32, y * 32,
self.spriteSheet))
# Check for coin blocks
if red == 255 and green == 255 and blue == 0 and alpha == 255:
self.interactableList.add(
Coin(x * 32, y * 32, self.spriteSheet))
# Checks for enemy AI detection
if red == 0 and green == 0 and blue == 0 and alpha == 255:
self.enemyAIList.add(EnemyAIBox(x * 32, y * 32, self))
# Checks for Crab enemy
if red == 255 and green == 0 and blue == 0 and alpha == 255:
self.enemyList.add(
Crab(x * 32, y * 32, self, self.spriteSheet))
# Checks for map piece
if red == 0 and green == 0 and blue == 255 and alpha == 255:
self.interactableList.add(
Map(x * 32, y * 32, self.spriteSheet))
if red == 0 and green == 255 and blue == 255 and alpha == 255:
self.interactableList.add(
Chest(x * 32, y * 32, self, self.spriteSheet))
print("Chest addded")
# Adds all the groups into one master group
self.allObjectList.add(self.terrainList)
self.allObjectList.add(self.interactableList)
self.allObjectList.add(self.enemyList)
self.allObjectList.add(self.enemyAIList)
def removeObject(self, object):
# Removes a game object from the game
self.allObjectList.remove(object)
self.activeObjectList.remove(object)
def nextLevel(self):
global highestLevelComplete
global currentLevel
# This makes it so that if you play a level you already beat, it doesn't unlock a new level
if currentLevel > highestLevelComplete:
highestLevelComplete += 1
def reset(self):
global highestLevelComplete
global currentLevel
highestLevelComplete = 0
currentLevel = 1
self.HUD.reset()
class MainScreen(Screen):
"""
The screen where all of the action takes place.
It consists of a viewport and a HUD
#Attributes:
@param viewport: A window into the active world.
@type viewport: L{Viewport}
@param hud: The HUD displays information to the player. It does not contain
a debug menu, but does contain resource counts, menus, etc...
@type hud: L{HUD}
@param clientID: identifying string or number given by the server
when a client is created
"""
def __init__(self,clientID):
Screen.__init__(self)
self.viewport = None
self.hud = None
self.clientID = clientID
def setClientID(self,clientID):
self.clientID = clientID
self.viewport.setClientID(clientID)
self.hud.setClientID(clientID)
def TEST_createViewport(self,world,manager):
scrollLoc = (0,0)
viewportPos = (0,0)
viewportSize = (1024,768)
testViewport = Viewport(world,manager,scrollLoc,viewportPos,viewportSize,self.clientID)
self.viewport = testViewport
self.hud=HUD(manager,self.clientID)
self.viewport.hud=self.hud
self.hud.viewport=self.viewport
def draw(self,displaySurface,size):
self.viewport.draw(displaySurface)
self.hud.draw(displaySurface)
def processMouseMovedEvent(self,event):
self.viewport.mouseMoved(event)
def processMouseClickEvent(self,event):
self.viewport.clickEvent(event)
def processDragBeganEvent(self,event):
self.viewport.startDrag(event)
def processDragEvent(self,event):
self.viewport.continueDrag(event)
def processDragCompletedEvent(self,event):
self.viewport.completeDrag(event)
def processAddDragCompletedEvent(self,event):
self.viewport.completeDrag(event)
def processNumberKeyPressEvent(self,event):
if event.state == Event.KeyLocals.UP:
if event.comboKeys['ctrl']:
self.viewport.setQuickSelect(event)
else:
self.viewport.getQuickSelect(event)
def processCompleteActionEvent(self,event):
self.viewport.completeActionEvent(event)
def processInitiateActionEvent(self,event):
self.viewport.initiateActionEvent(event)
def processUpdateEvent(self,event):
self.viewport.processUpdateEvent(event)
self.hud.processUpdateEvent(event)
def processGameOverEvent(self,event):
self.viewport.setGameOver()
def changeWorld(self,world):
self.viewport.changeWorld(world)
