import player
class Game:
def __init__(self, player1, player2):
board = board.Board()
self.varnika = player1
self.sahitya = player2
print(
"chess program. enter moves in algebraic notation separated by space"
)
varnika = player.Player('white', True)
sahitya = player.Player('black', False)
game = Game(varnika, sahitya)
print(varnika.getColor())
print(varnika.turn)
print(sahitya.getColor())
def setUp(self):
self.size = 10
self.world = world.World(size=self.size)
self.world.spawn_player(player.Player('test_player'))
def add_table_set(self, name, first_player):
tabl = table.Table(name, first_player)
self.table_set.add(tabl)
self.add_player_dict(player.Player(first_player, tabl))
def __init__(self, *args, **kwargs):
super(MyFlask, self).__init__(*args, **kwargs)
self.player = player.Player()
self.playlist_result = []
self.search_result = []
from pygame.locals import *
import player
import neural
import random
import math
pygame.init()
pygame.font.init()
WIDTH = 1200
HEIGHT = 600
screen = pygame.display.set_mode((WIDTH, HEIGHT))
plr = player.Player(20, 20)
itemsize = 10
item = player.Item(random.randint(0, WIDTH - itemsize),
random.randint(0, HEIGHT - itemsize))
nn = neural.Network(4, 8, 4)
LR = 0.05
clock = pygame.time.Clock()
myfont = pygame.font.Font(None, 36)
accuracy = []
while True: # main game loop
def __init__(self):
self.map = map.Map()
self.player = player.Player()
self.round_phase = ''
# Created by MysteryBlokHed in 2019.
import pygame
import pygame.freetype
import player, ball
pygame.init()
width = 960
# Formula for 16:9
height = int(width/2+width/16)
screen = pygame.display.set_mode((width, height))
pygame.display.set_caption("Pong by MysteryBlokHed")
player1 = player.Player(25, 200, 25, 150)
player2 = player.Player(width-75, 200, 25, 150)
ball1 = ball.Ball(480, 270, 15, 15)
ball1.set_vel_x(10)
ball1.set_vel_y(-10)
player1_score = 0
player2_score = 0
scored = False
ai = True
text = pygame.freetype.SysFont("Roboto", 30)
running = True
while running:
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
return True
return False
def drawAndDelay(player):
#fill screen with black
screen.fill(black)
#Draw player
player.draw()
#Update the screen
pygame.display.flip()
#Delay to get 30 fps
clock.tick(30)
#Create the player
player = player.Player(screen, 100, 200)
#Main loop
done = False
while not done:
#Handle any events, possibly closing the game.
done = handleEvents()
#Send user input to the player
userInputToPlayer(player)
#Draw on the screen
drawAndDelay(player)
pygame.quit()
import player
obj = player.Player("A")
print(obj.name)
print(obj.lives)
def setUp(self):
self.player = player.Player('test')
import numpy as np
import nltk
import nlpy
import en
import psw
import gapi
import player
songPlayer = player.Player()
player.init()
import subprocess
from grooveshark import Client
#songClient = Client()
#songClient.init()
from sets import Set
def matchWord(tokens, words):
s = Set(tokens).intersection(Set(words))
if len(s) > 0:
return [(w, 1.0, w) for w in s]
else:
from nltk.metrics import distance
import operator
result = []
for token in Set(tokens):
def GET(self):
user_data = web.input()
file_name = user_data.fileName
pl = player.Player()
return pl.play_task(file_name)
def setup():
self.deck = deck.Deck()
self.player = player.Player(self.deck)
self.house = house.House(self.deck)
# - queen go to more than one cell
# - clean code
# - bug fixes, if any
import player
while True: # please choose a color
player_color = input('Please select your color (w/b): ')
if player_color.lower() in ['w', 'b']:
break
continue
# create an instance and display the start board
game = player.Player(player_color)
bot_color = game.get_invert(player_color)
print(game.print_board())
# start the game with the first move, depending on the user's choice
if player_color == 'w':
while not game.win(bot_color, player_color):
game.input(player_color)
if not game.win(bot_color, player_color):
game.bot(bot_color)
else:
def testInit_playerOrientation_isUserSpecified(self):
ori = bb.BaseBrain.ORIENTATION_LEFT
p4 = player.Player(self.brainClass, self.mObj, self.pos, ori)
self.assertEqual(ori, p4.getOrientation())
"""
calls the flush hands function for all the players
:return:
"""
for player in self.players:
player.flush_hand()
self.decks_remaining = self.get_remaing_deck()
self.true_count = self.game_count / (self.get_remaing_deck() + 1)
pass
if __name__ == '__main__':
deck = d.Deck()
deck.initialize(number_of_card=52, random_order=True)
player1 = p.Player(player_type="Gambler", name="Player One")
game = Game(deck)
game.add_players(player1)
for i in range(1):
game.pass_cards(2)
game.show_player_stats()
game.flush_hand()
def testInit_playerPosition_isUserSpecified(self):
pos = c.Coordinate(5, 4)
p2 = player.Player(self.brainClass, self.mObj, pos)
self.assertEqual(pos, p2.getPosition())
"""
GAME SETUP AND GAME SETTINGS, ALSO A START POINT
IF YOU WANT TO START A GAME, JUST RUN game.py (THIS ONE)
(YOU CAN SETUP HOW MANY CARDS ARE DRAWN AT WAR
AND BOTH PLAYERS START AMOUNT OF CARDS)
"""
#imports
import random
import player
import deck
import card
#setup
player_one = player.Player('Player1')
player_two = player.Player('Player2')
new_deck = deck.Deck()
new_deck.shuffle()
how_many_cards_at_war = 5
players_should_get = int(len(new_deck.all_cards) / 2)
#we can adjust cards for players by typing in range(amount of cards for each player)
for card in range(players_should_get):
player_one.add_cards(new_deck.deal_one())
player_two.add_cards(new_deck.deal_one())
game_on = True
round_num = 0
import player
import enemy
from game import Game
wn = turtle.Screen()
wn.bgcolor('black')
wn.setup(width=1600, height=900)
wn.tracer(0)
enemyTHEM = enemy.Boomyzoomy()
enemyTHEM2 = enemy.Boomyzoomy()
enemyTHEM3 = enemy.Boomyzoomy()
enemies = [enemyTHEM, enemyTHEM2, enemyTHEM3]
playerME = player.Player()
wn.listen()
wn.onkeypress(playerME.left, 'a')
wn.onkeypress(playerME.right, 'd')
game = Game(playerME, enemies)
loopCounter = 0
while True:
loopCounter += 1
if loopCounter >= 100000:
loopCounter = 0
game.moveEnemies(loopCounter)
def game():
print("[SYSTEM] Game starts")
dealer = player.Dealer()
user = player.Player()
user_win = -1
print("Dealer cards")
dealer.draw_card()
dealer.draw_card()
dealer.show_first()
print("unknown")
print("Player cards")
user.draw_card()
user.draw_card()
user.print_cards()
print("Score : " + str(user.get_score()))
player_sum, dealer_sum, action, p_hit, p_stand = recommend(
user.cards, dealer.cards)
choice = "begin"
while choice != "q":
choice = input("Enter [H]it, [S]tand, or [Q]uit\n").lower()
if choice == "h":
user.hit()
if check_bust(user) == 0:
print("Score : " + str(user.get_score()))
elif choice == "s":
while dealer.get_score() < 17:
dealer.draw_card()
print("Dealer score: " + str(dealer.get_score()))
if check_bust(dealer):
user_win = 1
elif dealer.get_score() > user.get_score():
user_win = 0
elif dealer.get_score() < user.get_score():
user_win = 1
else:
user_win = 2 # Draw
break
elif choice == "q":
print("Exit")
exit()
if check_bust(user) == 1:
print("[SYSTEM] Lose: User busted")
user_win = 0
break
print("USER")
user.print_cards()
print("Total: " + str(user.get_score()))
print("DEALER")
dealer.print_cards()
print("Total: " + str(dealer.get_score()))
if user_win == 0:
print("[SYSTEM] Lose")
if user_win == 1:
print("[SYSTEM] Win")
if user_win == 2:
print("[SYSTEM] Draw")
def __init__(self, grid_size=52):
self.client_player = player.Player()
self.players = [self.client_player]
self.grid_size = grid_size
directory_path = tkinter.filedialog.askdirectory()
if not directory_path:
return
audio_files_in_directory = self.get_all_audio_file_from_directory(
directory_path)
for audio_file in audio_files_in_directory:
self.model.add_to_play_list(audio_file)
file_path, file_name = os.path.split(audio_file)
self.list_box.insert(tk.END, file_name)
def get_all_audio_file_from_directory(self, directory_path):
audio_files_in_directory = []
for (dirpath, dirnames, filenames) in os.walk(directory_path):
for audio_file in filenames:
if audio_file.endswith(".mp3") or audio_file.endswith(".wav"):
audio_files_in_directory.append(dirpath + "/" + audio_file)
return audio_files_in_directory
def clear_play_list(self):
self.model.clear_play_list()
self.list_box.delete(0, tk.END)
if __name__ == '__main__':
root = tk.Tk()
root.resizable(width=False, height=False)
model = model.Model()
player = player.Player()
app = View(root, model, player)
root.mainloop()
def __intro(self):
for ev in pygame.event.get():
if ev.type == QUIT:
pygame.quit()
sys.exit()
self.introManager.process_events(ev)
if ev.type == pygame.USEREVENT:
if ev.user_type == pygame_gui.UI_BUTTON_PRESSED:
if ev.ui_element == self.startBtn:
self.state = "control"
if not self.doublePlayer:
self.player1 = player.Player(
self.width, self.height, 1)
else:
self.player1 = player.Player(
self.width, self.height, 1)
self.player2 = player.Player(
self.width, self.height, 2)
if self.enemyNumber == 1:
self.enemy1 = enemy.Enemy(self.width, self.height,
1)
elif self.enemyNumber == 2:
self.enemy1 = enemy.Enemy(self.width, self.height,
1)
self.enemy2 = enemy.Enemy(self.width, self.height,
2)
if ev.ui_element == self.menuExitBtn:
pygame.quit()
sys.exit()
if ev.ui_element == self.onePlayerBtn:
self.doublePlayer = False
self.onePlayerBtn.select()
self.twoPlayerBtn.unselect()
self.noEnemyBtn.disable()
if self.enemyNumber == 0:
self.enemyNumber = 1
self.oneEnemyBtn.select()
if ev.ui_element == self.twoPlayerBtn:
self.doublePlayer = True
self.onePlayerBtn.unselect()
self.twoPlayerBtn.select()
self.noEnemyBtn.enable()
if ev.ui_element == self.noEnemyBtn:
self.enemyNumber = 0
self.noEnemyBtn.select()
self.oneEnemyBtn.unselect()
self.twoEnemyBtn.unselect()
if ev.ui_element == self.oneEnemyBtn:
self.enemyNumber = 1
self.noEnemyBtn.unselect()
self.oneEnemyBtn.select()
self.twoEnemyBtn.unselect()
if ev.ui_element == self.twoEnemyBtn:
self.enemyNumber = 2
self.noEnemyBtn.unselect()
self.oneEnemyBtn.unselect()
self.twoEnemyBtn.select()
self.introManager.update(self.time)
self.screen.fill((255, 255, 255))
self.screen.blit(self.menuBg, (0, 0))
self.screen.blit(self.titleImg, ((self.width / 2) - 350, 100))
self.introManager.draw_ui(self.screen)
pygame.display.update()
def render_SPH(runfolder,
args=gas_args,
snapprefix='snapshot_',
snap=-1,
inc=0,
azi=0,
inc2=0,
vel_field=False,
Hill_rad=False,
Slice=False,
upto=0,
zoom=False,
polyzoom=False,
overlay=False,
write=False,
hammer=False,
RZ_plot=False,
roffset=0.01,
dpi=100,
h_hist=False,
it=0,
rerun=False,
amin=0,
amax=0,
tracking=False,
track_R=3,
soffset=0):
'''Make rendered animation or single image of an SPH plot. Option to save.
field_mode:
---- Vertically averaged modes ----
Sigma - Surface Density [gcm^{-2}]
---------- Slice modes ----------
temp - Temperature [K]
tau - Dimensionless stopping time []
Q - Toomre Q parameter []
vz - zcoord (or rcoord) velocity [cm/s]
set snap to find snapshot. snap=-1 -> movie
If inc != 0 or 180, plot rho instead of Sigma
overlay - pixellated overlay of dust particles. Scatter too expensive.
vel_field - overlay of render data velocity structure
zoom - zooms on first planet
polyzoom - zooms on max rho SPH particles
upto - limits movie frames
tracking - track gas particles that are initially close to the planet
'''
#==== Load Arguments ====#
mode_name, p_type, map_col = args[0], args[1], args[2]
vmin, vmax, field_mode = args[3][0], args[3][1], args[5]
zoom_str, overlay_str, angle_str, hammer_str = '', '', '', ''
movie = False
box_lim = XYdim * AU_scale
if polyzoom == True:
zoom = True
if zoom == True:
zoom_str = '_zoom'
box_lim = XYdim_zoom * AU_scale
vmin, vmax = args[4][0], args[4][1]
if inc != 0:
angle_str += '_i' + str(inc)
if mode_name == 'vz':
mode_name = r'$v_{\phi}$'
if azi != 0:
angle_str += '_a' + str(azi)
if field_mode == 'Sigma':
render_mode = 'Sigma'
if Slice == False:
if (field_mode == 'rho') or (field_mode == 'temp') or (
field_mode == 'tau') or (field_mode == 'vz') or (field_mode
== 'h'):
render_mode = 'rho_grid'
else:
render_mode = 'Sigma'
if field_mode == 'vz':
A = 'vz'
angle_str += '_vz'
elif field_mode == 'h':
A = 'h'
else:
A = 'u'
box_limx, box_limy = box_lim, box_lim
if hammer == True:
angle_str += 'hammer'
box_limx = np.pi
box_limy = 1
#==== Build grids ====#
binsx = np.linspace(-box_limx, box_limx, ngrid + 1)
binx_mids = (binsx[1:] + binsx[:-1]) / 2
binsy = np.linspace(-box_limx, box_limx, ngrid + 1)
biny_mids = (binsy[1:] + binsy[:-1]) / 2
Bin_Xs, Bin_Ys = np.meshgrid(binx_mids, biny_mids)
#================ Find Time data and num snaps ==================#
globbed = glob.glob(filepath + runfolder + 'snapshot*')
num_snaps = len(globbed)
snaps = []
slen = len(globbed[0].split('.hdf')[0].split('snapshot_')[1])
print 'slen', slen
time1 = time.time()
try:
time_zero = readheader(
filepath + runfolder + snapprefix + '001'.zfill(slen), 'time')
try:
time_one = readheader(
filepath + runfolder + snapprefix + '002'.zfill(slen), 'time')
time_dt = time_one - time_zero
except:
'Only one snapshot!'
time_dt = 0
except:
print 'No snapshots found!'
time_dt = 0
snap_dt = time_dt * code_time / c.sec_per_year
if snap == -1:
movie = True
print savedir + runfolder
if upto != 0:
num_snaps = upto
min_snap = 0
else:
for i in range(len(globbed)):
snaps.append(int(globbed[i][-5 - slen:][:slen]))
min_snap = min(snaps)
print 'Running movie for ', num_snaps, ' frames'
snapids = np.arange(num_snaps) + min_snap
else:
num_snaps = 1
snapids = [snap]
#======== Set up overlay data ========#
if tracking == True:
coarse = 4
track_IDs = b.ID_selection(runfolder,
snapprefix=snapprefix,
track_R=track_R,
zoom='planet')
ngrid_coarse = int(ngrid / coarse)
#track_store = np.zeros((num_snaps,ngrid_coarse,ngrid_coarse))
else:
track_IDs = []
#======== Load saved files or rerun rendering routine ========#
try:
if (rerun == True) or (movie == False):
1 / 0
else:
print savedir + runfolder.rstrip(
'//'
) + '_' + p_type + zoom_str + overlay_str + angle_str + render_mode + '_movie.npy'
save_array = np.load(savedir + runfolder.rstrip('//') + '_' +
p_type + zoom_str + overlay_str + angle_str +
render_mode + '_movie.npy')
except:
print 'No file currently exists, must compute simulation render!'
save_array = np.zeros((num_snaps, 6, ngrid + 1, ngrid))
for i in range(len(snapids)):
idn = snapids[i]
print 'i', idn + 1, ' out of', num_snaps
print 'render_mode', render_mode
store, dust_pos, track_pos = render(runfolder,
snapprefix=snapprefix,
snapid=idn,
slen=slen,
p_type=p_type,
inc=inc,
azi=azi,
inc2=inc2,
hammer=hammer,
RZ_plot=RZ_plot,
A=A,
roffset=roffset,
render_mode=render_mode,
zoom=zoom,
track_IDs=track_IDs,
polyzoom=polyzoom,
overlay=overlay,
h_hist=h_hist,
it=it)
print 'A', store[1, 1:, :]
save_array[i, 0, 0, :] = store[0, 0, :] #Header info
save_array[
i, 0,
1:, :] = store[0, 1:, :] * code_M / code_L**2 #Sigma [g/cm^2]
save_array[i, 2,
1:, :] = store[2,
1:, :] * code_L / code_time #vx [cm/s]
save_array[i, 3,
1:, :] = store[3,
1:, :] * code_L / code_time #vy [cm/s]
dust_pos *= AU_scale
track_pos *= AU_scale
if A == 'u':
save_array[i, 1, 1:, :] = store[
1, 1:, :] * code_L**2 / code_time**2 #u [cm^2/s^2]
elif A == 'h':
save_array[i, 1, 1:, :] = store[1, 1:, :] * AU_scale #h in AU
elif A == 'vz':
save_array[i, 1,
1:, :] = store[1, 1:, :] * code_L / code_time #cm/s
#==== Add image floor to remove low density errors ====#
save_array[i, 0, 1:, :][save_array[i, 0, 1:, :] > roof] = floor
save_array[i, 0, 1:, :][save_array[i, 0, 1:, :] < floor] = floor
print 'Min/Max: ', np.min(save_array[i, 0, 1:, :]), np.max(
save_array[i, 0, 1:, :])
print '\n'
#==== Add dust_overlay info ====#
save_array[i, 4, 1:, :] = track_overlay(dust_pos, box_lim, ngrid)
if tracking == True:
save_array[i, 5,
1:ngrid_coarse + 1, :ngrid_coarse] = track_overlay(
track_pos, box_lim, ngrid_coarse)
#==== Save output ====#
if snap == -1:
try:
print 'try removing file'
print savedir + runfolder.rstrip(
'//'
) + '_' + p_type + zoom_str + overlay_str + angle_str + render_mode + '_movie.npy'
os.remove(savedir + runfolder.rstrip('//') + '_' + p_type +
zoom_str + overlay_str + angle_str + render_mode +
'_movie.npy')
print 'file removed'
except:
print 'pass'
print 'Starting save!'
np.save(
savedir + runfolder.rstrip('//') + '_' + p_type + zoom_str +
overlay_str + angle_str + render_mode + '_movie', save_array)
print 'Loading Complete'
#------------------======== Load Header info =========----------------#
Time = save_array[:, 0, 0,
0] #snap_dt*np.arange(num_snaps)#save_array[:,0,0,0] #Years
M_star = save_array[:, 0, 0, 1] #code_M
NP = save_array[:, 0, 0, 2] #Number of planets
MP = save_array[:, 0, 0, 3] #code_M
p_pos = save_array[:, 0, 0, 4:7] * AU_scale #AU
p_sep = np.sqrt(p_pos[:, 0]**2 + p_pos[:, 1]**2 + p_pos[:, 2]**2)
RH = b.hill_radius(p_sep, MP, M_star) #AU
Sigma = save_array[:, 0, 1:, :] + floor
bonus_field = save_array[:, 1, 1:, :]
vx_field = save_array[:, 2, 1:, :]
vy_field = save_array[:, 3, 1:, :]
dust_store = save_array[:, 4, 1:, :]
if tracking == True:
track_store = save_array[:, 5, 1:ngrid_coarse + 1, :ngrid_coarse]
NP_max = int(np.max(NP))
print 'Max Number of planets: ', NP_max
p_poss = save_array[:, 0, 0, 3:7 + 4 * (NP_max - 1)] * AU_scale #AU
p_poss = np.reshape(p_poss, (num_snaps, NP_max, 4))
if hammer == True:
p_poss[:, :, 1] *= np.pi / box_lim
p_poss[:, :, 2] *= 1 / box_lim
#====================== Determine plot field ========================#
if field_mode == 'Sigma':
plot_field = Sigma
cax_label = r'$\Sigma \quad \rm{[g cm^{-2}}]$'
if field_mode == 'rho':
plot_field = Sigma / code_L
cax_label = r'$\rho \quad \rm{[g cm^{-3}}]$'
else:
Om_K, Rs = calc_Om_K_field(M_star, zoom=zoom, p_pos=p_pos)
if field_mode == 'tau':
plot_field = calc_tau(u=bonus_field,
Om_K=Om_K,
Sigma=Sigma,
render_mode=render_mode)
cax_label = r'$\tau$'
elif field_mode == 'Q':
if zoom == True:
Om_K, Rs = calc_Om_K_field(MP,
zoom=zoom,
p_pos=[0, 0],
render_mode=render_mode)
plot_field = calc_Q(u=bonus_field, Om_K=Om_K, Sigma=Sigma, Rs=Rs)
cax_label = 'Toomre Q'
elif field_mode == 'temp':
plot_field = calc_temp(u=bonus_field,
Sigma=Sigma,
Om_K=Om_K,
render_mode=render_mode)
cax_label = 'T [K]'
elif field_mode == 'vz':
plot_field = bonus_field / code_L * code_time
cax_label = r'$v_r [cms^{-1}]$'
if inc != 0:
cax_label = r'$v_{\phi}$ $[cms^{-1}]$'
elif field_mode == 'h':
plot_field = bonus_field #h in AU
cax_label = r'Smoothing length h'
#========================= Plotting Code ========================#
#-=========================-------------========================-#
fig1 = plt.figure(it, facecolor='white', figsize=(8, 8))
ax1 = fig1.add_axes([0.15, 0.2, 0.76, 0.76])
cax = fig1.add_axes([0.15, 0.08, 0.76, 0.02])
norm = LogNorm(vmin=vmin, vmax=vmax)
if field_mode == 'vz':
norm = SymLogNorm(linthresh=vmin, vmin=-vmax, vmax=vmax)
map_col = 'RdYlBu_r'
elif (field_mode == 'temp') and (zoom == True):
norm = colors.Normalize(vmin=vmin, vmax=vmax)
elif field_mode == 'h':
norm = colors.Normalize(vmin=vmin, vmax=vmax)
smoothed = ax1.imshow(plot_field[0],
interpolation='none',
norm=norm,
aspect='auto',
cmap=map_col,
extent=[-box_limx, box_limx, -box_limy, box_limy],
origin='lower')
plt.colorbar(smoothed, cax=cax, orientation='horizontal')
'''
#==== 3D test ====#
dim = np.shape(plot_field[0])[0]
Xs = np.linspace(-box_lim,box_lim,dim)
X,Y = np.meshgrid(Xs,Xs)
ax1 = fig1.gca(projection='3d')
ax1.plot_surface(X, Y, plot_field[0], rstride=8, cstride=8, alpha=0.3)
'''
print 'Max dust store', np.max(dust_store)
if overlay == True:
dust = ax1.imshow(dust_store[0],
interpolation='none',
norm=LogNorm(1, 5e4),
aspect='auto',
cmap='gray_r',
extent=[-box_limx, box_limx, -box_limy, box_limy],
origin='lower',
alpha=0.7)
if tracking == True:
tracker = ax1.imshow(track_store[0],
interpolation='none',
norm=LogNorm(1, 100),
alpha=0.5,
aspect='auto',
cmap='RdPu',
extent=[-box_limx, box_limx, -box_limy, box_limy],
origin='lower')
ax1.set_xlabel('x [AU]')
ax1.set_ylabel('y [AU]')
if hammer == True:
ax1.set_xlabel(r'$\phi$')
ax1.set_ylabel(r'cos($\theta$)')
ax1.set_xlim(-box_limx, box_limx)
if inc == 90:
ax1.set_ylabel('z [AU]')
#==== Plot sinks ====#
print np.shape(p_poss)
planet_col = '#581845' #'#22ddff'
if args[0] == 'Dust':
planet_col = '#dd00cc'
planets = ax1.scatter(p_poss[0, :, 1],
p_poss[0, :, 2],
s=30,
color=planet_col) #'#ff1493')#,edgecolors='purple')
#Get parameter plotting strings
beta_string = beta_stringify(runfolder)
grain_string = grain_stringify(runfolder) + ' cm'
tbox = dict(facecolor='white')
ax1.set_rasterized(True)
#ax1.text(0.04,1.015,mode_name + r', $\beta$ = ' + beta_string, transform=ax1.transAxes)
ax1.text(0.06,
0.9,
r'$\beta$ = ' + beta_string + '\n' + mode_name,
transform=ax1.transAxes,
bbox=tbox)
cax.set_xlabel(cax_label)
timetext = ax1.text(0.75,
1.015,
'Time: {:.0f} '.format(Time[0]) + ' Yrs',
transform=ax1.transAxes)
#timetext = ax1.text(0.75,1.015,'Time: {:.0f} '.format(int(snap_dt*soffset)) + ' Yrs', transform=ax1.transAxes)
if vel_field == True:
n_v = 16 #int(ngrid/50)
dv = int(ngrid / n_v)
vel_gridx = np.linspace(-box_limx, box_limx, n_v)
vel_gridy = np.linspace(-box_limy, box_limy, n_v)
Quivers = ax1.quiver(vel_gridx,
vel_gridy,
vx_field[0, ::dv, ::dv],
vy_field[0, ::dv, ::dv],
angles='xy')
if (zoom == True) and (Hill_rad == True):
Hill_radius = plt.Circle((0, 0), RH[0], fc='none', ec='#ffffff')
Half_Hill_radius = plt.Circle((0, 0),
RH[0] / 2,
fc='none',
ec='#ffffff',
ls='--')
ax1.add_patch(Hill_radius)
ax1.add_patch(Half_Hill_radius)
#==== Movie making code ====#
if movie == True:
def animate(i):
returns = []
smoothed.set_array(plot_field[i])
timetext.set_text('Time: {:.0f} '.format(int(Time[i])) + ' Yrs')
#timetext.set_text('Time: {:.0f} '.format(int(snap_dt*(i+soffset))) + ' Yrs')
returns.append([smoothed, timetext])
planets.set_offsets(p_poss[i, :, 1:3])
returns.append(planets)
if vel_field == True:
Quivers.set_UVC(vx_field[i, ::dv, ::dv],
vy_field[i, ::dv, ::dv])
if (zoom == True) and (polyzoom == False) and (Hill_rad == True):
Hill_radius.set_radius(RH[i])
Half_Hill_radius.set_radius(RH[i] / 2)
returns.append([Hill_radius, Half_Hill_radius])
if overlay == True:
dust.set_array(dust_store[i])
returns.append([dust])
if tracking == True:
tracker.set_array(track_store[i])
returns.append([tracker])
return returns
print 'reached animation'
interval = 200 #10#50#100
print 'N snaps', num_snaps
anim = player.Player(fig1,
animate,
interval=interval,
maxi=num_snaps,
blit=False,
repeat=True,
save_count=num_snaps - 1)
#anim = FuncAnimation(fig1, animate, interval=interval, blit=False, repeat=True,save_count=num_snaps)
if write == True:
print 'Writing savefile'
anim = FuncAnimation(fig1,
animate,
interval=interval,
blit=False,
repeat=True,
save_count=num_snaps)
writer = animation.writers['ffmpeg'](fps=20)
anim.save(runfolder.strip('//') + '_' + p_type + zoom_str +
overlay_str + angle_str + field_mode + '.mp4',
writer=writer,
dpi=dpi)
plt.show()
#==== If no movie, save image ====#
else:
if write == True:
fig1.savefig(runfolder.strip('//') + '_' + p_type + zoom_str +
overlay_str + angle_str + field_mode + '_' +
str(snap).zfill(3) + '.pdf',
dpi=dpi)
print 'Runtime: ', time.time() - time1
return
def init_game():
"""
Initialize the game with map, players and bank
1. generate a map
2. initialize players
3. initialize bank
all of the data
:return: map, players list and bank
"""
# generate a map
parent_addr = os.path.abspath(os.pardir)
block_list_data = json_reader(
os.path.join(parent_addr, 'Data/block_data.json'))
station_list_data = json_reader(
os.path.join(parent_addr, 'Data/station_data.json'))
utility_list_data = json_reader(
os.path.join(parent_addr, 'Data/utility_data.json'))
estate_list_data = json_reader(
os.path.join(parent_addr, 'Data/estate_data.json'))
chest_list_data = json_reader(
os.path.join(parent_addr, 'Data/chest_data.json'))
chance_list_data = json_reader(
os.path.join(parent_addr, 'Data/chance_data.json'))
block_list = [0 for x in range(40)]
station_list = []
utility_list = []
estate_list = []
corner_list = []
chest_block_list = []
chance_block_list = []
tax_list = []
# initialize bank
epic_bank = bank.Bank('99', 'EpicBank', 32, 12)
json_writer(os.path.join(parent_addr, 'Data/bank_data.json'), {
"house_number": epic_bank.cur_house,
"hotel_number": epic_bank.cur_hotel
})
for b in block_list_data["data"]:
if b['block_type'] == 0:
# ["Go", "Go to Jail", "In Jail", "Free Parking"]
if b['name'] == "Go":
corner_block = block.Go(b['name'], b['block_id'],
b['position'])
elif b['name'] == "Go to Jail":
corner_block = block.Go_To_Jail(b['name'], b['block_id'],
b['position'])
elif b['name'] == "In Jail":
corner_block = block.In_Jail(b['name'], b['block_id'],
b['position'])
elif b['name'] == "Free Parking":
corner_block = block.Free_Parking(b['name'], b['block_id'],
b['position'])
else:
pass
block_list[corner_block.position] = corner_block
corner_list.append(corner_block)
elif b['name'] == "Community Chest":
# "Community Chest"
new_block = cardpile.Community_Chest(b['name'], b['block_id'],
b['position'])
block_list[new_block.position] = new_block
chest_block_list.append(new_block)
elif b['name'] == "Chance": # "Chance"
new_block = cardpile.Chance(b['name'], b['block_id'],
b['position'])
block_list[new_block.position] = new_block
chance_block_list.append(new_block)
elif b['block_type'] == 3:
# ["Income Tax", "Super Tax"]
if b['name'] == "Income Tax":
new_block = tax.Income_Tax(b['name'], b['block_id'],
b['position'], 0.10)
elif b['name'] == "Super Tax":
new_block = tax.Super_Tax(b['name'], b['block_id'],
b['position'], 0.10)
else:
pass
block_list[new_block.position] = new_block
tax_list.append(new_block)
# name, position, uid, estate_value, status, street_id
for s in station_list_data["data"]:
new_block = station.Station(s['name'], s['block_id'], s['position'],
s['uid'], s['estate_value'], s['status'])
station_list.append(new_block)
block_list[new_block.position] = new_block
epic_bank.add_asset(new_block)
# name, position, uid, estate_value, status, street_id
for u in utility_list_data["data"]:
new_block = utility.Utility(u['name'], u['block_id'], u['position'],
u['uid'], u['estate_value'], u['status'])
utility_list.append(new_block)
block_list[new_block.position] = new_block
epic_bank.add_asset(new_block)
for e in estate_list_data["data"]:
new_block = estate.Estate(e['name'], e['block_id'], e['position'],
e['uid'], e['estate_value'], e['status'],
e['street_id'], e['house_value'])
estate_list.append(new_block)
block_list[new_block.position] = new_block
epic_bank.add_asset(new_block)
# initialize players
player_dict_data = json_reader(
os.path.join(parent_addr, 'Data/player_list.json'))
player_dict = {}
player_dict_data = player_dict_data["data"]
for i in range(len(player_dict_data)):
p = player.Player(player_dict_data[i]['id'],
player_dict_data[i]['name'],
player_dict_data[i]['cash'],
player_dict_data[i]['alliance'])
out_put_line = "%d %d %s %s" % (p.cash, p.id, p.name, p.alliance)
operation.push2all(out_put_line)
player_dict[player_dict_data[i]['id']] = p
# initialize chest cards
chest_list = []
for chest in chest_list_data["data"]:
# 0: Collection, 1: Collect_from_players
if chest['card_type'] == 0 or chest['card_type'] == 1:
chest_list.append(
card.CollectCard(chest['card_id'], chest['card_type'],
chest['description'], chest['amount']))
elif chest['card_type'] == 2 or chest[
'card_type'] == 3: # 2: Pay, 3: Pay_for_repair
# or chest['card_type'] == 8 8: Pay_to_players
chest_list.append(
card.PayCard(chest['card_id'], chest['card_type'],
chest['description'], chest['amount']))
# elif chest['card_type'] == 4 or chest['card_type'] == 6: # 4: Move_indicate_position, 6: Move_nearby
# chest_list.append(card.MoveCard(chest['card_id'], chest['card_type'], chest['description'],
# chest['block_id']))
# elif chest['card_type'] == 7: # Move
# chest_list.append(card.MoveCard(chest['card_id'], chest['card_type'], chest['description'],
# chest['steps']))
elif chest['card_type'] == 5: # Bailcard
chest_list.append(
card.BailCard(chest['card_id'], chest['card_type'],
chest['description']))
# initialize chance cards
chance_list = []
for chance in chance_list_data["data"]:
if chance['card_type'] == 0: # 0: Collection
# or chance['card_type'] == 1, 1: Collect_from_players
chance_list.append(
card.CollectCard(chance['card_id'], chance['card_type'],
chance['description'], chance['amount']))
elif chance['card_type'] == 2 or chance['card_type'] == 3 or chance[
'card_type'] == 8: # 2: Pay,
# 3: Pay_for_repair
# 8: Pay_to_players
chance_list.append(
card.PayCard(chance['card_id'], chance['card_type'],
chance['description'], chance['amount']))
# 4: Move_indicate_position, 6: Move_nearby
elif chance['card_type'] == 4 or chance['card_type'] == 6:
chance_list.append(
card.MoveCard(chance['card_id'], chance['card_type'],
chance['description'], chance['block_id']))
elif chance['card_type'] == 7: # Move
chance_list.append(
card.MoveCard(chance['card_id'], chance['card_type'],
chance['description'], chance['steps']))
elif chance['card_type'] == 5: # Bailcard
chance_list.append(
card.BailCard(chance['card_id'], chance['card_type'],
chance['description']))
# initialize chess board
two_block_street = []
three_block_street = []
for e in estate_list:
if e.street_id == 1 or e.street_id == 8:
two_block_street.append(e)
else:
three_block_street.append(e)
chess_board_object = board.Board(two_block_street, three_block_street,
station_list, utility_list, block_list,
corner_list, chest_block_list,
chance_block_list, tax_list)
global data
data['chess_board'] = block_list
data['player_dict'] = player_dict
data['epic_bank'] = epic_bank
data['chest_list'] = chest_list
data['chance_list'] = chance_list
data['station_list'] = station_list
data['utility_list'] = utility_list
data['estate_list'] = estate_list
data['corner_list'] = corner_list
data['chest_block_list'] = chest_block_list
data['chance_block_list'] = chance_block_list
data['tax_list'] = tax_list
return data
def join_game():
""" Add a player to the game """
human = player.Player()
human.get_name()
if human:
players.append(human)
def add_player(self, name, flag_index):
self.players.append(player.Player(self.world, name, flag_index))
if self.current_player is None:
self.current_player = self.players[0]
print(hand1.show_hand_obj()[0].value()) print(hand1.show_hand_obj()[0].color()) print(hand1.best_five(board)) print(hand1.hand_strength(board)) hand2 = hand.Hand(deck.make_hand()) print(deck.show_deck()) print(hand2.show_hand()) print(hand2.show_hand_obj()[1].show_card()) print(hand2.show_hand_obj()[1].value()) print(hand2.show_hand_obj()[1].color()) print(hand2.best_five(board)) print(hand2.hand_strength(board)) player1 = player.Player(1, 100, "yoink") player1.add_hand(hand1) print(player1.show_player_hand().show_hand()) print(player1.show_player_hand().show_hand_obj()[0].color()) print(player1.show_player_hand().hand_strength(board)) print(str(player1.chips())) player1.increase_chips(50) print(str(player1.chips())) print(player1.position_name()) player1.add_position(4) print(player1.position_name()) player2 = player.Player(2, 100, "yeet") player2.add_hand(hand2)
s = hands.printHand(pl.pocket,justReturn=True)
if smPos == pl.position:
sm = "SMALL BLIND"
if bbPos == pl.position:
bb = "BIG BLIND"
if dealerPos == pl.position:
d = "DEALER"
print(f"{pl.name} £{pl.money} {s}{sm}{bb}{d}")
if(len(sys.argv) < 2):
name = input("Enter your name for the server")
else:
name = sys.argv[1]
s.send(pickle.dumps([0,player.Player(None,None,name=name)]))
t = threading.Thread(target=threadInput)
t.start()
