def addValidBlock(self, Block):
# TODO: TEAM PLEASE THINK ABOUT ANY CONDITIONS THAT I MAY NOT HAVE THOUGHT ABOUT
# Condition #1: Valid Chain and Empty Chain (This is verbose as an empty chain will always be valid)
# We must now check that the Block trying to be added has a previousHash value of 0
# if these conditions aren't met, Block will be denied entry into chain.
# Condtion #2: Valid Chain which means all blocks have been properly verified and that their hashes align
# correctly. It is important to now verify that the Block being added has the proper hash value
# lastBlockInChain.getBlockHash() == potentialBlockToBeAdded.previousHash(). This condition may
# help solve and validate the Proof of Work Step if it needs to be implemented.
# Condition #3: No Blocks will ever be accepted by a invalid Chain. Therefore, until the error is corrected this
# chain will allow no other activity to be completed
if self.getChainValidity() == True and self.getBlockCount() == 0:
if Block.getPreviousHash() == '0':
self.__theChain.append(Block)
print('Block Added to Valid Chain.')
else:
print(
'Genesis block must have Previous Hash of 0. Block Not added'
)
elif self.getChainValidity() == True and self.getBlockCount() > 0:
if self.__theChain[self.getBlockCount() -
1].getBlockHash() == Block.getPreviousHash():
self.__theChain.append(Block)
print('Block Added to Valid Chain.')
else:
print(
'Invalid Block prohibited from being added to chain. Rework your PoW'
)
else:
print('Block was not added. This BlockChain is corrupted.')
def fill_bottom_row(board, max_block_length):
"""
Fill the bottom row of the given board with new blocks whose length does
not exceed the given maximum length.
- Upon completion, there will be at least one free cell in the bottom row and
it will not be possible to add an additional block of the given maximum
length to the bottom row.
ASSUMPTIONS
- The given board is a proper board.
- The bottom row of the given board is empty.
- The given maximum length is at least 2 and does not exceed halve the number
of columns in the given board.
NOTE
- This function is already provided (you do not have to work out this function yourself).
"""
nb_filled_cells = 0
block_to_add = Block.make_random_block(max_block_length)
position_for_block = get_random_position_for(board, block_to_add)
while (position_for_block is not None) and \
(nb_filled_cells + Block.get_length(block_to_add) < \
Dimension.get_nb_of_columns(get_dimension(board))):
add_block_at(board, block_to_add, position_for_block)
nb_filled_cells += Block.get_length(block_to_add)
block_to_add = Block.make_random_block(max_block_length)
position_for_block = get_random_position_for(board, block_to_add)
def fullyAssociativeRead(self, address):
block = Block(self.blockWord, Address(address))
line = self.cacheHit(block)
if line != -1:
if self.replacementPolicy == 2:
self.queue.put(line)
if self.replacementPolicy == 3:
self.frequency[line] += 1
return 'CACHE HIT linha ' + str(line) + '\n'
else:
emptyLine = self.cacheHit(Block(self.blockWord, Address(None)))
if emptyLine != -1:
if self.replacementPolicy == 2:
self.queue.put(emptyLine)
if self.replacementPolicy == 3:
self.frequency[emptyLine] += 1
oldBlock = self.lines[emptyLine].blockId
self.lines[emptyLine] = block
return 'CACHE MISS -> alocado na linha ' + str(
emptyLine) + ' -> bloco ' + str(
oldBlock) + ' substituido\n'
if self.replacementPolicy == 1:
line, oldBlock = self.randomReplacement(block)
return 'CACHE MISS -> alocado na linha ' + str(
line) + ' -> bloco ' + str(oldBlock) + ' substituido\n'
if self.replacementPolicy == 2:
line, oldBlock = self.fifoReplacement(block)
return 'CACHE MISS -> alocado na linha ' + str(
line) + ' -> bloco ' + str(oldBlock) + ' substituido\n'
if self.replacementPolicy == 3:
line, oldBlock = self.lfuReplacement(block)
return 'CACHE MISS -> alocado na linha ' + str(
line) + ' -> bloco ' + str(oldBlock) + ' substituido\n'
def test_Get_Top_Moves__Single_Row_Single_Solution(score, max_score):
"""Function get_top_moves: single row, single best solution."""
max_score.value += 12
try:
the_board = Board.make_board((6, 10))
block1_1 = Block.make_block(1, color=Color.RED)
Board.add_block_at(the_board, block1_1, ("a", 3))
block1_2 = Block.make_block(2, color=Color.RED)
Board.add_block_at(the_board, block1_2, ("a", 8))
block2_1 = Block.make_block(2, color=Color.BLUE)
block2_2 = Block.make_block(3, color=Color.BLUE)
block2_3 = Block.make_block(2, color=Color.BLUE)
blocks_to_fill = [[(("a", 1), block2_1), (("a", 4), block2_2), (("a", 9), block2_3)]]
best_moves = Game.get_top_moves(the_board, blocks_to_fill, min_score=10, max_nb_moves=1)
if best_moves != [(("b", 8), block1_2, -1)]:
raise Exception
best_moves = Game.get_top_moves(the_board, blocks_to_fill, min_score=6, max_nb_moves=3)
if best_moves != [(("b", 8), block1_2, -1)]:
raise Exception
best_moves = Game.get_top_moves(the_board, blocks_to_fill, min_score=12, max_nb_moves=2)
if best_moves is not None:
raise Exception
score.value += 12
except:
pass
def __init__(self,*args,**kwargs):
super().__init__(*args,**kwargs)
settings.multiplayer = False
self.fpsDisplay = pyglet.clock.ClockDisplay()
self.clear()
self.startScreen = True
self.startScreenDisplay = StartScreen()
self.pauseScreenDisplay = PauseScreen()
self.saveScreenDisplay = SaveScreen()
self.loadScreenDisplay = LoadScreen()
self.helpScreenDisplay = HelpScreen()
self.stlSelectionScreenDisplay = StlSelectionScreen()
self.playTypeScreenDisplay = PlayTypeScreen()
self.ipSelectionScreenDisplay = IpSelectionScreen()
self.stlCompleteScreenDisplay = StlCompleteScreen()
self.stlConversion = stlConvert()
self.player = Player(29,29)
self.blocks = Block()
self.save= SaveMap()
self.load = LoadMap()
self.keys = key.KeyStateHandler()
self.push_handlers(self.keys)
self.set_exclusive_mouse(False)
self.mouse = [0,0]
self.loadScreen = False
self.playing= False
self.pauseScreen = False
self.saveScreen=False
self.helpScreen = False
self.stlSelectionScreen = False
self.playTypeScreen = False
self.ipSelectionScreen = False
self.stlCompleteScreen=False
pyglet.clock.schedule_interval(self.update,1/settings.FPS)
def receive():
port = 7777
save = []
while True:
sc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sc.bind(('', port))
sc.listen(1)
content, addr = sc.accept()
data = content.recv(1024).decode('utf-8')
if data == "bc":
if os.path.isfile("key.pem") == False:
KeyGenerator.create_key()
print("block!")
f = open('chat.txt', 'a+t')
f.writelines(str(save))
f.write('\n')
pow = ProofOfWork.pow()
if pow == True:
Block.brick()
break
else:
print(data)
save.append(data)
def splitBlocks(self, event=None):
"""splitBlocks"""
if not self._items:
return
# all_items = self._items
sel_items = list(map(int, self.curselection()))
change = True
# newblocks = []
for bid in sel_items:
n_bl = Block.Block(self.gcode[bid].name())
for line in self.gcode[bid]:
if line == "( ---------- cut-here ---------- )":
# newblocks.append(bl)
# self.insertBlock(bl)
self.gcode.addUndo(self.gcode.addBlockUndo(bid + 1, n_bl))
n_bl = Block.Block(self.gcode[bid].name())
else:
n_bl.append(line)
self.gcode.addUndo(self.gcode.addBlockUndo(bid + 1, n_bl))
# newblocks.append(bl)
# self.gcode.extend(newblocks)
if change:
self.fill()
self.deleteBlock()
self.winfo_toplevel().event_generate("<<Modified>>")
def creatAppointPeo(self):
allPeople = []
# b1=Block.Block(1)
# b1.x=3
# b1.y=5
# b1.type=True
# allPeople.append(b1)
#
# b2=Block.Block(1)
# b2.x=4
# b2.y=5
# b2.type=False
# allPeople.append(b2)
b3 = Block.Block(1)
b3.x = 6
b3.y = 10
b3.type = True
allPeople.append(b3)
b4 = Block.Block(1)
b4.x = 2
b4.y = 10
b4.type = False
allPeople.append(b4)
return allPeople
def creatAppointPeo(self):
allPeople=[]
b1=Block.Block(1)
b1.x=3
b1.y=5
b1.type=True
allPeople.append(b1)
b2=Block.Block(1)
b2.x=4
b2.y=5
b2.type=False
allPeople.append(b2)
b3 = Block.Block(1)
b3.x = 5
b3.y = 5
b3.type = False
allPeople.append(b3)
b4 = Block.Block(1)
b4.x = 6
b4.y = 5
b4.type = False
allPeople.append(b4)
return allPeople
def __init__(self, disk_name="Sorted.cbd", indexBy=[]):
self.disk_name = disk_name
self.r_block = Block(disk_name)
self.w_block = Block(disk_name)
self.indexes = {}
for i in indexBy:
self.indexes.update({i: open(i+"_"+disk_name, "w+")})
def creatAreaPeople():
allBlock = [] #用于存放格子
allPeople = [] #用于存放行人
'''将所有格子全部存入列表'''
for i in range(10, 14):
for j in range(7, 13):
b = Block.Block(1)
b.x = i
b.y = j
if j > Data.ROOM_N / 2:
b.isInGrend = 2
b.isNewDefine = 1
# else:
# b.type=True
b.type = False
allBlock.append(b)
b3 = Block.Block(1)
b3.x = 8
b3.y = 10
b3.debug = 1
b3.type = False
allBlock.append(b3)
'''随机排序'''
# random.shuffle(allBlock)
'''取前N个'''
'''可有效防止无限产生随机数'''
allPeople = allBlock[:Data.PEOPLE_NUMBER]
return allPeople
def get_droppable_positions(board, block):
"""
Return a list of all positions at which the given block can be dropped
on the given board.
- The positions in the resulting list are in ascending order.
ASSUMPTIONS
- The given board is a proper board.
- The given block is a proper block.
NOTE
- The function should only examine positions at which the given block
fully fits within the boundaries of the given board.
"""
block_copy = block.copy()
droppable_positions = []
horizontal_offsets = Block.get_horizontal_offsets_from_anchor(block_copy)
vertical_offsets = Block.get_vertical_offsets_from_anchor(block_copy)
# check every position where block fully fits within the boundaries of the given board
for x_value in range(1 - horizontal_offsets[0],
dimension(board) - horizontal_offsets[1] + 1):
for y_value in range(1 - vertical_offsets[0],
dimension(board) - vertical_offsets[1] + 1):
possible_position = (x_value, y_value)
if can_be_dropped_at(board, block, possible_position):
droppable_positions.append(possible_position)
return droppable_positions
def ply_parse(text):
tokens = ('BEGIN', 'END', 'COLOR', 'TITLE', 'EMPTY_BLK', 'NEW_LINES')
t_BEGIN = r'\['
t_END = r'\]'
t_COLOR = r'(?:\#[\da-fA-F]{6}|[a-zA-Z]\w*):'
t_TITLE = r'[^][/\n]+'
t_EMPTY_BLK = r'\[\]'
t_NEW_LINES = r'/+'
t_ignore = ' \t'
def t_newline(t):
r'\n+'
t.lexer.lineno += len(t.value)
def t_error(t):
line = t.value.lstrip()
new_line_idx = line.find('\n')
line = line if new_line_idx == -1 else line[:new_line_idx]
raise ParseError('cannot parse line {}'.format(line))
lexer = ply.lex.lex()
stack = [Block.create_root_block()]
block = None
brackets = 0
try:
lexer.input(text)
for token in lexer:
if token.type == 'BEGIN':
block = Block.create_empty_block()
stack[-1].children.append(block)
stack.append(block)
brackets += 1
elif token.type == 'END':
block = None
stack.pop()
brackets -= 1
if brackets < 0:
raise ParseError('too many "]"')
elif token.type == 'COLOR':
if block is None or Block.is_empty(block):
raise ParseError("syntax error")
block.color = token.value[:-1]
elif token.type == 'TITLE':
if block is None or Block.is_empty(block):
raise ParseError("syntax error")
block.title = token.value
elif token.type == 'NEW_LINES':
for x in range(len(token.value)):
stack[-1].children.append(Block.create_empty_row())
elif token.type == 'EMPTY_BLK':
stack[-1].children.append(Block.create_empty_block)
if brackets:
raise ParseError('unbalanced brackets')
except ParseError as err:
raise ValueError('Error {{0}}: line {0}: {1}'.format(
token.lineno + 1, err))
return stack[0]
def initialize(self):
"""
A function to create the initial block in the chain.
"""
initial_block = Block(0, [], time.time(), "0")
initial_block.hash = initial_block.calc_hash()
self.chain.append(initial_block)
def test_Play_Greedy__Two_Rows_Single_Solution(score, max_score):
"""Function play_greedy: blocks to fill two rows with one best solution."""
max_score.value += 3
try:
block1_1 = Block.make_block(2, color=Color.RED)
block1_2 = Block.make_block(2, color=Color.RED)
block1_3 = Block.make_block(1, color=Color.RED)
block2_1 = Block.make_block(2, color=Color.BLUE)
block2_2 = Block.make_block(3, color=Color.BLUE)
blocks_to_fill = \
[[(("a", 1), block1_1), (("a", 5), block1_2), (("a", 7), block1_3)],
[(("a", 1), block2_1), (("a", 5), block2_2)]]
# In the first step, block1_1 is moved 1 step to the right.
# In the second step, the same block is again moved 1 step to the right.
# This will make it fall in the bottom row, which is then completely
# filled and yields a score of 7 points.
total_score, moves = Game.play_greedy(blocks_to_fill, (6, 7))
if total_score != 7:
raise Exception
if moves != [(block1_1, 1), (block1_1, 1)]:
raise Exception
if moves[0][0] is not block1_1:
raise Exception
score.value += 3
except:
pass
def creatTable():
allTable = []
for i in range(5, 37, 2):
for j in range(6, 19):
t1 = Block.Block(10)
t1.x = i
t1.y = j
t1.type = True
allTable.append(t1)
for k in range(22, 35):
t1 = Block.Block(10)
t1.x = i
t1.y = k
t1.type = True
allTable.append(t1)
return allTable
# def creatWall():
# allWall=[]
# for i in range(40):
# for ii in range(8):
# D=[i,0]
# U=[ii,0]
# L=[0,i]
# R=[Data.ROOM_M,i]
def json_to_blockchain(data):
try:
chain = create()
genesis_block = Block.create_genesis_block(data[0]["time"])
chain.add_genesis_block(genesis_block)
for block_index in range(1, len(data)):
block = Block.create(
data[block_index]["transactions"][0]["receiver"],
data[block_index]["time"], data[block_index]["prev_hash"],
data[block_index]["proof"])
for transaction in range(1,
len(data[block_index]["transactions"])):
message = bytes.fromhex(
data[block_index]["transactions"][transaction]["message"])
signature = bytes.fromhex(data[block_index]["transactions"]
[transaction]["signature"])
t = Transaction.create(message, signature)
block.add_transaction(t)
if not chain.add_block(block, chain.chain[-1].proof):
return None
return chain
except:
#raise
return None
def print_board(board):
"""
Print the given board on the standard output stream.
ASSUMPTIONS
- The given board is a proper board.
NOTE
- This function is already provided (you do not have to work out this function yourself).
"""
current_position = ("X", 1)
while current_position is not None:
for lines in range(0, 2):
if lines == 1:
print("\033[1;31;48m" +
'{:2}'.format(Position.get_row(current_position)),
end=" ")
else:
print("\033[1;30;48m" + " ", end=" ")
column_position = current_position
left_position = None
while column_position is not None:
current_block = get_block_at(board, column_position)
right_position = Position.right(get_dimension(board),
column_position)
if current_block is None:
print("\033[1;30;48m" + ("| " if lines == 1 else "----"),
end="")
else:
block_symbol = Block.get_symbol(current_block)
if (left_position is None) or \
(get_block_at(board, left_position) is not current_block):
# Leftmost cell of a block.
if lines == 1:
print("\033[1;" +
str(Block.get_color(current_block)) +
";48m|" + block_symbol * 3,
end="")
else:
print("\033[1;30;48m----", end="")
else:
if lines == 1:
print("\033[1;" +
str(Block.get_color(current_block)) +
";48m" + block_symbol * 4,
end="")
else:
print("\033[1;30;48m----", end="")
left_position = column_position
column_position = right_position
print("\033[1;30;48m" + ("|" if lines == 1 else "-"))
current_position = Position.down(get_dimension(board),
current_position)
print(
" ", "\033[1;30;48m" +
("-" * (Dimension.get_nb_of_columns(get_dimension(board)) * 4 + 1)))
print(" ", end="")
for column in range(1,
Dimension.get_nb_of_columns(get_dimension(board)) + 1):
print("\033[1;30;48m" + '{:3d}'.format(column), end=" ")
print()
def create_genesis_block(self):
"""
A function to generate genesis block and appends it to
the chain. The block has index 0, previous_hash as 0, and
a valid hash.
"""
genesis_block = Block(0, [], time.time(), "0")
genesis_block.hash = genesis_block.compute_hash()
self.chain.append(genesis_block)
def test_Is_Proper_Block__False_Case(score, max_score):
"""Function is_proper_block: false case."""
max_score.value += 2
try:
assert not Block.is_proper_block("ku leuven")
assert not Block.is_proper_block((0, 0))
score.value += 2
except:
pass
def test_Normalize__Standard_Blocks(score, max_score):
"""Function normalize: standard blocks."""
max_score.value += 10
try:
for block in Block.standard_blocks:
assert Block.is_normalized(Block.normalize(block))
score.value += 10
except:
pass
def test_Is_Proper_Block__True_Case(score, max_score):
"""Function is_proper_block: true case."""
max_score.value += 1
try:
the_block = Block.make_block(100)
if not Block.is_proper_block(the_block):
return
score.value += 1
except:
pass
def test_Make_Block__Regular_Case(score, max_score):
"""Function make_block: regular case."""
max_score.value += 2
try:
given_dot_positions = {(0, 0), (1, 0), (0, 1), (1, 1)}
the_block = Block.make_block(given_dot_positions)
assert Block.get_all_dot_positions(the_block) == given_dot_positions
score.value += 2
except:
pass
def test_Is_Proper_Block__True_Case(score, max_score):
"""Function is_proper_block: true case."""
max_score.value += 4
try:
dot_positions = {(0, 0), (1, 0), (0, 1), (1, 1)}
the_block = Block.make_block(dot_positions)
assert Block.is_proper_block(the_block)
score.value += 4
except:
pass
def test_Get_Top_Moves__Single_Row_Several_Solutions_Same_Blocks(score, max_score):
"""Function get_top_moves: single row, several best solutions with same blocks."""
max_score.value += 14
try:
the_board = Board.make_board((6, 10))
block1_1 = Block.make_block(1, color=Color.RED)
Board.add_block_at(the_board, block1_1, ("a", 2))
block1_2 = Block.make_block(1, color=Color.CYAN)
Board.add_block_at(the_board, block1_2, ("a", 9))
block2_1 = Block.make_block(2, color=Color.BLUE)
block2_2 = Block.make_block(2, color=Color.CYAN)
block2_3 = Block.make_block(2, color=Color.YELLOW)
block2_4 = Block.make_block(2, color=Color.MAGENTA)
block3_1 = Block.make_block(4, color=Color.GREEN)
block3_2 = Block.make_block(1, color=Color.GREEN)
block3_3 = Block.make_block(3, color=Color.GREEN)
blocks_to_fill = \
[[(("a", 1), block2_1), (("a", 4), block2_2), (("a", 6), block2_3), (("a", 9), block2_4)],
[(("a", 1), block3_1), (("a", 6), block3_2), (("a", 7), block3_3)]]
# Moving block1_1 one step to the right followed by moving block1_2 one step to
# the left, yield the requested score. The same score is obtained from moving
# block1_1 6 steps to the right followed by moving block1_2 6 steps to the
# left. The function must return the first solution.
best_moves = Game.get_top_moves(the_board, blocks_to_fill, min_score=10, max_nb_moves=2)
if best_moves != [(("b", 2), block1_1, 1), (("c", 9), block1_2, -1)]:
raise Exception
score.value += 14
except:
pass
def mine(blockData, nonce, address):
# print(blockData)
blockDataHash = blockData['blockDataHash']
difficulty = blockData['difficulty']
prevBlockHash = blockData['prevBlockHash']
transactions = blockData['transactions']
index = blockData['index']
timestamp = time()/1000
block = Block(blockDataHash,
difficulty,
nonce,
timestamp,
prevBlockHash,
transactions,
index,
address)
block.calculateHash()
timeStart = time()
while(block.blockHash[0:block.difficulty] != ''.join(str(x) for x in np.zeros(block.difficulty, int))):
block.nonce = block.nonce + 1
block.timestamp = datetime.fromtimestamp(time() - 28800).isoformat() + "Z"
block.calculateHash()
# print(str(block.nonce) + "\t=>\t" + str(block.blockHash))
minedBlock = block.minedBlock()
return minedBlock
def test_play_greedy__Larger_Sequence_Blocks(score, max_score):
"""Function play_greedy: larger sequence of blocks."""
max_score.value += 37
try:
# This is that same game as in the last test for highest_score
positions_to_fill = \
{(1, 4), (2, 1), (3, 2), (3, 4), (3, 6), (4, 2), (5, 1), (5, 3), (5, 4), (5, 6), (6, 3), (6, 5)}
the_board = Board.make_board(6, positions_to_fill)
blocks = \
[Block.make_block({(-3, 0), (-2, 0), (-1, 0), (0, 0)}),
Block.make_block({(0, 2), (1, 2), (2, 2), (3, 2), (4, 2)}),
Block.make_block({(-2, 2), (-2, 3), (-2, 4), (-2, 5)}),
Block.make_block({(0, 0), (0, 1), (1, 0)}),
Block.make_block({(0, 0), (1, 0), (0, 1), (1, 1)}),
Block.make_block({(0, 0), (1, 0), (2, 0)}),
Block.make_block({(0, 0), (1, 0), (0, 1), (1, 1), (0, 2), (1, 2)}),
Block.make_block({(0, 0), (1, 0), (2, 0)}),
Block.make_block \
({(0, 0), (1, 0), (2, 0), (0, 1), (1, 1), (2, 1), (0, 2), \
(1, 2), (2, 2)}),
Block.make_block({(0, 0)})]
assert Game.play_greedy(the_board, blocks) is None
assert Board.get_all_filled_positions(the_board) == \
{(1, 3), (5, 6), (2, 1), (6, 2), (1, 6), (5, 1), (1, 2), (3, 6), (2, 2),
(6, 4), (3, 2), (5, 4), (2, 6), (1, 4), (4, 2), (6, 1), (3, 4)}
score.value += 37
except:
pass
def main():
pygame.init()
height = 620
width = height / 16 * 9
screen = pygame.display.set_mode((width, height))
font = pygame.font.Font(pygame.font.get_default_font(), 30)
running = True
elapsed_time = 0
clock = pygame.time.Clock()
current_block = Block(0, 5, 10)
board = GameBoard(width, height)
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
break
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_DOWN:
current_block.y_pos += 1
if event.key == pygame.K_LEFT:
if current_block.x_pos > 0:
current_block.x_pos -= 1
if event.key == pygame.K_RIGHT:
if current_block.x_pos + current_block.block_width < board.grid_width:
current_block.x_pos += 1
if event.key == pygame.K_UP:
current_block.rotate()
if current_block.finished:
board.add_block(current_block)
current_block = Block(random.randint(0, 3), 0, 0)
dt = clock.tick()
elapsed_time += dt
if elapsed_time > 500:
elapsed_time = 0
if current_block.frozen:
current_block.finished = True
current_block.y_pos += 1
board.check_if_scored()
board.update_board()
board.update_block(current_block)
board.render()
screen.blit(board.display, (0, 0))
screen.blit(font.render(str(board.score), True, (255, 255, 255)), (280, 30))
pygame.display.flip()
def test_Normalize__Already_Normalized(score, max_score):
"""Function normalize: block already normalized."""
max_score.value += 2
try:
the_block = Block.make_block({(0, 0), (1, 0), (0, 1), (1, 1)})
normalized_block = Block.normalize(the_block)
assert Block.is_normalized(normalized_block)
assert Block.are_equivalent(the_block, normalized_block)
score.value += 2
except:
pass
def test_Is_Normalized__True_Cases(score, max_score):
"""Function is_normalized: true cases."""
max_score.value += 2
try:
the_block = Block.make_block({(0, 0)})
assert Block.is_normalized(the_block)
the_block = Block.make_block({(0, 0), (1, 0), (0, 1), (1, 1)})
assert Block.is_normalized(the_block)
score.value += 2
except:
pass
def test_Make_Block__Hackers_Test1(score, max_score):
"""Function make_block: hacker's test 1."""
max_score.value += 10
try:
dot_positions = {(0, 0), (1, 0), (0, 1), (1, 1)}
the_block = Block.make_block(dot_positions)
set.add(dot_positions, "hacker")
assert Block.is_proper_block(the_block)
score.value += 10
except:
pass
def create_level(self):
for l in self.levelFile:
newStr=l
if newStr.endswith("\n"):
newStr=newStr[:-1]
self.levelLines.append(stripTrailingSpaces(newStr))
self.readHeaders()
#print self.messages
x=0
y=0
#an enemy port tells the game where to spawn enemies
for row in self.levelLines:
for col in row:
if col == "X":
obstacle = Block(x, y, "world/blocks/cinder.png")
self.world.append(obstacle)
self.all_sprite.add(self.world)
if col == "C":
obstacle = Block(x, y, "level/tutorial/sign.png")
obstacle.solid=False
self.world.append(obstacle)
self.all_sprite.add(self.world)
if col in LevelTutorial.DIGITS:
obstacle = InfoBlock(x, y, self.messages[int(col)])
self.world.append(obstacle)
self.all_sprite.add(self.world)
if col == "P":
self.crashman = CrashmanTutorial(x,y,self,self.character)
self.all_sprite.add(self.crashman)
if col == "L":
pep = Pipe(x, y-75, "world/pipes/leftpipe.png","left")
self.world.append(pep)
self.all_sprite.add(self.world)
self.enemy_ports.append( (x,y, "left") )
if col == "R":
pep = Pipe(x-125, y-75, "world/pipes/rightpipe.png","right")
self.world.append(pep)
self.all_sprite.add(self.world)
self.enemy_ports.append( (x,y, "right") )
if col == "l":
pep = Pipe(x+25, y-75, "world/pipes/leftpipe.png","left")
self.world.append(pep)
self.all_sprite.add(self.world)
if col == "r":
pep = Pipe(x-125, y-75, "world/pipes/rightpipe.png","right")
self.world.append(pep)
self.all_sprite.add(self.world)
x += 25
y += 25
x = 0
def populate_children(items, stack):
for item in items:
if isinstance(item, Block.Block):
stack[-1].children.append(item)
elif isinstance(item, list) and item:
stack.append(stack[-1].children[-1])
populate_children(item, stack)
stack.pop()
elif isinstance(item, int):
if item == EmptyBlock:
stack[-1].children.append(Block.get_empty_block())
else:
for x in range(item):
stack[-1].children.append(Block.get_new_row())
def __init__(self, id, dataBitSize): # self.count = 0 self.count = SharedCounter() self.dataSum = Block(id, dataBitSize) self.hashProd = 1 self.f = 0 self.pickleHackCounter = 0
def connect(self, name = None, address = None):
if name != None:
self.__connect_type = HyperSocket.__LOCAL
self.__target = Block.find(name)
else:
self.__connect_type = HyperSocket.__SOCKET
socket.socket.connect(address)
def __init__(self, text):
self.text = text
self.pos = 0
self.line = 1
self.column = 1
self.brackets = 0
self.stack = [Block.get_root_block()]
def render_on(self, renderer):
if hasattr(web.ctx, 'source_page_title'):
old_source_page_title = web.ctx.source_page_title
else:
old_source_page_title = None
try:
web.ctx.source_page_title = self.title
doc = Block.parsestring(self.body())
return renderer.visit(doc.children)
finally:
web.ctx.source_page_title = old_source_page_title
def __init__(self, res, screen): self.res = res self.board = Board() self.defs = Defs() self.screen = screen self.board = self.board.new_board() self.block = Block(self.board) self.block.new_block() self.endgame = False self.score = 0 self.scoreImageName = "./images/score.png" self.scoreImage = pygame.image.load(self.scoreImageName).convert() self.then = pygame.time.get_ticks()
def main():
block = Block()
transaction = Transaction()
block_user = User()
running = True
user_id = block_user.sign_in()
while running:
if user_id < 11:
print("You are an admin. Welcome to the admin page")
break
else:
print("Welcome to the main menu")
print("1) Create a transaction")
print("2) Check on the blockchain")
print("3) look at my account")
print("Enter the number or word associated with what you want to do "
"(i.e. transaction, blockchain, or account")
print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n")
us_input = input("What would you like to do: ")
us_input = us_input.lower()
if us_input == "exit" or us_input == "done":
running = False
elif us_input == "1" or us_input == "transaction":
transaction.candidate_list()
print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
elif us_input == "2" or us_input == "blockchain":
block.block_size()
print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
elif us_input == "3" or us_input == "account":
block_user.handshake()
print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
else:
print("Please enter a valid input")
print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
print("Byebye")
def parse_block_data(data, end):
color = None
colon = data.text.find(":", data.pos)
if -1 < colon < end:
color = data.text[data.pos:colon]
data.advance_to_position(colon + 1)
name = data.text[data.pos:end].strip()
data.advance_to_position(end)
if not name and color is None:
block = Block.get_empty_block()
else:
block = Block.Block(name, color)
data.stack[-1].children.append(block)
return block
def test_bitcoin_chainheaders(self):
GENESIS_BLOCK = BitcoinBlock(version=1,
prevblock=0,
merkleroot=0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b,
timestamp=1231006505,
bits=0x1d00ffff,
nonce=2083236893)
state = { GENESIS_BLOCK.get_hash(): GENESIS_BLOCK.as_bytes() }
next_block_bytes = binascii.unhexlify('010000006fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000982051fd1e4ba744bbbe680e1fee14677ba1a3c3540bf7b1cdb606e857233e0e61bc6649ffff001d01e36299')
tx = Transaction(sender=None, fee=None, amount=None, data=[next_block_bytes])
state2 = ChainHeaders.on_transaction(state.copy(), tx, None)
next_block_hash = sha256(sha256(next_block_bytes))
expected_state2 = state.copy()
expected_state2[next_block_hash] = next_block_bytes
self.assertEqual(expected_state2, state2)
def populate_cells(block, row, column, cells):
cell = Cell(row, column, 1, 1, block.name, block.color)
if block.children:
row += 1
for child in block.children:
if Block.is_new_row(child):
row += 1
column = 0
else:
child_cell = populate_cells(child, row, column, cells)
column += 1
cell.rows += child_cell.rows
cell.columns += child_cell.columns
cells.append(cell)
return cell
def Create_units(self): self.Keys = [] self.Blocks = [] self.tmp = [] #Creamos bloques en las posiciones del mapa count = 0 #we iterate one time to collect all the coordinates tmp_list = [] for val in maze_map: for i in range(0,21): tmp_list.append(int(val[i])) maze.append(list(tmp_list)) tmp_list = [] for i in range(0,21): for j in range(0,20): if ( maze[i][j] == 0): self.screen.blit(self.block_img ,(self.x,self.y)) self.Blocks.append( Block.block( self.x, self.y,self.dimension,self.block_img) ) if(maze[i][j] ==3): self.Lock = Lock.Lock( self.lock_img,self.x, self.y) if ( maze[i][j] ==2): self.key_x = i self.key_y = j self.key_points = [self.key_x,self.key_y,2] self.Key = Key.Key( self.Key_img_list(), self.x, self.y,self.dimension,self.key_points,maze,2) self.key_list.append(self.Key) self.x=self.dimension+self.x self.x=0 self.y=self.dimension+self.y print "weey ",maze[0][9]
def parse_new_row(data):
data.stack[-1].children.append(Block.get_new_row())
data.advance_by(1)
def main(argv):
level1=[[1,2,3,4,5,5,4,3,2,1],[5,4,3,2,1,1,2,3,4,5],[1,2,3,4,5,5,4,3,2,1],[5,4,3,2,1,1,2,3,4,5],[1,2,3,4,5,5,4,3,2,1]]
# imprime en consola
print 'Earth Defender'
## LEVELS ##
## COLORS ##
# R G B
GRAY=(100, 100,100)
NAVYBLUE = ( 60, 60, 100)
WHITE = (255, 255, 255)
RED = (255, 0, 0)
GREEN = ( 0, 255, 0)
BLUE = ( 0, 0, 255)
YELLOW = (255, 255, 0)
ORANGE = (255, 128, 0)
PURPLE = (255, 0, 255)
CYAN = ( 0, 255, 255)
BLACK = ( 0, 0, 0)
COMBLUE = (233, 232, 255)
Colors=[RED,ORANGE,YELLOW,GREEN,NAVYBLUE]
## PARAMETERS ##
BGCOLOR = BLACK
BLOCKWIDTH = 62
BLOCKHEIGHT = 25
BLOCKGAP = 2
PADDLEWIDTH = 100
PADDLEHEIGHT = 10
BALLRADIUS = 20
BALLCOLOR = WHITE
w = 640
h = 480 # alto
t = 0 # tiempo de conteo para generar meteoritos
# inicializando ...
init_pygame((w,h),"Arkanoid")
init_opengl((w,h))
# sonidos
# sound_shoot = pygame.mixer.Sound("laser.wav")
# sound_shoot.set_volume(0.2)
# # música de fondo
# pygame.mixer.music.load("background.mp3")
# pygame.mixer.music.play(-1,0.0)
# medida de tiempo inicial
t0=pygame.time.get_ticks()
paddle=Paddle(WHITE,PADDLEHEIGHT,PADDLEWIDTH)
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)
run=True
inity=h - 5*BLOCKHEIGHT
initx=0
score=Score(h)
blockArray=[]
for i in range(0,len(level1)):
temp=[]
print(inity)
for j in range(0,len(level1[i])):
try:
a=Block(Colors[level1[i][j]-1],Vector(initx,inity),BLOCKHEIGHT,BLOCKWIDTH)
a.dibujar()
except Exception, e:
raise
else:
pass
finally:
class Game:
instance = None
def __new__(cls, *args, **kwargs):
if not cls.instance:
cls.instance = super(Game, cls).__new__(cls, *args, **kwargs)
return cls.instance
def __init__(self, res, screen):
self.res = res
self.board = Board()
self.defs = Defs()
self.screen = screen
self.board = self.board.new_board()
self.block = Block(self.board)
self.block.new_block()
self.endgame = False
self.score = 0
self.scoreImageName = "./images/score.png"
self.scoreImage = pygame.image.load(self.scoreImageName).convert()
self.then = pygame.time.get_ticks()
def draw_matrix(self, matrix, offset):
#print(matrix, offset)
off_x, off_y = offset
for y, row in enumerate(matrix):
#print(y, row)
for x, val in enumerate(row):
#print(x, val)
if val:
pygame.draw.rect(
self.screen,
self.defs.colors[val],
pygame.Rect(
(off_x+x) *
self.defs.cell_size,
(off_y+y) *
self.defs.cell_size,
self.defs.cell_size,
self.defs.cell_size),0)
#print((off_x+x)*self.defs.cell_size, (off_y + y)*self.defs.cell_size)
def Check_keys(self):
for event in pygame.event.get():
print("checking keys")
if event.type == pygame.KEYDOWN:
if not self.defs.check_collision(self.board, self.block.shape, (self.block.x, self.block.y)):
self.score += 1
if event.key == K_s:
print("dropping~")
self.block.drop()
if event.key == K_d:
self.block.move(1)
if event.key == K_a:
self.block.move(-1)
if event.key == K_w:
self.block.rotate_clockwise(self.block.shape)
if event.key == K_ESCAPE:
self.endgame = True
if event.key == K_SPACE:
self.score += 60
while(not self.defs.check_collision(self.board, self.block.shape, (self.block.x, self.block.y))):
self.block.drop()
if not self.defs.check_collision(self.board, self.block.shape, (self.block.x, self.block.y)):
self.now = pygame.time.get_ticks()
if self.now - self.then > self.defs.maxfps * 8:
self.then = self.now
self.block.drop()
def Run(self):
self.Draw()
def draw_next_block(self, matrix):
for y, row in enumerate(matrix):
#print(y, row)
for x, val in enumerate(row):
#print(x, val)
if val:
pygame.draw.rect(
self.screen,
self.defs.colors[val],
pygame.Rect(
300+x*self.defs.cell_size,
self.res[1]-65+y*self.defs.cell_size,
self.defs.cell_size,
self.defs.cell_size),0)
def Draw(self):
self.board, bonus = Board().check_filled_rows(self.board)
self.score += bonus
#self.timer = pygame.time.Clock()
self.scoreLabel = self.screen.blit(self.scoreImage, (60, self.res[1]-60))
self.font_size = 48
self.font = pygame.font.SysFont("arial", self.font_size)
self.w, self.h = self.font.size(str(self.score))
self.font_image = self.font.render(str(self.score), 1, (255, 255, 255))
self.screen.blit(self.font_image, (200, self.res[1]-65))
#print(self.block.shape, self.block.x, self.block.y)
print("NSHAPE: ", self.block.nshape, self.block.nx, self.block.ny)
self.draw_next_block(self.block.nshape)
# check collision
if not self.endgame:
if self.defs.check_collision(self.board, self.block.shape, (self.block.x, self.block.y)):
self.set_block(self.board, self.block.shape, (self.block.prevX, self.block.prevY))
# if collides => make a new block
self.block.new_block()
print("collision!")
if self.defs.check_collision(self.board, self.block.shape, (self.block.x, self.block.y)):
print("endgame!")
self.endgame = True
else:
# draw a block
if not self.endgame:
self.draw_matrix(self.block.shape, (self.block.x, self.block.y))
# draw a board
self.draw_matrix(self.board, (0,0))
def set_block(self, board, shape, offset):
print("setting a block")
of_x, of_y = offset
for cy, row in enumerate(shape):
for cx, val in enumerate(row):
if val:
self.board[of_y + cy][of_x + cx] = val
def Update(self, frameDeltaTime):
self.Check_keys()
pygame.display.update()
def ply_parse(text):
"""
>>> import os
>>> dirname = os.path.join(os.path.dirname(__file__), "data")
>>> filename = os.path.join(dirname, "error1.blk")
>>> with open(filename, encoding="utf8") as file:
... ply_parse(file.read())
Traceback (most recent call last):
...
ValueError: Error {0}:line 8: unbalanced brackets []
>>> filename = os.path.join(dirname, "error2.blk")
>>> with open(filename, encoding="utf8") as file:
... ply_parse(file.read())
Traceback (most recent call last):
...
ValueError: Error {0}:line 2: syntax error
>>> filename = os.path.join(dirname, "error3.blk")
>>> with open(filename, encoding="utf8") as file:
... ply_parse(file.read())
Traceback (most recent call last):
...
ValueError: Error {0}:line 8: too many ']'s
>>> expected = "[white: ]\\n[lightblue: Director]\\n/\\n/\\n[white: ]\\n[lightgreen: Secretary]\\n/\\n/\\n[white: Minion #1]\\n[white: ]\\n[white: Minion #2]"
>>> filename = os.path.join(dirname, "hierarchy.blk")
>>> with open(filename, encoding="utf8") as file:
... blocks = ply_parse(file.read())
>>> str(blocks).strip() == expected
True
>>> expected = "[#00CCDE: MessageBox Window\\n[lightgray: Frame\\n[white: ]\\n[white: Message text]\\n/\\n/\\n[goldenrod: OK Button]\\n[white: ]\\n[#ff0505: Cancel Button]\\n/\\n[white: ]\\n]\\n]"
>>> filename = os.path.join(dirname, "messagebox.blk")
>>> with open(filename, encoding="utf8") as file:
... blocks = ply_parse(file.read())
>>> str(blocks).strip() == expected
True
"""
tokens = ("NODE_START", "NODE_END", "COLOR", "NAME", "NEW_ROWS",
"EMPTY_NODE")
t_NODE_START = r"\["
t_NODE_END = r"\]"
t_COLOR = r"(?:\#[\dA-Fa-f]{6}|[a-zA-Z]\w*):"
t_NAME = r"[^][/\n]+"
t_NEW_ROWS = r"/+"
t_EMPTY_NODE = r"\[\]"
t_ignore = " \t"
def t_newline(t):
r"\n+"
t.lexer.lineno += len(t.value)
def t_error(t):
line = t.value.lstrip()
i = line.find("\n")
line = line if i == -1 else line[:i]
raise LexError("syntax error: {1}".format(line))
stack = [Block.get_root_block()]
block = None
brackets = 0
lexer = ply.lex.lex()
try:
lexer.input(text)
for token in lexer:
if token.type == "NODE_START":
brackets += 1
block = Block.get_empty_block()
stack[-1].children.append(block)
stack.append(block)
elif token.type == "NODE_END":
brackets -= 1
if brackets < 0:
raise LexError("too many ']'s")
block = None
stack.pop()
elif token.type == "COLOR":
if block is None or Block.is_new_row(block):
raise LexError("syntax error")
block.color = token.value[:-1]
elif token.type == "NAME":
if block is None or Block.is_new_row(block):
raise LexError("syntax error")
block.name = token.value
elif token.type == "EMPTY_NODE":
stack[-1].children.append(Block.get_empty_block())
elif token.type == "NEW_ROWS":
for x in range(len(token.value)):
stack[-1].children.append(Block.get_new_row())
if brackets:
raise LexError("unbalanced brackets []")
except LexError as err:
raise ValueError("Error {{0}}:line {0}: {1}".format(
token.lineno + 1, err))
return stack[0]
def pyparsing_parse(text):
"""
>>> import os
>>> dirname = os.path.join(os.path.dirname(__file__), "data")
>>> filename = os.path.join(dirname, "error1.blk")
>>> with open(filename, encoding="utf8") as file:
... pyparsing_parse(file.read())
Traceback (most recent call last):
...
ValueError: Error {0}: syntax error, line 8
>>> filename = os.path.join(dirname, "error2.blk")
>>> with open(filename, encoding="utf8") as file:
... pyparsing_parse(file.read())
Traceback (most recent call last):
...
ValueError: Error {0}: syntax error, line 1
>>> filename = os.path.join(dirname, "error3.blk")
>>> with open(filename, encoding="utf8") as file:
... pyparsing_parse(file.read())
Traceback (most recent call last):
...
ValueError: Error {0}: syntax error, line 4
>>> expected = "[white: ]\\n[lightblue: Director]\\n/\\n/\\n[white: ]\\n[lightgreen: Secretary]\\n/\\n/\\n[white: Minion #1]\\n[white: ]\\n[white: Minion #2]"
>>> filename = os.path.join(dirname, "hierarchy.blk")
>>> with open(filename, encoding="utf8") as file:
... blocks = pyparsing_parse(file.read())
>>> str(blocks).strip() == expected
True
>>> expected = "[#00CCDE: MessageBox Window\\n[lightgray: Frame\\n[white: ]\\n[white: Message text]\\n/\\n/\\n[goldenrod: OK Button]\\n[white: ]\\n[#ff0505: Cancel Button]\\n/\\n[white: ]\\n]\\n]"
>>> filename = os.path.join(dirname, "messagebox.blk")
>>> with open(filename, encoding="utf8") as file:
... blocks = pyparsing_parse(file.read())
>>> str(blocks).strip() == expected
True
"""
def add_block(tokens):
return Block.Block(tokens.name, tokens.color if tokens.color
else "white")
left_bracket, right_bracket = map(Suppress, "[]")
new_rows = Word("/")("new_rows").setParseAction(
lambda tokens: len(tokens.new_rows))
name = CharsNotIn("[]/\n")("name").setParseAction(
lambda tokens: tokens.name.strip())
color = (Word("#", hexnums, exact=7) |
Word(alphas, alphanums))("color")
empty_node = (left_bracket + right_bracket).setParseAction(
lambda: EmptyBlock)
nodes = Forward()
node_data = Optional(color + Suppress(":")) + Optional(name)
node_data.setParseAction(add_block)
node = left_bracket - node_data + nodes + right_bracket
nodes << Group(ZeroOrMore(Optional(new_rows) +
OneOrMore(node | empty_node)))
stack = [Block.get_root_block()]
try:
results = nodes.parseString(text, parseAll=True)
assert len(results) == 1
items = results.asList()[0]
populate_children(items, stack)
except (ParseException, ParseSyntaxException) as err:
raise ValueError("Error {{0}}: syntax error, line "
"{0}".format(err.lineno))
return stack[0]
def __init__(self, filename="getonmy.lvl"):
"""
Loads a map from a filename according to the Map filetype specifications.
"""
self.filename = filename
self.block_list = []
self.spawner_list = []
self.player_pos = (0,0)
self.waypoint_list = []
s_n = 0
# Iterate over each row in the map
cur_x = -16
cur_y = -16
level_file = open(self.filename)
for line in level_file:
for char in line:
# if it is not an empty space or newline
if char not in {' ', '\n'}:
#===========================================================
# Create the thing and add special functionality
# based on the type.
#===========================================================
# Blocks
if char in {'-', '='}:
block = Block(self.char_to_filename[char], cur_x, cur_y)
if char == '-':
# Jump through-able platforms
block.can_jump_through = True
# if char == 'somechar':
# give it some special property
# or initialize it or something
# This is where the enemies and
# players and teleporters and
# whatnot will get initialized.
# Add the block to the block_list
self.block_list.append(block)
# Player
if char == 'p':
self.player_pos = (cur_x, cur_y)
#------------------------------------
# Spawner and Spawner Characteristics
# spawnlist -> [dict{spawtype:[min_spawn_time, max_spawn_time}]
# s_n is the spawner number, topleft
# to bottom right
#------------------------------------
spawn_list = [{"basic":[5,10], "spiky":[20,30]},
{"basic":[5,10], "spiky":[20,30]},
{"basic":[5,10], "spiky":[20,30]},
{"basic":[5,15], "spiky":[20,30]}]
if char == 's':
spawner = Spawner(self.char_to_filename[char],
cur_x, cur_y,
spawn_list[s_n])
self.spawner_list.append(spawner)
s_n += 1
# Waypoint
if char == 'w':
self.waypoint_list.append((cur_x, cur_y))
cur_x += 16
cur_x = -16
cur_y += 16
class Cell(object):
def __init__(self, identity, dataBitSize):
self.count = 0
self.dataSum = Block(identity, dataBitSize)
self.hashProd = 1 #previously 1
self.f = 0
self.pickleHackCounter = 0
def cellFromProtobuf(self, count, hashProd, data):
self.count = count
#self.count = (count)
self.hashprod = hashProd
self.dataSum.data = bitarray(str(data))
def zeroCell(self):
self.count = 0
# self.count.setValue(0)
self.dataSum.data.setall(False)
self.hashProd = 1 #previously 1
def setCount(self, count):
self.count = count
# self.count.setValue(count)
def setHashProd(self, hashProd):
self.hashProd = hashProd
def setDataSum(self, dataSum):
self.dataSum = dataSum
def getCount(self):
return self.count
# return self.count.getValue()
def getHashProd(self):
return self.hashProd
def getDataSum(self):
return self.dataSum
def add(self, block, secret, N, g, keepHashProdOne=False):
self.count += 1
# self.count.increment()
self.dataSum.addBlockData(block)
if keepHashProdOne == False:
f = MessageAuthenticationCode(secret, block)
self.f = f
self.hashProd = f ^ self.hashProd
#f = apply_f(block, N, secret, g)
#self.f = f
#self.hashProd *= f
#self.hashProd = gmpy2.powmod(self.hashProd, 1, N)
else:
self.hashProd = 1
return
def remove(self, block, secret, N, g):
#TODO
#count handling
if (self.count < 0):
self.count += 1
else:
self.count -= 1
# self.count.decrementIfNotZero()
if block.isZeroDataSum()==False: #TODO
self.dataSum.addBlockData(block)
f = MessageAuthenticationCode(secret, block)
self.hashProd = f ^ self.hashProd
#f = apply_f(block, N, secret, g)
#fInv = number.inverse(f, N) #TODO: Not sure this is true
#self.hashProd *= fInv
#self.hashProd = gmpy2.powmod(self.hashProd, 1, N)
def isPure(self):
if self.count == 1:
return True
return False
# return self.count.isPure()
def isEmpty(self):
if self.count == 0:
return True
return False
# return self.count.isEmpty()
def subtract(self, otherCell, dataBitSize, N, isHashProdOne=False):
diffCell = Cell(0, dataBitSize)
#counter
diffCell.count = self.count - otherCell.getCount()
# diffCell.count.setValue(self.count.getValue()-otherCell.count.getValue())
#datasum
diffCell.dataSum.addBlockData(self.getDataSum())
diffCell.dataSum.addBlockData(otherCell.getDataSum())
if diffCell.count == 0 and diffCell.dataSum.isZeroDataSum() == False:
print "AWESOME"
#dataSum.addBlockData(localDS ^ otherDS)
#hashProd
diffCell.hashProd = long(1)
if isHashProdOne == False:
otherF = otherCell.getHashProd()
diffCell.hashProd = otherF ^ self.hashProd
#otherFInv = number.inverse(otherCell.getHashProd(), N)
#diffCell.hashProd = otherFInv * self.hashProd
#diffCell.hashProd = gmpy2.powmod(diffCell.hashProd, 1, N)
return diffCell
def printSelf(self):
print "Index:" + str(self.dataSum.getDecimalIndex())
print "Count: " + str(self.count.getValue())
print "HashProd: " + str(self.hashProd)
print "DataSum " + str(self.dataSum.getWholeBlockBitArray())
print "------"
def readVI(self):
reader = self.reader
lastPos = -1
curPos = 0
header = {}
while lastPos != curPos:
lastPos = curPos
reader.seek(curPos)
#print curPos
header['id1'] = reader.read(6)
header['id2'] = reader.readInt16()
header['id3'] = reader.read(4)
header['id4'] = reader.read(4)
if header['id1'] != "RSRC\r\n":
raise IOError("Wrong File Format: Missing header 1")
if header['id3'] != "LVIN":
raise IOError("Wrong File Format: Missing header 3")
if header['id4'] != "LBVW":
raise IOError("Wrong File Format: Missing header 4")
header['RSRCOffset'] = reader.readUInt32()
header['RSRCSize'] = reader.readUInt32()
#print header['RSRCOffset'], header['RSRCSize']
if header['RSRCOffset'] >= 0 and header['RSRCSize'] >= 0:
curPos = header['RSRCOffset']
else:
raise IOError("Wrong RSRC-Header")
t = header['DataSet'] = {}
t['Offset'] = reader.readUInt32()
t['Size'] = reader.readUInt32()
t['Int1'] = reader.readUInt32()
t['Int2'] = reader.readUInt32()
t['Int3'] = reader.readUInt32()
t = header['BlockInfo'] = {}
t['Offset'] = header['RSRCOffset'] + reader.readUInt32()
t['Size'] = reader.readUInt32()
self.header = header
reader.seek(header['BlockInfo']['Offset'])
blockInfoCount = reader.readUInt32() + 1
if blockInfoCount > 1000:
raise IOError("VI.BlockInfoCount too large?")
blocks = {}
blocks_arr = []
block_headers = []
for i in range(0, blockInfoCount):
t = {}
t['Name'] = reader.read(4)
t['Count'] = reader.readUInt32() + 1
t['Offset'] = header['BlockInfo']['Offset'] + reader.readUInt32()
block_headers.append(t)
self.block_headers = block_headers
for i in range(0, blockInfoCount):
block_head = block_headers[i]
name = block_head['Name']
if name in globals() and isinstance(globals()[name], type):
print name, "!",
block = globals()[name](self, block_head)
else:
block = Block(self, block_head)
blocks_arr.append(block)
self.blocks_arr = blocks_arr
for i in range(0, blockInfoCount):
block = blocks_arr[i]
block.getData()
blocks[block.name] = block
self.blocks = blocks
self.icon = self.blocks['icl8'].loadIcon() if 'icl8' in self.blocks else None
def __init__(self, identity, dataBitSize): self.count = 0 self.dataSum = Block(identity, dataBitSize) self.hashProd = 1 #previously 1 self.f = 0 self.pickleHackCounter = 0
