def main():
parser = argparse.ArgumentParser()
parser.add_argument("-s", "--size", help="grid size",
type=int, default=DEFAULT_GRID_SIZE)
parser.add_argument("-d", "--debug", help="debug mode",
type=bool, default=DEBUG_MODE)
parser.add_argument("-f", "--fps", help="frames per second",
type=int, default=DEFAULT_FPS)
args = parser.parse_args()
gm = GameManager(size=args.size, debug_mode=args.debug, fps=args.fps)
gm.game_loop()
def main():
game_manager = GameManager()
game_manager.initialize()
while game_manager.running():
game_manager.tick()
game_manager.clean_up()
def main():
# change the current directory to the one of the game
os.chdir(os.path.abspath(os.path.dirname(sys.argv[0])))
# parse, get game's command line
# options, return options' flags
game_opts = get_parsed_opts()
# make the window of the game always centered
os.environ["SDL_VIDEO_CENTERED"] = "1"
# set up the pygame system for the game
pygame.init()
# create game's window screen
pygame.display.set_mode(
(constants.SCREEN_WIDTH, constants.SCREEN_HEIGHT),
pygame.FULLSCREEN if game_opts.fullscreen else 0)
# set game's window title
pygame.display.set_caption(GAME_WINDOW_TITLE)
# set game's window icon
pygame.display.set_icon(load_image(
constants.FILES['graphics']['window']['icon'][0])[0])
# hide game's mouse cursor
pygame.mouse.set_visible(False)
# create the game manager
gm = GameManager(game_opts)
# main loop flag
main_loop_running = True
# main game event loop
while main_loop_running:
# run the game manager
gm.run_scene()
# on quit exit the game
for event in pygame.event.get():
if event.type == pygame.QUIT:
main_loop_running = False
# uninitialize all the pygame systems
pygame.quit()
def setUp(self):
self.gm = GameManager()
self.chat0 = Chat(0, 'group')
self.chat1 = Chat(1, 'group')
self.chat2 = Chat(2, 'group')
self.user0 = User(0, 'user0')
self.user1 = User(1, 'user1')
self.user2 = User(2, 'user2')
from game_manager import GameManager
game_manager = GameManager()
while True:
game_manager.turn_manage()
class Test(unittest.TestCase):
game = None
def setUp(self):
self.gm = GameManager()
self.chat0 = Chat(0, 'group')
self.chat1 = Chat(1, 'group')
self.chat2 = Chat(2, 'group')
self.user0 = User(0, 'user0')
self.user1 = User(1, 'user1')
self.user2 = User(2, 'user2')
def test_new_game(self):
g0 = self.gm.new_game(self.chat0)
g1 = self.gm.new_game(self.chat1)
self.assertListEqual(self.gm.chatid_games[0], [g0])
self.assertListEqual(self.gm.chatid_games[1], [g1])
def test_join_game(self):
self.assertRaises(NoGameInChatError, self.gm.join_game,
*(self.user0, self.chat0))
g0 = self.gm.new_game(self.chat0)
self.gm.join_game(self.user0, self.chat0)
self.assertEqual(len(g0.players), 1)
self.gm.join_game(self.user1, self.chat0)
self.assertEqual(len(g0.players), 2)
g0.open = False
self.assertRaises(LobbyClosedError, self.gm.join_game,
*(self.user2, self.chat0))
g0.open = True
self.assertRaises(AlreadyJoinedError, self.gm.join_game,
*(self.user1, self.chat0))
def test_leave_game(self):
g0 = self.gm.new_game(self.chat0)
self.gm.join_game(self.user0, self.chat0)
self.gm.join_game(self.user1, self.chat0)
self.assertRaises(NotEnoughPlayersError, self.gm.leave_game,
*(self.user1, self.chat0))
self.gm.join_game(self.user2, self.chat0)
self.gm.leave_game(self.user0, self.chat0)
self.assertRaises(NoGameInChatError, self.gm.leave_game,
*(self.user0, self.chat0))
def test_end_game(self):
g0 = self.gm.new_game(self.chat0)
self.gm.join_game(self.user0, self.chat0)
self.gm.join_game(self.user1, self.chat0)
self.assertEqual(len(self.gm.userid_players[0]), 1)
g1 = self.gm.new_game(self.chat0)
self.gm.join_game(self.user2, self.chat0)
self.gm.end_game(self.chat0, self.user0)
self.assertEqual(len(self.gm.chatid_games[0]), 1)
self.gm.end_game(self.chat0, self.user2)
self.assertFalse(0 in self.gm.chatid_games)
self.assertFalse(0 in self.gm.userid_players)
self.assertFalse(1 in self.gm.userid_players)
self.assertFalse(2 in self.gm.userid_players)
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import json
from telegram.ext import Updater
from telegram.contrib.botan import Botan
from game_manager import GameManager
from database import db
import user_setting # required to generate db mapping
db.bind('sqlite', 'uno.sqlite3', create_db=True)
db.generate_mapping(create_tables=True)
gm = GameManager()
with open("config.json","r") as f:
config = json.loads(f.read())
updater = Updater(token=config.get("token"), workers=config.get("workers", 32))
dispatcher = updater.dispatcher
if config.get("botan_token"):
botan = Botan(config.get("botan_token"))
else:
botan = None
from game_manager import GameManager
from game_state import GameState
"""This module represents the drop-token game service. All methods are 1:1 matches with api routes. Ideally documentation for the endpoints is done there."""
game_manager = GameManager()
def get_all_in_progress_games():
output = {}
output['games'] = get_all_games(game_state=GameState.IN_PROGRESS)
return output
def create_new_game(players, columns, rows):
output = {}
new_game = game_manager.new_game(players, columns, rows)
output['gameId'] = new_game.get_game_id()
return output
def get_game_state(game_id):
output = {}
game = game_manager.get_game(game_id)
output['players'] = game.get_players()
game_state = game.get_game_state()
output['state'] = game_state.name
if game_state == GameState.DONE:
output['winner'] = game.get_winner()
return output
def start_example_game():
gm = GameManager()
score = gm.start_game(RandomAgent(), display=True)
print("Score:", score)
def check_hero_death(self):
if self.game_manager.hero.current_health <= 0:
self.canvas.delete("all")
self.game_manager = GameManager()
self.fill_canvas()
def __init__(self):
"""default constructor"""
super(MainManager, self).__init__("main_manager")
self.game_manager = GameManager()
self.clock = None
# Card(name='5', suit='Sword'),
# Card(name='7', suit='Star'),
# Card(name='8', suit='Star'),
# Card(name='6', suit='Star'),
# Card(name='9', suit='Star'),
# Card(name='4', suit='Star'),
# Card(name='4', suit='Pagoda'),
# Card(name='4', suit='Pagoda'),
Phoenix(),
# Dog(),
# Mahjong(),
# Mahjong(),
# Dragon(),
]
test = [1, 2, 3, 4]
d = Dragon()
hand1 = Hand(cards_string='K_Pa, K_Sw')
hand2 = Hand(cards_string='Phoenix, A_Pa, Q_Pa')
hand3 = Hand(cards_string='K_Pa, Mahjong, 2_Pa, 3_Pa, 4_Pa, 5_Pa, 6_Pa')
hand4 = Hand(cards_string='J_Pa')
# players = [DumbAI(hand1, 'AI1'), DumbAI(hand2, 'AI2'), DumbAI(hand3, 'AI3'), DumbAI(hand4, 'AI4')]
# players = [DumbAI(Hand(), 'AI1'), DumbAI(Hand(), 'AI2'), DumbAI(Hand(), 'AI3'), DumbAI(Hand(), 'AI4')]
# gman = GameManager(players)
gman = GameManager()
gman.run_game()
from game_objects.game_object import pg
from game_manager import GameManager
from game_objects.shell import Shell
from constants import BLACK, SCREEN_SIZE
go = Shell(0, 0)
screen = pg.display.set_mode(SCREEN_SIZE)
pg.display.set_caption("The cannon game")
done = False
clock = pg.time.Clock()
mg = GameManager()
while not done:
clock.tick(200)
screen.fill(BLACK)
done = mg.process(pg.event.get(), screen)
pg.display.flip()
pg.quit()
screen = t.Screen()
screen.setup(width=600, height=600)
screen.bgcolor("black")
screen.title("Snake Game")
screen.tracer(0)
snake = Snake()
screen.update()
food_spawner = FoodSpawner()
screen.update
collider = Collider(snake=snake, food_spawner=food_spawner)
game_manager = GameManager(snake=snake,
food_spawner=food_spawner,
collider=collider)
collider.ref_game_manager(game_manager)
screen.listen()
screen.onkey(key="Left", fun=snake.turn_left)
screen.onkey(key="Right", fun=snake.turn_right)
screen.onkey(key="Up", fun=snake.turn_up)
screen.onkey(key="Down", fun=snake.turn_down)
# write game logic below
while game_manager.game_is_on:
screen.update()
time.sleep(0.1)
snake.move()
collider.check_collision()
from product import Product
from city import City
from game_manager import GameManager
def welcome_message():
print("Welcome to Python Pirate Trader")
def get_firm_name():
# firm_name = input("Please enter your Firm Name: ")
return "Jack Sparrow Traders"
def get_starting_options():
starting_options = input("How do you wish to start. 1) Cash & Debt 2) Cannons No debt. : ")
if starting_options == "1":
opts = (250, 2000, 0)
else:
opts = (0, 0, 5)
# Tuples is a list of data that cannot be changed
return opts
# Get Game Options
welcome_message()
firm_name = get_firm_name()
cash, debt, cannons = get_starting_options()
game = GameManager(shiphold=100, name=firm_name, cash=cash, debt=debt, cannons=cannons) # Creating an instance of a Game Manager Class
# Start Up Game
game.start_up()
from game_manager import GameManager
from agents import SLAgent
agent = SLAgent(n_frames_per_action=1)
gm = GameManager("pong.bin",
agent, 'results/testbed3',
remove_old_results_dir=True, use_minimal_action_set=True,
visualise=None, min_time_between_frames=0.000001)
# visualise='rgb')
gm.run(n_episodes=500)
def test_scoring():
game = GameManager(width, ROW_COUNT, COLUMN_COUNT, SIDE)
window = [1, 1, 1, 0, 2, 2, 2]
assert game.scoring(window, game.AI_piece) == -70
#os.environ['SDL_VIDEO_WINDOW_POS'] = "%d,%d" % (300,300)
pygame.mixer.pre_init(44100, -16, 2, 4096)
pygame.init()
# Game base settings
FRAME_MODE = pygame.NOFRAME
WINDOW_SIZE = constants.WINDOW_SIZE
GAME = RushGame(WINDOW_SIZE)
# Set up the display
PYGAME_DISPLAY = pygame.display.set_mode((WINDOW_SIZE), FRAME_MODE)
pygame.display.set_caption("Real Rush")
manager = GameManager(PYGAME_DISPLAY)
RUNNING = True
CLOCK = pygame.time.Clock()
while RUNNING:
# Tick Clock
CLOCK.tick(constants.FRAME_RATE)
ELAPSED_TIME = CLOCK.get_time() / 1000
for event in pygame.event.get():
if event.type == pygame.QUIT:
RUNNING = False
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
RUNNING = False
def test_find_move():
board = Board(8, 8, 100)
gm = GameManager(board)
gm.find_moves(gm.board.spaces[3][4], 255)
assert gm.legal_move == {(5, 4): [(4, 4)], (3, 2): [(3, 3)]}
gm.find_moves(gm.board.spaces[4][3], 255)
assert gm.legal_move == {
(5, 4): [(4, 4)],
(2, 3): [(3, 3)],
(4, 5): [(4, 4)],
(3, 2): [(3, 3)]
}
# reset the dictionary to empty
gm.legal_move = dict()
gm.find_moves(gm.board.spaces[3][3], 0)
assert gm.legal_move == {(3, 5): [(3, 4)], (5, 3): [(4, 3)]}
gm.find_moves(gm.board.spaces[4][4], 0)
assert gm.legal_move == {
(3, 5): [(3, 4)],
(5, 3): [(4, 3)],
(4, 2): [(4, 3)],
(2, 4): [(3, 4)]
}
class Test(unittest.TestCase):
game = None
def setUp(self):
self.gm = GameManager()
self.chat0 = Chat(0, 'group')
self.chat1 = Chat(1, 'group')
self.chat2 = Chat(2, 'group')
self.user0 = User(0, 'user0')
self.user1 = User(1, 'user1')
self.user2 = User(2, 'user2')
def test_new_game(self):
g0 = self.gm.new_game(self.chat0)
g1 = self.gm.new_game(self.chat1)
self.assertListEqual(self.gm.chatid_games[0], [g0])
self.assertListEqual(self.gm.chatid_games[1], [g1])
def test_join_game(self):
self.assertRaises(NoGameInChatError,
self.gm.join_game,
*(self.user0, self.chat0))
g0 = self.gm.new_game(self.chat0)
self.gm.join_game(self.user0, self.chat0)
self.assertEqual(len(g0.players), 1)
self.gm.join_game(self.user1, self.chat0)
self.assertEqual(len(g0.players), 2)
g0.open = False
self.assertRaises(LobbyClosedError,
self.gm.join_game,
*(self.user2, self.chat0))
g0.open = True
self.assertRaises(AlreadyJoinedError,
self.gm.join_game,
*(self.user1, self.chat0))
def test_leave_game(self):
g0 = self.gm.new_game(self.chat0)
self.gm.join_game(self.user0, self.chat0)
self.gm.join_game(self.user1, self.chat0)
self.assertRaises(NotEnoughPlayersError,
self.gm.leave_game,
*(self.user1, self.chat0))
self.gm.join_game(self.user2, self.chat0)
self.gm.leave_game(self.user0, self.chat0)
self.assertRaises(NoGameInChatError,
self.gm.leave_game,
*(self.user0, self.chat0))
def test_end_game(self):
g0 = self.gm.new_game(self.chat0)
self.gm.join_game(self.user0, self.chat0)
self.gm.join_game(self.user1, self.chat0)
self.assertEqual(len(self.gm.userid_players[0]), 1)
g1 = self.gm.new_game(self.chat0)
self.gm.join_game(self.user2, self.chat0)
self.gm.end_game(self.chat0, self.user0)
self.assertEqual(len(self.gm.chatid_games[0]), 1)
self.gm.end_game(self.chat0, self.user2)
self.assertFalse(0 in self.gm.chatid_games)
self.assertFalse(0 in self.gm.userid_players)
self.assertFalse(1 in self.gm.userid_players)
self.assertFalse(2 in self.gm.userid_players)
def test_player_make_move():
board_1 = Board(4, 4, 100)
gm_1 = GameManager(board_1)
gm_1.player_make_move(10, 100)
assert gm_1.legal_move == {
(0, 1): [(1, 1)],
(1, 0): [(1, 1)],
(2, 3): [(2, 2)],
(3, 2): [(2, 2)]
}
assert gm_1.board.spaces[0][1].color == 0
board_2 = Board(8, 8, 100)
gm_2 = GameManager(board_2)
gm_2.player_make_move(10, 10)
assert gm_2.legal_move == {
(5, 4): [(4, 4)],
(2, 3): [(3, 3)],
(4, 5): [(4, 4)],
(3, 2): [(3, 3)]
}
assert not gm_2.board.spaces[0][0]
board_3 = Board(6, 6, 100)
gm_3 = GameManager(board_3)
gm_3.player_make_move(400, 300)
assert gm_3.legal_move == {
(1, 2): [(2, 2)],
(4, 3): [(3, 3)],
(3, 4): [(3, 3)],
(2, 1): [(2, 2)]
}
assert gm_3.board.spaces[4][3].color == 0
from game_manager import GameManager
from agents import UniformRandomAgent
from . import get_results_path
results_path = get_results_path(__name__)
agent = UniformRandomAgent()
gm = GameManager("pong.bin",
agent,
results_path,
n_epochs=3,
n_episodes=10,
remove_old_results_dir=True,
use_minimal_action_set=True)
gm.run()
def test_player_make_move():
board_1 = Board(4, 4, 100)
gm_1 = GameManager(board_1)
gm_1.ai_make_move()
assert gm_1.legal_move == {
(0, 2): [(1, 2)],
(1, 3): [(1, 2)],
(2, 0): [(2, 1)],
(3, 1): [(2, 1)]
}
board_2 = Board(8, 8, 100)
gm_2 = GameManager(board_2)
gm_2.ai_make_move()
assert gm_2.legal_move == {
(2, 4): [(3, 4)],
(3, 5): [(3, 4)],
(4, 2): [(4, 3)],
(5, 3): [(4, 3)]
}
board_3 = Board(6, 6, 100)
gm_3 = GameManager(board_3)
gm_3.ai_make_move()
assert gm_3.legal_move == {
(1, 3): [(2, 3)],
(2, 4): [(2, 3)],
(3, 1): [(3, 2)],
(4, 2): [(3, 2)]
}
class App:
def __init__(self):
self.setup_gui()
self.root.protocol("WM_DELETE_WINDOW", self.callback)
self.key_listener()
self.move_monsters() # enable: monsters move periodically
self.root.mainloop()
def setup_gui(self):
self.create_window()
self.game_manager = GameManager()
self.create_canvas()
self.create_stat_bar()
self.create_description()
self.create_info_bar()
def create_window(self):
self.root = Tk()
self.root.title("Wanderer by Mark Ambrus")
def create_canvas(self):
self.size = self.game_manager.area.size
self.canvas = Canvas(self.root, width=self.size, height=self.size)
self.canvas.pack()
self.fill_canvas()
def fill_canvas(self):
self.game_manager.area.draw_map(self.canvas)
self.game_manager.spawn_characters(self.canvas)
def create_stat_bar(self):
self.hero_stat_bar = Label(text=self.game_manager.hero.introduce())
self.hero_stat_bar.pack()
def create_description(self):
self.game_description = Label(text='''Welcome to the Wanderer game!
Let's play! Use the arrow keys or WASD to move the hero.
Cross path with monsters to fight them.
Collect the key and kill the boss to go to the next level.''')
self.game_description.pack()
def create_info_bar(self):
self.progress_info = Label(
text="Area: " + str(self.game_manager.area_number) + " | " +
str(self.game_manager.kill_count) + " monsters slayed.")
self.progress_info.pack()
def key_listener(self):
self.canvas.bind("<KeyPress>", self.on_key_press)
self.canvas.focus_set()
def on_key_press(self, e):
# W or w or up arrow key
if e.keycode == 87 or e.keycode == 119 or e.keycode == 8320768:
direction = 'up'
# S or s or down arrow key
elif e.keycode == 83 or e.keycode == 115 or e.keycode == 8255233:
direction = 'down'
# A or a or left arrow key
elif e.keycode == 65 or e.keycode == 97 or e.keycode == 8124162:
direction = 'left'
# D or d or right arrow key
elif e.keycode == 68 or e.keycode == 100 or e.keycode == 8189699:
direction = 'right'
else:
return
self.game_turn(direction)
def game_turn(self, direction):
self.game_manager.set_hero_position(self.canvas, direction)
self.after_move()
def move_monsters(self):
wait = self.calculate_wait()
self.game_manager.move_monsters(self.canvas)
self.after_move()
self.root.after(wait, self.move_monsters)
def calculate_wait(self):
difficulty = (self.game_manager.area_number - 1) * 40
wait = 1500 - difficulty # max 1.5 sec wait
min_wait = 300 # min 0.3 sec wait
if wait < min_wait:
return min_wait
else:
return wait
def after_move(self):
self.check_hero_death()
self.game_manager.check_next_area(self.canvas)
self.config_labels()
def check_hero_death(self):
if self.game_manager.hero.current_health <= 0:
self.canvas.delete("all")
self.game_manager = GameManager()
self.fill_canvas()
def config_labels(self):
self.progress_info.config(
text="Area: " + str(self.game_manager.area_number) + " | " +
str(self.game_manager.kill_count) + " monsters slayed.")
self.hero_stat_bar.config(text=self.game_manager.hero.introduce())
def callback(self):
self.root.quit()
def on_close(self):
print("client disconnected")
def check_origin(self, origin):
return True
def send_message(self, action, **data):
message = {"action": action, "data": data}
try:
self.write_message(json.dumps(message))
except tornado.WebSocketClosedError:
#logger.warning("WS_CLOSED", "Could Not send Message: " + json.dumps(message))
# Send Websocket Closed Error to Paired Opponent
#self.send_pair_message(action="pair-closed")
self.close()
gameManager = GameManager()
urls = [
(r"/", MainHandler),
(r"/demo/ws", SocketHandler, dict(game_manager=gameManager)),
]
port = int(os.environ.get('PORT', 5000))
if __name__ == "__main__":
app = tornado.web.Application(urls, **settings)
app.listen(port)
tornado.ioloop.IOLoop.current().start()
class GameManagerTest(unittest.TestCase):
"""Unit tests for game manager module."""
def setUp(self):
"""Initialises all test cases."""
self.game = GameManager()
self.game.frame_counter = 0
self.game.frame_scores = None
self.game.roll = 0
self.maxDiff = None
def test_get_score(self):
"""Verifies, score is fetched in expected format when is ongoing.
And if game has not started yet, error string should be returned."""
# Case 1: Game is not started yet, should return error message.
self.assertEqual(self.game.get_score(),
{'message': constants.GAME_NOT_STARTED})
# Case 2: No pins knocked, should return initial score.
self.game.start_new_game()
frame_scores = {
frame_id: {
'roll': {
0: -1,
1: -1
},
'score': -1
}
for frame_id in range(constants.TOTAL_FRAMES)
}
expected_rsp = {'frame-scores': frame_scores, 'total-score': 0}
self.assertEqual(self.game.get_score(), expected_rsp)
def test_pins_knocked_negative(self):
"""Verifies that if pins knocked is invalid, error is returned."""
# Case 1: Game not started, should return relevant error message.
self.assertEqual(
self.game.pins_knocked('5'),
{'message': constants.PINS_KNOCKED_BEFORE_GAME_STARTED})
self.game.start_new_game()
# Case 2: Pins knocked is not number, should return relevant error.
self.assertEqual(self.game.pins_knocked('a'),
{'message': constants.INVALID_PINS_KNOCKED})
# Case 3: Pins knocked more than 10, should return relevant error.
self.assertEqual(self.game.pins_knocked('20'),
{'message': constants.INVALID_PINS_KNOCKED})
# Case 4: Sum of pins knocked in first and second roll exceeds 10.
roll1 = '8'
roll2 = '5'
self.assertEqual(self.game.pins_knocked(roll1),
{'message': constants.SCORES_UPDATED})
err_msg = constants.INVALID_SECOND_ROLL.format(first_roll_pins=roll1)
self.assertEqual(self.game.pins_knocked(roll2), {'message': err_msg})
# Case 5: Pins knocked received when game has ended, should ask for
# starting new game.
self.game.start_new_game()
for roll in range(2 * constants.TOTAL_FRAMES):
self.assertEqual(self.game.pins_knocked('1'),
{'message': constants.SCORES_UPDATED})
self.assertEqual(self.game.pins_knocked('1'),
{'message': constants.GAME_ENDED})
def test_pins_knocked_all_strikes(self):
"""Verifies perfect 300 case."""
self.game.start_new_game()
# Last frame has 3 rolls so +2.
for roll in range(constants.TOTAL_FRAMES + 2):
self.assertEqual(self.game.pins_knocked('10'),
{'message': constants.SCORES_UPDATED})
# Verify score after all strikes.
scores = {}
for frame in range(constants.TOTAL_FRAMES - 1):
scores[frame] = {'roll': {0: 10, 1: -1}, 'score': 30}
# Update score for last frame.
scores[constants.TOTAL_FRAMES - 1] = {
'roll': {
0: 10,
1: 10,
2: 10
},
'score': 30
}
self.assertEqual(self.game.get_score(), {
'frame-scores': scores,
'total-score': 300
})
def test_pins_knocked_all_spares(self):
"""Verifies case when all frames knocked with a spare."""
self.game.start_new_game()
# Last frame has 3 rolls so +1.
for roll in range(2 * constants.TOTAL_FRAMES + 1):
self.assertEqual(self.game.pins_knocked('5'),
{'message': constants.SCORES_UPDATED})
# Verify score after all spares.
scores = {}
for frame in range(constants.TOTAL_FRAMES - 1):
scores[frame] = {'roll': {0: 5, 1: 5}, 'score': 15}
# Update score for last frame.
scores[constants.TOTAL_FRAMES - 1] = {
'roll': {
0: 5,
1: 5,
2: 5
},
'score': 15
}
self.assertEqual(self.game.get_score(), {
'frame-scores': scores,
'total-score': 150
})
def test_pins_knocked_normal(self):
"""Verifies case when no frame is knocked with a strike or spare."""
self.game.start_new_game()
for roll in range(2 * constants.TOTAL_FRAMES):
self.assertEqual(self.game.pins_knocked('4'),
{'message': constants.SCORES_UPDATED})
scores = {}
for frame in range(constants.TOTAL_FRAMES):
scores[frame] = {'roll': {0: 4, 1: 4}, 'score': 8}
self.assertEqual(self.game.get_score(), {
'frame-scores': scores,
'total-score': 80
})
def main():
game_manager = GameManager()
game_manager.run_game()
import random
from game_manager import GameManager
gm = GameManager.instance()
class GameObject:
def __init__(self, pos, size, color):
self.x = pos[0]
self.y = pos[1]
self.width = size[0]
self.heigth = size[1]
self.color = color
self.pivot = (self.x - self.width / 2, self.y - self.heigth / 2)
def getpos(self):
return (self.x, self.y)
def setpos(self, value):
self.x = value[0]
self.y = value[1]
@property
def x(self):
return self.__x
@x.setter
def x(self, value):
self.__x = value
@property
def y(self):
import pygame
import os
from game_manager import GameManager
from board import Board
from constants import WIDTH, HEIGHT
pygame.init()
pygame.font.init()
clock = pygame.time.Clock()
pygame.display.set_caption("Chess")
pygame.display.set_icon(
pygame.image.load(f"{os.getcwd()}\images\\white_king.png"))
screen = pygame.display.set_mode((WIDTH, HEIGHT))
game = GameManager(screen)
while True:
clock.tick(60)
game.draw()
for event in pygame.event.get():
if event.type == pygame.QUIT:
game.quit()
if event.type == pygame.MOUSEBUTTONDOWN:
x, y = game.get_clicked()
game.select(x, y)
if event.type == pygame.KEYDOWN:
game.started = True
if event.key == pygame.K_r:
import os
import pandas as pd
from threading import Thread
import queue
import requests
import threading
#from predict_cards import predict_box, show_class, draw_bounding_box#, predictThread # , predict_image
from predict_cards_RetNet import draw_detections, predict_image, predictThread, predict_cropped
from game_manager import GameManager
labels_to_names = pd.read_csv('classes.csv', header=None,
index_col=0).to_dict()[1]
WIDTH = 1280 #1920
HEIGHT = 720 #1080
Manager = GameManager(WIDTH, HEIGHT)
url = "http://192.168.1.113:8080/shot.jpg"
def show_webcam(mirror=False):
#cam = cv2.VideoCapture(1) # 0 for build in cam, 1 for usb cam
#if not cam.isOpened():
# print('Could not open video')
# return
pred_thread = predictThread()
bboxes = []
classes = []
confis = []
frame = 0
cv2.namedWindow('webcam', cv2.WINDOW_NORMAL)
i: int = 25
while i > 0:
print(
"\n-----------------------\n-----------------------\n-----------------------\nSTORY {}\n"
.format(25 - i))
GameManager.new_game(player_data=[{
"name": 'Player 1',
"spotlight_modifier": 4
}, {
"name": 'Player 2'
}, {
"name": 'Player 3'
}, {
"name": 'Player 4'
}],
mps={
"mental": 0,
"physical": 0,
"social": 1
},
story_template="journey")
GameManager.run_story_introduction()
n: int = GameManager.storyworld.story_template.scene_length
while n > 0:
GameManager.run_scene()
n -= 1
GameManager.run_story_ending()
import pygame
from game_manager import GameManager
# Initialize pygame
pygame.init()
clock = pygame.time.Clock()
pygame.display.set_caption('Man\'s Labyrinth')
gameExit = False
generated = False
# Initialize the game manager
gm = GameManager()
while not gameExit:
# Keep generating the maze if not done generating
if not gm.maze.generated:
gm.generate_maze()
# Handle user events
for event in pygame.event.get():
if event.type == pygame.QUIT:
gameExit = True
gm.handle_event(event)
gm.menu.update(gm.disp)
pygame.display.update() # draw to screen
clock.tick(60) # fps limit
pygame.quit()
from game_manager import GameManager
from agents import SmartAgent
from . import get_results_path
results_path = get_results_path(__name__)
agent = SmartAgent()
gm = GameManager("pong.bin",
agent, results_path,
n_epochs=5, n_episodes=8,
remove_old_results_dir=True, use_minimal_action_set=True,
min_time_between_frames=0.0)
gm.run()
from game_manager import GameManager game_manager = GameManager() game_manager.start_game(2, 3)
#!/usr/bin/env python from game_manager import GameManager manager = GameManager() manager.menu()
from game_manager import GameManager
from agents import UniformRandomAgent
agent = UniformRandomAgent()
gm = GameManager("pong.bin", agent, 'results/testbed2',
remove_old_results_dir=True, use_minimal_action_set=True, visualise='rgb')
gm.run(n_episodes=10)
if s is not '':
mct.deserialize(s)
with open('mct_states', 'w') as mf:
mf = mf.write(str(mct.record_length()))
game_state = StateMap()
states_in_game = []
is_discard_locked = False
game_count = 0
game_win = 0
game_lost = 0
prev_tiles = []
is_declare_updated = True
# Initializes game manager
game_mgr = GameManager()
# PLAY FUNCTION
def lets_play_it():
global game_mgr, game_state, mct, is_discard_locked, prev_tiles, is_declare_updated
if not game_mgr.is_game_active():
return
if game_mgr.is_game_paused():
print('Game paused. Our state is {}'.format(game_mgr.are_we_ready()))
if not game_mgr.are_we_ready():
game_mgr.send_ready()
return
if game_mgr.get_game_state() == client.DeclaringSpecials and \
game_mgr.is_our_turn() and not game_mgr.is_finish_declaring() \
from fastapi.responses import JSONResponse, RedirectResponse
from pyaxidraw.axidraw import AxiDraw
from pydantic import BaseModel
from quickdraw import QuickDrawData
import urllib
from game_manager import GameManager
app = FastAPI()
logging.basicConfig(level=logging.DEBUG)
log = logging.getLogger(__name__)
axidraw_client = AxiDraw()
quickdraw_client = QuickDrawData()
game_manager = GameManager(axidraw_client, quickdraw_client)
game_thread = None
class GuessRequest(BaseModel):
guess: str
@app.on_event("shutdown")
def shutdown_event():
log.info("shutting down")
if game_thread is not None:
log.debug("Joining game thread")
game_thread.join()
log.debug("game thread joined")
'''
Created on Jul 2, 2015
@author: jobota
'''
import os
import ConfigParser
from game_manager import GameManager
from event_factory import EventFactory
from dialog_factory import DialogFactory
cfg = ConfigParser.ConfigParser()
cfg.read(os.getcwd() + "\src\config.ini")
dia = cfg.get("settings", "dialog.xml")
eve = cfg.get("settings", "event.xml")
dif = float(cfg.get("settings", "difficulty"))
gm = GameManager(dia, eve, dif)
gm.update()
"""eve = EventFactory(eve)
dia = DialogFactory(dia)
eve.generate_event()
dia.generate_dialog()
print dia.dialog_name()
print dia.dialog_text()
print dia.dialog_options()"""
def change_turn():
GameManager.change_turn()
from game_manager import GameManager import object import threading #if __name__ == "__main__": GameManager.init() #key = GameManager.create_object(object.MovingObject()) #GameManager.get_object(key).set_accelerate((1, 1)) GameManager.create_object(object.StaticObject(position=(300, 300), size=(300, 300))) GameManager.create_object(object.StaticObject(position=(0, 748), size=(1376, 20))) #GameManager.create_object((object.MovingObject(position=(100, 100), size=(100, 50)))) GameManager.start()
