def start(self):
strategies = []
strategies.extend(self.generate_random(10))
for j in range(0, 100):
for strategy in strategies:
strategy.score = 0
for i in range(0, 10):
player = Player()
player.strategy = strategy
skip = True
while player.play():
if not skip:
moves = raw_input('Move? ')
if moves == 'y':
skip = True
print 'Run %d score %d' % (i, player._score)
strategy.score += player._score
print 'Score %d' % strategy.score
print 'Next strategy...'
sorted_strategies = sorted(strategies, cmp=lambda x, y: cmp(x.score, y.score), reverse=True)
print 'Best score: %d' % sorted_strategies[0].score
print 'Second score: %d' % sorted_strategies[1].score
print '\n'
strategies = [sorted_strategies[0], sorted_strategies[1]]
strategies.extend(self.breed(sorted_strategies[0], sorted_strategies[1], 2))
strategies.extend(self.generate_random(2))
strategies.append(self.mutate(strategies[4]))
strategies.append(self.mutate(strategies[5]))
print 'New Strategies...'
def createPlayer(self, name=None, word=None):
if name == None:
print ("Name is required")
return None
player = Player()
player.createPlayer(name=name, word=word)
self.players.append(player)
class Game:
def __init__(self, strategy, doorsNumber, numDoorsWin):
self.player = Player(strategy, doorsList = [])
self.strategy = strategy
self.doorsNumber = doorsNumber
self.numDoorsWin = numDoorsWin
def gamePreparing(self):
for i in range(1, int(self.doorsNumber)+1):
self.player.doorsList.append(Door())
for i in random.sample(self.player.doorsList, int(self.numDoorsWin)):
i.status = 'win'
def gameStart(self):
self.player.chooseDoor()
def playersDecision(self):
temp = []
if self.strategy == 'changeable':
for i in self.player.doorsList:
if i.condition != 'opened' and i.playersChoice != 'choosed':
#self.player.doorsList.remove(i)
temp.append(i)
self.player.doorsList = temp
def isWin(self):
for i in self.player.doorsList:
if i.condition == 'closed' and i.playersChoice == 'choosed' and i.status == 'win':
return True
def load(self):
for key in itersplit(self.playerKeys, ','):
player = Player(key, self)
player.load()
self.players.append(player)
self.terrain.load(self.players)
def get_get_reponse(self, intent_request, session):
data = {
"card_title": "Get Request",
"card_output": "Get card output",
"request_name": "get",
"should_end_session": False,
"speech_output": "",
"session_attributes": {},
}
item_name = intent_request["intent"]["slots"]["Item"]["value"]
session_attributes = session["attributes"]
dungeon = Dungeon(session_attributes["dungeon_data"])
player = Player(session_attributes["player_data"])
pos = player.data["position"]
if dungeon.item_is_available(item_name, pos):
item = dungeon.take_item(item_name, pos)
player.add_item(item)
data["speech_output"] = "You take the " + item_name
else:
data["speech_output"] = "You cannot take the " + item_name
session_attributes["player_data"] = player.data
session_attributes["dungeon_data"] = dungeon.data
data["session_attributes"] = session_attributes
return data
def serve(request):
p = Playlist()
player = Player()
doc = CGI.httpHeaders()
doc += CGI.htmlHead({ 'style':['../playlist.css'] })
if request.command == "POST":
form = request.form
if form.has_key('addSongs'):
for e in makeList(form.getvalue('song')):
if e is not None:
doc += addSong(p, e)
elif form.has_key('addAlbums'):
for e in makeList(form.getvalue('album')):
if e is not None:
doc += addAlbum(p, e)
elif form.has_key('clear'):
p.clear()
elif form.has_key('clearAndStop'):
p.clear()
request.state.stop()
player.stop()
f = p.update()
doc += playlistToHtml(f, p)
doc += CGI.htmlTail()
request.serve_string(doc)
def main():
"""hack"""
parser = SafeConfigParser()
parser.read('config.ini')
shots = parser.getint('shots', 'number_of_tryes')
current_word = Word()
category = current_word.random_category()
user = Player()
player = user.ask_for_name()
con = mdb.connect('localhost', 'testuser', '1', 'hangman');
cur = con.cursor()
with con:
cur.execute("INSERT INTO player(player_name) VALUES('%s');" % (player))
file_name = "%s.log" % player
logging.basicConfig(filename=file_name, level=logging.DEBUG,
format='%(message)s')
logging.info("USER:%s start the game and has %s wrong turns",
player, shots )
logging.info("###### [word]:[hidden]:[guess]:[wrong_guess]:[right_guess]")
word = current_word.random_word()
with con:
cur.execute("insert into game(currentWord) values('%s');" %(word))
print word
play_fun = Game(word,player)
play_fun.play()
def __init__(self, agent_filepath=""):
Player.__init__(self)
# Create the experience memory database
if not os.path.exists(REPLAY_MEMORY_FILENAME):
self.replay_memory = ReplayMemory()
else:
self.replay_memory = cPickle.load(open(REPLAY_MEMORY_FILENAME, 'r'))
# Initialize the convolutional neural network
self.network = MinecraftNet(agent_filepath)
self.ae_network = FeatureNet()
# Probability of selecting non-random action
self.epsilon = STARTING_EPSILON
# The total number of frames this agent has been trained on
# through all the minibatch training
self.frames_trained = 0
# Load old epsilon and frames learned values
self.load()
self.cnn_action_map = self.initActionMap()
# The current and previous sequences of game frames and actions
self.current_seq = None
self.previous_seq = None
self.previous_action = None
# Event logging
self.log = LogFile("run.log", True)
def __init__(self,gameDisplay,gameWidth,gameHeight,FPS): Player.__init__(self,gameDisplay, gameWidth, gameHeight,FPS) self.currentMotion = 0 self.currentWeapon = 1 self.x = 100 self.y = 100 self.playerSoundTime = 10
def serve(request):
c = Collection()
p = Playlist()
player = Player()
doc = CGI.httpHeaders()
doc += CGI.htmlHead({"style": ["../playlist.css"]})
if request.command == "POST":
form = request.form
if form.has_key("addSongs"):
for e in makeList(form.getvalue("song")):
if e is not None:
doc += addSong(p, c, e)
elif form.has_key("addAlbums"):
for e in makeList(form.getvalue("album")):
if e is not None:
doc += addAlbum(p, c, e)
elif form.has_key("clear"):
p.clear()
elif form.has_key("clearAndStop"):
p.clear()
request.state.stop()
player.stop()
f = p.update()
doc += playlistToHtml(f, p)
doc += CGI.htmlTail()
request.serve_string(doc)
def __init__(self, *args, **kwargs):
Player.__init__(self, *args, **kwargs)
self.cells = []
self.dir = 1
self.x = 40
self.y = 30
self.dead = False
class AmarokEventHandler:
def __init__(self, state):
self.__running = True;
self.__player = Player()
self.__state = state
Dcop.call("player enableRandomMode false")
def start(self):
while self.__running:
delay = 1
fd = sys.stdin.fileno()
(r,w,e) = select.select( [fd], [], [], delay)
for File in r:
if File == fd:
line = os.read(fd, 1024)
self.__dispatch(line)
def stop(self):
self.__running = False
def __dispatch(self, s):
Debug.log("Event received: " + s)
if s.find("engineStateChange: empty" ) >= 0:
Debug.log("Playlist is empty!")
if self.__state.isRunning():
Debug.log("Queuing random song")
self.__player.playRandom()
else:
Debug.log("Not running")
elif s.find("trackChange" ) >= 0:
pl = Playlist()
if not pl.isPlaying():
self.__player.playRandom()
def __init__(self):
#Initialize all variables
self.turn = 0
self.gameover = False
self.numPlayers = 0
self.CONST_PLAYERCOUNT = 0
self.dealer = 0
self.players = []
self.deck = []
self.drawpile = []
self.midPile = []
self.deadPile = []
self.playerOne = Player()
#playerOne.setName("Craig")
assert type(self.playerOne) == type(Player())
self.playerTwo = Player()
self.playerThree = Player()
self.playerFour = Player()
print "Name: %s" % self.playerOne.getName()
self.setupGame()
class StreamPiControls:
def __init__(self, btn_pwr, re_a, re_b, re_btn):
self._volume = Volume()
self._player = Player()
self._rotary_encoder = RotaryEncoder(re_a, re_b, re_btn, self.re_callback, self.re_btn_callback)
self._system = System()
GPIO.setup(btn_pwr, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.add_event_detect(btn_pwr, GPIO.FALLING, callback=self.pwr_callback, bouncetime=200)
def re_callback(self, direction, btn_pressed):
if direction == RotaryEncoder.DIRECTION_CLOCKWISE:
self._volume.volume_up()
elif direction == RotaryEncoder.DIRECTION_COUNTERCLOCKWISE:
self._volume.volume_down()
def re_btn_callback(self):
if(self._player.is_playing()):
self._player.stop()
else:
self._player.play("http://icecast.omroep.nl/3fm-bb-mp3")
def pwr_callback(self, channel):
self._system.shutdown()
def create_player_dict ():
""" This function populates player_dict for the players with their names
as keys and their player object as values"""
player_dict = {}
player_file = open("passers.csv", "r")
player_file.readline()
punctuation = string.punctuation
for line in player_file:
line = line.strip()
line = line.strip(punctuation)
stats_list = line.split(",")
full_name_str = stats_list[0] + " " + stats_list[1]
playerObject = Player(stats_list[0], stats_list[1])
if full_name_str not in player_dict:
player_dict[full_name_str] = [(playerObject)]
else:
player_dict[full_name_str].append(playerObject)
# stats_list[0] first name, [1] last name, [2] position(QB), [3] team,
# [4] year, [5] unimportant, [6] completions, [7] attempts,
# [8] yardage, [9] touchdowns, [10] unimportant, [11] unimportant,
# [12] interceptions
playerObject.update(stats_list[3], stats_list[4], stats_list[6], \
stats_list[7], stats_list[8], stats_list[9], \
stats_list[12])
player_file.close()
return player_dict
def main():
form = cgi.FieldStorage()
c = Collection()
p = Playlist()
player = Player()
CGI.httpHeaders()
CGI.htmlHead({ 'style':['../playlist.css'] })
if os.environ['REQUEST_METHOD'] == "POST":
if form.has_key('addSongs'):
for e in makeList(form.getvalue('song')):
if e is not None:
addSong(p, c, e)
elif form.has_key('addAlbums'):
for e in makeList(form.getvalue('album')):
if e is not None:
addAlbum(p, c, e)
elif form.has_key('clear'):
p.clear()
elif form.has_key('clearAndStop'):
p.clear()
player.stop()
f = p.update()
playlistToHtml(f, p)
CGI.htmlTail()
def __init__(self):
# 1) basic init
pygame.init()
self.size = self.width, self.height = 1200,800
self.black = 0,0,0
self.screen = pygame.display.set_mode(self.size)
pygame.key.set_repeat(1,50)
# 2) set up game objects
self.Player1 = Player(self) #Player1
self.Player1.choosePlayer("player1.png")
self.Player2 = Player(self) #Player2
self.Player2.choosePlayer("player2.png")
self.laserList = [] #List of laser objects
self.Victor = 0 #The winner of the game (1 or 2, or 0 if no winner yet)
# This image is displayed to the user when the other player is yet to connect
self.wait_image = None
self.wait_rect = None
# This is the scene in which the game is played on
self.back_image = pygame.image.load("media/background.png")
self.back_rect = self.back_image.get_rect()
# Two different victory screens
self.p1v_image = pygame.image.load("media/p1v.png")
self.p1v_rect = self.p1v_image.get_rect()
self.p2v_image = pygame.image.load("media/p2v.png")
self.p2v_rect = self.p2v_image.get_rect()
def __init__(self):
Player.__init__(self)
self._role = "ContingencyPlanner" #役職名英名
#役職名
self._name = u"%2s 危機管理官"
self._action_table = [u"", u"車/フェリー ", u"直行便 ", u"チャーター便 ", u"シャトル便 ", u"調査基地の設置 ", u"感染者の治療 ", u"知識の共有(受け取る) ", u"知識の共有(渡す) ", u"治療薬の発見 ", u"イベントカードの再利用 ", u"イベントカードの使用 "]
self._reuse_ev_card = 0
class Game(object):
isPlayer1Turn= True
def __init__(self):
self.player1 = Player("ATeam")
self.player2 = Player("BTeam")
def play(self):
point = None
while True:
try:
if(self.isPlayer1Turn):
hit=self.player1.mygrid.check(self.player1.fleet,point)
self.player2.enemygrid.update(point, hit)
point = self.player1.takeAGuess()
self.isPlayer1Turn = False
else:
hit = self.player2.mygrid.check(self.player2.fleet,point)
self.player1.enemygrid.update(point, hit)
point = self.player2.takeAGuess()
self.isPlayer1Turn = True
except GameOver:
print(GameOver.value)
if(self.isPlayer1Turn==True):
print(self.player1.teamName+" won")
else:
print(self.player2.teamName+" won")
break
def ServiceEntryPoint(self):
lastProgressUpdate = datetime.today()
player = Player()
lastFile = None
while (not xbmc.abortRequested):
xbmc.sleep(1000)
if xbmc.Player().isPlaying():
try:
playTime = xbmc.Player().getTime()
totalTime = xbmc.Player().getTotalTime()
currentFile = xbmc.Player().getPlayingFile()
addonSettings = xbmcaddon.Addon(id='service.nextup.notification')
notificationtime = addonSettings.getSetting("autoPlaySeasonTime")
if xbmcgui.Window(10000).getProperty("PseudoTVRunning") != "True":
if (totalTime - playTime <= int(notificationtime) and (lastFile==None or lastFile!=currentFile)) and totalTime != 0:
lastFile = currentFile
self.logMsg("Calling autoplayback totaltime - playtime is %s" % (totalTime - playTime) , 2)
player.autoPlayPlayback()
self.logMsg("Netflix style autoplay succeeded.", 2)
xbmc.sleep(1000)
except Exception, e:
self.logMsg("Exception in Playback Monitor Service: %s" % e)
pass
else:
xbmc.sleep(5000)
def play(self, scope = None):
scope = Scope(scope)
scope['_USER_INDEX_'] = self.user_index
assert self.scripts == [] and self.children == []
global_reporter = scope.lookup('global_reporter')
if global_reporter:
reporter = global_reporter.get_reporter()
scope['reporter'] = reporter
else:
reporter = None
try:
if self.iteration_factory:
self.before(scope)
for i in range(self.iteration_count):
# TODO: put _ITERATION_INDEX_ in iteration scope instead of user scope
scope['_ITERATION_INDEX_'] = i
iteration = self.iteration_factory.create()
iteration.player = self.player
Player.execute_here(self, iteration, scope)
self.after(scope)
else:
try:
for i in range(self.iteration_count):
scope['_ITERATION_INDEX_'] = i
self.children.append(self.player)
Player.play(self, scope)
finally:
self.children = []
except Errors.TerminateUser, e:
log.exception('User terminated because of %s' % e)
def play(self, scope = None):
assert self.scripts == [] and self.children == []
self.children = [self.player]
try:
Player.play(self, scope)
except Errors.TerminateIteration, e:
log.exception('Iteration terminated because of %s' % e)
def ServiceEntryPoint(self):
player = Player()
monitor = xbmc.Monitor()
lastFile = None
while not monitor.abortRequested():
# check every 5 sec
if monitor.waitForAbort(5):
# Abort was requested while waiting. We should exit
break
if xbmc.Player().isPlaying():
try:
playTime = xbmc.Player().getTime()
totalTime = xbmc.Player().getTotalTime()
currentFile = xbmc.Player().getPlayingFile()
addonSettings = xbmcaddon.Addon(id='service.nextup.notification')
notificationtime = addonSettings.getSetting("autoPlaySeasonTime")
nextUpDisabled = addonSettings.getSetting("disableNextUp") == "true"
if xbmcgui.Window(10000).getProperty("PseudoTVRunning") != "True" and not nextUpDisabled:
if (totalTime - playTime <= int(notificationtime) and (
lastFile is None or lastFile != currentFile)) and totalTime != 0:
lastFile = currentFile
self.logMsg("Calling autoplayback totaltime - playtime is %s" % (totalTime - playTime), 2)
player.autoPlayPlayback()
self.logMsg("Netflix style autoplay succeeded.", 2)
except Exception as e:
self.logMsg("Exception in Playback Monitor Service: %s" % e)
pass
self.logMsg("======== STOP %s ========" % self.addonName, 0)
def __init__(self):
self.merlin = Player(True, 'Merlin')
self.percival = Player(True, 'Percival')
self.vanilla = Player(True, 'Vanilla')
self.morgana = Player(False, 'Morgana')
self.assassin = Player(False, 'the Assassin')
sortedPlayers = [self.merlin, self.percival, self.vanilla, self.morgana, self.assassin]
self.players = []
while len(sortedPlayers) > 0:
index = randint(0, len(sortedPlayers) - 1)
player = sortedPlayers[index]
del sortedPlayers[index]
self.players.append(player)
currentIndex = len(self.players) - 1
player.myIndex(currentIndex)
if(player.getName() == 'Merlin'):
self.percival.addKnown(currentIndex)
if(player.getName() == 'Morgana'):
self.percival.addKnown(currentIndex)
self.assassin.addKnown(currentIndex)
self.merlin.addKnown(currentIndex)
if(player.getName() == 'the Assassin'):
self.morgana.addKnown(currentIndex)
self.merlin.addKnown(currentIndex)
for player in self.players:
print(player.getName())
self.rounds = [Round(self.players, 2, 1, 5), Round(self.players, 2, 1, 5), Round(self.players, 2, 1, 5), Round(self.players, 2, 1, 5), Round(self.players, 2, 1, 5)]
class Client:
proxy = None
screen = None
mainView = None
mapModel = None
playerModel = None
def __init__(self, proxy, screen):
self.proxy = proxy
self.screen = screen
self.playerModel = Player(self.proxy)
self.playerModel.initPlayer()
self.mapModel = Map(self.playerModel)
# create chat model
chatView = ChatView(self.screen)
mapView = MapView(self.screen, self.mapModel, self.playerModel)
inventoryView = InventoryView(self.screen, self.playerModel)
viewTuple = (chatView, mapView, inventoryView)
self.mainView = MainView(viewTuple)
def getMainView(self):
return self.mainView
def GenerarPlayerData(self,nick):
x = len(self.players)
miColor = self.COLORS[x%self.TEAMS]
player = Player(nick, 3, x/2, x%2, "SP_"+str(x)+"_"+miColor)
player.setTeam(miColor)
return player
def __init__(self):
Player.__init__(self)
self._role = "Dispatcher" #役職名英名
self._action_table = [u"", u"車/フェリー ", u"直行便 ", u"チャーター便 ", u"シャトル便 ", u"調査基地の設置 ", u"感染者の治療 ", u"知識の共有(受け取る) ", u"知識の共有(渡す) ", u"治療薬の発見 ", u"他プレイヤーの移動 ", u"イベントカードの使用 "]
self._special_action_table = [u"", u"車/フェリー", u"直行便", u"チャーター便", u"シャトル便", u"他プレイヤーコマへの移動"]
#役職名
self._name = u" 通信司令員"
def __init__(self):
self.p = Player(savedPlayerJSON)
#self.updatePlayer(self.p,True,0,0)
if self.p.isDead():
self.p = Player("./json/newPlayerTemplate.json")
self.trend = getTrend()
#print self.trend
self.scen = Scenario()
self.scen.loadFromFile(savedScenJSON)
if self.scen.finished:
option = getReplies(self.p.lastID)
self.followUpTweet(option)
if option == 1:
item = self.scen.finish1[1]
exp = self.scen.finish1[2]
health = self.scen.finish1[3]
elif option ==2:
item = self.scen.finish2[1]
exp = self.scen.finish2[2]
health = self.scen.finish2[3]
else:
item = self.scen.finish3[1]
exp = self.scen.finish3[2]
health = self.scen.finish3[3]
self.updatePlayer(self.p,item,exp,health)
tempEnviro = Environment(self.trend)
tempEnviro.generateScenario(self.trend).saveScenario()
self.scen = loadScenFromFile(savedScenJSON)
class BlackArturo(object):
def __init__(self):
self._player1 = Player('14', '7')
self._player2 = Player('2', '9')
@property
def player1(self):
return self._player1
@property
def player2(self):
return self._player2
def start(self):
pass
def get_players(self):
return 2
def do_we_have_an_winner(self):
if self._player1.get_points() == 21 or \
self._player2.get_points() == 21:
return True
return False
class AmarokEventHandler:
def __init__(self, state):
self.__running = True;
self.__player = Player()
self.__state = state
def start(self):
while self.__running:
delay = 1
fd = sys.stdin.fileno()
(r,w,e) = select.select( [fd], [], [], delay)
for File in r:
if File == fd:
line = os.read(fd, 1024)
self.__dispatch(line)
def stop(self):
self.__running = False
def __dispatch(self, s):
if s.find("engineStateChange: empty" ) >= 0:
if self.__state.isRunning():
sys.stderr.write("Unknown notification: " + s + " -> ignoring\n")
self.__player.playRandom()
elif s.find("trackChange" ) >= 0:
pl = Playlist()
if not pl.isPlaying():
self.__player.playRandom()
else:
sys.stderr.write("Unknown notification: " + s + " -> ignoring\n")
init() # Инициализация pygame
window = display.set_mode(WINDOW) # Создание окна
display.set_caption("Dakota`s run") # Название окна
screen = Surface(DISPLAY) # Создание видимой поверхности
# Строка состояния
info_string = Surface((640, 30))
# Шрифты
font.init()
inf_font = font.Font(None, 32)
# Создание героя
hero = Player(320, 1320)
left = right = up = False
# Создание уровня
with open(LEVEL_1, 'r') as level1:
level_mas = level1.read().split('\n')
sprite_group = sprite.Group()
sprite_group.add(hero)
platforms = []
x = 0
y = 0
for row in level_mas:
for col in row:
if col == "1":
def start_server(self):
print("Server listening.")
print(HOST)
while True:
connection, address = self.server_socket.accept()
print('[+] New connection from', str(address[0]), str(address[1]))
player = Player()
player.set_address(address)
player.set_connection(connection)
# self.players[PlayerType.Player1.value] = player
message = "Welcome " + str(
player.get_address()) + "\nPlease enter your name: "
player.get_connection().send(message.encode())
message = player.get_connection().recv(1024).decode()
if not message:
print("Player may be disconnected. (while entering name)")
player.get_connection().close()
continue
player.set_name(message)
print("(", str(address[0]), str(address[1]), ") player's name is",
player.get_name())
if len(self.players) >= 1:
message = "At the moment the server is hosting "
game_message = ""
if self.game_type == GameType.TicTacToe.value:
game_message = "the tic tac toe game "
elif self.game_type == GameType.GuessingNumber.value:
game_message = "guessing a number game "
player.get_connection().send(
(message + game_message + "\nIf you want to join " +
self.players[PlayerType.Player1.value].get_name() +
" insert " + str(self.game_type)).encode())
data = player.get_connection().recv(1024).decode()
if not data:
print("Lost connection - while choosing game mode")
player.get_connection().close()
continue
game_mode_choice = int(data)
if game_mode_choice == self.game_type:
player.get_connection().send(
("Prepare for the match " +
str(player.get_name())).encode())
self.players.append(player)
else:
player.get_connection().close()
else:
message = "Please choose a game :\n1 for Tic Tac Toe \n2 for Guess a number \n "
player.get_connection().send(message.encode())
data = player.get_connection().recv(1024).decode()
if not data:
print("Lost connection - while choosing game mode")
player.get_connection().close()
#if len(self.players) > 0:
# self.players.pop()
continue
self.game_type = int(data)
player.get_connection().send(
("Prepare for the match " + str(player.get_name()) +
"\nWaiting for opponents").encode())
self.players.append(player)
if len(self.players) == 2:
self.handle_server_state_transitions(ServerEvent.START_GAME)
def __init__(self, name):
Player.__init__(self, name)
self.strategy = Strategy()
print(self.name + " follows the " + self.strategy.strategyName +
" strategy.")
if turn == 1:
turn = 2
else:
turn = 1
lock.release()
lock = threading.Lock()
HOST = ""
PORT = 6854
tcp = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
orig = (HOST, PORT)
tcp.bind(orig)
q = Queue()
# loop para conectar os jogadores max 2 jogadores
for i in range(1, 3):
tcp.listen(1)
connection, client = tcp.accept()
print('Conectado por', client)
if i == 1:
p1 = Player("X", i)
player1 = Conexoes(connection, p1)
connection.send(p1.getSymbol().encode())
elif i == 2:
p2 = Player("O", i)
player2 = Conexoes(connection, p2)
connection.send(p2.getSymbol().encode())
player1.start()
player2.start()
def __init__(self, player_name, decks_used=4):
self.players = [Player(player_name)]
self.dealer = Dealer()
self.number_of_decks = decks_used
self.card_pool = CardPool(number_of_decks=decks_used)
self.used_card_pool = []
class Game:
def __init__(self):
self.board = Board(ROWS, COLUMNS)
self.gui = GUI(ROWS, COLUMNS, SIZE, self.board)
self.rules = Rules()
self.cursor = Cursor()
self.player1 = Player(1)
self.player2 = AIPlayer(2, self.rules, self.board)
self.currentPlayer = self.assign_player()
self.gameOver = False
self.menuFlag = False
def assign_player(self):
a = random.randint(0, 1)
if a == 0:
self.gui.next_move_message(self.player1.get_id())
return self.player1
else:
self.gui.next_move_message(self.player2.get_id())
return self.player2
def switch_players(self):
if self.currentPlayer == self.player1:
self.currentPlayer = self.player2
else:
self.currentPlayer = self.player1
self.gui.next_move_message(self.currentPlayer.get_id())
def reset(self):
self.menuFlag = False
self.board.reset()
def change_rules(self, rule):
if rule == 1:
self.rules = Rules()
elif rule == 2:
self.rules = DiagonalOnly()
else:
self.rules = RowsColumnsOnly()
self.reset()
def update_cursor(self, event):
x = event.pos[0]
y = event.pos[1]
self.cursor.update(x, y)
def mouse_motion(self):
if self.gameOver is False and self.menuFlag is False:
if self.gui.are_buttons_hovered(self.cursor.gety()):
self.gui.buttons_hovered(self.cursor.getx())
else:
self.gui.draw_gui(self.board)
elif self.menuFlag:
if self.gui.are_rules_hovered(self.cursor.getx(),
self.cursor.gety()):
self.gui.rules_hovered(self.cursor.getx(), self.cursor.gety())
else:
self.gui.draw_gui(self.board)
def move_made(self):
if self.rules.winning_move(self.board.get_board(),
self.currentPlayer.get_id(),
self.board.get_columns(),
self.board.get_rows()):
self.gameOver = True
self.gui.winning_move_message(self.currentPlayer.get_id())
elif self.board.is_full():
self.gui.draw_message()
self.gameOver = True
else:
self.switch_players()
#print(self.board.get_board())
def mouse_clicked(self):
if self.gameOver is False and self.menuFlag is False:
if self.gui.are_buttons_hovered(self.cursor.gety()):
col = int(math.floor(self.cursor.getx() / self.gui.get_size()))
if self.currentPlayer.make_move(self.board, col):
self.move_made()
else:
self.gui.not_valid_loc_message(self.currentPlayer.get_id())
self.gui.draw_gui(self.board)
elif self.menuFlag:
if self.gui.are_rules_hovered(self.cursor.getx(),
self.cursor.gety()):
rule = self.gui.get_rule(self.cursor.getx(),
self.cursor.gety())
self.change_rules(rule)
self.gui.shut_rules()
self.gameOver = self.menuFlag = False
self.reset()
if self.gui.reset_hovered(self.cursor.getx(), self.cursor.gety()):
self.board.reset()
self.assign_player()
self.gameOver = self.menuFlag = False
if self.gui.are_options_hovered(self.cursor.getx(),
self.cursor.gety()):
self.gui.options_hovered(self.menuFlag)
self.menuFlag = not self.menuFlag
self.gui.draw_gui(self.board)
def start_game(self):
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
if self.currentPlayer.get_type() == "player":
if event.type == pygame.MOUSEMOTION:
self.update_cursor(event)
self.mouse_motion()
elif event.type == pygame.MOUSEBUTTONDOWN:
self.update_cursor(event)
self.mouse_clicked()
elif self.currentPlayer.get_type() == "AI":
if not self.gameOver and not self.menuFlag:
if self.currentPlayer.make_move(self.board, 0):
self.move_made()
else:
self.gui.not_valid_loc_message(
self.currentPlayer.get_id())
self.gui.draw_gui(self.board)
else:
self.currentPlayer = self.player1
def main():
""" Main program """
WIDTH, HEIGHT = 800, 600
# Initialize pygame
pygame.init()
myfont = pygame.font.SysFont("monospace", 15)
# Set screen dimensions
screen = pygame.display.set_mode([WIDTH, HEIGHT])
# Create the player
player = Player(50, 50)
movingsprites = pygame.sprite.Group()
movingsprites.add(player)
# Initialize the game map
levels = []
level = Level.Level1()
levels.append(level)
level = Level.Level2()
levels.append(level)
level = Level.Level3()
levels.append(level)
level = Level.Level4()
levels.append(level)
currentLevelNo = 0
currentLevel = levels[currentLevelNo]
clock = pygame.time.Clock()
quit = False
# Main game loop to check user input
while not quit:
for event in pygame.event.get():
if event.type == pygame.QUIT:
quit = True
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT:
player.changeSpeed(-5, 0)
if event.key == pygame.K_RIGHT:
player.changeSpeed(5, 0)
if event.key == pygame.K_UP:
player.changeSpeed(0, -5)
if event.key == pygame.K_DOWN:
player.changeSpeed(0, 5)
if event.type == pygame.KEYUP:
if event.key == pygame.K_LEFT:
player.changeSpeed(5, 0)
if event.key == pygame.K_RIGHT:
player.changeSpeed(-5, 0)
if event.key == pygame.K_UP:
player.changeSpeed(0, 5)
if event.key == pygame.K_DOWN:
player.changeSpeed(0, -5)
# Game Logic
player.move(currentLevel.wall_list, currentLevel.obsticles)
if player.rect.x < -15:
if currentLevelNo == 0:
currentLevelNo = 3
currentLevel = levels[currentLevelNo]
player.rect.x = 790
elif currentLevelNo == 3:
currentLevelNo = 2
currentLevel = levels[currentLevelNo]
player.rect.x = 790
player.rect.y = 285
elif currentLevelNo == 2:
currentLevelNo = 1
currentLevel = levels[currentLevelNo]
player.rect.x = 790
else:
currentLevelNo = 0
currentLevel = levels[currentLevelNo]
player.rect.x = 790
if player.rect.x > 801:
if currentLevelNo == 0:
currentLevelNo = 1
currentLevel = levels[currentLevelNo]
player.rect.x = 0
elif currentLevelNo == 1:
currentLevelNo = 2
currentLevel = levels[currentLevelNo]
player.rect.x = 0
elif currentLevelNo == 2:
currentLevelNo = 3
currentLevel = levels[currentLevelNo]
player.rect.x = 0
player.rect.y = 425
else:
currentLevelNo = 0
currentLevel = levels[currentLevelNo]
player.rect.x = 0
screen.fill(BLACK)
label = myfont.render("Level: %s" % (currentLevelNo + 1), 1,
(255, 255, 0))
screen.blit(label, (25, 50))
movingsprites.draw(screen)
currentLevel.wall_list.draw(screen)
currentLevel.obsticles.draw(screen)
pygame.display.flip()
clock.tick(60)
pygame.quit()
def turn(player_name):
game_list_top = ['aces' , 'twos' , 'threes' , 'fours' , 'fives' , 'sixes']
game_list_top_values = [1,2,3,4,5,6]
player = Player(player_name)
dice1 = Roll()
for index, item in enumerate(game_list_top):
print ('-'*40)
print (f'rolling for {item}')
print ('-'*40)
dice1.roll_dice()
keep1 = dice1.keep_dice()
dice1.reroll_dice(keep1)
keep2 = dice1.keep_dice()
roll3 = dice1.reroll_dice(keep2)
dice1.forced_keep(roll3)
final_roll_collection = dice1.get_kept_dice()
print (f'final roll collection: {final_roll_collection}')
top_score = dice1.single_values(final_roll_collection,game_list_top_values[index])
player.add_rolled(item, top_score)
player.add_top_score(top_score)
bottom_score = dice1.get_bottom_score(final_roll_collection)
player.add_bottom_score(bottom_score)
player.add_top_bonus()
player.add_bottom_bonus()
player.add_total_score()
player.print_scoreboard()
return player.get_total_score()
class MainView(View):
def __init__(self):
super().__init__()
self.time = 0
self.last_click = -1
self.last_start = -1
self.player = Player()
self.enemy = Enemy()
self.dialog_box = DialogBox()
self.background = load_texture(MAIN_PIC)
self.sprite_manager = SpriteManager()
self.set_buttons()
self.sprite_manager.setup()
self.enemy.setup()
def set_buttons(self):
for i in range(SHIPS_COUNT):
button = Button(BUTTON_X, BUTTON_Y[i], BUTTON_WIDTH[i], BUTTON_HEIGHT,
SHIPS_NAME[i] + '\n' + str(SHIPS_COST[i]) + '$', SHIPS_NAME[i], BUTTON_FONT_SIZE)
self.button_list.append(button)
self.button_list.append(self.dialog_box.supply_button)
self.button_list.append(self.dialog_box.weapon_button)
self.button_list.append(self.dialog_box.go_button)
def on_draw(self):
start_render()
draw_lrwh_rectangle_textured(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, self.background)
for button in self.button_list:
button.draw()
self.dialog_box.draw()
self.sprite_manager.draw_sprites()
self.player.draw()
def on_update(self, delta_time):
new_ship = self.enemy.on_update(delta_time, self.sprite_manager.game_state())
if new_ship is not None:
self.sprite_manager.add_enemy_ship(new_ship)
self.sprite_manager.update(delta_time)
self.player.money_increase(self.sprite_manager.player_fight_benefit())
self.enemy.money_increase(self.sprite_manager.enemy_fight_benefit())
for i in range(SHIPS_COUNT):
if self.button_list[i].pressed:
self.dialog_box.curr = i
self.dialog_box.update()
self.update_buttons(delta_time)
self.time += delta_time
status = self.sprite_manager.check_end_game()
if status != 0:
final_view = DefeatView() if status == 1 else WinView()
self.window.show_view(final_view)
def clone(self, number: int):
self.player.set_builder(number)
fighter = self.player.clone()
if self.dialog_box.weapon_button.checked:
fighter = WeaponDecorator(fighter)
if self.dialog_box.supply_button.checked:
fighter = SupplyDecorator(fighter)
if self.player.money < fighter.get_cost():
return
fighter.center_x = PLAYER_LOCATION_X
fighter.center_y = PLAYER_LOCATION_Y
fighter.change_x = FIGHTERS_SPEED
fighter.side = 'player'
self.sprite_manager.add_ship(fighter)
self.player.money_decrease(fighter.cost)
def lock_buttons(self, button):
button.locked = True
self.last_click = self.time
def update_buttons(self, delta_time):
if self.dialog_box.supply_button.pressed and self.time > self.last_click + TIME_DELAY * delta_time:
self.last_click = self.time
self.dialog_box.supply_button.checked = not self.dialog_box.supply_button.checked
if self.dialog_box.weapon_button.pressed and self.time > self.last_click + TIME_DELAY * delta_time:
self.last_click = self.time
self.dialog_box.weapon_button.checked = not self.dialog_box.weapon_button.checked
if self.dialog_box.go_button.pressed and not self.dialog_box.go_button.checked:
self.clone(self.dialog_box.curr)
self.dialog_box.go_button.checked = True
self.dialog_box.supply_button.checked = False
self.dialog_box.weapon_button.checked = False
self.last_start = self.time
if self.time > self.last_start + BUTTON_DELAY:
self.dialog_box.go_button.checked = False
if SHIPS_COST[self.dialog_box.curr] > self.player.money:
self.dialog_box.go_button.locked = True
else:
self.dialog_box.go_button.locked = False
if SHIPS_COST[self.dialog_box.curr] + EXTRA_SUPPLY_COST > self.player.money or \
self.dialog_box.weapon_button.checked and \
SHIPS_COST[self.dialog_box.curr] + EXTRA_WEAPON_COST + EXTRA_SUPPLY_COST > self.player.money:
self.dialog_box.supply_button.locked = True
else:
self.dialog_box.supply_button.locked = False
if SHIPS_COST[self.dialog_box.curr] + EXTRA_WEAPON_COST > self.player.money or \
self.dialog_box.supply_button.checked and \
SHIPS_COST[self.dialog_box.curr] + EXTRA_WEAPON_COST + EXTRA_SUPPLY_COST > self.player.money:
self.dialog_box.weapon_button.locked = True
else:
self.dialog_box.weapon_button.locked = False
#!/usr/bin/env python3
from Actions import Actions
from Player import Player
from Util import sendAction, recvAction
from Tournament import Tournament
from threading import Thread
from time import sleep
import asyncio
import websockets
tournaments = {"test": Tournament(Player("host", None))}
async def handleConnection(websocket, path):
global tournaments
action = await recvAction(websocket)
while action["type"] != Actions.JOIN_TOURNAMENT.value \
or action["tournamentId"] not in tournaments:
await sendAction(websocket, Actions.INVALID_TOURNAMENT)
action = await recvAction(websocket)
await sendAction(websocket, Actions.ASK_NAME)
nameA = await recvAction(websocket)
while nameA["type"] != Actions.SET_NAME.value \
or tournaments[action["tournamentId"]].isPlayerNameTaken(nameA["name"]):
await sendAction(websocket, Actions.INVALID_NAME)
nameA = await recvAction(websocket)
tournaments[action["tournamentId"]].addPlayer(
Player(nameA["name"], websocket))
def build_full_map(r=100):
my_map = Map()
gradient_of_randomness = [r, r, r, r, r, r]
random.shuffle(gradient_of_randomness)
Player1 = Player('ai_player', my_map, gradient_of_randomness[1])
Player2 = Player('player2', my_map, gradient_of_randomness[1])
Player3 = Player('player3', my_map, gradient_of_randomness[2])
Player4 = Player('player4', my_map, 100)
Player5 = Player('player5', my_map, 100)
Player6 = Player('player6', my_map, 100)
Player1.resetPlayerIndex()
Player_list = my_map.getPlayerList()
#Countries
#North America
alaska = Country('alaska', my_map, 1, 9, (0, 9, 5))
NWterritory = Country('NWterritory', my_map, 2, 8, (0, 9, 5))
alberta = Country('alberta', my_map, 1, 7, (0, 9, 5))
greenland = Country('greenland', my_map, 3, 8, (0, 9, 5))
ontario = Country('ontario', my_map, 2, 7, (0, 9, 5))
quebec = Country('quebec', my_map, 3, 7, (0, 9, 5))
WUS = Country('WUS', my_map, 1, 6, (0, 9, 5))
EUS = Country('EAS', my_map, 2, 6, (0, 9, 5))
central_america = Country('central_america', my_map, 1, 5, (0, 9, 5))
#NA Neighbours
my_map.makeNeighbours(alaska, NWterritory)
my_map.makeNeighbours(alaska, alberta)
my_map.makeNeighbours(alberta, NWterritory)
my_map.makeNeighbours(greenland, NWterritory)
my_map.makeNeighbours(greenland, quebec)
my_map.makeNeighbours(greenland, ontario)
my_map.makeNeighbours(alberta, ontario)
my_map.makeNeighbours(alberta, WUS)
my_map.makeNeighbours(ontario, WUS)
my_map.makeNeighbours(ontario, EUS)
my_map.makeNeighbours(quebec, EUS)
my_map.makeNeighbours(WUS, EUS)
my_map.makeNeighbours(WUS, central_america)
my_map.makeNeighbours(EUS, central_america)
#South America
venezuela = Country('venezuela', my_map, 1, 4, (1, 4, 2))
peru = Country('peru', my_map, 1, 3, (1, 4, 2))
brazil = Country('brazil', my_map, 2, 3, (1, 4, 2))
argentina = Country('argentina', my_map, 1, 2, (1, 4, 2))
my_map.makeNeighbours(central_america, venezuela)
my_map.makeNeighbours(venezuela, peru)
my_map.makeNeighbours(venezuela, brazil)
my_map.makeNeighbours(argentina, peru)
my_map.makeNeighbours(argentina, brazil)
#Europe
iceland = Country('iceland', my_map, 4, 8, (2, 7, 5))
scandinavia = Country('scandinavia', my_map, 5, 8, (2, 7, 5))
ukraine = Country('ukraine', my_map, 6, 7, (2, 7, 5))
GB = Country('GB', my_map, 4, 7, (2, 7, 5))
NEU = Country('NEU', my_map, 5, 7, (2, 7, 5))
WEU = Country('WEU', my_map, 4, 6, (2, 7, 5))
SEU = Country('SEU', my_map, 5, 6, (2, 7, 5))
my_map.makeNeighbours(iceland, greenland)
my_map.makeNeighbours(iceland, scandinavia)
my_map.makeNeighbours(iceland, GB)
my_map.makeNeighbours(scandinavia, GB)
my_map.makeNeighbours(scandinavia, NEU)
my_map.makeNeighbours(scandinavia, ukraine)
my_map.makeNeighbours(GB, NEU)
my_map.makeNeighbours(GB, WEU)
my_map.makeNeighbours(NEU, ukraine)
my_map.makeNeighbours(NEU, WEU)
my_map.makeNeighbours(NEU, SEU)
my_map.makeNeighbours(ukraine, SEU)
#Africa
north_africa = Country('north_africa', my_map, 4, 4, (3, 6, 3))
egypt = Country('egypt', my_map, 5, 4, (3, 6, 3))
east_africa = Country('east_africa', my_map, 5, 3, (3, 6, 3))
congo = Country('congo', my_map, 4, 3, (3, 6, 3))
south_africa = Country('south_africa', my_map, 4, 2, (3, 6, 3))
madagascar = Country('madagascar', my_map, 5, 2, (3, 6, 3))
my_map.makeNeighbours(north_africa, brazil)
my_map.makeNeighbours(north_africa, SEU)
my_map.makeNeighbours(north_africa, WEU)
my_map.makeNeighbours(egypt, SEU)
my_map.makeNeighbours(north_africa, egypt)
my_map.makeNeighbours(north_africa, east_africa)
my_map.makeNeighbours(north_africa, congo)
my_map.makeNeighbours(egypt, east_africa)
my_map.makeNeighbours(east_africa, congo)
my_map.makeNeighbours(east_africa, south_africa)
my_map.makeNeighbours(east_africa, madagascar)
my_map.makeNeighbours(congo, south_africa)
my_map.makeNeighbours(south_africa, madagascar)
#Asia
middle_east = Country('middle_east', my_map, 6, 5, (4, 12, 7))
afghanistan = Country('afghanistan', my_map, 7, 6, (4, 12, 7))
ural = Country('ural', my_map, 7, 7, (4, 12, 7))
siberia = Country('siberia', my_map, 8, 7, (4, 12, 7))
yakutsk = Country('yakutsk', my_map, 7, 8, (4, 12, 7))
kamchatka = Country('kamchatka', my_map, 9, 9, (4, 12, 7))
india = Country('india', my_map, 7, 5, (4, 12, 7))
china = Country('china', my_map, 8, 6, (4, 12, 7))
mongolia = Country('mongolia', my_map, 9, 7, (4, 12, 7))
irkutsk = Country('irkutsk', my_map, 8, 8, (4, 12, 7))
japan = Country('japan', my_map, 9, 8, (4, 12, 7))
siam = Country('siam', my_map, 8, 5, (4, 12, 7))
my_map.makeNeighbours(middle_east, egypt)
my_map.makeNeighbours(middle_east, east_africa)
my_map.makeNeighbours(middle_east, SEU)
my_map.makeNeighbours(middle_east, ukraine)
my_map.makeNeighbours(middle_east, afghanistan)
my_map.makeNeighbours(middle_east, india)
my_map.makeNeighbours(afghanistan, ukraine)
my_map.makeNeighbours(afghanistan, ural)
my_map.makeNeighbours(afghanistan, india)
my_map.makeNeighbours(afghanistan, china)
my_map.makeNeighbours(ural, ukraine)
my_map.makeNeighbours(ural, siberia)
my_map.makeNeighbours(ural, china)
my_map.makeNeighbours(siberia, yakutsk)
my_map.makeNeighbours(siberia, irkutsk)
my_map.makeNeighbours(siberia, mongolia)
my_map.makeNeighbours(siberia, china)
my_map.makeNeighbours(yakutsk, irkutsk)
my_map.makeNeighbours(irkutsk, kamchatka)
my_map.makeNeighbours(irkutsk, mongolia)
my_map.makeNeighbours(kamchatka, alaska)
my_map.makeNeighbours(kamchatka, yakutsk)
my_map.makeNeighbours(kamchatka, mongolia)
my_map.makeNeighbours(kamchatka, japan)
my_map.makeNeighbours(mongolia, japan)
my_map.makeNeighbours(mongolia, china)
my_map.makeNeighbours(china, india)
my_map.makeNeighbours(china, siam)
my_map.makeNeighbours(india, siam)
#Australia
indonesia = Country('indonesia', my_map, 8, 4, (5, 4, 2))
new_guinea = Country('new_guinea', my_map, 9, 4, (5, 4, 2))
western_australia = Country('western_australia', my_map, 8, 3, (5, 4, 2))
eastern_australia = Country('eastern_australia', my_map, 9, 3, (5, 4, 2))
my_map.makeNeighbours(indonesia, siam)
my_map.makeNeighbours(indonesia, western_australia)
my_map.makeNeighbours(indonesia, new_guinea)
my_map.makeNeighbours(western_australia, new_guinea)
my_map.makeNeighbours(western_australia, eastern_australia)
my_map.makeNeighbours(eastern_australia, new_guinea)
"""
ireland = Country('ireland', my_map,5,5,(1,2,3))
scotland = Country('scotland',my_map,7,5,(0,2,10))
wales = Country('wales',my_map,7,6,(2,2,3))
france = Country('france',my_map,6,7,(2,2,3))
england = Country('england', my_map,6,6,(0,2,10))
ni = Country('NI', my_map,5,6,(1,2,3))
"""
Country_list = my_map.nodes()
"""
my_map.makeNeighbours(england,ireland)
"""
index_list = [0, 1, 2, 3, 4, 5]
random.shuffle(index_list)
counter = 0
while counter < len(Country_list):
if counter % len(index_list) == 0:
random.shuffle(index_list)
Player_list[index_list[counter % len(index_list)]].addCountry(
Country_list[counter])
counter += 1
#Player1.addCountry(ireland)
#Player1.addCountry(ni)
#Player2.addCountry(england)
#Player3.addCountry(scotland)
#Player3.addCountry(wales)
#Player2.addCountry(france)
#for node in my_map.nodes():
# node.setSoldiers(random.randint(1,6))
for i in range(28):
for player in Player_list:
player.place_random_soldier()
return my_map
from Player import Player
from AI import play
from chessGP import fileToGPTree
randomTree = fileToGPTree('./solutions/randomSolution.txt')
stockfishTree = fileToGPTree('./solutions/stockfishSolution.txt')
randomPlayer = Player('custom', randomTree.pickChessMove)
stockfishPlayer = Player('custom', stockfishTree.pickChessMove)
win = 0
draw = 0
loss = 0
for i in range(25):
resultBoard = play(stockfishPlayer, randomPlayer)
result = resultBoard.result()
print(result)
if result == '1-0':
win += 1
elif result == '0-1':
loss += 1
else:
draw += 1
print("White: Stockfish, Black: Random")
print(win, draw, loss)
win = 0
draw = 0
loss = 0
for i in range(25):
resultBoard = play(randomPlayer, stockfishPlayer)
result = resultBoard.result()
from Player import Player
from Enemy import Troll, Vampire, VampireKing
tim = Player('Tim')
ugly_troll = Troll('Urg')
another_troll = Troll('Ug')
first_vampire = Vampire('Dracula')
print(ugly_troll)
print(another_troll)
print(first_vampire)
first_vampire.take_damage(10)
print(first_vampire)
vamp_king = VampireKing('KingDracula')
print(vamp_king)
while vamp_king.alive:
vamp_king.take_damage(12)
print(vamp_king)
print('*' * 40)
x = str(myString)
parsed = True # we only get here if the previous line didn't throw an exception
if (parsed == True):
fileinput.close()
except ValueError:
print 'Invalid value! Please enter standard text.'
break
if __name__ == '__main__':
print("Please enter your name")
for line in fileinput.input():
validateStringInput(line)
myString = str(line)
player = Player(myString, 1)
fileinput.close()
print("How many rounds do you want to play?")
for line in fileinput.input():
validateIntInput(line)
game = Game(line)
fileinput.close()
##test and write an order to a rfid
print("Test now your Raspi and your RFID reader")
nfc = NFC()
##testdata
firstOrder = True
amount = 5
def __init__(self, name=None):
Player.__init__(self, name)
self.taken_rounds = 0
self.taken_cards_pack = set()
pass
def __init__(self, map):
Player.__init__(self, map)
self.searchAlgorithm = 0
class State:
def __init__(self):
self.deck = Deck()
self.allcards = self.deck.all_cards
self.player1 = Player(self.deck, "Player1")
self.player2 = Player(self.deck, "Player2")
self.used_cards = []
def deal_cards(self):
first, second = self.deck.deal_cards()
self.player1.set_cards(first)
self.player2.set_cards(second)
def test(self):
self.deal_cards()
main_card = self.deck.get_first_card()
# for card in self.deck.deck:
# print(card)
card = self.player1.current_cards[0]
# better_cards_in_game(card,self.used_cards,self.player1.current_cards,self.allcards, main_card)
# print(main_card)
# check_main_power(main_card,self.used_cards,self.player1.current_cards,self.allcards)
def make_move(self):
print("")
def game(self):
self.deal_cards()
main_card = self.deck.get_first_card()
first = self.player1
second = self.player2
# monte = MonteCarlo(self.player1, self.player2,1,main_card,self.deck)
# monte.check_moves()
while True:
player1_pick = input("It's " + first.name +
" turn to play,\n(Main card is " +
str(main_card) +
") select number from 1 to 3,\n" +
str(first.current_cards) +
" \nwhich card in deck you want to play: ")
card1_playing = first.throw_card(int(player1_pick))
first.card_down = card1_playing
print(card1_playing)
player2_pick = input("It's " + second.name +
" turn to play,\n(Main card is " +
str(main_card) +
") select number from 1 to 3,\n" +
str(second.current_cards) +
"\n which card in deck you want to play: ")
card2_playing = second.throw_card(int(player2_pick))
second.card_down = card2_playing
print(card2_playing)
if card1_playing.color == main_card.color and card2_playing.color != main_card.color:
print(first.name + " win the turn.")
first.add_to_loot(card1_playing, card2_playing)
print(first.count_score() + "\n\n")
elif card1_playing.color != main_card.color and card2_playing.color == main_card.color:
print(second.name + " win the turn.")
second.add_to_loot(card1_playing, card2_playing)
print(second.count_score() + "\n\n")
tmp = first
first = second
second = tmp
elif card1_playing.color == main_card.color and card2_playing.color == main_card.color:
if card1_playing.power > card2_playing.power:
print(first.name + " win the turn.")
first.add_to_loot(card1_playing, card2_playing)
print(first.count_score() + "\n\n")
elif card1_playing.power < card2_playing.power:
print(second.name + " win the turn.")
second.add_to_loot(card1_playing, card2_playing)
print(second.count_score() + "\n\n")
tmp = first
first = second
second = tmp
elif card1_playing.color != main_card.color and card2_playing.color != main_card.color:
if card1_playing.color != card2_playing.color:
print(first.name + " win the turn.")
first.add_to_loot(card1_playing, card2_playing)
print(first.count_score() + "\n\n")
elif card1_playing.color == card2_playing.color:
if card1_playing.power > card2_playing.power:
print(first.name + " win the turn.")
first.add_to_loot(card1_playing, card2_playing)
print(first.count_score() + "\n\n")
elif card1_playing.power < card2_playing.power:
print(second.name + " win the turn.")
second.add_to_loot(card1_playing, card2_playing)
print(second.count_score() + "\n\n")
tmp = first
first = second
second = tmp
self.used_cards.append(card1_playing)
self.used_cards.append(card2_playing)
if self.deck.check_if_deck_empty() is False:
card1, card2 = self.deck.deal_cards_on_turn()
first.pick_up_card(card1)
second.pick_up_card(card2)
if second.check_hand():
break
print("\n\n")
print(first.name + " has collected " + first.count_score() +
" points.")
print(second.name + " has collected " + second.count_score() +
" points.")
print("\n")
if first.score > second.score:
print(first.name +
" has won the game because he collected more points!")
elif first.score < second.score:
print(second.name +
" has won the game because he collected more points!")
else:
print("Game has finished with tied score!")
def check_cards(self, card1_playing, card2_playing, main_card):
if card1_playing.color == main_card.color and card2_playing.color != main_card.color:
return True
elif card1_playing.color != main_card.color and card2_playing.color == main_card.color:
return False
elif card1_playing.color == main_card.color and card2_playing.color == main_card.color:
if card1_playing.power > card2_playing.power:
return True
elif card1_playing.power < card2_playing.power:
return False
elif card1_playing.color != main_card.color and card2_playing.color != main_card.color:
if card1_playing.color != card2_playing.color:
return True
elif card1_playing.color == card2_playing.color:
if card1_playing.power > card2_playing.power:
return True
elif card1_playing.power < card2_playing.power:
return False
# def random_game(self, move):
# self.deal_cards()
# main_card = self.deck.get_first_card()
# first = self.player1
# second = self.player2
#
# random = move.move
# while True:
# # player1_pick = input("It's " + first.name + " turn to play,\n(Main card is " + str(
# # main_card) + ") select number from 1 to 3,\n"
# # + str(first.current_cards) + " \nwhich card in deck you want to play: ")
# card1_playing = first.throw_card(int(random))
#
# print(card1_playing)
# # player2_pick = input("It's " + second.name + " turn to play,\n(Main card is " + str(
# # main_card) + ") select number from 1 to 3,\n"
# # + str(second.current_cards) + "\n which card in deck you want to play: ")
#
# player2_pick = randint(1, len(second.current_cards))
#
# card2_playing = second.throw_card(int(player2_pick))
# print(card2_playing)
#
# if card1_playing.color == main_card.color and card2_playing.color != main_card.color:
# print(first.name + " win the turn.")
# first.add_to_loot(card1_playing, card2_playing)
# print(first.count_score() + "\n\n")
#
# elif card1_playing.color != main_card.color and card2_playing.color == main_card.color:
# print(second.name + " win the turn.")
# second.add_to_loot(card1_playing, card2_playing)
# print(second.count_score() + "\n\n")
#
# tmp = first
# first = second
# second = tmp
#
# elif card1_playing.color == main_card.color and card2_playing.color == main_card.color:
# if card1_playing.power > card2_playing.power:
# print(first.name + " win the turn.")
# first.add_to_loot(card1_playing, card2_playing)
# print(first.count_score() + "\n\n")
#
# elif card1_playing.power < card2_playing.power:
# print(second.name + " win the turn.")
# second.add_to_loot(card1_playing, card2_playing)
# print(second.count_score() + "\n\n")
#
# tmp = first
# first = second
# second = tmp
#
# elif card1_playing.color != main_card.color and card2_playing.color != main_card.color:
# if card1_playing.color != card2_playing.color:
# print(first.name + " win the turn.")
# first.add_to_loot(card1_playing, card2_playing)
# print(first.count_score() + "\n\n")
#
# elif card1_playing.color == card2_playing.color:
# if card1_playing.power > card2_playing.power:
# print(first.name + " win the turn.")
# first.add_to_loot(card1_playing, card2_playing)
# print(first.count_score() + "\n\n")
#
# elif card1_playing.power < card2_playing.power:
# print(second.name + " win the turn.")
# second.add_to_loot(card1_playing, card2_playing)
# print(second.count_score() + "\n\n")
#
# tmp = first
# first = second
# second = tmp
#
# if self.deck.check_if_deck_empty() is False:
# card1, card2 = self.deck.deal_cards_on_turn()
# first.pick_up_card(card1)
# second.pick_up_card(card2)
# if second.check_hand():
# break
#
# game = GameManager()
# game.test()
# print(game.player1.current_cards)
def __init__(self):
#initializing the player
player = Player()
#variable to hold whether the game is over
gameOver = False
#here we could ask for user input for board dimensions, but a 5x5 grid seemed appropriate
#all you would need to do is have
#populating the neighborhood size right now it is a 5 by 5 grid, but easily modified
#list comprehension is awesome!
neighborhood = [[0 for y in range(5)] for x in range(5)]
#variable to keep track of the number of monsters in the entire game
monster_num = 0
#populating the neighborhood and getting the number of monsters in the game
for i in range(len(neighborhood)):
for j in range(len(neighborhood[i])):
neighborhood[i][j] = House()
monster_num = monster_num + neighborhood[i][j].monster_count
#random start location stored as a tuple
location = (random.randint(0,
len(neighborhood) - 1),
random.randint(0,
len(neighborhood) - 1))
#printing initial message
print(
"----------------------------------------------------\n On the eve of Halloween, you wake up and realize that your entire neighborhood has been took over by Monsters! You must take your candy and save the neighborhood by killing each monster! Best of luck... you'll need it...\n --------------------------------------------------- "
)
print("You have this much HP: " + str(player.hp))
print("And right now you are at this location: " + str(location))
playerName = input("What is your Name?")
print("Welcome... Play at your own risk...")
#Counting the turns of the game
turnCounter = -1
#main game
while gameOver != True:
turnCounter = turnCounter + 1
#print information for each turn
print("\n\n\n\n\n")
print("Turn: " + str(turnCounter))
print("Name: " + playerName)
print("HP: " + str(player.hp))
print("location: " + str(location))
print("Monsters in this house: " +
str(neighborhood[location[0] - 1][location[1] -
1].monster_count))
print("All Monsters left: " + str(monster_num))
#checking gameOver Conditions
if monster_num <= 0:
print(
"CONGRATULATIONS YOU SURVIVED AND SAVED THE NEIGHBORHOOD... At the expense of your candy go ahead and type Yay!"
)
gameOver = True
if player.hp < 0:
print("You perished... It's not like we didn't warn you...")
gameOver = True
#taking in commands
direction = input("Enter a Direction")
#list off some help
if direction == "help":
print(
"1. go [north,south,east,west]-- Allows you to traverse the neighborhood houses... at your own risk"
)
print(
"2. look around-- looks around the house you are in and examine the monsters in that house"
)
print("3. look at candy-- allows you to check your inventory")
print(
"4. attack-- Allows you to start attacking the monsters in the house you are given, attacking a person heals you, but they are not damaged (think of them as checkpoints), so don't waste your nerd bombs on them"
)
print(
"5. exit-- Let's you exit the game, but do you really want to leave?"
)
#quitting the game
elif direction.lower() == "exit":
print("How could you leave us?")
print("-----------------GAME OVER--------------------------")
gameOver = True
#go North
elif direction.lower().lstrip() == "go north":
if location[0] != 0:
location = (location[0] - 1, location[1])
else:
print("Sorry you can't go North out of this neighborhood")
#go South
elif direction.lower().lstrip() == "go south":
if location[0] != len(neighborhood):
location = (location[0] + 1, location[1])
else:
print("Sorry you can't go South out of this neighborhood")
#go East
elif direction.lower().lstrip() == "go east":
if location[1] != len(neighborhood):
location = (location[0], location[1] + 1)
else:
print("Sorry you can't go South out of this neighborhood")
#Go West
elif direction.lower().lstrip() == "go west":
if location[1] != 0:
location = (location[0], location[1] - 1)
else:
print("Sorry you can't go West out of this neighborhood")
#allows you to see the monsters in the house
elif direction.lower().lstrip() == "look around":
counter = 0
print("You see: ")
for i in neighborhood[location[0]][location[1]].monster_list:
counter = counter + 1
print(
str(counter) + "-" + str(i.Name) + " --HP: " +
str(i.Health))
#checking inventory
elif direction.lower().lstrip() == "look at candy":
counter = 0
for i in player.weapons:
counter = counter + 1
print(
str(counter) + "-" + str(i.Name) + " --qty: " +
str(i.qty))
#attacking Monsters logic
elif direction.lower().lstrip() == "attack":
counter = 0
#print out monster_list for conveniece :)
for i in neighborhood[location[0]][location[1]].monster_list:
print(
str(counter) + "-" + str(i.Name) + " --" +
str(i.Health))
counter = counter + 1
directed_attack = input("Which index would you like to attack")
if directed_attack == exit:
pass
#checking valid input for the list player is supposed to enter an index in order to do a lookup
#One problem here is I could not find a way to check a string being an int without casting it as an int beforehand which is a problem :(
elif type(int(directed_attack)) is int and int(
directed_attack) < len(
neighborhood[location[0]][location[1]].monster_list
) and int(directed_attack) >= 0:
counter = 0
print("\n\n\n\n\n")
for i in player.weapons:
print(
str(counter) + "-" + str(i.Name) + " --qty: " +
str(i.qty))
counter = counter + 1
#wanting to know the index of what item the player wants
attackItem = input(
"Enter an index for which weapon you want to use: ")
if type(int(attackItem)) is int and int(attackItem) < len(
player.weapons) and int(
attackItem) >= 0 and player.weapons[int(
attackItem)].qty > 0:
#calling getAttackedBy on the monster that the player wants to attack
neighborhood[location[0]][location[1]].monster_list[
int(directed_attack)].getAttackedBy(
player.useItem(int(attackItem)),
player.weapons[int(attackItem)].Name)
#The player used a weapon, so we now have 1 less of that item
player.weapons[int(attackItem)].qty = player.weapons[
int(attackItem)].qty - 1
#getting the damage appropriate for the monster
damage = neighborhood[location[0]][location[
1]].monster_list[int(directed_attack)].Attack()
#changing print message depending on whether or not the monster is a person or not
if neighborhood[location[0]][location[1]].monster_list[
int(directed_attack)].Name == "Person":
#in case they want to get healed different message
print(
"The person finds you and gives you some orange juice: You feel better: +"
+ str(damage * -1) + " HP")
else:
#printing message for monster attacks
print("The " +
neighborhood[location[0]][location[1]].
monster_list[int(directed_attack)].Name +
" Leaps towards you and attacks you for " +
str(damage) + " damage")
#updating player health
player.hp = player.hp - damage
#checking if monster dies, which then we wnat to notify the house and then that will mean that we have 1 less monster
if neighborhood[location[0]][location[1]].monster_list[
int(directed_attack)].isDead():
neighborhood[location[0]][location[1]].update(
int(directed_attack))
monster_num = monster_num - 1
else:
print("Please enter a correct number next time")
else:
print(
"please enter a correct number corresponding to a monster"
)
else:
print(
"Sorry you look around and realize that you can't do that")
class Board:
potArray = []
storeP1 = 0
storeP2 = 0
selectedPlayer = 1
playNum = 0
computer = Player()
computerState = []
gameStates = []
@staticmethod
def getPermutations(inputArray, interable):
perms = list(itertools.permutations(inputArray, interable))
returnPerms = list()
for permutation in perms:
if len(returnPerms) > 0:
keepPerm = True
for perm in returnPerms:
if perm == permutation:
keepPerm = False
break
if keepPerm:
returnPerms.append(permutation)
else:
returnPerms.append(permutation)
return returnPerms
def generateGameStates(self):
gameStates = []
permList = [0, 0, 0, 0, 0, 0]
for i in range(0, 6):
comb = self.getPermutations(permList, 6)
for perm in comb:
gameStates.append(perm)
permList[i] = 1
gameStates.append(permList)
del gameStates[0]
return gameStates
def setCurrentComputerState(self):
self.computerState = [
self.potArray[6].hasStones, self.potArray[7].hasStones,
self.potArray[8].hasStones, self.potArray[9].hasStones,
self.potArray[10].hasStones, self.potArray[11].hasStones
]
def __init__(self, pots, computer):
self.potArray = pots
self.computer = computer
self.gameStates = self.generateGameStates()
def test(self):
self.setCurrentComputerState()
potIndex = self.askForIndex()
return self.moveStonesAtIndex(potIndex)
def player1Stones(self, index, stoneNum):
length = len(self.potArray)
maxIndex1 = (length - (length / 2))
lastPot = (index + stoneNum)
lastCheck = 0
i = index + 1
while i <= lastPot:
if i == maxIndex1:
self.storeP1 += 1
if lastPot == maxIndex1:
self.playNum -= 1
lastCheck = 1
# lastPot -= 1
# lastCheck = 1
if i >= length and lastCheck == 0:
self.potArray[i - length].stoneNum += 1
elif lastCheck == 0:
self.potArray[i].stoneNum += 1
if i == maxIndex1:
lastPot -= 1
lastCheck = 0
i += 1
self.potArray[index].stoneNum = 0
def player2Stones(self, index, stoneNum):
length = len(self.potArray)
lastPot = (index + stoneNum)
lastCheck = 0
i = index + 1
while index + 1 <= i < lastPot + 1:
if i == length:
self.storeP2 += 1
if lastPot == length:
self.playNum -= 1
# lastPot -= 1
lastCheck = 1
if i > length:
var = math.floor(i / length) * length
var = int(var)
self.potArray[i - var - 1].stoneNum += 1
elif lastCheck == 0:
self.potArray[i].stoneNum += 1
lastCheck = 0
i += 1
self.potArray[index].stoneNum -= stoneNum
def setCurrentPlayer(self):
if self.playNum % 2 == 0:
self.selectedPlayer = 1
else:
self.selectedPlayer = 2
def moveStonesAtIndex(self, index):
stone = self.potArray[index]
self.checkPots()
self.setCurrentPlayer()
if stone.hasStones:
stoneNum = stone.stoneNum
self.setCurrentPlayer()
if self.selectedPlayer == 1:
self.player1Stones(index, stoneNum)
else:
self.player2Stones(index, stoneNum)
self.playNum += 1
return self.checkGameOver()
else:
print "Pot does not contain any stones!"
def askForIndex(self):
if self.playNum % 2 == 0:
inputIndex = input("P1 Input Index: ")
if 5 < inputIndex < 12:
print "Incorrect Index"
return self.askForIndex()
else:
self.selectedPlayer = 1
return inputIndex
else:
self.setCurrentComputerState()
if self.computer.stateMoveDictionary.values()[0] < 6:
for state in self.gameStates:
self.computer.stateMoveDictionary[tuple(state)] += 6
inputIndex = self.computer.stateMoveDictionary[tuple(
self.computerState)]
if inputIndex < 6:
print "Error"
print "Player 2 plays: " + str(inputIndex)
self.selectedPlayer = 2
return inputIndex
def checkPots(self):
for pot in self.potArray:
if pot.stoneNum <= 0:
pot.hasStones = False
else:
pot.hasStones = True
def checkGameOver(self):
self.checkPots()
if not self.potArray[0].hasStones and not self.potArray[1].hasStones and not self.potArray[2].hasStones and not \
self.potArray[3].hasStones and not self.potArray[4].hasStones and not self.potArray[5].hasStones:
return 1
if not self.potArray[11].hasStones and not self.potArray[10].hasStones and not self.potArray[
9].hasStones and not \
self.potArray[8].hasStones and not self.potArray[7].hasStones and not self.potArray[6].hasStones:
return 1
return 0
def printValues(self):
print "Store1 " + str(self.storeP1)
print "Store2 " + str(self.storeP2)
index = 0
for i in self.potArray:
print "Pot" + str(index)
print i.stoneNum
index += 1
def __init__(self):
self.deck = Deck()
self.allcards = self.deck.all_cards
self.player1 = Player(self.deck, "Player1")
self.player2 = Player(self.deck, "Player2")
self.used_cards = []
from Aimbotz import Aimbotz
from Deck import Deck
from Player import Player
Player1 = Player()
Deck1 = Deck()
Aimbotz1 = Aimbotz()
Resume = True
Comdraw = True
Playdraw = True
Game = True
End = False
Player1.Score = 0
Aimbotz1.Score = 0
Deck1.Rawdeck = []
Deck1.initdeck()
Player1.Rawdeck = []
Aimbotz1.Rawdeck = []
while Resume:
Comdraw = True
Playdraw = True
Game = True
Player1.Score = 0
Aimbotz1.Score = 0
Deck1.Rawdeck = []
Deck1.initdeck()
Player1.Rawdeck = []
Aimbotz1.Rawdeck = []
#coding:UTF-8"
from Bom import Bom
from Player import Player
from Object import Object
from Board import Board
if __name__ == '__main__':
# main()
p = []
board = Board(width=7, height=7)
p.append(Player(x=1, y=1, fire=2, ID=chr(65))) # randomに
p.append(Player(x=7, y=7, fire=2, ID='T'))
"""
p.append(Player(x=1, y=7, fire=2, ID='M'))
p.append(Player(x=7, y=1, fire=2, ID='N'))
p.append(Player(x=4, y=3, fire=2, ID='E'))
"""
board.display(p)
while True:
print('input direction')
directions = input().strip().split()
for i, player in enumerate(p): # ボム置く
if '1' in directions[i]:
board.putObject(player.createBom())
elif 'q' in directions[i]:
break
for i, player in enumerate(p): # 移動
player.move(directions[i], board.movable_range(player))
#print(board.getClassList(Bom))
from config import *
from Player import Player
from EnemyFactory import EnemyFactory
player = Player(WIDTH / 2, HEIGHT / 2)
enemy_factory = EnemyFactory()
def setup():
size(WIDTH, HEIGHT)
imageMode(CENTER)
rectMode(CENTER)
def draw():
#Setup
background(0)
player.controller()
translate(WIDTH / 2 - player.x, HEIGHT / 2 - player.y)
#Bullet
for i, bullet in enumerate(BULLET_LIST):
if bullet.outOfRange():
BULLET_LIST.pop(i)
bullet.move()
bullet.draw()
#Player
player.draw()
def pruebaPuntuacionVm():
from Player import Player
from Dice import Dice
dices = [Dice().roll() for i in range(5)]
player = Player("Salvador")
player.setScore("Ones", 6)
player.setScore("Chance", 21)
player.setScore("Fours", 16)
player.setScore("Full House", 25)
vmLower, vmUpper = player.getScoreCardVm(dices)
print("Dices: ", dices, sep=" ")
print("Lower Section: ", vmLower, sep=" ")
print("Upper Section: ", vmUpper, sep=" ")
class Window(pyglet.window.Window):
def __init__(self):
super(Window, self).__init__(width=width,
height=height,
vsync=True,
caption="Platformer")
self.set_icon(icon1, icon2)
self.CurrentLevel = 1
self.PlayerSprite = Player(playerStill.width, playerStill.height,
playerStill, 0, 0)
self.LoadLevel(self.CurrentLevel)
pyglet.clock.schedule_interval(self.DrawScreen, 1 / 60)
pyglet.clock.schedule_interval(self.UpdatePlayer, 1 / 60)
self.Gravity = -1
self.AveFPS = []
def on_draw(self):
pyglet.clock.tick()
FPSVal = str(round(pyglet.clock.get_fps(), 2))
self.AveFPS.append(float(FPSVal))
if Extras:
TotFPS = 0
for FPSValue in self.AveFPS:
TotFPS += float(FPSValue)
TotFPS /= len(self.AveFPS)
while len(self.AveFPS) > 5000:
del self.AveFPS[0]
fpsDisplay = pyglet.text.Label(f"FPS: {FPSVal}",
font_size=10,
x=10,
y=700)
AveFPSDisplay = pyglet.text.Label(f"Ave FPS: {round(TotFPS, 2)}",
font_size=10,
x=10,
y=680)
fpsDisplay.draw()
AveFPSDisplay.draw()
def on_key_release(dt, symbol, modifiers):
try:
del pressedKeys[symbol]
except:
pass
def on_key_press(dt, symbol, modifiers):
global Extras
if symbol == key.ESCAPE:
pyglet.app.exit()
if symbol == key.F3:
Extras = not Extras
pressedKeys[symbol] = True
def UpdatePlayer(self, dt):
Moved = False
if key.W in pressedKeys and self.PlayerSprite.OnFloor:
self.PlayerSprite.applyforce(0, 18)
Moved = "W"
if key.S in pressedKeys:
self.PlayerSprite.applyforce(0, -0.8)
Moved = "S"
if key.A in pressedKeys:
self.PlayerSprite.applyforce(-1, 0)
Moved = "A"
if key.D in pressedKeys:
self.PlayerSprite.applyforce(1, 0)
Moved = "D"
if not (Moved):
self.PlayerSprite.update(playerStill)
elif Moved == "W":
self.PlayerSprite.update(playerUp)
elif Moved == "S":
self.PlayerSprite.update(playerDown)
elif Moved == "A":
self.PlayerSprite.update(playerLeft)
elif Moved == "D":
self.PlayerSprite.update(playerRight)
Collide = False
for CurrentTile in self.LoadedData:
if abs(CurrentTile.Pos[0] - self.PlayerSprite.Pos[0]) > 100:
continue
if abs(CurrentTile.Pos[1] - self.PlayerSprite.Pos[1]) > 100:
continue
if self.PlayerSprite.collideswith(CurrentTile):
if key.W in pressedKeys:
self.PlayerSprite.resetvel(CurrentTile, "UP")
Collide = True
if key.S in pressedKeys:
self.PlayerSprite.resetvel(CurrentTile, "DOWN")
Collide = True
if key.A in pressedKeys:
self.PlayerSprite.resetvel(CurrentTile, "LEFT")
Collide = True
if key.D in pressedKeys:
self.PlayerSprite.resetvel(CurrentTile, "RIGHT")
Collide = True
if Moved == False:
self.PlayerSprite.resetvel(CurrentTile)
Collide = True
if self.PlayerSprite.checkfloor(CurrentTile):
self.PlayerSprite.resetvel(CurrentTile)
Collide = True
if not Collide:
self.PlayerSprite.OnFloor = False
if self.PlayerSprite.nextlevel(self.width):
self.CurrentLevel += 1
self.LoadLevel(self.CurrentLevel)
def DrawScreen(self, dt):
self.clear()
self.PlayerSprite.draw()
for CurrentTile in self.LoadedData:
CurrentTile.draw()
def LoadLevel(self, num: int):
Index = num - 1
self.LoadedData = []
with open("Level.Data", "r") as LevelData:
LevelData = json.loads(LevelData.read())
GroundData = LevelData["levels"][Index]["Data"]
for Data in GroundData:
Data = Data.split(",")
if Data[2] == "gr":
Data[2] = groundTexture
elif Data[2] == "drt":
Data[2] = dirtTexture
Data[0] = int(Data[0])
Data[1] = int(Data[1])
CurrentTile = Tile(Data[2].width, Data[2].height, Data[2], Data[0],
Data[1], Data[3])
self.LoadedData.append(CurrentTile)
StartingPos = LevelData["levels"][Index]["StartingPos"]
self.PlayerSprite.movepos(StartingPos[0], StartingPos[1])
def setUp(self):
TestDatabaseSetup.setUp(self)
self.p1 = Player("Vladimir", Alignment.WOOD)
self.p2 = Player("Estragon", Alignment.METAL)
self.rock = Rock()
self.gp3 = GoldPiece(3)
def addPlayer(self, playerName): self.players.append(Player(playerName))
from Game import Game
from Player import Player
player1 = Player(race='horde', start_gold=10, name='Grubby', number=1)
player2 = Player(race='human', start_gold=10, name='a1sok', number=2)
game = Game(player1, player2)
player2.factory.create_unit('footman', (4, 5))
player2.factory.create_unit('footman', (4, 7))
game.run()
return text_rect
if __name__ == '__main__':
pygame.init()
window_surface: Surface = pygame.display.set_mode(SCREEN_DIMENSION)
pygame.display.set_caption(WINDOW_CAPTION)
pygame.mixer.init()
pygame.mixer.music.load(BGM_PATH)
pygame.mixer.music.play(loops=-1)
running = True
ball_1 = Ball(WINDOW_WIDTH / 2, WINDOW_HEIGHT / 2)
player_1 = Player(WINDOW_WIDTH / 2, WINDOW_HEIGHT - 60)
# drawing screen borders
left_limit_rect = Rect(10, 10, 10, 700)
right_limit_rect = Rect(440, 10, 10, 700)
top_limit_rect = Rect(20, 10, 420, 20)
clock = pygame.time.Clock()
brick_list = []
number_of_lines = 8
brick_y_position = top_limit_rect.bottom + 40
line_value = 1000
for i in range(number_of_lines):
has_space = True
def on_update(self, delta_time: float):
if self.drawn:
player1 = Player(int(1/8 * SCREEN_WIDTH), Y_BASELINE, BOX_WIDTH, BOX_HEIGHT, 0, character='nate')
player2 = Player(int(7/8 * SCREEN_WIDTH), Y_BASELINE, BOX_WIDTH, BOX_HEIGHT, 1, character='nate')
fight_view = FightView(self.window, player1=player1, player2=player2)
self.window.show_view(fight_view)
