def __init__(self, map_screen, background_screen, text_screen):
"""
Constructor.
:param map_screen: Surface
:param background_screen: Surface
:param text_screen: Surface
"""
self.amount_of_enemies = 0
self.amount_of_empty_colonies = 0
self.map_to_load = None
self.race_manager = RaceManager()
self.human_players = []
self.players = []
self.map = Map(GUISettings.SCREEN_WIDTH, GUISettings.SCREEN_HEIGHT)
self.event_handler = EventHandler(self)
self.screen = map_screen
self.background_screen = background_screen
self.player_one = Player()
self.human_players.append(self.player_one)
self.sound_driver = SoundDriver()
self.map_loader = MapLoader(self)
self.text_screen = text_screen
self.running = True
self.map_manager = MapManager()
self.state = MainMenu(self)
self.menu = MenuSettings.MAIN_MENU(self)
def __init__(self):
# player erstellen
self.player = Player(1000, 3000)
# towerliste
self.towers = []
# bloonliste
self.bloons = []
# projectileliste
self.projectiles = []
# wellen
self.level = Level.from_file("res/level/level_1.json")
# ui liste
self.ui_elements = [
Button(1620, 950, 280, 50, (107, 142, 35), (34, 139, 34), "Start", self.set_spawn_true),
Button(1620, 1020, 280, 50, (205, 92, 92), (178, 34, 34), "Exit", exit),
Label(1620, 10, (255, 0, 0), "Lifepoints: ", self.player),
Label(1620, 60, (255, 0, 0), "Money: ", self.player),
Label(1620, 110, (255, 0, 0), "Wave: ", self.level.curr_wave),
Image(1870, 20, "res\pictures\heart.png"),
Image(1870, 70, "res\pictures\money.png"),
]
# market
self.shops = [Bananamarket(1615, 155)]
# mouscoordinates
self.mouse = pygame.mouse.get_pos()
# später in menu class
self.font = pygame.font.SysFont('monospace', 30)
# grid
self.grid = MapLoader.zwerg_101()
def main():
pygame.mixer.Channel(0).set_volume(0.1)
pygame.mixer.Channel(1).set_volume(0.2)
pygame.mixer.Channel(2).set_volume(0)
pygame.mixer.Channel(3).set_volume(0.3)
pygame.mixer.Channel(4).set_volume(0)
pygame.mouse.set_visible(False)
# Запускаем главное меню
StartMenu(screen)
# Загружаем игру, когда главное меню закрылось
level = MainMap('world.tmx', MapLoader())
level.player.health = 100
level.player.temperature = 100
level.player.wood = 2
# Панели состояния игрока
heath_hud = HealthHUD(level.player)
inv_hud = InventoryHUD(level.player)
# Открываем окно с правилами
level.text_window.open()
pygame.mixer.Channel(0).set_volume(0.2)
clock = pygame.time.Clock()
running = True
while running:
start = time.time()
# Если здоровье падает до нуля открываем окно game_over
if level.player.health <= 0:
level.game_over(screen)
return True
for event in pygame.event.get():
if event.type == pygame.QUIT:
return False
# Нажатие на клетку
if event.type == pygame.MOUSEBUTTONDOWN:
if event.button == 1:
level.click_listener(event.pos)
# Отрисовка элементов
level.update(screen)
heath_hud.render(screen)
inv_hud.render(screen)
screen.blit(compass, (SCREEN_WIDTH - compass.get_width(),
SCREEN_HEIGHT - compass.get_height()))
# Убираем курсор если окно не в фокусе
if pygame.mouse.get_focused():
screen.blit(pointer, (pygame.mouse.get_pos()))
pygame.display.update()
framerate = 1 / (time.time() - start)
clock.tick(FPS)
def __init__(self, sweepOffset):
self.sweepAngle = 0
self.sweepOffset = sweepOffset
self.calcDone = 0
self.collisionPointAdjustX = 5
self.minAllowedPairDist = 15
self.rotation = 0.0
self.extremePoints = []
self.boundingBox = []
self.centerPoint = Point(0, 0)
self.sweepLines = []
self.collisionGroups = []
self.collisionPairs = []
self.innerBorders = []
self.outerBorder = Shape()
self.mowerPoint = None
self.stationPoint = None
self.mLoader = MapLoader()
def __init__(self):
# Get some references
self.engine = annchienta.getEngine()
self.inputManager = annchienta.getInputManager()
self.mapManager = annchienta.getMapManager()
self.cacheManager = annchienta.getCacheManager()
self.mathManager = annchienta.getMathManager()
self.sceneManager = SceneManager.getSceneManager()
# Set variables
self.player = 0
self.records = []
self.inventory = 0
self.lastMaps = []
self.currentMap = 0
self.startTime = 0
# Create a map loader
self.mapLoader = MapLoader()
# Battle variables
self.randomBattleDelay = self.mathManager.randInt(300, 400)
def __init__(self, screen: pygame.Surface):
clock = pygame.time.Clock()
# Камера в начальном экране крутится по эллипсу
self.angle = 0 # Текущий угол
self.Rx = 80 # Радиус по горизонтали
self.Ry = 30 # Радиус по вертикали
# Для стартового окна есть отдельная карта
self.level = MenuMap('start_menu.tmx', MapLoader())
# Бесконечный костер
for fire in self.level.objects.values():
if type(fire) == Fire:
fire.time = 100000
# Начальное смещение камеры
self.ofx = -9 * 32
self.ofy = -12 * 32
# Рамки, интерфейса и их выравнивание
self.frame1 = Frame1()
self.frame1.align_center()
self.frame2 = Frame2()
self.frame2.align_center()
self.frame1.y += self.frame2.image.get_height() // 2
self.frame2.y -= self.frame1.image.get_height() // 2
# Название игры
self.text_frame1_title = Text(text='The long way', size=90)
self.text_frame1_title.align_center()
self.text_frame1_title.y -= self.frame1.image.get_height() // 2
self.button_start = Button1('Начать игру')
self.button_start.align_center()
self.button_start.set_pos(
self.button_start.frame.x,
self.frame1.y + self.frame1.image.get_height() // 6)
self.button_exit = Button1('Выйти')
self.button_exit.align_center()
self.button_exit.set_pos(
self.button_exit.frame.x,
self.frame1.y + self.frame1.image.get_height() * 9 // 10 -
self.button_exit.frame.image.get_height() -
self.button_exit.frame.image.get_height())
# Установка функций на кнопки
self.button_exit.func = self.exit
self.button_start.func = self.start
self.running = True
while self.running:
self.camera_moving()
for event in pygame.event.get():
# Выход из программы при закрытии окна
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
# Анимация огня
for fire in self.level.objects.values():
if type(fire) == Fire:
fire.update()
# Обновления состояний кнопок
self.button_start.update()
self.button_exit.update()
# Отрисоква уровня
self.level.render(screen)
# Затемнение фона, путем наложения полупрозрачного прямоугольника на экран
s = pygame.Surface(screen.get_size())
s.set_alpha(128)
s.fill((0, 0, 0))
screen.blit(s, (0, 0))
# Отрисовка интерфейса поверх уровня
self.frame1.render(screen)
self.frame2.render(screen)
self.text_frame1_title.render(screen)
self.button_start.render(screen)
self.button_exit.render(screen)
# Отрисовка курсора
if pygame.mouse.get_focused():
screen.blit(pointer, (pygame.mouse.get_pos()))
pygame.display.update()
clock.tick(FPS)
def __init__(self, playerProperties, sizeX: int, sizeY: int, gameEngine,
screen, level, settings, sounds):
self.sounds = sounds
self.screenSizeX = sizeX
self.screenSizeY = sizeY
self.MOUSE_CONTROL = settings['MOUSE_CONTROL']
#self.screen = pygame.display.set_mode((sizeX, sizeY))
self.screen = screen
self.background = pygame.Surface((sizeX, sizeY))
self.engine = gameEngine
self.player = Player(**playerProperties)
self.keyControl = {
pygame.K_SPACE:
KeyState(
lambda: self.addPlayerMissile(self.player.shoot(self.sounds)))
}
# self.obstacles = [Obstacle(400, 400, 100, 100, (50,50,50), points = ((0, 50), (90, 80), (100, 10), (0,0)))]
# self.obstacles.append(Obstacle(-100, -100, 1200, 100, visible = False))
# self.obstacles.append(Obstacle(-100, -100, 100, 1200, visible = False))
# self.obstacles.append(Obstacle(-100, 1000, 1200, 100, visible=False))
self.mapEl = set()
self.playerMissiles = set()
self.missiles = set()
self.turrets = set()
self.obstacles = set()
M = MapLoader(self, level)
M.load()
# letter replace next lines with map loader
# el = MapElement(0, 0, 1000, 1000, "space1.jpeg", ((0, 0), (1000, 0), (1000, 1000), (0, 500)))
# self.addMapEl(el)
# el = MapElement(1000, 1000, 100, 100, "space1.jpeg") # if el is a rect it not need cords
# self.addMapEl(el)
# el = MapElement(1000, 400, 1000, 2000, "space1.jpeg")
# self.addMapEl(el)
# self.turrets.append(StandardTurret(500,500,75,20,100,2,pi/2,0,1000))
# self.turrets.append(RocketTurret(500,700,75,100,100,5,pi/2,0,600,self.player))
#"""
if level == 0:
for i in range(5, 1000, 5):
self.turrets.add(
StandardTurret(i * 200 + 500, 500, 75, 20, 100, 2, pi / 2,
0, 1000))
self.turrets.add(
RocketTurret(i * 200 + 500, 700, 75, 100, 100, 5, pi / 2,
0, 600, self.player))
self.turrets.add(
LaserTurret(i * 200 + 550, 800, 75, 20, 40, 4, pi / 2, pi,
3, self))
self.obstacles.add(
Obstacle(200 * i - 100, -100, 1200, 100, visible=False))
self.obstacles.add(
Obstacle(200 * i - 100, 1000, 1200, 100, visible=False))
#self.addMapEl( MapElement(200*i, 0, 1000, 1000, "space1.jpeg", ) )
self.obstacles.add(Obstacle(8900, -100, 100, 1200, visible=False))
#"""
self.sectors = Sectors(self.turrets, self.obstacles)
class Map:
sweepAngle = 0
sweepOffset = 0
calcDone = 0
extremePoints = []
boundingBox = []
centerPoint = Point(0, 0)
sweepLines = []
collisionGroups = []
collisionPairs = []
outerBorder = Shape()
innerBorders = []
mLoader = MapLoader()
#
def __init__(self, sweepOffset):
self.sweepAngle = 0
self.sweepOffset = sweepOffset
self.calcDone = 0
self.collisionPointAdjustX = 5
self.minAllowedPairDist = 15
self.rotation = 0.0
self.extremePoints = []
self.boundingBox = []
self.centerPoint = Point(0, 0)
self.sweepLines = []
self.collisionGroups = []
self.collisionPairs = []
self.innerBorders = []
self.outerBorder = Shape()
self.mowerPoint = None
self.stationPoint = None
self.mLoader = MapLoader()
#
def FindExtremePoints(self):
mostNorth = self.outerBorder.pointList[0]
for point in self.outerBorder.pointList:
if mostNorth.y > point.y:
mostNorth = point
mostSouth = self.outerBorder.pointList[0]
for point in self.outerBorder.pointList:
if mostSouth.y < point.y:
mostSouth = point
mostEast = self.outerBorder.pointList[0]
for point in self.outerBorder.pointList:
if mostEast.x < point.x:
mostEast = point
mostWest = self.outerBorder.pointList[0]
for point in self.outerBorder.pointList:
if mostWest.x > point.x:
mostWest = point
mostNorth.y -= 0
mostSouth.y += 0
mostEast.x += 0
mostWest.x -= 0
self.extremePoints = []
self.extremePoints.append(mostNorth)
self.extremePoints.append(mostSouth)
self.extremePoints.append(mostEast)
self.extremePoints.append(mostWest)
print 'Positions relative window: '
print('mostNorth', self.extremePoints[0].x, self.extremePoints[0].y)
print('mostSouth', self.extremePoints[1].x, self.extremePoints[1].y)
print('mostEast', self.extremePoints[2].x, self.extremePoints[2].y)
print('mostWest', self.extremePoints[3].x, self.extremePoints[3].y)
#
def CreateBoundingBox(self):
self.boundingBox = []
self.boundingBox.append(Point(0, 0))
self.boundingBox.append(Point(0, 0))
self.boundingBox.append(Point(0, 0))
self.boundingBox.append(Point(0, 0))
self.boundingBox[0].y = self.extremePoints[0].y # most north
self.boundingBox[0].x = self.extremePoints[3].x # most west
self.boundingBox[1].y = self.extremePoints[0].y # most north
self.boundingBox[1].x = self.extremePoints[2].x # most east
self.boundingBox[2].y = self.extremePoints[1].y # most south
self.boundingBox[2].x = self.extremePoints[2].x # most east
self.boundingBox[3].y = self.extremePoints[1].y # most south
self.boundingBox[3].x = self.extremePoints[3].x # most west
#
def LineSweep(self):
self.sweepLines = []
self.collisionGroups = []
distX = self.boundingBox[0].DistToPoint(self.boundingBox[1].x,
self.boundingBox[1].y)
distY = self.boundingBox[0].DistToPoint(self.boundingBox[3].x,
self.boundingBox[3].y)
print('Distance X:', distX)
print('Distance Y:', distY)
if self.sweepAngle == 0 or self.sweepAngle == 180:
# traverse down on y-axis
y = 0
count = 0
trigger = self.sweepOffset
while True:
if y >= distY:
break
# "Fire line ray"
if y >= trigger:
p1 = Point(self.boundingBox[0].x,
self.boundingBox[0].y + y)
p2 = Point(self.boundingBox[0].x + distX,
self.boundingBox[0].y + y)
l = Line(p1, p2)
collisionsOnSameLine = []
# check line intersections and collect intersect points from lawn boundarys
for line in self.outerBorder.lineList:
point = l.GetIntersectionPoint(line)
if point:
collisionsOnSameLine.append(point)
# check collision with obstacles
if len(self.innerBorders) > 0:
for shape in self.innerBorders:
# check line intersections and collect intersect points from lawn boundarys
for line in shape.lineList:
point = l.GetIntersectionPoint(line)
if point:
collisionsOnSameLine.append(point)
#prevPoint = point
self.SortPoints(collisionsOnSameLine)
self.VertexPointAdjust(collisionsOnSameLine)
#
if len(collisionsOnSameLine) % 2 != 0:
print("Error! odd number of collisions on line!")
print("num collisions on this line",
len(collisionsOnSameLine))
for point in collisionsOnSameLine:
print point.x
if len(collisionsOnSameLine) > 0:
self.collisionGroups.append(collisionsOnSameLine)
trigger += self.sweepOffset
count += 1
self.sweepLines.append(l)
y += 1
count = 0
for points in self.collisionGroups:
for point in points:
count += 1
print("Number of collision points: ", count)
return
# Sorts the points in a list from left closest to the y-axis line
def SortPoints(self, inPoints):
i = 0
sortedPoints = []
points = copy.deepcopy(inPoints)
while True:
if len(points) == 0:
break
j = 1
# x = 0 but y on the same y as the point
newDist = points[0].DistToPoint(0, points[0].y)
dist = 0
currPoint = points[0]
while True:
if j >= len(points):
index = points.index(currPoint)
sortedPoints.append(points.pop(index))
#print ("saved new Dist:", newDist)
break
dist = points[j].DistToPoint(0, points[j].y)
if newDist > dist:
newDist = dist
currPoint = points[j]
j += 1
i += 1
points = sortedPoints
# Sorts the collision points on the same line from left closest to y-axis
def SortCollisionPoints(self):
i = 0
while True:
if i >= len(self.collisionGroups):
break
j = 0
points = self.collisionGroups[i]
sortedPoints = []
while True:
if len(points) == 0:
break
k = 1
# x = 0 but y on the same y as the point
newDist = points[0].DistToPoint(0, points[0].y)
dist = 0
currPoint = points[0]
while True:
if k >= len(points):
index = points.index(currPoint)
sortedPoints.append(points.pop(index))
#print ("saved new Dist:", newDist)
break
dist = points[k].DistToPoint(0, points[k].y)
if newDist > dist:
newDist = dist
currPoint = points[k]
k += 1
j += 1
self.collisionGroups[i] = sortedPoints
i += 1
#
def SplitVertexAndGetCenterPoint(self, p1, p2):
l1 = p1.intersectingLine
l2 = p2.intersectingLine
yDirection1 = None
yDirection2 = None
pEnd1 = p1.intersectingLine.p1
if pEnd1.x == p1.x and pEnd1.y == p1.y:
pEnd1 = p1.intersectingLine.p2
pEnd2 = p2.intersectingLine.p1
if pEnd2.x == p2.x and pEnd2.y == p2.y:
pEnd2 = p2.intersectingLine.p2
print("pEnd1:", pEnd1.x, pEnd1.y)
print("pEnd2:", pEnd2.x, pEnd2.y)
if p1.y > pEnd1.y:
yDirection1 = -1
elif p1.y < pEnd1.y:
yDirection1 = 1
elif p1.y == pEnd1.y:
print "WARNING! p1 vertex y values the same"
return p1
if p2.y > pEnd2.y:
yDirection2 = -1
elif p2.y < pEnd2.y:
yDirection2 = 1
if p2.y == pEnd2.y:
print "WARNING! p2 vertex y values the same"
if yDirection1 == yDirection2:
return None
return p1
#
def VertexPointAdjust(self, inPoints):
if len(inPoints) <= 0:
return
#print "BEGIN VERTEX ADJUST"
i = 0
while True:
if i >= len(inPoints):
break
currPoint = inPoints[i]
j = i + 1
while True:
if j >= len(inPoints):
break
if currPoint.x == inPoints[j].x and currPoint.y == inPoints[
j].y:
print "Vertex Found"
print(currPoint.x, inPoints[j].x)
if self.SplitVertexAndGetCenterPoint(
currPoint, inPoints[j]):
print "removing 1 points"
inPoints.pop(j)
j -= 1
else:
print "removing 2 points"
inPoints.pop(j)
inPoints.pop(i)
j -= 1
i -= 1
j += 1
i += 1
#
def RemoveClosePairs(self, shapeList, minAllowedDist):
# remove pairs that are to close to each other. Set distance to max mower width
for points in shapeList:
i = 0
while True:
if i >= len(self.collisionGroups):
break
j = 0
points = self.collisionGroups[i]
while True:
if j >= len(points):
break
dist = points[j].DistToPoint(points[j + 1].x,
points[j + 1].y)
if dist < minAllowedDist:
points.pop(j + 1)
points.pop(j)
j -= 2
j += 2
i += 1
#
def PairAndAdjustCollisionPoints(self):
if len(self.collisionGroups) <= 0:
return
self.collisionPairs = []
newId = 1
for points in self.collisionGroups:
i = 0
while True:
if i >= len(points):
break
#pair and adjust collision points on x-axis
points[i].id = newId
points[i].x += self.collisionPointAdjustX
points[i + 1].id = newId
points[i + 1].x -= self.collisionPointAdjustX
self.collisionPairs.append(points[i])
self.collisionPairs.append(points[i + 1])
newId += 1
i += 2
print("Number of Pair Id's: ", newId - 1)
print("First Pair id: ", 1)
print("Last Pair id: ", newId)
#
def ScaleBorder(self, pList, k):
length = len(pList)
if length > 0:
i = 0
while True:
if i >= length:
break
mat2 = Mat2()
pList[i] = mat2.Scale(pList[i], k)
i += 1
#
def RotateBorder(self, pList, degree):
length = len(pList)
if length > 0:
i = 0
while True:
if i >= length:
break
mat2 = Mat2()
pList[i] = mat2.Rotate(pList[i], degree)
i += 1
#
def TranslateBorder(self, pList, dst):
length = len(pList)
if length > 0:
i = 0
while True:
if i >= length:
break
mat2 = Mat2()
pList[i] = mat2.Translate(pList[i], dst)
i += 1
#
def Calculate(self):
print "Begin Map Calculation!......................"
if len(self.outerBorder.pointList) <= 0:
return
#
self.centerPoint.y = 400 * -1
self.centerPoint.x = 400 * -1
self.TranslateBorder(self.outerBorder.pointList, self.centerPoint)
self.RotateBorder(self.outerBorder.pointList, self.rotation)
#self.ScaleBorder( self.outerBorder.pointList, 5 )
#
self.centerPoint.y = 400 * 1
self.centerPoint.x = 400 * 1
self.TranslateBorder(self.outerBorder.pointList, self.centerPoint)
self.FindExtremePoints()
self.CreateBoundingBox()
self.LineSweep()
self.SortCollisionPoints()
minAllowedDist = self.minAllowedPairDist * 3
self.RemoveClosePairs(self.collisionGroups, minAllowedDist)
self.PairAndAdjustCollisionPoints()
#
self.centerPoint.y = 400 * -1
self.centerPoint.x = 400 * -1
self.TranslateBorder(self.outerBorder.pointList, self.centerPoint)
self.TranslateBorder(self.collisionPairs, self.centerPoint)
self.RotateBorder(self.outerBorder.pointList, 360 - self.rotation)
self.RotateBorder(self.collisionPairs, 360 - self.rotation)
#self.ScaleBorder( self.outerBorder.pointList, 1.052631579 )
#
self.centerPoint.y = 400 * 1
self.centerPoint.x = 400 * 1
self.TranslateBorder(self.outerBorder.pointList, self.centerPoint)
self.TranslateBorder(self.collisionPairs, self.centerPoint)
#self.CreateBoundingBox()
self.calcDone = 1
print "Map Calculation......................Complete!"
#
def LoadMap(self):
self.mLoader.LoadMap()
self.outerBorder = []
self.innerBorders = []
self.outerBorder = self.mLoader.shape
self.innerBorders = self.mLoader.shapes
self.mowerPoint = self.mLoader.mowerP
self.stationPoint = self.mLoader.stationP
#
def SaveMap(self, mower=None, station=None):
if mower and station:
self.mLoader.SaveMap(self.outerBorder, self.innerBorders, mower,
station)
elif mower:
self.mLoader.SaveMap(self.outerBorder, self.innerBorders, mower)
elif station:
self.mLoader.SaveMap(self.outerBorder, self.innerBorders, None,
station)
else:
self.mLoader.SaveMap(self.outerBorder, self.innerBorders)
#
def Reset(self):
self.sweepAngle = 0
self.calcDone = 0
self.lawnExtremePoints = []
self.boundingBox = []
self.sweepLines = []
self.collisionPoints = []
self.collisionPairs = []
self.innerBorders = []
self.outerBorder = Shape()
self.mowerPoint = None
self.stationPoint = None
class Driver:
"""
Game driver. Sets matches, takes input, controls game flow and checks for a winner.
"""
def __init__(self, map_screen, background_screen, text_screen):
"""
Constructor.
:param map_screen: Surface
:param background_screen: Surface
:param text_screen: Surface
"""
self.amount_of_enemies = 0
self.amount_of_empty_colonies = 0
self.map_to_load = None
self.race_manager = RaceManager()
self.human_players = []
self.players = []
self.map = Map(GUISettings.SCREEN_WIDTH, GUISettings.SCREEN_HEIGHT)
self.event_handler = EventHandler(self)
self.screen = map_screen
self.background_screen = background_screen
self.player_one = Player()
self.human_players.append(self.player_one)
self.sound_driver = SoundDriver()
self.map_loader = MapLoader(self)
self.text_screen = text_screen
self.running = True
self.map_manager = MapManager()
self.state = MainMenu(self)
self.menu = MenuSettings.MAIN_MENU(self)
def get_races(self):
"""
:return: Dictionary with available races
"""
return self.race_manager.get_races()
def get_races_array(self):
"""
:return: Array with available races
"""
return self.race_manager.get_races_array()
def get_maps(self):
"""
:return: Dictionary with available maps
"""
return self.map_manager.get_maps()
def get_maps_array(self):
"""
:return: Array with available maps
"""
return self.map_manager.get_maps_array()
def is_running(self):
"""
:return: True if the game is running and False otherwise
:rtype: bool
"""
return self.running
def quit(self):
"""
Set running state to False.
"""
self.running = False
def load_map(self):
"""
Load map from selected data.
"""
# Clear players
self.players = []
# Load map
self.map_loader.load_in_map(self.map_to_load, self.map,
self.human_players)
# Set new players
self.players = self.map_loader.players
def add_random_player(self):
"""
Add an enemy with a random race.
"""
self.players.append(RandomPlayer())
def set_player_name(self, name):
"""
Set a name for the player.
:param name: Name to set
"""
# TODO: Set and use player name
self.player_one.set_name(name)
def set_player_race(self, race):
"""
Set race for the human player.
:param race: Race to set
"""
self.player_one.set_race(race)
def get_player_name(self):
"""
:return: Player's name
"""
return self.player_one.name
def get_player_race(self):
"""
:return: Player's race
"""
return self.player_one.race
def add_player(self, player):
"""
:param player: Add a new player to the game
"""
self.players.append(player)
def check_winning_condition(self):
"""
Check if there's a winner. A race is the winning race when there are no other races on the map.
:return The winner
:rtype AbstractRace
"""
win = NullRace()
for gr_col in self.map.graphic_colonies:
race = gr_col.colony.race
if win.same_type(NullRace()):
win = race
if not race.same_type(NullRace()) and not race.same_type(win):
return NullRace()
for gr_pty in self.map.graphic_parties:
if not gr_pty.party.race.same_type(win):
return NullRace()
self.won(win)
return win
def won(self, race):
"""
React after a winner has been found.
:param race: Winning race
:type race: AbstractRace
"""
self.state.won(race)
def set_state(self, state):
"""
Change current game state.
:param state: The new state
:type state: GameState
"""
self.state = state
def tick(self):
"""
Actions to perform every tick.
"""
# Handle input
self.handle_events()
# Update background
self.map.tick_background()
# Draw background
self.map.draw_background(self.background_screen)
# Run main
self.run()
# Check for a winner
self.check_winning_condition()
def handle_events(self):
"""
Ask the event handler to handle input.
"""
self.event_handler.handle_events()
def run(self):
"""
Run main, specified by current state.
"""
self.state.run()
def get_colonies_in(self, position):
"""
Get colonies that contain given point.
:param position: Point to scan
:type position: Point
:return: Array of colonies
:rtype List
"""
return self.map.get_colonies_in(position)
def select(self, position):
"""
Select given position and act according to current state.
:param position: Position selected
:type position: tuple
"""
position = Point(position[0], position[1])
self.state.select(position)
def release_mouse(self, position):
"""
Release mouse at given position and act according to current state.
:param position: Position where release occurs
:type position: tuple
"""
position = Point(position[0], position[1])
self.state.release_mouse(position)
def hover(self, position):
"""
Hover at given position and act according to current state.
:param position: Position to hover
:type position: tuple
"""
position = Point(position[0], position[1])
self.state.hover(position)
def update_mouse_position(self, position):
"""
Acknowledge current mouse position.
:param position: Mouse position
:type position: tuple
"""
position = Point(position[0], position[1])
self.state.update_mouse_position(position)
def pause_key(self):
"""
Pause key has been pressed.
"""
self.state.pause()
def main_menu_key(self):
"""
Main menu key has been pressed.
"""
self.state.main_menu_key()
def selection_left(self):
"""
Selection left key has been pressed.
"""
self.state.selection_left()
def selection_right(self):
"""
Selection right key has been pressed.
"""
self.state.selection_right()
def selection_up(self):
"""
Selection up key has been pressed.
"""
self.state.selection_up()
def selection_down(self):
"""
Selection down key has been pressed.
"""
self.state.selection_down()
def select_key(self):
"""
Selection key has been pressed.
"""
self.state.select_key()
def load_random_map(self):
"""
Load a random map.
"""
# Make screen transparent in one tick
self.move_alpha_to(self.screen, 0, 255)
# Remove all players
self.players = []
# Load map
# # self.map_loader.load_in_map(FOUR_BASES, self.map, self.human_players)
self.map_loader.load_random(self.map, self.amount_of_empty_colonies,
40, 60, self.human_players,
self.amount_of_enemies,
self.race_manager.get_races_array())
# Retrieve players for this match
self.players = self.map_loader.players
@staticmethod
def move_alpha_to(surface,
target,
speed=GUISettings.DEFAULT_ALPHA_CHANGE_SPEED):
"""
Move alpha of a given surface towards a target value.
:param surface: Surface which alpha to change
:type surface: Surface
:param target: Target alpha value
:type target: int
:param speed: Maximum change
:type speed: int
"""
current_alpha = surface.get_alpha()
if not current_alpha == target:
move_dir = (target - current_alpha) / abs(target - current_alpha)
move_amount = min(speed, abs(target - current_alpha))
surface.set_alpha(current_alpha + move_dir * move_amount)
def start_game(self):
"""
Start game. Load a map and change state.
"""
self.load_random_map()
self.set_state(InGame(self))
def start_custom_map_game(self):
"""
Start game. Load a map and change state.
"""
self.load_map()
self.set_state(InGame(self))
def set_menu(self, menu):
"""
Set current menu.
:param menu: Next menu
:type menu: Menu
"""
self.menu = menu
def play_select(self):
"""
Play select sound.
"""
self.sound_driver.play_select()
def play_move_selection(self):
"""
Play move selection sound.
"""
self.sound_driver.play_move_selection()
def play_taken(self):
"""
Play taken sound.
"""
self.sound_driver.play_taken()
class PartyManager(object):
def __init__(self):
# Get some references
self.engine = annchienta.getEngine()
self.inputManager = annchienta.getInputManager()
self.mapManager = annchienta.getMapManager()
self.cacheManager = annchienta.getCacheManager()
self.mathManager = annchienta.getMathManager()
self.sceneManager = SceneManager.getSceneManager()
# Set variables
self.player = 0
self.records = []
self.inventory = 0
self.lastMaps = []
self.currentMap = 0
self.startTime = 0
# Create a map loader
self.mapLoader = MapLoader()
# Battle variables
self.randomBattleDelay = self.mathManager.randInt(300, 400)
def getInventory(self):
return self.inventory
def getPlayer(self):
return self.player
def getCurrentMap(self):
return self.currentMap
def free(self):
self.currentMap.removeObject(self.player)
self.lastMaps += [self.currentMap]
self.clearMapCache()
self.currentMap = 0
self.team = 0
self.records = []
self.inventory = 0
self.mapManager.setNullMap()
self.player = 0
def clearMapCache(self):
self.lastMaps = []
def load(self, filename):
# Store filename for later use
self.filename = filename
self.document = xml.dom.minidom.parse(self.filename)
# Let's asume this is a valid file and
# the needed elements are there.
# Load the playtime for profiling reasons
playTimeElement = self.document.getElementsByTagName("playtime")[0]
self.seconds = int(playTimeElement.getAttribute("seconds"))
self.startTime = self.engine.getTicks()
# Start by loading the records, because they are needed by the map
recordsElement = self.document.getElementsByTagName("records")[0]
self.records = str(recordsElement.firstChild.data).split()
# Now we can safely load the map
mapElement = self.document.getElementsByTagName("map")[0]
self.currentMap = self.mapLoader.loadMap(
str(mapElement.getAttribute("filename")))
self.currentMap.setCurrentLayer(int(mapElement.getAttribute("layer")))
self.mapManager.setCurrentMap(self.currentMap)
# Now that we have a map we can place the player in it
playerElement = self.document.getElementsByTagName("player")[0]
self.player = annchienta.Person(
str(playerElement.getAttribute("name")),
str(playerElement.getAttribute("config")))
playerPosition = annchienta.Point(
annchienta.IsometricPoint, int(playerElement.getAttribute("isox")),
int(playerElement.getAttribute("isoy")))
# Add the player to the map and give him control
self.currentMap.addObject(self.player, playerPosition)
self.player.setInputControl()
self.mapManager.cameraFollow(self.player)
self.mapManager.cameraPeekAt(self.player, True)
# Load our inventory
inventoryElement = self.document.getElementsByTagName("inventory")[0]
self.inventory = Inventory.Inventory(inventoryElement)
# Load the team
teamElement = self.document.getElementsByTagName("team")[0]
self.team = map(Ally.Ally,
teamElement.getElementsByTagName("combatant"))
# Saves the game to filename.
def save(self, filename=None):
# Find out our filename
self.filename = self.filename if filename is None else filename
# Clear our map cache. (This is a good moment to do it, generally)
self.clearMapCache()
# Create the document and main document node.
self.document = xml.dom.minidom.Document()
partyElement = self.document.createElement("party")
self.document.appendChild(partyElement)
# Add the playtime to the party node
playTimeElement = self.document.createElement("playtime")
playTimeElement.setAttribute(
"seconds",
str(
int(self.seconds +
(self.engine.getTicks() - self.startTime) / 1000)))
partyElement.appendChild(playTimeElement)
# Append the records to the party node.
recordsElement = self.document.createElement("records")
# Create a text with the records
text = " "
for record in self.records:
text += record + " "
textNode = self.document.createTextNode(text)
recordsElement.appendChild(textNode)
partyElement.appendChild(recordsElement)
# Create an element for the map and add it to the party node
mapElement = self.document.createElement("map")
currentMap = self.mapManager.getCurrentMap()
mapElement.setAttribute("filename", currentMap.getFileName())
mapElement.setAttribute("layer",
str(currentMap.getCurrentLayerIndex()))
partyElement.appendChild(mapElement)
# Create an element for the player
playerElement = self.document.createElement("player")
playerElement.setAttribute("name", self.player.getName())
playerElement.setAttribute("config", self.player.getXmlFile())
point = self.player.getPosition()
point.convert(annchienta.IsometricPoint)
playerElement.setAttribute("isox", str(int(point.x)))
playerElement.setAttribute("isoy", str(int(point.y)))
partyElement.appendChild(playerElement)
# Append the inventory to the party node.
inventoryElement = self.document.createElement("inventory")
# Create a text with the records
text = self.inventory.toXml()
textNode = self.document.createTextNode(text)
inventoryElement.appendChild(textNode)
partyElement.appendChild(inventoryElement)
# Create an element for the team
teamElement = self.document.createElement("team")
for combatant in self.team:
combatantElement = self.document.createElement("combatant")
combatant.writeToXML(combatantElement, self.document)
teamElement.appendChild(combatantElement)
partyElement.appendChild(teamElement)
# Now open the file and throw it all in.
file = open(self.filename, "wb")
file.write(self.document.toprettyxml())
file.close()
def addRecord(self, record):
if not self.hasRecord(record):
self.records.append(record.lower())
def hasRecord(self, record):
return record.lower() in self.records
def removeRecord(self, record):
if self.hasRecord(record):
self.records.remove(record)
def changeMap(self,
newMapFileName,
newPosition=annchienta.Point(annchienta.TilePoint, 2, 2),
newLayer=0,
fade=True):
if fade:
self.sceneManager.fade()
# Remove player from map
self.currentMap.removeObject(self.player)
self.lastMaps += [self.currentMap]
self.currentMap = self.mapLoader.loadMap(newMapFileName)
self.currentMap.setCurrentLayer(newLayer)
self.currentMap.addObject(self.player, newPosition)
self.mapManager.setCurrentMap(self.currentMap)
self.mapManager.cameraPeekAt(self.player, True)
# Because loading a map can take some time:
self.mapManager.resync()
def changeLayer(self,
index,
newPosition=annchienta.Point(annchienta.TilePoint, 2, 2),
fade=True):
if fade:
self.sceneManager.fade()
self.player.setPosition(newPosition)
self.currentMap.removeObject(self.player)
self.currentMap.setCurrentLayer(index)
self.currentMap.addObject(self.player, newPosition)
# Because changing a layer can take some time:
self.mapManager.resync()
def refreshMap(self):
pos = self.player.getPosition()
self.changeMap(self.currentMap.getFileName(), pos, 0, False)
def heal(self):
for combatant in self.team:
combatant.setHp(combatant.getMaxHp())
combatant.setMp(combatant.getMaxMp())