def look_in_direction(self, direction):
data = np.zeros((3, ))
position = Position(self.head_x, self.head_y)
distance = 0
tail_found = False
apple_found = False
while 0 < position.x < Const.G_B_W and 0 < position.y < Const.G_B_H:
distance += 1
position = position + Move(Const.SQUARE_SIZE,
Const.SQUARE_SIZE) * direction
item = self.canvas.find_in_position(position +
Const.SQUARE_SIZE // 2)
if len(item) > 0:
item_tag = self.canvas.gettags(item)
if not apple_found and 'apple' in item_tag:
apple_found = True
data[0] = 1 / distance
elif not tail_found and 'tail' in item_tag:
tail_found = True
data[1] = 1 / distance
if tail_found and apple_found:
break
else:
data[2] = 1 / distance
return data
def use_bonus_squares(tiles, letters, state):
avg_tile_score = 1.9
avg_word_score = avg_tile_score * 3.5
board = state.playing_board
squares = [board.get(c) for c,t in letters.items()]
word_mult = reduce(lambda x, lm: x*lm, [s.word_multiplier for s in squares], 1)
bonus_list = []
for c, t in letters.items():
s = board.get(c)
if s.letter_multiplier > 1:
bonus_list.append(avg_tile_score * (s.letter_multiplier - 1))
letter_bonus = sum(bonus_list)
word_bonus = (word_mult - 1) * avg_word_score
move = Move(letters, state)
base_score = move.score()
return float(base_score + letter_bonus + word_bonus)
def save_common(tiles, move, state):
ts = [Tile(t.letter) for t in tiles]
for _, tile in move.items():
if tile in ts:
ts.remove(tile)
scale = 0
for tile in ts:
if tile.letter in ['E', 'A', 'I', 'O', 'N']:
scale += 5
return float(Move(move, state).score() + scale)
def use_bonus_squares(tiles, letters, state):
avg_tile_score = 1.9
avg_word_score = avg_tile_score * 3.5
board = state.playing_board
squares = [board.get(c) for c, t in letters.items()]
word_mult = reduce(lambda x, lm: x * lm,
[s.word_multiplier for s in squares], 1)
bonus_list = []
for c, t in letters.items():
s = board.get(c)
if s.letter_multiplier > 1:
bonus_list.append(avg_tile_score * (s.letter_multiplier - 1))
letter_bonus = sum(bonus_list)
word_bonus = (word_mult - 1) * avg_word_score
move = Move(letters, state)
base_score = move.score()
return float(base_score + letter_bonus + word_bonus)
def calculate_first_move(self, tiles_in_hand, utility_mapper):
possible_words = self.lookup.find_all_words(
[tile.letter for tile in tiles_in_hand])
horizontal = [True, False]
best_score = 0.0
best_move = None
if GameConfig.debug:
print "calculate_first_move"
while self.restarts > 0:
if GameConfig.debug:
print "restarts to go: %i" % self.restarts
stop = False
current_score = 0.0
current_move = None
random_possibilities = deepcopy(possible_words)
shuffle(random_possibilities)
if not random_possibilities:
stop = True
self.restarts -= 1
for o in horizontal:
for word in random_possibilities:
for start in self.possible_starts(word, o):
if not stop:
lts = [(start.next(o, i), Tile(word.upper()[i]))
for i in range(0, len(word))]
move = Move(dict(lts), self.state)
score = utility_mapper(tiles_in_hand, move.letters,
self.state)
if score > current_score:
current_score = score
current_move = move
else:
stop = True
self.restarts -= 1
if current_score > best_score:
best_score = current_score
best_move = current_move
if best_score > 0.0:
return PlaceMove(best_move.letters)
else:
return Pass()
def only_play_7s(tiles, move, state):
if len(move) >= 7:
return float(Move(move, state).score())
else:
return 0.0
# manca smart_s_moves().
# //combine two for the best of both worlds
# let SmartSMovesSaveCommon(tiles:TileList, move:Map<Config.Coordinate, Tile>) =
# let sMoves = SmartSMoves(tiles, move)
# let common = SaveCommon(tiles, move)
# max sMoves common
# let SmartSMovesSaveCommonUseBonus(tiles:TileList, move:Map<Config.Coordinate, Tile>) =
# let sCommon = SmartSMovesSaveCommon(tiles, move)
# let bonus = UseBonusSquares(tiles, move)
# max bonus sCommon
def valid_moves(self, c, word, o, board):
letter = board.get(c).tile.letter
unchecked_starts = []
for i in range(0, len(word)):
if word.upper()[i] == letter:
if o == Orientation.horizontal:
if (c.x - i) >= 0 and (c.x + len(word) - i) <= 14:
unchecked_starts.append(Coordinate(c.x - i, c.y))
else:
if (c.y - i) >= 0 and (c.y + len(word) - i) <= 14:
unchecked_starts.append(Coordinate(c.x, c.y - i))
vmoves = []
for start in unchecked_starts:
coords_letters = []
for i in range(0, len(word)):
coord = start.next(o, i)
if not board.has_tile(coord):
coords_letters.append((coord, Tile(word.upper()[i])))
if coords_letters:
move = Move(dict(coords_letters), self.state)
if move.is_valid:
vmoves.append(move)
if GameConfig.debug:
the_pusher[GameConfig.debug_channel].trigger(
'debug', [{
'x': c.x,
'y': c.y,
'tile': {
'letter': t.letter,
'score': t.score
}
} for c, t in move.letters.items()])
time.sleep(1)
the_pusher[GameConfig.debug_channel].trigger(
'clear_debug')
return vmoves
def first_possible_moves(self, tiles_in_hand, state, utility_mapper):
possible_words = self.lookup.find_all_words(
[tile.letter for tile in tiles_in_hand])
horizontal = [True, False]
moves = []
if GameConfig.debug:
print "calculate_first_move"
for o in horizontal:
for word in possible_words:
for start in self.possible_starts(word, o):
moves.append(
Move(
dict([(start.next(o, i), Tile(word.upper()[i]))
for i in xrange(0, len(word))]), state))
fm = sorted(
[
move for move in moves
if utility_mapper(tiles_in_hand, move.letters, state) > 0.0
],
key=lambda i: -utility_mapper(tiles_in_hand, i.letters, state))
return fm[0:self.max_depth - 1]
def only_play_over5(tiles, move, state):
if len(move) > 5:
return float(Move(move, state).score())
else:
return 0.0
def maximum_score(tiles, move, state):
return float(Move(move, state).score())