def __init__(self, data=None, name=None, kind=None, element=None):
self.val = 0
self.free_spaces = 8
self.name = name
UserList.__init__(self)
if data == None:
# The code below creates 4 units of element with a comp
# of (4,2,2,0). Each unit is equiped with a unique weapon.
if kind == 'mins':
if element != None:
s = Stone()
s[element] = 4
s[OPP[element]] = 0
for o in ORTH[element]:
s[o] = 2
for wep in WEP_LIST:
scient = Scient(element, s)
scient.equip(eval(wep)(element, Stone()))
scient.name = "Ms. " + wep
self.append(scient)
else:
raise ("Kind requires element from %s." % ELEMENTS)
if self.name == None:
self.name = element + " " + 'mins'
return
if isinstance(data, list):
for x in data:
self.append(x)
else:
self.append(data)
def init_levels(self):
level1 = Level()
self.generate_ground(level1)
for i in range(2, 8):
level1.blocks.add(
Crate((1200, self.window_height - 102 * i), (0, 0), 100, 100,
"crate"))
level1.blocks.add(
Stone((1500, self.window_height - 310), (0, 0), 200, 200, "stone"))
level1.enemies.add(
Sheep((1500, self.window_height - 400), (0, 0), 100, 100, "sheep"))
level2 = Level()
self.generate_ground(level2)
level2.blocks.add(
Crate((1200, self.window_height - 200), (0, 0), 100, 100, "crate"))
level2.blocks.add(
Stone((1300, self.window_height - 200), (0, 0), 100, 100, "stone"))
level2.blocks.add(
Ice((1400, self.window_height - 200), (0, 0), 100, 100, "Ice"))
level2.enemies.add(
Sheep((1500, self.window_height - 200), (0, 0), 100, 100, "sheep"))
level2.enemies.add(
Sheep((1000, self.window_height - 200), (0, 0), 100, 100, "sheep"))
level3 = Level()
self.generate_ground(level3)
level3.enemies.add(Ice((400, 900), (0, 0), 100, 100, "Ice"))
level3.enemies.add(Sheep((300, 900), (0, 0), 100, 100, "sheep"))
self.levels = [level1, level2, level3]
def __init__(self,
element,
comp,
name=None,
weapon=None,
weapon_bonus=None,
location=None,
sex='female'):
for orth in ORTH[element]:
if comp[orth] > comp[element] / 2:
raise ValueError("Scients' orthogonal elements cannot be \
more than half the primary element's value.")
Unit.__init__(self, element, comp, name, location, sex)
self.move = 4
self.weapon = weapon
if weapon_bonus == None:
self.weapon_bonus = Stone()
else:
self.weapon_bonus = weapon_bonus
self.equip_limit = Stone({E: 1, F: 1, I: 1, W: 1})
for i in self.equip_limit:
self.equip_limit[i] = self.equip_limit[i] + self.comp[i] \
+ self.weapon_bonus[i]
self.calcstats()
#equiping weapons should be done someplace else.
self.equip(self.weapon)
def test_board_setitem(self):
board = self._get_empty_board()
board_obj = Board(board, BOARD_DIM)
board_obj[0][0] = Stone(BLACK_STONE)
self.assertTrue(Stone(BLACK_STONE), board_obj[0][0])
board_obj[0][0] = Stone(WHITE_STONE)
self.assertTrue(Stone(WHITE_STONE), board_obj[0][0])
def max_comp(suit, kind='Scient'):
"""Returns the maximum composition of 'kind' of element 'suit'"""
comp = Stone()
if kind == 'Scient':
comp[suit] = 255
comp[OPP[suit]] = 0
comp[ORTH[suit][0]] = comp[ORTH[suit][1]] = 127
return comp
if kind == 'Weapon':
comp2 = Stone()
comp2[suit] = comp[suit] = 63
comp2[OPP[suit]] = comp[OPP[suit]] = 0
comp2[ORTH[suit][0]] = comp[ORTH[suit][1]] = 0
comp2[ORTH[suit][1]] = comp[ORTH[suit][0]] = 63
return (comp, comp2)
if kind == 'Nescient':
comp2 = Stone()
comp2[suit] = comp[suit] = 255
comp2[OPP[suit]] = comp[OPP[suit]] = 0
comp2[ORTH[suit][0]] = comp[ORTH[suit][1]] = 0
comp2[ORTH[suit][1]] = comp[ORTH[suit][0]] = 254
return (comp, comp2)
if kind == 'Stone':
for i in comp:
comp[i] = 255
return comp
def parse_move(arr):
if isinstance(arr[1], str):
return Stone(arr[0]).get_type(), arr[1]
else:
return Stone(arr[0]).get_type(), [
str_to_point(arr[1][0]),
[parse_board(board) for board in arr[1][1]]
]
def addStone(self,side,pos,variant=NORMAL):
stone = Stone(side,(pos[0]*34,pos[1]*34),variant)
if side == ATTACKER:
self.attack.append(stone)
if side == DEFENDER:
self.defense.append(stone)
def toggle(self, colour):
"""Put or remove stone at cursor."""
point = self._cursor.point
if point in self._board:
del self._board[point]
else:
self._board[point] = Stone(colour)
def enter():
game_framework.reset_time()
global map, player, house, background, avalanche, coin, snows, map_on_coins, game_over, santa, game_clear, distance, stones
map = Map()
player = Player()
house = House()
background = Background()
avalanche = Avalanche()
coin = Coin()
game_over = Game_over()
santa = Santa()
game_clear = Game_clear()
distance = Distance()
map_on_coins = [Map_on_Coin() for i in range(200)]
snows = [Snow() for i in range(20)]
stones = [Stone() for i in range(10)]
Player.x = 300.0
Player.y = 300.0
Player.unreal_x = 300.0
Player.unreal_y = 0
Player.jump_before_y = 0
Map.map_move_y_minor = 0
Avalanche.game_over = 0
Game_clear.game_clear = 0
Santa.game_clear = 0
def test_check_valid_move():
WIDTH = 600
stone = Stone(WIDTH)
gc = GameController(WIDTH, stone)
gc.counter = 2
gc.stone.total_row[3][3].color = 0
gc.stone.total_row[4][4].color = 0
gc.stone.total_row[3][4].color = 1
gc.stone.total_row[4][3].color = 1
assert gc.check_valid_move(4, 2) is True
assert gc.check_valid_move(5, 3) is True
assert gc.check_valid_move(2, 4) is True
assert gc.check_valid_move(3, 5) is True
assert gc.check_valid_move(3, 4) is False
assert gc.check_valid_move(2, 2) is False
assert gc.check_valid_move(0, 0) is False
assert gc.check_valid_move(7, 7) is False
gc.counter = 1
gc.stone.total_row[3][3].color = 0
gc.stone.total_row[4][4].color = 0
gc.stone.total_row[3][4].color = 1
gc.stone.total_row[4][3].color = 1
assert gc.check_valid_move(3, 2) is True
assert gc.check_valid_move(4, 5) is True
assert gc.check_valid_move(5, 4) is True
assert gc.check_valid_move(2, 3) is True
assert gc.check_valid_move(3, 4) is False
assert gc.check_valid_move(2, 2) is False
assert gc.check_valid_move(0, 0) is False
assert gc.check_valid_move(7, 7) is False
def t2c(tup):
"""Converts a tuple to a comp"""
if len(tup) != 4: raise Exception("Incorrect number of values in tuple")
comp = Stone()
for i in range(4):
comp[ELEMENTS[i]] = tup[i]
return comp
def one_three_zeros(value):
squad = Squad()
for i in ELEMENTS:
s = Stone()
s[i] = value
squad.append(Scient(i, s))
return squad
def rand_comp(suit=None, kind=None, max_v=255):
"""Returns a random comp in 'suit' for use instaniating 'kind'
If 'suit' is not valid, random element used.
If 'kind' is not valid stone is used
if 'kind' is 'Stone' suit ignored"""
if not suit in ELEMENTS:
suit = rand_element()
comp = Stone()
if kind is None or kind not in KINDS:
kind = 'Stone'
if kind == 'Stone':
for element in comp:
comp[element] = random.randint(0, max_v)
return comp
else:
if kind == 'Scient':
comp[suit] = random.randint(1, max_v)
for picked in ORTH[suit]:
#NOTE: if comp[suit] = 1 orths will be 0.
comp[picked] = random.randint(0, (comp[suit] / 2))
return comp
else: #Nescient is currently the only other kind
comp[suit] = random.randint(1, max_v)
comp[random.choice(ORTH[suit])] = \
random.randint(1, comp[suit])
return comp
def run_game():
#init游戏并创建一个窗口对象
pygame.init()
ai_settings=Settings()#创建Settings类的实例
screen=pygame.display.set_mode((ai_settings.screen_width,ai_settings.screen_height))
pygame.display.set_caption("地球保卫战 v1.0")
#创建实例
sscol=Group()
stone=Stone(screen)
stats=GameStats(ai_settings)
bullets=Group()
ship=Ship(ai_settings,screen)
sscol.add(ship)
aliens=Group()
button=Button(ai_settings,screen,"Play")
score=Score(ai_settings,screen,stats)
while True:
#帧数
pygame.time.Clock().tick(120)
#监视键盘和鼠标事件
func.check_events(ai_settings,screen,ship,aliens,bullets,button,stats,score)
#决定游戏是否开始
if stats.game_status:
ship.update()
func.release_bullet(ai_settings,bullets,screen,aliens,stats,score)
func.update_alien(ai_settings,screen,aliens,ship,stats,bullets,score,stone,sscol)
#每次循环都重绘屏幕
func.update_screen(ai_settings,screen,ship,bullets,aliens,stats,button,score,stone)
def move(self, stones):
num = 0
i = 0
j = 0
if (len(stones[0]) == 0 and len(stones[1]) == 0):
return self.grid.center()
# Get last stone of opponent
opponentLastStone = stones[1][-1]
if opponentLastStone.x + 66 < self.grid.WIDTH:
finalCoord = Coordinate(opponentLastStone.x + 66,
opponentLastStone.y)
else:
finalCoord = Coordinate(opponentLastStone.x - 66,
opponentLastStone.y)
for i in range(0, len(self.coordList), self.JUMP):
coord = self.coordList[i]
x = opponentLastStone.x + coord.x
y = opponentLastStone.y + coord.y
if x < 0 or y < 0 or x > self.grid.WIDTH or y > self.grid.HEIGHT:
continue
currStone = Stone(x, y)
flag = 0
if not opponentLastStone.getFeasible(currStone):
continue
for l in range(0, 2):
for stone in stones[l]:
if not stone.getFeasible(currStone):
flag = 1
break
if flag == 1:
break
if flag == 1:
continue
stones[0].append(currStone)
self.grid.setColor(stones)
ret = self.grid.getColorDist()
stones[0].pop()
if (ret[0] > num):
num = ret[0]
finalCoord = Coordinate(currStone.x, currStone.y)
return finalCoord
def test_read_file():
WIDTH = 600
stone = Stone(WIDTH)
gc = GameController(WIDTH, stone)
assert gc.score_list == []
# The default when scores.txt is blank
gc.read_file('test_scores.txt')
assert gc.score_list == [['Khai4', 22], ['Khai3', 20]]
def harvest_stones(self):
"""returns set of stones generated at harvest"""
stones = Stone()
for x in xrange(self.grid.x):
for y in xrange(self.grid.y):
for suit, value in self.grid[x][y].comp.iteritems():
stones[suit] += value
for suit, value in stones.iteritems():
stones[suit] /= 8 #8 seems like a good number...
return stones
def process_stone(frame_desc,
id,
contour,
src_img,
result_img,
save_stones=None):
m = cv2.moments(contour)
try:
cx = int(m['m10'] / m['m00'])
cy = int(m['m01'] / m['m00'])
except:
return None
bbox = cv2.boundingRect(contour)
ec, es, ea = cv2.minAreaRect(contour)
ec = (int(ec[0]), int(ec[1]))
es = (int(es[0]) / 2, int(es[1]) / 2)
ea = int(ea)
if es[1] > es[0]:
es = es[1], es[0]
ea += 90
ea = ea % 180
resy, resx, _ = src_img.shape
if not preselect_stone((resx, resy), ec, es):
return None
cutout = src_img[bbox[1]:bbox[1] + bbox[3], bbox[0]:bbox[0] + bbox[2]]
b, g, r = cv2.split(cutout)
a = np.zeros_like(b, dtype=np.uint8)
cv2.drawContours(a, [contour], 0, 255, -1, offset=(-bbox[0], -bbox[1]))
cropped = cv2.merge((b, g, r, a))
color = find_dominant_color(cropped)
structure = lbp_histogram(cropped)
if result_img is not None:
dummy = np.array([np.array([color])])
rgb_color = (cv2.cvtColor(dummy, cv2.COLOR_LAB2BGR)[0, 0]).tolist()
cv2.drawContours(result_img, [contour], 0, rgb_color, -1)
cv2.circle(result_img, ec, 4, (128, 0, 0))
cv2.rectangle(result_img, (bbox[0], bbox[1]),
(bbox[0] + bbox[2], bbox[1] + bbox[3]), (255, 0, 0))
cv2.ellipse(result_img, ec, es, ea, 0, 360, (0, 0, 255))
ret = Stone(ec, es, ea, color, structure)
if save_stones:
cv2.imwrite(
'stones/stone_{}_{:03d}.{}'.format(frame_desc, id, save_stones),
cropped)
ret.save('stones/stone_{}_{:03d}.data'.format(frame_desc, id))
return ret
def test_can_go():
WIDTH = 600
stone = Stone(WIDTH)
gc = GameController(WIDTH, stone)
gc.counter = 2
gc.stone.total_row[3][3].color = 0 # 4 starting stones
gc.stone.total_row[4][4].color = 0
gc.stone.total_row[3][4].color = 1
gc.stone.total_row[4][3].color = 1
gc.can_go()
assert len(gc.moves_list) == 4 # First move: 4 valids moves for player
def update(self, dt):
# 读入NUM_SAMPLES个取样
string_audio_data = self.stream.read(self.NUM_SAMPLES)
k = max(struct.unpack('1000h', string_audio_data))
# 平均音量
if self.sample_count < 50:
self.average_volume = (self.average_volume * self.sample_count +
k) / (self.sample_count + 1)
self.sample_count += 1
else:
self.sample_count = 0
self.average_volume = 0
self.average_volume = (self.average_volume * self.sample_count +
k) / (self.sample_count + 1)
self.sample_count += 1
# print voice
self.voiceBar.scale_x = self.average_volume / 10000.0
if self.role_run_to_right:
self.role.x += 4
# self.floor.x -= 5
if self.role_run_to_left:
self.role.x -= 4
# self.floor.x += 5
if self.role.can_shot:
if self.sample_count == 50 and self.average_volume > 4000:
pos = self.role.x + self.role.width * 0.8, self.role.y + self.role.height * 0.6
stone = Stone((self.average_volume - 3000) / 1000.0 + 1, pos,
self.role.direction)
self.stone = stone
self.add(stone)
self.role.can_shot = False
# if k > 3000:
# self.floor.x -= min((k / 20.0), 150) * dt
# k > 8000:
# self.role.jump((k - 8000) / 1000.0)
# destination
if (self.role.x + self.role.width / 2) >= self.floor.flag.x:
time.sleep(0.5)
self.end_game()
self.role.pause_scheduler()
return
# spider trigger
if self.role.x > self.floor.spider.x - 50:
self.floor.spider.passed = True
# collision
self.role_collide()
self.monster_collide_on_role()
if not self.role.can_shot:
self.stone_collide()
self.monster_collide_on_stone()
def load_map(file, move_keys, player_number):
# Load map
# Load background color
f = open(path.join("levels", file + ".txt"), "r")
data = f.read()
f.close()
data = data.split("\n")
data[0] = data[0].split(",")
color = data[0]
tile_chars = {}
data.pop(0)
# Load tiles
while "=" in data[0]:
tile_chars[data[0][0]] = data[0].split("=")[1].split(",")
data.pop(0)
# Initialize objects
tiles = []
net = []
walkers = []
climbers = []
stones = []
players = []
# Load objects
y = 1
for row in range(len(data)):
x = -1
for tile in range(len(data[row])):
if data[row][tile] in tile_chars:
tiles.append(
Tile(x, y, TILE_WIDTH, TILE_HEIGHT,
tile_chars[data[row][tile]]))
elif data[row][tile] == "p" and len(players) < player_number:
players.append(
Player(x, y, CHAR_WIDTH, CHAR_HEIGHT, 0,
move_keys[len(players)]))
elif data[row][tile] == "w":
walkers.append(Walker(x, y, CHAR_WIDTH, CHAR_HEIGHT, 0))
elif data[row][tile] == "n":
net.append(Net(x, y, TILE_WIDTH, TILE_HEIGHT, 6))
elif data[row][tile] == "c":
net.append(Net(x, y, TILE_WIDTH, TILE_HEIGHT, 6))
climbers.append(Climber(x, y, CHAR_WIDTH, CHAR_HEIGHT, 0))
elif data[row][tile] == "s":
stones.append(Stone(x, y, TILE_WIDTH, TILE_HEIGHT, 7))
x += TILE_WIDTH
y -= TILE_HEIGHT
# Return objects
return tiles, net, stones, players, walkers, climbers, color
def test_is_corner():
WIDTH = 600
stone = Stone(WIDTH)
gc = GameController(WIDTH, stone)
assert gc.is_corner(0, 0) is True
assert gc.is_corner(7, 7) is True
assert gc.is_corner(0, 7) is True
assert gc.is_corner(7, 0) is True
assert gc.is_corner(1, 8) is None
assert gc.is_corner(3, 4) is None
assert gc.is_corner(2, 6) is None
assert gc.is_corner(5, 5) is None
def test_is_edge():
WIDTH = 600
stone = Stone(WIDTH)
gc = GameController(WIDTH, stone)
assert gc.is_edge(0, 8) is True
assert gc.is_edge(3, 0) is True
assert gc.is_edge(4, 7) is True
assert gc.is_edge(7, 4) is True
assert gc.is_edge(1, 8) is None
assert gc.is_edge(3, 4) is None
assert gc.is_edge(2, 6) is None
assert gc.is_edge(5, 5) is None
def test_is_third_away():
WIDTH = 600
stone = Stone(WIDTH)
gc = GameController(WIDTH, stone)
assert gc.is_third_away(2, 2) is True
assert gc.is_third_away(5, 1) is True
assert gc.is_third_away(1, 2) is True
assert gc.is_third_away(2, 5) is True
assert gc.is_third_away(1, 8) is None
assert gc.is_third_away(6, 4) is None
assert gc.is_third_away(3, 3) is None
assert gc.is_third_away(4, 4) is None
def __init__(self, color):
self.xcoords = [800, 738, 676, 613, 550, 485, 373, 308, 247, 182, 121, 60, 60, 121, 182, 247, 308, 373, 485, 550, 613, 676, 738, 800]
self.stones = []
self.movableStones = set()
self.color = color
self.restrict = False
self.victory = False
#configuring initial positions of stones per game logic
for i in range(2):
newStone = Stone(self.color, 1)
self.stones.append(newStone)
for i in range(3):
newStone = Stone(self.color, 17)
self.stones.append(newStone)
for i in range(5):
newStone = Stone(self.color, 12)
newStone2 = Stone(self.color, 19)
self.stones.append(newStone)
self.stones.append(newStone2)
def move(self, position):
reverse_stons = []
# 石を打つ
self.board[position.y][position.x] = Stone(self.turn.value)
# 石をひっくり返す
# 各方向に石をひっくり返せるか調べる
for dx, dy in Board.DIRS:
y = position.y + dy
x = position.x + dx
enemy = self.turn.invert()
if self.in_board(x, y) \
and self.board[y][x] == enemy:
# 隣が相手の石
y += dy
x += dx
while self.in_board(x, y) \
and self.board[y][x] == enemy:
y += dy
x += dx
if self.in_board(x, y) \
and self.board[y][x] == self.turn:
# この方向は返せる
# 1マス戻る
y -= dy
x -= dx
# 戻りながら返す
stons = []
while self.in_board(x, y) \
and self.board[y][x] == enemy:
self.board[y][x] = Stone(self.turn.value)
stons.append([x, y])
y -= dy
x -= dx
reverse_stons.append(stons)
self.turn = self.turn.invert() # 手番を変更
self.move_num += 1 # 手数を増やす
return reverse_stons
def equip(self, weapon): #TODO move to battlefield
"""
A function that automagically equips items based on element.
should be moved someplace else.
"""
if weapon == None:
if self.element == 'Earth':
self.weapon = Sword(self.element, Stone())
elif self.element == 'Fire':
self.weapon = Bow(self.element, Stone())
elif self.element == 'Ice':
self.weapon = Wand(self.element, Stone())
else:
self.weapon = Glove(self.element, Stone())
else:
'''
if weapon.value() > self.equip_limit[weapon.type]:
raise Exception("This unit cannot equip this weapon")
else:
self.weapon = weapon
'''
self.weapon = weapon
def start(self):
while 1:
serverResponse = self.s.recv(1024)
data = serverResponse.split()
# Check if the game has ended
if int(data[0]) == 1:
break
self.noOfMoves = int(data[1]) - 1
self.playersMovedTillNow = int(data[1])
if (self.playersMovedTillNow < self.NUMBER_OF_PLAYERS):
for i in range(0, self.playersMovedTillNow):
self.lastMoveOfOpponent_x = int(data[2 + i * 3])
self.lastMoveOfOpponent_y = int(data[2 + i * 3 + 1])
self.stones[1].append(
Stone(self.lastMoveOfOpponent_x,
self.lastMoveOfOpponent_y))
self.greedy.updatePull(self.stones, 1)
else:
startIndex = self.playersMovedTillNow - self.NUMBER_OF_PLAYERS + 1
for i in range(startIndex, self.playersMovedTillNow):
self.lastMoveOfOpponent_x = int(data[2 + i * 3])
self.lastMoveOfOpponent_y = int(data[2 + i * 3 + 1])
self.stones[1].append(
Stone(self.lastMoveOfOpponent_x,
self.lastMoveOfOpponent_y))
self.greedy.updatePull(self.stones, 1)
nextMove = self.greedy.move(self.stones)
self.stones[0].append(Stone(nextMove.x, nextMove.y))
self.greedy.updatePull(self.stones, 0)
self.s.sendall(str(nextMove.x) + " " + str(nextMove.y))
self.s.close()
def max_squad_by_value(value):
"""Takes an integer, ideally even because we round down, and returns a
squad such that comp[element] == value, comp[orth] == value/2, comp[opp]
== 0"""
squad = Squad()
value = value / 2 #more logical, really.
half = value / 2
for i in ELEMENTS:
s = Stone()
s[i] = value
s[OPP[i]] = 0
for o in ORTH[i]:
s[o] = half
squad.append(Scient(i, s))
return squad
def can_move_nescient(self, body, nescient):
"""checks if nescient can move to body."""
for part in body:
xdestp, ydestp = body[part].location
if self.grid[xdestp][ydestp].contents != None:
if self.grid[xdestp][
ydestp].contents not in nescient.body.values():
if type(self.grid[xdestp][ydestp].contents) != type(
Stone()):
return False
else:
pass
else:
pass
else:
pass
return True
