def add_connection(self, block_1: Block, index_1, block_2: Block, index_2):
"""
Add an edge between index_1 of block_1 and index_2 of block_2
:param block_1: Block
:param index_1: int
:param block_2: Block
:param index_2: int
:return: None
"""
# Since Value Blocks only allow one connection, get_block() always returns a new block for that variable
block_1 = block_1.get_block()
if block_1 not in self.block:
self.block.append(block_1)
block_2 = block_2.get_block()
if block_2 not in self.block:
self.block.append(block_2)
if block_2 in block_1.adjacent.keys():
block_1.adjacent[block_2].append((index_1, index_2))
else:
block_1.adjacent[block_2] = [(index_1, index_2)]
if block_1 in block_2.adjacent.keys():
block_2.adjacent[block_1].append((index_2, index_1))
else:
block_2.adjacent[block_1] = [(index_2, index_1)]
def create_block_select(self):
b = Block()
for i in range(len(b.colors)):
b = Block(live=i)
b.sprite.position = (300 + i * 100, 50)
self.block_select.append(b)
self.add(b.sprite)
def __process_block(self, data, is_inverted):
if is_inverted:
block = Block(1 - data)
else:
block = Block(data)
if block.is_crc_ok:
# # # # # # # ecc lut # # # # # # #
if block.index in self.ecc_lut:
self.ecc_lut[block.index].append(block.index_ecc)
else:
self.ecc_lut[block.index] = [block.index_ecc]
# # # # # # # # # # # # # # # # # #
try:
if block.is_index_ecc_correct:
if block.is_metadata_block:
if self.__metadata_block is None:
self.__process_metadata_block(block)
else:
if self.__metadata_block_found:
self.__process_message_block(block)
if self.__blocks_received == self.__metadata_block.block_count - 1:
self.__processing_done = True
self.format_text()
except IndexError:
print("unknown block ecc: \n\tindex: {}\n\tecc: {}".format(
block.index, block.index_ecc))
return self.__processing_done
def contract(self, x: Block, y: Block):
"""
Contract two blocks on the edges between them. Removes both blocks from the network and adds a new block.
Edges between the blocks x and y and other blocks are carried over to the new block.
:param x:
:param y:
:return: None
"""
xi = [i[0] for i in x.adjacent[y]]
yi = [i[0] for i in y.adjacent[x]]
def construct_index_list(node, start, index_list):
l = []
correspondence = {}
compensation = 0
for i in range(1, node.get_value().ndim + 1):
idx = i + start
if i not in index_list:
l.append(-idx + compensation)
# correspondence between old and new
correspondence[i] = idx - compensation
else:
l.append(0)
compensation += 1
return l, correspondence
x_links, x_corr = construct_index_list(x, 0, xi)
y_links, y_corr = construct_index_list(y, abs(min(x_links)), yi)
common = 1
for x_out, y_in in x.adjacent[y]:
# Accounting for zero based indexing
x_links[x_out - 1] = common
y_links[y_in - 1] = common
common += 1
val = ncon([x.get_value(), y.get_value()], [x_links, y_links])
new_block = Block(val)
self.add_block(new_block)
# Restoring old connections
for z in x.adjacent.keys():
if z == y:
continue
for x_out, z_in in x.adjacent[z]:
self.add_connection(new_block, x_corr[x_out], z, z_in)
for z in y.adjacent.keys():
if z == x:
continue
for y_out, z_in in y.adjacent[z]:
self.add_connection(new_block, y_corr[y_out], z, z_in)
self.remove_block(x)
self.remove_block(y)
def create_block(self, data):
last_block = self.handler.blockchain.get_last_blocks()
block = Block(last_block[0].index + 1, data, last_block[0].hash,
datetime.now(), str(self.handler.server_host))
block.mine(number_0=self.handler.blockchain.number_0)
message = "****"
message += "mined_block|"
message += json.dumps(block, cls=BlockEncoder)
self.handler.blockchain.new_block(block)
self.handler.send_message_to_all(message)
message_dict = {"sender": "Me", "content": message}
self.handler.message_list.append(message_dict)
def generate_block_sequnce(self, data):
block_sequnce = []
if len(data):
for i in range(0, len(data), config.USABLE_BLOCK_SIZE):
block = Block.new(data[i:i + config.USABLE_BLOCK_SIZE])
if i < len(data) - config.USABLE_BLOCK_SIZE:
block.set_next_block(self.block_manager.get_empty_block())
block_sequnce.append(block)
else:
block_sequnce.append(Block.new(b""))
return block_sequnce
def reset(self):
'''生成blocks'''
self.load()
self.blocks = []
blocks_props = self.blocks_props
number_of_blocks = len(blocks_props)
for i in range(number_of_blocks):
x, y, live = blocks_props[i]
b = Block()
bx = int(x)
by = int(y)
b.sprite.position = (bx, by)
b.live = live
b.reset()
self.blocks.append(b)
def create_block(self):
"""
Create a block from what is typed in the GUI, mine it and send it
"""
data = self.dataText.toPlainText()
last_block = self.handler.blockchain.get_last_blocks()
block = Block(last_block[0].index + 1, data, last_block[0].hash,
datetime.now(), str(self.handler.server_host))
block.mine(number_0=self.handler.blockchain.number_0)
message = "****"
message += "mined_block|"
message += json.dumps(block, cls=BlockEncoder)
self.handler.blockchain.new_block(block)
self.handler.send_message_to_all(message)
message_dict = {"sender": "Me", "content": message}
self.handler.message_list.append(message_dict)
def create_first_block(self):
"""
Create the frist block of the blockchain
"""
first_block = Block(
0,
"First Block",
None,
datetime.now(),
"unknown",
branch_id=0,
)
# We can reduce the format if we want to take less space
fork_id = self.add_fork(first_block.hash, 0)
first_block.branch_id = fork_id
self.add_block(first_block)
def blockchain_protocol(self, message):
blockchain = json.loads(message.split("|")[1])
leaves = json.loads(message.split("|")[2])
blockchain = [Block(**block) for block in blockchain]
blockchain.sort() # The blocks are sorted by height.
for block in blockchain:
self.blockchain.new_block(block)
def add_block(self, x, y):
b = Block(live=self.block_live)
for r in self.recttmp:
if r.contains(x, y) and all(
[r.position != b.sprite.position for b in self.blocks]):
b.sprite.position = r.position
self.add(b.sprite)
self.blocks.append(b)
break
def add_block(self, block: Block):
"""
Adds a new block to the network
:param block: Block to be added
:return: None
"""
if isinstance(block, ValueBlock):
self.value_block.append(block)
self.block.append(block.get_block())
def test_rotating_4_times_should_result_in_same_shape(self):
input_block = Block(5, [2, 4], [[0, 1], [1, 0], [1, 1], [1, 2]])
expected_coords = [[-1, 0], [0, -1], [0, 0], [0, 1]]
actual_block = transformer.rotate_90(input_block, 2)
actual_block = transformer.rotate_90(actual_block, 2)
actual_block = transformer.rotate_90(actual_block, 2)
actual_block = transformer.rotate_90(actual_block, 2)
actual_coords = actual_block.coordinates
self.assertEqual(actual_coords, expected_coords)
def validate(blockchain):
genesisBlock = blockchain[0] #Genesis
blocks = blockchain[1:] #Resto de los bloques
if str(genesisBlock)!=str(Block.getGenesis()): #El genesis de blockchain debe ser igual al de Block.getGenesis() ya que es una variable de clase.
raise Exception('Invalid Genesis Block')
for i, bl in enumerate(blocks):
previousHash = bl.previousHash
timestamp = bl.timestamp
hash = bl.hash
data = bl.data
previousBlock = blockchain[i]
#El bloque actual debe apuntar al Hash del bloque anterior.
if previousHash!=previousBlock.hash:
raise Exception('Invalid previous hash')
#El hash del bloque actual debe ser correcto. Para eso comparo el hash del bloque actual con el devuelto por la funcion Hash en base a los datos del bloque.
if hash!=Block.getHash(timestamp,previousHash,data):
raise Exception('Invalid hash')
return True
def create_grid(self):
b = Block()
ewidth = self.editor_right - self.editor_left
left = int(self.editor_left + ewidth % b.sprite.width / 2)
right = self.editor_right
top = self.editor_top
bottom = self.editor_bottom
for x in range(left, right, b.sprite.width):
for y in range(bottom, top, b.sprite.height):
self.recttmp.append(Rect(x, y, b.sprite.width,
b.sprite.height))
def mine():
# get the last proof of work
last_block = blockchain.get_most_recent_block()
last_proof = last_block['data']['proof_of_work']
new_block_index = last_block['index'] + 1
logger.info('mining new block with height {}'.format(new_block_index))
# find the new proof of work for the current block being mined
# The program will hang here until the proof of work is found
proof = ProofOfWork(last_proof).calculate()
# once we find a valid proof of work, we know we can mine a block so
# we reward the miner by adding a transaction
transactions.add_transaction({
'from': 'network',
'to': MINER_ADDRESS,
'amount': MINER_REWARD
})
new_block_data = {
'proof_of_work': proof,
'transactions': transactions.get_transactions()
}
new_block_timestamp = str(date.datetime.now())
last_block_hash = last_block['hash']
# create the new block
new_block = Block(
new_block_index,
new_block_timestamp,
new_block_data
)
new_block.hash_block(last_block_hash)
blockchain.write_block_to_disk(new_block)
transactions.clear_transactions()
# notify all nodes in network of new block
network.broadcast_new_block(new_block)
def testInstantiationBasicBlock(self):
index = 123
transactions = [ 1, 2, 3 ]
timestamp = 999388
hashvalue = 123456
b = Block(index, transactions, timestamp, hashvalue)
self.assertEqual(b.index, index)
self.assertEqual(b.transactions, transactions)
self.assertEqual(b.timestamp, timestamp)
self.assertEqual(b.previousHash, hashvalue)
def post_newblock():
if request.method == 'POST':
data = json.loads(request.get_json(force=True))
logger.info('Received new block from {}'.format(request.remote_addr))
# load block object from json data
new_block = Block(data['index'], data['timestamp'], data['data'],
data['hash'])
blockchain.write_block_to_disk(new_block)
txns.clear_transactions()
return 'ok'
def augment_qgm(self, qgm: QGM, node_to_block):
x1 = node_to_block[self.node1]
x2 = node_to_block[self.node2]
d1 = Diag(1, np.sqrt(np.exp(self.b + self.a / 2)))
qgm.add_block(d1)
d1c = Diag(1, np.sqrt(np.exp(self.b + self.a / 2)))
qgm.add_block(d1c)
d2 = Diag(1, np.sqrt(np.exp(self.c + self.a / 2)))
qgm.add_block(d2)
d2c = Diag(1, np.sqrt(np.exp(self.c + self.a / 2)))
qgm.add_block(d2c)
l1 = 2
l2 = 2 * np.exp(-self.a / 2)
m = Block(
np.array([[.5 * (l1 + l2), .5 * (l1 - l2)],
[.5 * (l1 - l2), .5 * (l1 + l2)]]))
qgm.add_block(m)
trileg = []
for i in range(2):
trileg.append(Block(np.array([[[1, 0], [0, 0]], [[0, 0], [0,
1]]])))
qgm.add_block(trileg[i])
hadamard = []
for i in range(4):
hadamard.append(Hadamard())
qgm.add_block(hadamard[i])
qgm.add_connection(d1c, 1, hadamard[0], 1)
qgm.add_connection(hadamard[0], 2, trileg[0], 1)
qgm.add_connection(trileg[0], 2, m, 1)
qgm.add_connection(trileg[0], 3, hadamard[1], 1)
qgm.add_connection(hadamard[1], 2, d2c, 1)
qgm.add_connection(d1c, 2, x1, 1)
qgm.add_connection(x1, 1, d1, 1)
qgm.add_connection(d1, 2, hadamard[2], 1)
qgm.add_connection(hadamard[2], 2, trileg[1], 1)
qgm.add_connection(m, 2, trileg[1], 2)
qgm.add_connection(trileg[1], 3, hadamard[3], 1)
qgm.add_connection(d2c, 2, x2, 1)
qgm.add_connection(x2, 1, d2, 1)
qgm.add_connection(d2, 2, hadamard[3], 2)
class test_block(unittest.TestCase):
def setUp(self):
self.sample_block = Block('0x123fff', 123123123, 'my_doc')
def test_mine_hash_val_less_than_target(self):
# arrange
difficulty = 3
# act
hash_val = self.sample_block.mine(difficulty)
# assert
assert hash_val < 2**(257 - difficulty) - 1
def load_block_sequnce(self, address):
block_sequnce = []
with open(self.filepath, 'rb') as f:
f.seek(address)
while True:
block_bytes = f.read(config.BLOCK_SIZE)
block = Block.load(block_bytes)
block_sequnce.append(block)
if not block.is_last:
f.seek(BlockManager.address_from_id(block.next_block_id))
else:
break
return block_sequnce
def __parse_block(self, line, noerror=False):
tokens = []
self.emit_block_tokens = True
error = True
for tok in self:
if tok.id == token.TOKEN_LBLOCK:
tok.item = self.__parse_block(-1, True)
self.emit_block_tokens = True
tok.id = token.TOKEN_BLOCK
elif tok.id == token.TOKEN_RBLOCK:
error = False
break
tokens.append(tok)
if self.__at_end and error and not noerror:
raise Exception("[line {}] Unmatched [".format(line))
self.emit_block_tokens = False
return Block(tokens)
def test_from_block_json():
test_index = 0
test_nonce = 0
test_hash = "0000abc"
test_prev_hash = "prevHash"
test_miner_id = "miner_id"
test_reward = 5
from_address = "from"
to_address = "to"
amount = 10.99
id_ = "randomid"
signature = "randomsignature"
timestamp = 00000
test_json = {
"transaction": {
"from_address": from_address,
"to_address": to_address,
"amount": amount,
"id": id_,
"signature": signature,
"timestamp": timestamp,
},
"index": test_index,
"nonce": test_nonce,
"prev_hash": test_prev_hash,
"miner_id": test_miner_id,
"reward_amount": test_reward,
"hash": test_hash,
}
block = Block.from_json(test_json)
transaction = block.transaction
assert block.miner_id == test_miner_id
assert block.reward_amount == test_reward
assert block.index == test_index
assert block.nonce == test_nonce
assert block.prev_hash == test_prev_hash
assert transaction.from_address == from_address
assert transaction.to_address == to_address
assert transaction.id == id_
assert transaction.signature == signature
assert transaction.amount == amount
assert transaction.timestamp == timestamp
def mined_block_protocol(self, message):
block_info_json = json.loads(message.split("|")[1])
self.block_to_add = Block(**block_info_json)
self.client.hiddenRefreshButton.click()
if self.manual_validation:
self.wait = True
while self.wait:
pass
else:
message = self.blockchain.new_block(self.block_to_add)
for ip_node in self.other_nodes:
send_message(ip_node, message)
message_dict = {"sender": "Me", "content": message}
self.message_list.append(message_dict)
self.block_to_add = None
self.client.hiddenRefreshButton.click()
def test_block_constructor():
test_index = 0
test_transaction = Transaction("toAddress", "fromAddress", 5,
int(time.time()), "id", "signature")
test_nonce = 0
test_hash = "0000abc"
test_prev_hash = "prevHash"
test_miner_id = "miner_id"
test_reward = 5
test_block = Block(
test_index,
test_transaction,
test_nonce,
test_hash,
test_prev_hash,
test_miner_id,
test_reward,
)
assert (test_block.index == test_index and test_block.transaction != None
and test_block.nonce == 0 and len(test_block.hash) != 0
and test_block.prev_hash == test_prev_hash
and test_block.miner_id == "miner_id"
and test_block.reward_amount == test_reward)
os.system("cls")
print('Receiving peers updated')
public_list_of_peers = pickle.loads(data_)
print(public_list_of_peers)
peersr = False
except:
obj = pickle.loads(data_)
print(type(obj).__name__)
if type(obj).__name__ == 'Blockchain':
chain = obj
miner.savechain(chain)
miner.printchain()
if type(obj) == list:
blk = Block(time.time(), miner.getchain().return_last_block().get_hash())
blk.add_transactions(obj)
blk.hashblock = blk.get_hashblock()
print('Mining block')
chain = miner.getchain()
proof = miner.proof_of_work(blk.get_hash())
blk.proof_of_work = proof
blk.miner = socket.gethostname()
print('Proof Generated',proof)
chain.add_block(blk)
sock.send(pickle.dumps(chain))
#chain.print_block_chain()
if sys.argv[1] == 'wallet':
def generate_block(self, x, y):
"""Create a new Block object at the given x,y and return it"""
new_block = Block(self.settings, self.screen, self.block_image)
new_block.rect.top = y
new_block.rect.left = x
return new_block
def main():
global play_intro_music
""" Main Program """
pygame.time.set_timer(USEREVENT + 1, 1000)
pygame.time.set_timer(USEREVENT + 2, 1000)
# Sound
pygame.mixer.pre_init(44100, -16, 1, 512)
pygame.init()
pygame.mixer.init()
bg_sound = pygame.mixer.Sound("src/sound/bg.wav")
welcome_music = pygame.mixer.Sound("src/sound/welcome.wav")
sound_coin = pygame.mixer.Sound("src/sound/coin.wav")
oof = pygame.mixer.Sound("src/sound/oof.wav")
oof.set_volume(0.6)
# Set the height and width of the screen
size = [SCREEN_WIDTH, SCREEN_HEIGHT]
screen = pygame.display.set_mode(size)
pygame.display.set_caption("Lode Runner")
# health
heart = pygame.image.load('src/heart.png')
font = pygame.font.Font('src/Pixel.otf', 20)
# Loop until the user clicks the close button.
done = False
# Used to manage how fast the screen updates
clock = pygame.time.Clock()
FPS = 50
score = 0
removed_blocks = []
health = 5
last_time_hit = 0
removed_enemies = []
game_over = True
start_game = True
bg = pygame.image.load("src/oof.jpg")
welcome_bg = pygame.image.load("src/welcome_bg.jpg")
help = pygame.image.load('src/how_to.jpg')
# -------- Main Program Loop -----------
while not done:
if game_over:
if start_game:
choice = start_game_screen(screen, clock, welcome_music, welcome_bg, help)
start_game = False
game_over = False
score = 0
removed_blocks = []
health = 5
last_time_hit = 0
removed_enemies = []
# restart game
# player
if choice == 1:
# Create the player
bg_sound.play()
player = Player()
player_list = pygame.sprite.Group()
player_list.add(player)
# Create all the levels
level_list = [Level_01(player, 'src/brick_2.jpg')]
# Set the current level
current_level_no = 0
current_level = level_list[current_level_no]
player.level = current_level
# initialize player
player.rect.x = 500
player.rect.y = 490
# ladder
ladder_list = pygame.sprite.Group()
for i in range(10):
ladder = Ladder(210, 410 - (20 * (i + 1)), 'src/ladder.png') # 1
ladder_list.add(ladder)
for i in range(7):
ladder = Ladder(610, 215 - (20 * (i + 1)), 'src/ladder.png') # 2
ladder_list.add(ladder)
for i in range(11):
ladder = Ladder(790, 570 - (20 * (i + 1)), 'src/ladder.png') # 3
ladder_list.add(ladder)
for i in range(9):
ladder = Ladder(2.5, 570 - (20 * (i + 1)), 'src/ladder.png') # 4
ladder_list.add(ladder)
for i in range(8):
ladder = Ladder(680, 360 - (20 * (i + 1)), 'src/ladder.png') # 5
ladder_list.add(ladder)
# enemy
enemy_list = pygame.sprite.Group()
enemy = Enemy(5, 64, 64, current_level.get_platform_list(), current_level.get_levels())
enemy_list.add(enemy)
enemy = Enemy(3, 64, 64, current_level.get_platform_list(), current_level.get_levels())
enemy_list.add(enemy)
enemy = Enemy(1, 64, 64, current_level.get_platform_list(), current_level.get_levels())
enemy_list.add(enemy)
enemy = Enemy(0, 64, 64, current_level.get_platform_list(), current_level.get_levels())
enemy_list.add(enemy)
enemy = Enemy(6, 64, 64, current_level.get_platform_list(), current_level.get_levels())
enemy_list.add(enemy)
# coins
for i in range(1):
# This represents a block
block = Block('src/coin.png')
block_list = pygame.sprite.Group()
all_sprites_list = pygame.sprite.Group()
prev_level = random.randrange(0, 6)
prev_level = block.new_coin(current_level.get_levels(), prev_level)
while True:
if pygame.sprite.spritecollide(block, ladder_list, False):
prev_level = block.new_coin(current_level.get_levels(), prev_level)
else:
break
# Add the block to the list of objects
block_list.add(block)
all_sprites_list.add(block)
elif choice == 2:
# Create the player
bg_sound.play()
player = Player()
player_list = pygame.sprite.Group()
player_list.add(player)
# Create all the levels
level_list = [Level_02(player, 'src/brick_purple.jpg')]
# Set the current level
current_level_no = 0
current_level = level_list[current_level_no]
player.level = current_level
# initialize player
player.rect.x = 500
player.rect.y = 490
# ladder
ladder_list = pygame.sprite.Group()
for i in range(25):
ladder = Ladder(180, 570 - (20 * (i + 1)), 'src/ladder.png') # 1
ladder_list.add(ladder)
for i in range(25):
ladder = Ladder(770, 570 - (20 * (i + 1)), 'src/ladder.png') # 2
ladder_list.add(ladder)
# enemy
enemy_list = pygame.sprite.Group()
enemy = Enemy(5, 64, 64, current_level.get_platform_list(), current_level.get_levels())
enemy_list.add(enemy)
enemy = Enemy(3, 64, 64, current_level.get_platform_list(), current_level.get_levels())
enemy_list.add(enemy)
enemy = Enemy(1, 64, 64, current_level.get_platform_list(), current_level.get_levels())
enemy_list.add(enemy)
enemy = Enemy(0, 64, 64, current_level.get_platform_list(), current_level.get_levels())
enemy_list.add(enemy)
enemy = Enemy(6, 64, 64, current_level.get_platform_list(), current_level.get_levels())
enemy_list.add(enemy)
# blocks
for i in range(1):
# This represents a block
block = Block('src/coin.png')
block_list = pygame.sprite.Group()
all_sprites_list = pygame.sprite.Group()
prev_level = random.randrange(0, 6)
prev_level = block.new_coin(current_level.get_levels(), prev_level)
while True:
if pygame.sprite.spritecollide(block, ladder_list, False):
prev_level = block.new_coin(current_level.get_levels(), prev_level)
else:
break
# Add the block to the list of objects
block_list.add(block)
all_sprites_list.add(block)
elif choice == -1:
done = True
elif choice == 3:
return_button = Button('src/return_white.png', 930, 20, 10)
button_list = pygame.sprite.Group()
button_list.add(return_button)
x = pygame.mouse.get_pos()[0]
y = pygame.mouse.get_pos()[1]
cursor_list = pygame.sprite.Group()
cursor = Cursor('src/cursor.png', x, y)
cursor_list.add(cursor)
else:
if choice == 1:
choice = show_go_screen(screen, clock, bg_sound, 'src/oof.jpg', score, choice)
elif choice == 2:
choice = show_go_screen(screen, clock, bg_sound, 'src/oof_level02.jpg', score, choice)
start_game = True
if choice != -1 and choice != 3:
screen.fill(BLACK)
if pygame.sprite.spritecollide(player, ladder_list, False):
climbing = True
player.set_is_climbing(True)
player.setchangey(0)
else:
climbing = False
player.setpressingbutton(False)
player.set_is_climbing(False)
for event in pygame.event.get():
if event.type == pygame.QUIT:
done = True
if event.type == USEREVENT + 1:
for block in removed_blocks:
if block[1] >= 3:
replace_block = current_level.replace_block(block[0])
removed_blocks.remove(block)
hit_list = pygame.sprite.spritecollide(replace_block, enemy_list, False)
for enemies in hit_list:
enemies.set_vel(0)
removed_enemy = enemies.getID()
removed_enemies.append([removed_enemy, 0])
enemy_list.remove(enemies)
hit_list = pygame.sprite.spritecollide(replace_block, player_list, False)
for players in hit_list:
health = 0
player_list.remove(players)
platform_list = current_level.get_platform_list()
for enemies in enemy_list:
enemies.set_platform(platform_list)
else:
block[1] += 1
if event.type == USEREVENT + 2:
for enemies in removed_enemies:
enemies[1] += 1
if enemies[1] >= 10:
enemy = Enemy(enemies[0][0], enemies[0][1], enemies[0][2], enemies[0][3], enemies[0][4])
enemy_list.add(enemy)
removed_enemies.remove(enemies)
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT:
player.go_left(screen)
if event.key == pygame.K_RIGHT:
player.go_right(screen)
if event.key == pygame.K_SPACE:
player.jump()
if event.key == pygame.K_UP and climbing == True:
player.climb(-3, True)
if event.key == pygame.K_DOWN and climbing == True:
player.climb(3, True)
if event.key == pygame.K_r:
block_for_remove = player.destroy_block(current_level)
if block_for_remove != 0:
removed_blocks.append([block_for_remove, 0])
current_level.remove_block(block_for_remove)
platform_list = current_level.get_platform_list()
for enemies in enemy_list:
enemies.set_platform(platform_list)
if event.type == pygame.KEYUP:
if event.key == pygame.K_UP:
player.climb(0, False)
if event.key == pygame.K_DOWN:
player.climb(0, False)
if event.key == pygame.K_LEFT and player.change_x < 0:
player.stop()
if event.key == pygame.K_RIGHT and player.change_x > 0:
player.stop()
# Update items in the level
current_level.update()
# If the player gets near the right side, shift the world left (-x)
if player.rect.right > SCREEN_WIDTH:
player.rect.right = SCREEN_WIDTH
# If the player gets near the left side, shift the world right (+x)
if player.rect.left < 0:
player.rect.left = 0
# ALL CODE TO DRAW SHOULD GO BELOW THIS COMMENT
blocks_hit_list = pygame.sprite.spritecollide(player, block_list, False)
# Check the list of collisions.
for block in blocks_hit_list:
score += 1
sound_coin.play()
prev_level = block.new_coin(current_level.get_levels(), prev_level)
while True:
if pygame.sprite.spritecollide(block, ladder_list, False):
prev_level = block.new_coin(current_level.get_levels(), prev_level)
else:
break
for players in player_list:
if pygame.time.get_ticks() > last_time_hit + 3000 or last_time_hit == 0:
if pygame.sprite.spritecollide(players, enemy_list, False):
health -= 1
oof.play()
last_time_hit = pygame.time.get_ticks()
if health == 0:
player_list.remove(players)
# health
for i in range(health):
if choice == 1:
screen.blit(heart, [850 + (i * 30), 30])
elif choice == 2:
screen.blit(heart, [437 + (i * 30), 30])
# Draw all the sprites
# Update the player.
text2 = font.render("Score: " + str(score), True, WHITE)
if choice == 1:
screen.blit(text2, [850, 0])
elif choice == 2:
screen.blit(text2, [450, 0])
current_level.draw(screen)
block_list.update(screen)
ladder_list.draw(screen)
player_list.update(screen)
for enemies in enemy_list:
enemies.movement(screen)
# ALL CODE TO DRAW SHOULD GO ABOVE THIS COMMENT
if health == 0:
game_over = True
elif choice == 3:
for event in pygame.event.get():
if event.type == pygame.QUIT:
done = True
if event.type == pygame.MOUSEBUTTONDOWN and pygame.sprite.spritecollide(cursor, button_list, False):
buttons = pygame.sprite.spritecollide(cursor, button_list, False)
for button in buttons:
level = button.selected()
if level == 10:
start_game = True
game_over = True
play_intro_music = False
image = pygame.image.load('src/how_to.jpg')
screen.blit(image, (0, 0))
isOverOut = False
for button in pygame.sprite.spritecollide(cursor, button_list, False):
isOverOut = True
level = button.selected()
if level == 10:
button.isOver('src/return.png')
if not isOverOut:
for button in button_list:
level = button.selected()
if level == 10:
button.isOver('src/return_white.png')
button_list.draw(screen)
x = pygame.mouse.get_pos()[0]
y = pygame.mouse.get_pos()[1]
cursor.update(x, y)
cursor_list.draw(screen)
# Limit to 50 frames per second
clock.tick(FPS)
# Go ahead and update the screen with what we've drawn.
pygame.display.flip()
pygame.quit()
def addBlock(self, data):
previousBlock = self.blocks[-1]
block = Block.mine(previousBlock, data)
self.blocks.append(block)
return block
def __init__(self):
self.blocks = [Block.getGenesis()]
