简略的战旗游戏开发学习
在网上找寻教程之后搞出了这么个雏形
游戏介绍
游戏实现了战斗场景的回合制玩法：对战单方每个生物每一轮有一次口头机会，能够行走或攻打对方。每个生物属性有：行走范畴，速度，生命，挫伤，进攻，攻打 和 是否是近程兵种。当把对方生物都毁灭时，即胜利。
代码介绍
对于战旗类游戏的外围还是地图，尽管网上有六边形的地图教程然而没看太懂就做正方形的吧 首先定义函数，width 和 height 为地图的宽度和长度，bg_map 设置方格的背景色彩，entity_map 保留哪个方格上有生物。active_entity 示意以后要口头的生物。
class Map():
def __init__(self, width, height, grid):
self.width = width
self.height = height
self.bg_map = [[0 for x in range(self.width)] for y in range(self.height)]
self.entity_map = [[None for x in range(self.width)] for y in range(self.height)]
self.active_entity = None
self.select = None
self.setupMapImage(grid)
self.setupMouseImage()当我方生物抉择口头时，设置生物可行走范畴内的方格背景为 c.BG_RANGE。active_entity 的 inRange 函数判断一个方格是否在行走范畴内。
def updateMap(self):
for y in range(self.height):
for x in range(self.width):
self.bg_map[y][x] = c.BG_EMPTY
if self.entity_map[y][x] is not None and self.entity_map[y][x].isDead():
self.entity_map[y][x] = None
if self.active_entity is None or self.active_entity.state != c.IDLE:
return
map_x, map_y = self.active_entity.map_x, self.active_entity.map_y
self.bg_map[map_y][map_x] = c.BG_ACTIVE
for y in range(self.height):
for x in range(self.width):
if not self.isMovable(x,y) or not self.isValid(x,y):
continue
if self.active_entity.inRange(self, x, y):
self.bg_map[y][x] = c.BG_RANGE
mouse_x, mouse_y = pg.mouse.get_pos()
self.checkMouseMove(mouse_x, mouse_y)接下来欠缺下咱们的 map 代码
import pygame as pg
from .. import tool
from .. import constants as c
class Map():
def __init__(self, width, height, grid):
self.width = width
self.height = height
self.bg_map = [[0 for x in range(self.width)] for y in range(self.height)]
self.entity_map = [[None for x in range(self.width)] for y in range(self.height)]
self.active_entity = None
self.select = None
self.setupMapImage(grid)
self.setupMouseImage()
def setupMapImage(self, grid):
self.grid_map = [[0 for x in range(self.width)] for y in range(self.height)]
if grid is not None:
for data in grid:
x, y, type = data['x'], data['y'], data['type']
self.grid_map[y][x] = type
self.map_image = pg.Surface((self.width * c.REC_SIZE, self.height * c.REC_SIZE)).convert()
self.rect = self.map_image.get_rect()
self.rect.x = 0
self.rect.y = 0
for y in range(self.height):
for x in range(self.width):
type = self.grid_map[y][x]
if type != c.MAP_EMPTY:
if c.MAP_HEXAGON:
base_x, base_y = tool.getHexMapPos(x, y)
self.map_image.blit(tool.GRID[type], (base_x, base_y))
else:
self.map_image.blit(tool.GRID[type], (x * c.REC_SIZE, y * c.REC_SIZE))
self.map_image.set_colorkey(c.BLACK)
def setupMouseImage(self):
self.mouse_frames = []
frame_rect = (0, 0, 25, 27)
self.mouse_image = tool.get_image(tool.GFX[c.MOUSE], *frame_rect, c.BLACK, 1)
self.mouse_rect = self.mouse_image.get_rect()
pg.mouse.set_visible(False)
def isValid(self, map_x, map_y):
if c.MAP_HEXAGON:
if map_y % 2 == 0:
max_x = self.width
else:
max_x = self.width - 1
else:
max_x = self.width
if (map_x < 0 or map_x >= max_x or
map_y < 0 or map_y >= self.height):
return False
return True
def isMovable(self, map_x, map_y):
return (self.entity_map[map_y][map_x] == None and
self.grid_map[map_y][map_x] != c.MAP_STONE)
def getMapIndex(self, x, y):
if c.MAP_HEXAGON:
return tool.getHexMapIndex(x, y)
else:
return (x//c.REC_SIZE, y//c.REC_SIZE)
def getDistance(self, x1, y1, map_x2, map_y2):
if c.MAP_HEXAGON:
x2, y2 = tool.getHexMapPos(map_x2, map_y2)
x2 += c.HEX_X_SIZE // 2
y2 += c.HEX_Y_SIZE // 2
distance = (abs(x1 - x2) + abs(y1 - y2))
else:
map_x1, map_y1 = self.getMapIndex(x1, y1)
x2 = map_x2 * c.REC_SIZE + c.REC_SIZE//2
y2 = map_y2 * c.REC_SIZE + c.REC_SIZE//2
distance = (abs(x1 - x2) + abs(y1 - y2))
if map_x1 != map_x2 and map_y1 != map_y2:
distance -= c.REC_SIZE//2
return distance
def checkMouseClick(self, x, y):
if self.active_entity is None:
return False
map_x, map_y = self.getMapIndex(x, y)
if not self.isValid(map_x, map_y):
return False
entity = self.entity_map[map_y][map_x]
if ((entity is None or entity == self.active_entity) and
self.active_entity.inRange(self, map_x, map_y)):
self.active_entity.setDestination(map_x, map_y)
return True
elif entity is not None:
if self.active_entity.isRemote():
self.active_entity.setTarget(entity)
return True
elif self.select is not None:
self.active_entity.setDestination(self.select[0], self.select[1], entity)
return True
return False
def checkMouseMove(self, x, y):
if self.active_entity is None:
return False
map_x, map_y = self.getMapIndex(x, y)
if not self.isValid(map_x, map_y):
return False
self.select = None
entity = self.entity_map[map_y][map_x]
if ((self.isMovable(map_x, map_y) or entity == self.active_entity) and
self.active_entity.inRange(self, map_x, map_y)):
self.bg_map[map_y][map_x] = c.BG_SELECT
elif entity is not None:
if entity.group_id != self.active_entity.group_id:
if self.active_entity.isRemote():
self.bg_map[map_y][map_x] = c.BG_ATTACK
else:
dir_list = tool.getAttackPositions(map_x, map_y)
res_list = []
for offset_x, offset_y in dir_list:
if self.isValid(map_x + offset_x, map_y + offset_y):
type = self.bg_map[map_y + offset_y][map_x + offset_x]
if type == c.BG_RANGE or type == c.BG_ACTIVE:
res_list.append((map_x + offset_x, map_y + offset_y))
if len(res_list) > 0:
min_dis = c.MAP_WIDTH
for tmp_x, tmp_y in res_list:
distance = self.getDistance(x, y, tmp_x, tmp_y)
if distance < min_dis:
min_dis = distance
res = (tmp_x, tmp_y)
self.bg_map[res[1]][res[0]] = c.BG_SELECT
self.bg_map[map_y][map_x] = c.BG_ATTACK
self.select = res
def setEntity(self, map_x, map_y, value):
self.entity_map[map_y][map_x] = value
def drawMouseShow(self, surface):
x, y = pg.mouse.get_pos()
map_x, map_y = self.getMapIndex(x, y)
if self.isValid(map_x, map_y):
self.mouse_rect.x = x
self.mouse_rect.y = y
surface.blit(self.mouse_image, self.mouse_rect)
def updateMap(self):
for y in range(self.height):
for x in range(self.width):
self.bg_map[y][x] = c.BG_EMPTY
if self.entity_map[y][x] is not None and self.entity_map[y][x].isDead():
self.entity_map[y][x] = None
if self.active_entity is None or self.active_entity.state != c.IDLE:
return
map_x, map_y = self.active_entity.map_x, self.active_entity.map_y
self.bg_map[map_y][map_x] = c.BG_ACTIVE
for y in range(self.height):
for x in range(self.width):
if not self.isMovable(x,y) or not self.isValid(x,y):
continue
if self.active_entity.inRange(self, x, y):
self.bg_map[y][x] = c.BG_RANGE
mouse_x, mouse_y = pg.mouse.get_pos()
self.checkMouseMove(mouse_x, mouse_y)
def drawBackground(self, surface):
if c.MAP_HEXAGON:
return self.drawBackgroundHex(surface)
pg.draw.rect(surface, c.LIGHTYELLOW, pg.Rect(0, 0, c.MAP_WIDTH, c.MAP_HEIGHT))
for y in range(self.height):
for x in range(self.width):
if self.bg_map[y][x] == c.BG_EMPTY:
color = c.LIGHTYELLOW
elif self.bg_map[y][x] == c.BG_ACTIVE:
color = c.SKY_BLUE
elif self.bg_map[y][x] == c.BG_RANGE:
color = c.NAVYBLUE
elif self.bg_map[y][x] == c.BG_SELECT:
color = c.GREEN
elif self.bg_map[y][x] == c.BG_ATTACK:
color = c.GOLD
pg.draw.rect(surface, color, (x * c.REC_SIZE, y * c.REC_SIZE,
c.REC_SIZE, c.REC_SIZE))
surface.blit(self.map_image, self.rect)
for y in range(self.height):
# draw a horizontal line
start_pos = (0, 0 + c.REC_SIZE * y)
end_pos = (c.MAP_WIDTH, c.REC_SIZE * y)
pg.draw.line(surface, c.BLACK, start_pos, end_pos, 1)
for x in range(self.width):
# draw a horizontal line
start_pos = (c.REC_SIZE * x, 0)
end_pos = (c.REC_SIZE * x, c.MAP_HEIGHT)
pg.draw.line(surface, c.BLACK, start_pos, end_pos, 1)
def calHeuristicDistance(self, x1, y1, x2, y2):
if c.MAP_HEXAGON:
dis_y = abs(y1 - y2)
dis_x = abs(x1 - x2)
half_y = dis_y // 2
if dis_y >= dis_x:
dis_x = 0
else:
dis_x -= half_y
return (dis_y + dis_x)
else:
return abs(x1 - x2) + abs(y1 - y2)
def drawBackgroundHex(self, surface):
Y_LEN = c.HEX_Y_SIZE // 2
X_LEN = c.HEX_X_SIZE // 2
pg.draw.rect(surface, c.LIGHTYELLOW, pg.Rect(0, 0, c.MAP_WIDTH, c.MAP_HEIGHT))
for y in range(self.height):
for x in range(self.width):
if self.bg_map[y][x] == c.BG_EMPTY:
color = c.LIGHTYELLOW
elif self.bg_map[y][x] == c.BG_ACTIVE:
color = c.SKY_BLUE
elif self.bg_map[y][x] == c.BG_RANGE:
color = c.NAVYBLUE
elif self.bg_map[y][x] == c.BG_SELECT:
color = c.GREEN
elif self.bg_map[y][x] == c.BG_ATTACK:
color = c.GOLD
base_x, base_y = tool.getHexMapPos(x, y)
points = [(base_x, base_y + Y_LEN//2 + Y_LEN), (base_x, base_y + Y_LEN//2),
(base_x + X_LEN, base_y), (base_x + X_LEN * 2, base_y + Y_LEN//2),
(base_x + X_LEN * 2, base_y + Y_LEN//2 + Y_LEN), (base_x + X_LEN, base_y + Y_LEN*2)]
pg.draw.polygon(surface, color, points)
surface.blit(self.map_image, self.rect)
for y in range(self.height):
for x in range(self.width):
if y % 2 == 1 and x == self.width - 1:
continue
base_x, base_y = tool.getHexMapPos(x, y)
points = [(base_x, base_y + Y_LEN//2 + Y_LEN), (base_x, base_y + Y_LEN//2),
(base_x + X_LEN, base_y), (base_x + X_LEN * 2, base_y + Y_LEN//2),
(base_x + X_LEN * 2, base_y + Y_LEN//2 + Y_LEN), (base_x + X_LEN, base_y + Y_LEN*2)]
pg.draw.lines(surface, c.BLACK, True, points)接下来咱们要搞定的就是人物类，咱们的函数要实现：1. 生物属于敌我哪一方 2. 初始时生物在地图上的地位 3. 保留生物的所有属性 4. 生物的行走 5. 生物的三种状态那么看代码
import pygame as pg
from .. import tool
from .. import constants as c
from .. import AStarSearch
from . import map
class FireBall():
def __init__(self, x, y, enemy, hurt):
# first 3 Frames are flying, last 4 frams are exploding
frame_rect = (0,0,14,14)
self.image = tool.get_image(tool.GFX[c.FIREBALL], *frame_rect, c.BLACK, c.SIZE_MULTIPLIER)
self.rect = self.image.get_rect()
self.rect.centerx = x
self.rect.centery = y
self.enemy = enemy
self.hurt = hurt
self.done = False
self.calVelocity()
def calVelocity(self):
#print('calVelocity: x:', self.enemy.rect.centerx, self.rect.centerx, 'y:', self.enemy.rect.centery,self.rect.centery)
dis_x = self.enemy.rect.centerx - self.rect.centerx
dis_y = self.enemy.rect.centery - self.rect.centery
distance = (dis_x ** 2 + dis_y ** 2) ** 0.5
self.x_vel = (dis_x * 10)/distance
self.y_vel = (dis_y * 10)/distance
def update(self):
self.rect.x += self.x_vel
self.rect.y += self.y_vel
if abs(self.rect.x - self.enemy.rect.x) + abs(self.rect.y - self.enemy.rect.y) < 25:
self.enemy.setHurt(self.hurt)
self.done = True
def draw(self, surface):
surface.blit(self.image, self.rect)
class EntityAttr():
def __init__(self, data):
self.max_health = data[c.ATTR_HEALTH]
self.range = data[c.ATTR_RANGE]
self.damage = data[c.ATTR_DAMAGE]
self.attack = data[c.ATTR_ATTACK]
self.defense = data[c.ATTR_DEFENSE]
self.speed = data[c.ATTR_SPEED]
if data[c.ATTR_REMOTE] == 0:
self.remote = False
else:
self.remote = True
def getHurt(self, enemy_attr):
offset = 0
if self.attack > enemy_attr.defense:
offset = (self.attack - enemy_attr.defense) * 0.05
elif self.attack < enemy_attr.defense:
offset = (self.attack - enemy_attr.defense) * 0.025
hurt = int(self.damage * (1 + offset))
return hurt
class Entity():
def __init__(self, group, sheet, map_x, map_y, data):
self.group = group
self.group_id = group.group_id
self.map_x = map_x
self.map_y = map_y
self.frames = []
self.frame_index = 0
self.loadFrames(sheet)
self.image = self.frames[self.frame_index]
self.rect = self.image.get_rect()
self.rect.x, self.rect.y = self.getRectPos(map_x, map_y)
self.attr = EntityAttr(data)
self.health = self.attr.max_health
self.weapon = None
self.enemy = None
self.state = c.IDLE
self.animate_timer = 0.0
self.current_time = 0.0
self.move_speed = c.MOVE_SPEED
def getRectPos(self, map_x, map_y):
if c.MAP_HEXAGON:
base_x, base_y = tool.getHexMapPos(map_x, map_y)
return (base_x + 4, base_y + 6)
else:
return(map_x * c.REC_SIZE + 5, map_y * c.REC_SIZE + 8)
def getRecIndex(self, x, y):
if c.MAP_HEXAGON:
x += c.HEX_X_SIZE // 2 - 4
y += c.HEX_Y_SIZE // 2 - 6
map_x, map_y = tool.getHexMapIndex(x, y)
else:
map_x, map_y = (x//c.REC_SIZE, y//c.REC_SIZE)
return (map_x, map_y)
def loadFrames(self, sheet):
frame_rect_list = [(64, 0, 32, 32), (96, 0, 32, 32)]
for frame_rect in frame_rect_list:
self.frames.append(tool.get_image(sheet, *frame_rect,
c.BLACK, c.SIZE_MULTIPLIER))
def setDestination(self, map_x, map_y, enemy=None):
self.dest_x, self.dest_y = self.getRectPos(map_x, map_y)
self.next_x, self.next_y = self.rect.x, self.rect.y
self.enemy = enemy
self.state = c.WALK
def setTarget(self, enemy):
self.enemy = enemy
self.state = c.ATTACK
def getHealthRatio(self):
if self.health > 0:
return self.health / self.attr.max_health
else:
return 0
def isDead(self):
return self.health <= 0
def isRemote(self):
return self.attr.remote
def inRange(self, map, map_x, map_y):
location = AStarSearch.AStarSearch(map, (self.map_x, self.map_y), (map_x, map_y))
if location is not None:
_, _, distance = AStarSearch.getFirstStepAndDistance(location)
if distance <= self.attr.range:
return True
return False
def putHurt(self, enemy):
hurt = self.attr.getHurt(enemy.attr)
enemy.setHurt(hurt)
def setHurt(self, damage):
self.health -= damage
if self.isDead():
self.group.removeEntity(self)
def shoot(self, enemy):
hurt = self.attr.getHurt(enemy.attr)
self.weapon = FireBall(*self.rect.center, self.enemy, hurt)
def walkToDestination(self, map):
if self.rect.x == self.next_x and self.rect.y == self.next_y:
source = self.getRecIndex(self.rect.x, self.rect.y)
dest = self.getRecIndex(self.dest_x, self.dest_y)
location = AStarSearch.AStarSearch(map, source, dest)
if location is not None:
map_x, map_y, _ = AStarSearch.getFirstStepAndDistance(location)
self.next_x, self.next_y = self.getRectPos(map_x, map_y)
else:
self.state = c.IDLE
if c.MAP_HEXAGON and self.rect.x != self.next_x and self.rect.y != self.next_y:
self.rect.x += self.move_speed if self.rect.x < self.next_x else -self.move_speed
self.rect.y += self.move_speed if self.rect.y < self.next_y else -self.move_speed
elif self.rect.x != self.next_x:
self.rect.x += self.move_speed if self.rect.x < self.next_x else -self.move_speed
elif self.rect.y != self.next_y:
self.rect.y += self.move_speed if self.rect.y < self.next_y else -self.move_speed
def update(self, game_info, map):
self.current_time = game_info[c.CURRENT_TIME]
if self.state == c.WALK:
if (self.current_time - self.animate_timer) > 250:
if self.frame_index == 0:
self.frame_index = 1
else:
self.frame_index = 0
self.animate_timer = self.current_time
if self.rect.x != self.dest_x or self.rect.y != self.dest_y:
self.walkToDestination(map)
else:
map.setEntity(self.map_x, self.map_y, None)
self.map_x, self.map_y = self.getRecIndex(self.dest_x, self.dest_y)
map.setEntity(self.map_x, self.map_y, self)
if self.enemy is None:
self.state = c.IDLE
else:
self.state = c.ATTACK
elif self.state == c.ATTACK:
if self.attr.remote:
if self.weapon is None:
self.shoot(self.enemy)
else:
self.weapon.update()
if self.weapon.done:
self.weapon = None
self.enemy = None
self.state = c.IDLE
else:
self.putHurt(self.enemy)
self.enemy = None
self.state = c.IDLE
if self.state == c.IDLE:
self.frame_index = 0
def draw(self, surface):
self.image = self.frames[self.frame_index]
surface.blit(self.image, self.rect)
width = self.rect.width * self.getHealthRatio()
height = 5
pg.draw.rect(surface, c.RED, pg.Rect(self.rect.left, self.rect.top - height - 1, width, height))
if self.weapon is not None:
self.weapon.draw(surface)
class EntityGroup():
def __init__(self, group_id):
self.group = []
self.group_id = group_id
self.entity_index = 0
def createEntity(self, entity_list, map):
for data in entity_list:
entity_name, map_x, map_y = data['name'], data['x'], data['y']
if map_x < 0:
map_x = c.GRID_X_LEN + map_x
if map_y < 0:
map_y = c.GRID_Y_LEN + map_y
entity = Entity(self, tool.GFX[entity_name], map_x, map_y, tool.ATTR[entity_name])
self.group.append(entity)
map.setEntity(map_x, map_y, entity)
#self.group = sorted(self.group, key=lambda x:x.attr.speed, reverse=True)
def removeEntity(self, entity):
for i in range(len(self.group)):
if self.group[i] == entity:
if (self.entity_index > i or
(self.entity_index >= len(self.group) - 1)):
self.entity_index -= 1
self.group.remove(entity)
def isEmpty(self):
if len(self.group) == 0:
return True
return False
def nextTurn(self):
self.entity_index = 0
def getActiveEntity(self):
if self.entity_index >= len(self.group):
entity = None
else:
entity = self.group[self.entity_index]
return entity
def consumeEntity(self):
self.entity_index += 1
def update(self, game_info, map):
for entity in self.group:
entity.update(game_info, map)
def draw(self, surface):
for entity in self.group:
entity.draw(surface)实现这两个类后咱们的游戏（手游）基本上就实现了
游戏运行截图