def spawn_star(self): coin = Coin(parent=self) coin.position = (random.uniform(20, self.size.w-20), self.size.h + 30) d = random.uniform(2.0, 4.0) actions = [A.move_by(0, -(self.size.h + 60), d), A.remove()] coin.run_action(A.sequence(actions)) self.items.append(coin)
def update(self):
time = pg.time.get_ticks()
if time - self.creationTimer > 1000:
pass
if len(self.evil_sprites) < 10:
i = Player.PacManEvil(random.randrange(0, 30),
random.randrange(0, 30), self,
random.choice(COLORS))
self.evil_sprites.add(i)
self.all_sprites.add(i)
print("Creado")
self.creationTimer = time
if time - self.creationTimer > 10:
if len(self.coin_sprites) < 10:
i = Coin.Coin(random.randrange(0, 30), random.randrange(0, 30),
self, YELLOW)
self.coin_sprites.add(i)
self.all_sprites.add(i)
print("COINER")
self.creationTimer = time
for i in self.evil_sprites:
i.mov()
i.update()
self.player.update()
def run(self):
#Loop del juego
self.playing = True
while self.playing:
#Mantains the speed
self.clock.tick(FPS)
self.events()
self.update()
self.draw()
for i in self.evil_sprites:
if self.player.updateX() == i.updateX(
) and self.player.updateY() == i.updateY():
print("Choque")
pg.quit()
for i in self.coin_sprites:
if self.player.updateX() == i.updateX(
) and self.player.updateY() == i.updateY():
print("Coin up")
i.kill()
self.coins += 1
q = Coin.Coin(random.randrange(0, 30),
random.randrange(0, 30), self, YELLOW)
self.coin_sprites.add(q)
self.all_sprites.add(q)
print("COINER")
print(self.coins)
if self.coins == 20:
i = Coin.Coin(random.randrange(0, 30), random.randrange(0, 30),
self, PURPLE)
self.pill_sprites.add(i)
self.all_sprites.add(i)
self.coins = 0
q = Player.Chaser(random.randrange(0, 30),
random.randrange(0, 30), self,
random.choice(COLORS))
self.evil_sprites.add(q)
self.all_sprites.add(q)
for i in self.pill_sprites:
if self.player.updateX() == i.updateX(
) and self.player.updateY() == i.updateY():
print("Pill up")
i.kill()
pg.quit()
def __init__(self):
self._width = 480
self._height = 320
self._frame_thickness = 3
self._inventory_rect = pygame.Rect(
Constants.GAME_WINDOW_WIDTH // 2 - self._width // 2,
Constants.GAME_WINDOW_HEIGHT // 2 - self._height // 2, self._width,
self._height)
self._resources = {
'gold_coin': [
Coin.Coin(
Constants.GAME_WINDOW_WIDTH // 2 - self._width // 2 + 30,
Constants.GAME_WINDOW_HEIGHT // 2 + self._height // 2,
'resources/images/coins/gold_coin.png',
GameEnums.CoinTypes.GOLD), 0, None
],
'silver_coin': [
Coin.Coin(
Constants.GAME_WINDOW_WIDTH // 2 - 20,
Constants.GAME_WINDOW_HEIGHT // 2 + self._height // 2,
'resources/images/coins/silver_coin.png',
GameEnums.CoinTypes.SILVER), 0, None
],
'bronze_coin': [
Coin.Coin(
Constants.GAME_WINDOW_WIDTH // 2 + self._width // 2 - 60,
Constants.GAME_WINDOW_HEIGHT // 2 + self._height // 2,
'resources/images/coins/bronze_coin.png',
GameEnums.CoinTypes.BRONZE), 0, None
]
}
self._cells = list()
self._index_cell_to_add_new_resource = 0
self._start_cell_to_move_item = 0
self._end_cell_to_move_item = 0
self._create_inventory_cells()
def __init__(self, game_elements=None, output_file=None):
if game_elements is None or len(game_elements) == 0:
game_elements = [
Dice([6], 6),
Coin('Heads'),
Deck(['J', 'Spades', 'A', 'Diamonds'])
]
if output_file is None:
output_file = open('GameResults.txt', 'w+')
self.game_elements = game_elements
self.output_file = output_file
self.attempts = 0
self.win_flag = False
def trade(self):
if Utils.playerInventory:
gold = Coin.Coin()
counter = 0
for item in Utils.playerInventory:
if self.gold >= 0:
self.store.append(item)
Utils.playerInventory.remove(item)
gold.value += random.randint(1, 3)
self.gold -= 1
counter += 1
Utils.playerCoins.append(gold)
print("Traded %s items for %s gold" % (counter, gold.value))
def startGame(self):
self.currentOffset = random.random() * math.pi * 2
self.currentTrack = GhostTrack()
self.player.resetCar();
self.player.setAng(self.currentOffset);
self.currentFrame = 0
self.state = STATE_COUNTDOWN
self.startTime = time.time()
self.waves += 1
self.coin = Coin()
def setCoinList(self, coin_list):
# set tradable coin list
result = []
for i in coin_list :
try :
withdrawalFee = GlobalVariable.marketWithdrawFee[self.marketName][i]
except :
print(" Currency(" + str(sys._getframe().f_lineno) + ") : "+self.name,"_",i + "_withdrawal fee error")
continue
try :
result.append(Coin(i, self.API.GetOrderBook(self.name, i), withdrawalFee))
except :
print(" Currency(" + str(sys._getframe().f_lineno) + ") : " + self.name ,"_", i + "_ set Coin error")
continue
return result
def parseStage(stagename, gameWindow):
file = open('stages/'+stagename+'.mmstg', 'r')
data = file.read()
rows = [s.strip() for s in data.splitlines()]
firstRow = rows[0]
rows.remove(firstRow)
playerCommands = firstRow.split(' ')
players = []
for playerCommand in playerCommands:
[playerType, argString] = playerCommand.split('/')
args = argString.split(',')
players.append([playerType, args])
rowCount = len(rows)
colCount = len(rows[0])
stage = Stage(State(rowCount, colCount))
for rowNumber in range(0, rowCount):
for colNumber in range(0, colCount):
position = {'row':rowNumber, 'col':colNumber}
if rows[rowNumber][colNumber] == '1':
player = StageParser.createNewPlayer(players[0], stage, gameWindow)
stage.state.placeObject(player, position)
if rows[rowNumber][colNumber] == '2':
player = StageParser.createNewPlayer(players[1], stage, gameWindow)
stage.state.placeObject(player, position)
if rows[rowNumber][colNumber] == '3':
player = StageParser.createNewPlayer(players[2], stage, gameWindow)
stage.state.placeObject(player, position)
if rows[rowNumber][colNumber] == '4':
player = StageParser.createNewPlayer(players[3], stage, gameWindow)
stage.state.placeObject(player, position)
if rows[rowNumber][colNumber] == '5':
player = StageParser.createNewPlayer(players[4], stage, gameWindow)
stage.state.placeObject(player, position)
if rows[rowNumber][colNumber] == 'C':
coin = Coin(stage)
stage.state.placeObject(coin, position)
if rows[rowNumber][colNumber] == 'W':
wall = Wall(stage)
stage.state.placeObject(wall, position)
return stage
back = pygame.sprite.Group()
clouds_sprites = pygame.sprite.Group()
coin_sprites = pygame.sprite.Group()
monsters = pygame.sprite.Group()
bullets = pygame.sprite.Group()
hero_bullets = pygame.sprite.Group()
finish_group = pygame.sprite.Group()
heart = pygame.sprite.Group()
Heart.Heart(heart)
player_group = pygame.sprite.Group()
type_monster = {
"1_1": "sprites/monster1_1.png",
"1_2": "sprites/monster1_2.png"
}
coin.Coin(coin_sprites)
player_x = 0
player_y = 0
background = bg.Background(back)
for _ in range(5):
cl = cloud.Cloud(clouds_sprites, all_sprites)
running = True
mapName = ""
if dead:
start_screen('sprites/gameover.png')
elif finish:
start_screen('sprites/win.png')
else:
start_screen('sprites/fon.png')
def run_program(my_account):
from matplotlib.figure import Figure
from log_label import LLabel
import data_button as db
import tkinter as tk
from tkinter import Canvas, Label, Menu, Pack, StringVar, Toplevel, ttk
import menu
import Coin as c
import GraphPlot as gp
import trade
bitcoin = c.Coin('BTC')
ethereum = c.Coin('ETH')
ethereumC = c.Coin('ETC')
dogecoin = c.Coin('DOGE')
cardano = c.Coin('ADA')
eos = c.Coin('EOS')
ripple = c.Coin('XRP')
chainlink = c.Coin('LINK')
litecoin = c.Coin('LTC')
bitcoinCash = c.Coin('BCH')
root = tk.Tk()
root.resizable(False, False) # 창 크기조절 비활성화
root.title("crypto")
root.option_add('*tearOff', False) # Menu버튼을 만들기 위해서 넣어줘야 하는 코드
s = ttk.Style()
s.configure('button.TFrame', background='red')
# 그래프가 들어갈 프레임
graph_frame = tk.Frame(root, width=900, height=600)
graph_frame.grid(row=1, column=0)
graph_graph_frame = tk.Frame(graph_frame, width=900, height=570, bg='red')
graph_graph_frame.grid(row=0, column=0)
navigation_frame = tk.Frame(graph_frame, width=900, height=30)
navigation_frame.grid(row=1, column=0)
graph = gp.graph(bitcoin, graph_graph_frame, navigation_frame)
# 로그가 들어갈 프레임
log_frame = tk.Frame(root, width=900, height=200, bg='yellow')
log_frame.grid(row=2, column=0)
index_label = tk.Label(log_frame,
text='\tTIME\t\tPRICE(KRW)\t\tVOLUME(BTC)',
bd=5,
font='TIMES 17',
bg='#4A4A4A',
fg='white')
index_label.place(x=0, y=0, width=900, height=40)
log_label = LLabel(log_frame)
log_label.place_label(0, 40)
# 판매,구매 버튼이 들어갈 프레임
interact_frame = tk.Frame(root, width=300, height=200, bg='pink')
interact_frame.grid(row=2, column=1)
coin_entry = trade.TradeEntry(interact_frame, x=0, y=110)
coin_label = trade.TradeLabel(interact_frame, bitcoin, x=240, y=110)
coin_to_cash_label = trade.Coin2CashLabel(interact_frame, coin_label)
# cash_label = trade.TradeLabel(interact_frame, x=240, y=155, text='KRW')
refresh_button = trade.RefreshButton(interact_frame, coin_entry,
coin_label, coin_to_cash_label)
text_widget = trade.TextWidget(interact_frame, my_account)
buy_button = trade.BuyButton(interact_frame, my_account,
coin_to_cash_label, coin_entry, text_widget)
sell_button = trade.SellButton(interact_frame, my_account,
coin_to_cash_label, coin_entry, text_widget)
# 10가지 코인의 가격 정보가 들어갈 프레임
s.configure('data.TFrame', background="green")
data_frame = ttk.Frame(root)
data_frame.configure(width=300, height=600, style='data.TFrame')
data_frame.grid(row=1, column=1)
s.configure("Bold.TLabel", size=40, weight="bold")
index_label = tk.Label(data_frame,
text='Name\tPrice\tChange',
font='TIMES 15',
bg='#4A4A4A',
fg='white')
# 절대 위치를 설정하여 label 표시, data_frame내의 (0,0)위치
index_label.place(x=0, y=0, width=300, height=50)
# 데이터 버튼 삽입
btc_button = db.data_button(data_frame, bitcoin, log_label, graph,
coin_label, text_widget, my_account)
btc_button.place_button(0, 50)
btc_button.updater()
eth_button = db.data_button(data_frame, ethereum, log_label, graph,
coin_label, text_widget, my_account)
eth_button.place_button(0, 105)
eth_button.updater()
etc_button = db.data_button(data_frame, ethereumC, log_label, graph,
coin_label, text_widget, my_account)
etc_button.place_button(0, 160)
etc_button.updater()
doge_button = db.data_button(data_frame, dogecoin, log_label, graph,
coin_label, text_widget, my_account)
doge_button.place_button(0, 215)
doge_button.updater()
ada_button = db.data_button(data_frame, cardano, log_label, graph,
coin_label, text_widget, my_account)
ada_button.place_button(0, 270)
ada_button.updater()
eos_button = db.data_button(data_frame, eos, log_label, graph, coin_label,
text_widget, my_account)
eos_button.place_button(0, 325)
eos_button.updater()
ripple_button = db.data_button(data_frame, ripple, log_label, graph,
coin_label, text_widget, my_account)
ripple_button.place_button(0, 380)
ripple_button.updater()
chainlink_button = db.data_button(data_frame, chainlink, log_label, graph,
coin_label, text_widget, my_account)
chainlink_button.place_button(0, 435)
chainlink_button.updater()
litecoin_button = db.data_button(data_frame, litecoin, log_label, graph,
coin_label, text_widget, my_account)
litecoin_button.place_button(0, 490)
litecoin_button.updater()
bch_button = db.data_button(data_frame, bitcoinCash, log_label, graph,
coin_label, text_widget, my_account)
bch_button.place_button(0, 545)
bch_button.updater()
# 메뉴가 들어갈 프레임
menu_frame = ttk.Frame(root)
menu_frame.configure(relief='raised', style='button.TFrame')
menu_frame.grid(row=0, column=0, sticky=tk.NSEW, columnspan=2)
# 메뉴 객체 생성
menu = menu.Menu_class(menu_frame, graph, my_account, text_widget)
root.config(menu=menu.menubar)
root.mainloop()
import Coin
import random
heads = 0
tails = 0
for i in range(20):
HorT = random.randint(0,1)
myCoin = Coin.Coin(HorT)
HorT = int(HorT)
if HorT == 0:
myCoin.headsUp()
heads += 1
if HorT == 1:
myCoin.tailsUp()
tails += 1
print("Total Heads:", heads)
print("Total Tails:", tails)
def __init__(self,
playerObj,
locationx,
locationy,
adjective=random.randint(0,
len(nameGenerator.adjectives) - 1),
noun=random.randint(0,
len(nameGenerator.nouns) - 1),
verb=random.randint(0,
len(nameGenerator.verbs) - 1)):
VariableEnemy.enemyList.append(self)
VariableEnemy.numberOfEnemies += 1
self.adjective = adjective
self.noun = noun
self.verb = verb
self.name = nameGenerator.adjectives[self.
adjective] + " " + nameGenerator.verbs[self.
verb] + " " + nameGenerator.nouns[self.
noun]
self.x = locationx
self.y = locationy
self.collisionx = self.x
self.collisiony = self.y
self.size = SIZE
self.rect = pygame.Rect(self.x, self.y, self.size, self.size)
self.range = RANGE
self.speed = SPEED
self.health = HEALTH
self.damage = DAMAGE
self.rangeDamage = 1
self.attack = ATTACK
self.color = COLOR
self.drawDifferent = False
self.isDead = False
self.chase = True
self.shouldFlank = False
self.knocksBack = True
self.dot = False
self.dotCount = 3
self.weaponx = 0
self.weapony = 0
self.dropRate = DROPRATE #number out of 100 for how often cool stuff drops
self.coin = Coin.Coin()
self.font = pygame.font.SysFont("monospace", 12)
self.text = self.font.render(self.name, 1, (0, 0, 0))
self.spriteList = [self.outline_sprite]
self.spriteObj = SpriteAnimation.SpriteAnimation(
[self.outline_sprite, self.outline_sprite], 10)
self.verbAnimSpriteObj = None
self.playerObj = playerObj
self.items = []
self.inventory = 0
#Functions To update self before spawning
self.getAdjectiveTraits()
self.getNounTraits()
self.getVerbTraits()
self.currentWeapon = Weapon.MeleeWeapon()
self.rangedWeapon = RangedWeapon.RangedWeapon(self)
self.arrows = 3
self.reload = 1
self.updateStatsToCurrentWeapon()
self.updateInventory()
pb, mobs, False) #, pygame.sprite.collide_mask)
for mob in playerHitMobs:
pb.collide(mob)
mob.collide(pb)
if pb.collide(mob):
playerLives = pb.lives
###~BULLET KILL ENEMIES~###
bulletsHitMobs = pygame.sprite.groupcollide(
bullets, mobs, True, False) #, pygame.sprite.collide_mask)
for bullet in bulletsHitMobs:
for mob in bulletsHitMobs[bullet]:
if mob.collide(bullet):
if mob.lives == 0:
if random.randint(0, mob.dropRate) == 0:
Coin(mob.rect.center)
###~POWER UP COLLECTION~###
playerHitPowerUps = pygame.sprite.spritecollide(
pb, powerUps, True) #, pygame.sprite.collide_mask)
for power in playerHitPowerUps:
if pb.collide(power):
hasPowers += [power.kind]
print hasPowers
###~COIN COLLECTION~###
playerHitCoins = pygame.sprite.spritecollide(
pb, coins, True) #, pygame.sprite.collide_mask)
for coin in playerHitCoins:
if pb.collide(coin):
PlayerCoins += 1
def __init__(self):
#create coin object
self.__coin = Coin()
#create instance of Tk()
self.__root = Tk()
#change title of window
self.__root.title("FlipACoin")
#change Tk background color
#self.__root.configure(background = "red")
#create flip button
self.__flipButton = Button(self.__root, text = "Flip", command =\
self.flipCoin)
self.__flipButton.grid(row = 3, column = 2)
#change flip button color
#self.__flipButton.configure(background = "red")
#create header for flip label
self.__flipHeader = Label(self.__root, text = "Outcome", width = 10)
self.__flipHeader.grid(row = 1, column = 1)
#change header for flip label color
#self.__flipHeader.configure(background = "red")
#create label to display heads or tails
self.__flipLabelText = self.__coin.getStatus()
self.__flipLabelVar = StringVar()
self.__flipLabelVar.set(self.__flipLabelText)
self.__flipLabel = Label(self.__root, textvariable = self.__flipLabelVar,\
width = 20)
self.__flipLabel.grid(row = 1, column = 3)
#change label color
#self.__flipLabel.configure(background = "red")
#create label to display randomly generated number
#create header for random number display
self.__ranNumHeader = Label(self.__root, text = "Random Num Used", width = 20)
self.__ranNumHeader.grid(row = 2, column = 1)
#change header for random number display color
#self.__ranNumHeader.configure(background = "red")
#create label to display random number
self.__ranNumText = self.__coin.getNumber()
self.__ranNumVar = StringVar()
self.__ranNumVar.set(self.__ranNumText)
self.__ranNumLabel = Label(self.__root, textvariable = self.__ranNumVar, \
width = 20)
self.__ranNumLabel.grid(row = 2, column = 3)
#change label to display random number color
#self.__ranNumLabel.configure(background = "red")
#initialize GUI
mainloop()
import Coin
coin1 = Coin.Coin1()
coin1.throw()
print(coin1.side)
coin2 = Coin.Coin1()
coin1.throw()
print(coin1.side)
coin1 = Coin.Coin2()
coin1.throw()
print(coin1.side)
coin = Coin.Coin1()
for i in range(15):
coin.throw()
print(f"Rzut nr {i+1} dał wynik: {coin.side}")
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='Gambling')
parser.add_argument('-c',
'--capital',
help='set the starting capital amount',
default=75,
type=int)
parser.add_argument('-p',
'--head_prob',
help='set the head probability of a coin',
default=0.4,
type=float)
args = parser.parse_args()
capital = args.capital
p = args.head_prob
coin = Coin(p)
gamblers = [Gambler(p), Gambler()]
## TODO test random gambler
## TODO print how much the random gamler has lost
## TODO test informed gambler
## TODO print how much informed gambler has lost
def setUpClass(cls):
cls.values = ['heads', 'tails']
cls.coin = CoinClass.Coin()
def run(self, game_mode, gameNumber=1000000):
# Main loop in the game
if game_mode !='Options':
self.initialize_game_variables(game_mode)
while (gameNumber > 0):
self.game_board = Board.Board(cfg.BOARD_SIZE[0], cfg.BOARD_SIZE[1],game_mode)
(self.board_rows, self.board_cols) = self.game_board.get_dimensions()
self.game_logic = gl.GameLogic(self.game_board, self.connect_mode)
self.background.fill(cfg.BLACK)
self.game_board.draw(self.background, game_mode)
self.game.set_game_over(False)
turn_ended = False
uninitialized = True
current_type = 1
if game_mode == "TeachAgents" or game_mode == "Singleplayer":
human_turn = (self.p1.get_coin_type() == current_type)
elif game_mode == "Multiplayer":
human_turn = True
elif game_mode == "Options":
pass
elif game_mode == "AgentsLearn":
human_turn = False
p1_turn = (self.p1.get_coin_type() == current_type)
(first_slot_X, first_slot_Y) = self.game_board.get_slot(0,0).get_position()
coin = Coin.Coin(current_type)
self.game.set_game_over_screen(False)
while not self.game.get_game_over():
if uninitialized:
coin = Coin.Coin(current_type)
coin.set_position(first_slot_X, first_slot_Y - Slot.Slot.SIZE)
coin.set_column(0)
uninitialized = False
coin_inserted = False
coin.draw(self.background, False)
current_player = self.p1 if p1_turn else self.p2
if not human_turn:
temp = current_player.complete_move(coin, self.game_board, self.game_logic, self.background)
self.game.set_game_over(temp)
coin_inserted = True
uninitialized = True
# handle the keyboard events
for event in pygame.event.get():
if event.type == pygame.MOUSEBUTTONDOWN:
position = pygame.mouse.get_pos()
clicked = self.game_board.onClick(position, self.menu, self.game)
if game_mode == "AgentsLearn" or game_mode == "TeachAgents":
#execfile( "main.py", {'GAMES_NUMBER':5000})
#os.system('python main.py 50000')
#os.execl(sys.executable, os.path.abspath(__file__), *sys.argv) #return
if clicked:
os.execv(sys.executable, ['python'] + sys.argv)
if event.type == pygame.QUIT:
self.game.set_game_over(True)
return
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
exit()
if event.key == pygame.K_RIGHT and human_turn:
if (coin.get_column() + 1 < self.board_cols):
coin.move_right(self.background)
elif event.key == pygame.K_LEFT and human_turn:
if (coin.get_column() - 1 >= 0):
coin.move_left(self.background)
elif event.key == pygame.K_RETURN and human_turn and not coin_inserted:
try:
temp = self.game_board.insert_coin(coin, self.background, self.game_logic)
self.game.set_game_over(temp)
last_action_human = coin.col
if not game_mode == "Multiplayer":
current_player.complete_move(self.game_board, last_action_human, self.game_logic)
uninitialized = True
coin_inserted = True
except exception.ColumnFullException as e:
pass
if self.game.get_game_over():
winner = self.game_logic.determine_winner_name()
if winner!="STOP":
winner_value = self.game_logic.get_winner()
if (game_mode == "AgentsLearn" or game_mode=="TeachAgents"):
self.win_list[winner_value]+=1
self.game.set_game_over_screen(True)
pygame.display.set_caption(str("Connect 4 : yellow {}, tie {}, red {}").format(self.win_list[1], self.win_list[0], self.win_list[2]))
if coin_inserted:
if game_mode == "TeachAgents" or game_mode=="Singleplayer":
human_turn = not human_turn
current_type = 1 if current_type == 2 else 2
p1_turn = not p1_turn
pygame.display.flip()
self.screen.blit(self.background, (0, 0))
gameNumber -= 1
if game_mode == "AgentsLearn" :
self.main_menu()
else:
if winner!="STOP":
self.game.game_over(winner, self.menu, self.screen)
self.main_menu()
else:
# Display the game over screen
self.options.set_options_mode(True)
self.menu.set_menu_mode(False)
self.background.fill(cfg.LIGHT_BLUE)
self.options.draw_options(self.games_number, self.speed_train, self.music, self.epsilon)
self.games_number, self.speed_train, self.music, self.epsilon = self.options.running_options(self.games_number, self.speed_train, self.music, self.epsilon, self.screen, self.menu)
self.main_menu()
player.fly("fly straight")
arrowKeyPressed = True
now = time.time() - start
#print "Event handling: ", now
start = time.time()
if player.virtPos[0] % 50 == 0:
for y in range(75, 254 * 50, 50):
y += -2000
gamePiece = random.randint(0, 1000)
if gamePiece in range(0, coinDensity + 1):
Coin([
"Pictures/Game pieces/GoldCoinSprite/GoldCoinSprite/Coin1.png",
"Pictures/Game pieces/GoldCoinSprite/GoldCoinSprite/Coin2.png",
"Pictures/Game pieces/GoldCoinSprite/GoldCoinSprite/Coin3.png",
"Pictures/Game pieces/GoldCoinSprite/GoldCoinSprite/Coin4.png",
"Pictures/Game pieces/GoldCoinSprite/GoldCoinSprite/Coin5.png",
"Pictures/Game pieces/GoldCoinSprite/GoldCoinSprite/Coin6.png"
], "0", [1100, y])
#print y, gamePieces.sprites()[-1].kind
elif gamePiece == 100:
Cloud("Pictures/Blocks, and background/BadCloud.png",
[1500, y])
elif gamePiece in range(31, boosterDensity + 31):
Booster([
"Pictures/Game pieces/Booster1.png",
"Pictures/Game pieces/Booster2.png",
"Pictures/Game pieces/Booster3.png",
"Pictures/Game pieces/Booster2.png"
], "^", [1100, y])
elif gamePiece in range(0, spikeDensity):
class Game:
def __init__(self):
self.BOARD_SIZE = 720
self.size = width, height = self.BOARD_SIZE, self.BOARD_SIZE
self.speed = [0.2, 0.2]
self.black = 0, 0, 0
self.screen = pygame.display.set_mode(self.size)
self.roundaboutImage = pygame.image.load("media/roundaboutNew.png")
#roundabout = pygame.image.load("ball.gif")
self.readyImg = pygame.image.load("media/readyScreen.png")
self.roundaboutImage = pygame.transform.scale(self.roundaboutImage, self.size);
self.readyImg = pygame.transform.scale(self.readyImg, self.size);
self.roundaboutRect = self.roundaboutImage.get_rect()
self.readyBox = self.readyImg.get_rect()
self.inputManager = InputManager()
self.player = Player(0, 200);
self.currentTrack = GhostTrack();
self.currentOffset = 0
self.oldCars = []
self.oldTracks = []
self.oldOffsets = []
self.doneLaps = 0
self.framesToRun = 1000
self.waves = 0
self.state = STATE_MENU
self.explosionSound = pygame.mixer.Sound("media/Explosion.wav")
def restartGame(self):
self.oldTracks.append(self.currentTrack)
self.oldOffsets.append(self.currentOffset)
#Restart the game and spawn some stuff
self.oldCars.append(GhostCar())
for track in self.oldTracks:
track.reset_count()
self.startGame()
def startGame(self):
self.currentOffset = random.random() * math.pi * 2
self.currentTrack = GhostTrack()
self.player.resetCar();
self.player.setAng(self.currentOffset);
self.currentFrame = 0
self.state = STATE_COUNTDOWN
self.startTime = time.time()
self.waves += 1
self.coin = Coin()
def main(self):
while 1:
self.screen.fill(self.black)
for event in pygame.event.get():
if event.type == pygame.QUIT: sys.exit()
self.inputManager.onEvent(event);
if self.state == STATE_GAME:
self.player.update(self.inputManager);
self.currentTrack.add_pos(self.player.getAng(), self.player.getRad())
self.currentFrame += 1
if self.currentFrame >= self.framesToRun:
self.restartGame()
for i in range(0, len(self.oldCars)):
oldPos = self.oldTracks[i].get_next_pos()
self.oldCars[i].setAng(oldPos[0])
self.oldCars[i].setRad(oldPos[1] + self.oldOffsets[i])
self.oldCars[i].update()
self.oldCars[i].setFuture(self.oldTracks[i].get_future_pos(60))
if self.oldCars[i].checkCollision(self.player):
self.player.shakeSound.stop()
score = self.player.score
self.explosionSound.play()
print "You died, final score: {}".format(score)
pygame.display.quit()
if(score >= highScore.getLowest()):
name = raw_input("New high score, what's your name?\n")
highScore.addScore(name, score)
highScore.save()
return
self.coin.update(self.player)
elif self.state == STATE_COUNTDOWN:
if(time.time() > self.startTime + 1):
self.state = STATE_GAME
for car in self.oldCars:
car.updateGraphics()
self.player.updateGraphics()
self.coin.updateGraphics()
#self.screen.blit(self.roundaboutImage, screenshaker.offset.getTuple(), self.roundaboutRect)
self.screen.blit(self.roundaboutImage, screenshaker.offset.getTuple(), self.roundaboutRect)
self.player.draw(self.screen);
for car in self.oldCars:
car.draw(self.screen)
self.coin.draw(self.screen)
if self.state == STATE_COUNTDOWN:
self.screen.blit(self.readyImg, self.readyBox)
pygame.display.flip()
def parseRoomXML(self, xml):
self.w, self.h = map(int, [xml.get('width'), xml.get('height')])
for obj in xml: # Iterate through room objects
attr = obj.attrib
x, y = int(attr["x"]), int(attr["y"])
if obj.tag == "spawn":
typ = int(obj[0].get('type'))
var = int(obj[0].get('variant'))
subtype = int(obj[0].get('subtype'))
# Spawn the correct item for the type
if typ in [1500, -1, -1, 1496, -1]:
self.poops.append(
Poop([1500, -1, -1, 1496, -1].index(typ), (x, y),
self.textures["poops"], self.sounds["pop"]))
elif typ == 1000:
self.rocks.append(
Rock(randint(0, 2), (x, y), False,
self.sounds["rockBreak"], self.textures["rocks"]))
elif typ == 33:
self.fires.append(
Fire(0, (x, y),
[self.sounds["fireBurn"], self.sounds["steam"]],
self.textures["fires"]))
elif typ == 5 and var == 10:
self.other.append(
Heart(
[1, 3, 6].index(subtype), (x, y),
[self.sounds["heartIntake"], self.sounds["holy"]],
self.textures["pickupHearts"]))
elif typ == 5 and var == 20:
self.other.append(
Coin(subtype - 1, (x, y), [
self.sounds["coinDrop"], self.sounds["coinPickup"]
], self.textures["coins"]))
elif typ == 5 and var == 30:
self.other.append(
Key(0, (x, y),
[self.sounds["keyDrop"], self.sounds["keyPickup"]],
self.textures["keys"]))
elif typ == 5 and var == 40:
self.other.append(
Bomb(self,
0, (x, y), [self.sounds["explosion"]],
self.textures["bombs"],
explode=False))
elif typ == 13:
self.enemies.append(
Fly((x, y), [self.sounds["deathBurst"]],
self.textures["enemies"]["fly"]))
elif typ == 14:
self.enemies.append(
Pooter((x, y), [self.sounds["deathBurst"]],
self.textures["enemies"]["pooter"]))
elif typ == 26:
self.enemies.append(
Maw((x, y), [self.sounds["deathBurst"]],
self.textures["enemies"]["maw"]))
elif typ == 27:
self.enemies.append(
Host((x, y), self.sounds, self.textures))
elif typ == 30:
self.enemies.append(
Boil((x, y), self.sounds, self.textures))
def _create_random_content(self):
def create_random_health_potion():
volume = random.randint(0, 6)
if volume == 0:
return HealthPotion(random_x, random_y,
'resources/images/potions/health/small_health_potion.png',
GameEnums.PotionVolume.SMALL.value)
elif volume == 1:
return HealthPotion(random_x, random_y,
'resources/images/potions/health/lesser_health_potion.png',
GameEnums.PotionVolume.LESSER.value)
elif volume == 2:
return HealthPotion(random_x, random_y,
'resources/images/potions/health/medium_health_potion.png',
GameEnums.PotionVolume.MEDIUM.value)
elif volume == 3:
return HealthPotion(random_x, random_y,
'resources/images/potions/health/greater_health_potion.png',
GameEnums.PotionVolume.GREATER.value)
elif volume == 4:
return HealthPotion(random_x, random_y,
'resources/images/potions/health/huge_health_potion.png',
GameEnums.PotionVolume.HUGE.value)
def create_random_mana_potion():
volume = random.randint(0, 6)
if volume == 0:
return ManaPotion(random_x, random_y,
'resources/images/potions/mana/small_mana_potion.png',
GameEnums.PotionVolume.SMALL.value)
elif volume == 1:
return ManaPotion(random_x, random_y,
'resources/images/potions/mana/lesser_mana_potion.png',
GameEnums.PotionVolume.LESSER.value)
elif volume == 2:
return ManaPotion(random_x, random_y,
'resources/images/potions/mana/medium_mana_potion.png',
GameEnums.PotionVolume.MEDIUM.value)
elif volume == 3:
return ManaPotion(random_x, random_y,
'resources/images/potions/mana/greater_mana_potion.png',
GameEnums.PotionVolume.GREATER.value)
elif volume == 4:
return ManaPotion(random_x, random_y,
'resources/images/potions/mana/huge_mana_potion.png',
GameEnums.PotionVolume.HUGE.value)
content_local = []
for _ in range(self._amount_things_in_chest):
random_thing = random.randint(0, 7)
random_x = random.randint(self._rect.centerx - 20, self._rect.centerx + 20)
random_y = random.randint(self._rect.centery + 10, self._rect.centery + 30)
thing = 0
if random_thing == 0:
thing = create_random_health_potion()
if random_thing == 1:
thing = create_random_mana_potion()
if random_thing == 3:
thing = Coin.Coin(random_x, random_y,
'resources/images/coins/gold_coin.png',
GameEnums.CoinTypes.GOLD)
if random_thing == 4:
thing = Coin.Coin(random_x, random_y,
'resources/images/coins/silver_coin.png',
GameEnums.CoinTypes.SILVER)
if random_thing == 5:
thing = Coin.Coin(random_x, random_y,
'resources/images/coins/bronze_coin.png',
GameEnums.CoinTypes.BRONZE)
if random_thing == 6:
thing = Key(random_x, random_y, basic_image='resources/images/chests/key.png')
content_local.append(thing)
return content_local
def render(self, surface, character, currTime):
if len(self.enemies) > 0:
for door in self.doors:
door.close()
else:
for door in self.doors:
door.open()
if self.hadEnemies and len(self.other) == 0 and randint(
0, 5) == 0 and not self.spawnedItem:
typ = randint(0, 2)
self.spawnedItem = True
# Random spawn
if typ == 0:
self.other.append(
Coin(0, (6, 2), [
self.sounds["coinDrop"], self.sounds["coinPickup"]
], self.textures["coins"]))
elif typ == 1:
self.other.append(
Bomb(self,
1, (6, 2), [self.sounds["explosion"]],
self.textures["bombs"],
explode=False))
elif typ == 2:
self.other.append(
Key(0, (6, 2),
[self.sounds["keyDrop"], self.sounds["keyPickup"]],
self.textures["keys"]))
# Create trapdoor in empty boss room
if self.variant == 2 and self.floor < 6 and not Trapdoor in list(
map(type, self.other)):
self.other.append(Trapdoor(self.textures["trapdoor"]))
if not self.animating:
# Render stationary room
surface.blit(self.backdrop, (38, -16))
for door in self.doors:
door.render(surface)
for rock in self.rocks:
rock.render(surface)
for poop in self.poops:
poop.render(surface)
for fire in self.fires:
fire.render(surface, currTime)
objects = self.rocks + self.poops + self.fires
for other in self.other[::-1]:
if not other.render(surface, currTime, objects + self.enemies):
self.other.remove(other)
everything = objects + self.other
# Character x and y
cx, cy = int((character.x - GRIDX) / GRATIO), int(
(character.y - GRIDY) / GRATIO)
if cx != self.lcx or cy != self.lcy:
self.lcx, self.lcy = cx, cy
for enemy in self.enemies:
enemy.pathFind((cx, cy), self.nodes, self.paths)
for enemy in self.enemies[:]:
if not enemy.render(surface, currTime, character, self.nodes,
self.paths, self.levelBounds, objects):
self.enemies.remove(enemy)
move = character.render(surface, currTime, self.levelBounds,
everything, self.doors)
return move
else:
# Render moving room
moveDistance = 40 # How far the canvas should move
self.ax += [0, 1, 0, -1][self.aDirection] * moveDistance
self.ay += [-1, 0, 1, 0][self.aDirection] * moveDistance
if abs(self.sx - self.ax) >= WIDTH or abs(self.sy -
self.ay) >= HEIGHT:
self.animating = False
self.ax, self.ay = 0, 0
self.sx, self.sy = 0, 0
else:
surface.blit(self.backdrop, (38 + self.ax, -16 + self.ay))
for door in self.doors:
door.render(surface, ox=self.ax, oy=self.ay)
for rock in self.rocks:
rock.render(surface, ox=self.ax, oy=self.ay)
for poop in self.poops:
poop.render(surface, ox=self.ax, oy=self.ay)
for fire in self.fires:
fire.render(surface, currTime, ox=self.ax, oy=self.ay)
objects = self.rocks + self.poops + self.fires
for other in self.other[::-1]:
if not other.render(
surface, currTime, objects, ox=self.ax,
oy=self.ay):
self.other.remove(other)
return [0, 0]
import Coin
import Commit
#Bob picks
a = Coin.flip_coin()
#Alice flips
b = Coin.flip_coin()
#Bob runs the commit algorithm and give alice the public commitment
r_bob = Commit.nonce()
c_bob = Commit.commit(a, r_bob)
#Alice does too
r_alice = Commit.nonce()
c_alice = Commit.commit(b, r_alice)
#Both runs the reveal
if (c_bob != Commit.commit(a, r_bob)):
print("Bob lied!")
elif (c_alice != Commit.commit(b, r_alice)):
print("Alice lied!")
else:
shared_coin = a ^ b
if (shared_coin == 1):
print("Bob wins")
else:
print("Alice wins")
import random import Coin from Crypto.Hash import SHA256 def nonce(): return random.getrandbits(128) def commit(m, r): return ( SHA256.new(str.encode(str(m)) + str.encode(str(r))).hexdigest() ) m = Coin.flip_coin() r = nonce() c = commit(m, r)
