def test_cell_kill_dead_state(): location = [1, 2] cell = Cell(location, True) cell.kill() assert cell.alive is False assert cell.location is location
def test_cell_init_at_origin_no_above_and_below_neighbors(): location = [0, 0] cell = Cell(location, True) neighbors_expected = [[0, 1], [1, 1], [1, 0]] neighbors = cell.get_neighbors() assert neighbors == neighbors_expected
def test_cell_neighbor_locations_correct(): #There are a max of 8 neighbors for any one cell on a grid location = [2, 3] cell = Cell(location, True) neighbors_row_above = helper_get_above_neigbors(location) neighbors_row_on = helper_get_on_neighbors(location) neighbors_row_below = helper_get_below_neigbors(location) neighbors_expected = neighbors_row_above neighbors_expected.extend(neighbors_row_on) neighbors_expected.extend(neighbors_row_below) neighbor_locations = cell.get_neighbors() assert neighbors_expected == neighbor_locations
def build_extend_cell(handshake_type: str, x_bytes: bytes, gx_bytes: bytes, circ_id: int, onion_key, hop2_ip, hop2_port) -> Cell: """ The method used to build a Extend/Extend2 cell :param handshake_type: The handshake type. TAP or ntor. :param x_bytes: The diffie hellman private key as a bytes object :param gx_bytes: The diffie hellman public key as a bytes object :param circ_id: The circuit ID :param onion_key: The onion key of the next hop used in hybrid_encrypt method :param lspec: The link specifier as a string :return: The extend Cell object """ client_h_data = CoreCryptoRSA.hybrid_encrypt(gx_bytes, onion_key) nspec = 1 # Always keep this 1 to avoid going to hell lspec = bytearray(IPv4Address(hop2_ip).packed) + pack('!H', int(hop2_port)) extend_cell_payload = RelayExtendPayload(nspec, RelayExtendPayload.LSTYPE_ENUM['TLS_TCP_IPV4'], RelayExtendPayload.LSTYPE_LSLEN_ENUM['TLS_TCP_IPV4'], lspec, CreateCellPayload.CREATE_HANDSHAKE_TYPE[handshake_type], CreateCellPayload.CREATE_HANDSHAKE_LEN[handshake_type], client_h_data) relay_cell_payload = RelayCellPayload(RelayCellPayload.RELAY_CMD_ENUM['RELAY_EXTEND2'], 0, 0, b'', Cell.PAYLOAD_LEN - 11, extend_cell_payload) relay_extend_cell = Cell(circ_id, Cell.CMD_ENUM['RELAY'], Cell.PAYLOAD_LEN, relay_cell_payload) return relay_extend_cell
def build_relay_data_cell(CIRCID: int, StreamID, kdf_dict1, kdf_dict2, kdf_dict3, http_req: str): enc_StreamID = unpack( '!H', CoreCryptoSymmetric.encrypt_from_origin(pack('!H', StreamID), kdf_dict1, kdf_dict2, kdf_dict3))[0] enc_relay_data_len = unpack( '!H', CoreCryptoSymmetric.encrypt_from_origin( pack('!H', Cell.PAYLOAD_LEN - 3), kdf_dict1, kdf_dict2, kdf_dict3))[0] #encrypting the http_req encoded_http_req = http_req.encode() http_req_len = len(http_req) enc_http_req = unpack( '!http_req_lenc', CoreCryptoSymmetric.encrypt_from_origin( pack('!http_req_lenc', StreamID), kdf_dict1, kdf_dict2, kdf_dict3))[0] #creating the relay cell payload with http_req as payload relay_cell_payload = RelayCellPayload( RelayCellPayload.RELAY_CMD_ENUM['RELAY_DATA'], 0, enc_StreamID, b'', enc_relay_data_len, http_req) #creating the complete cell relay_data_cell = Cell(CIRCID, Cell.CMD_ENUM['RELAY'], Cell.PAYLOAD_LEN, relay_cell_payload) return relay_data_cell
def build_relay_connected_cell(CIRCID: int, StreamID, kdf_dict, IPv4_address : str,TTL : int) -> Cell: """ :param CIRCID: The Circuit ID :param StreamID: The Stream ID :param kdf_dict: A dictionary (key) to encrypt data :param IPv4_address: The IPv4 address to which the connection was made [4 octets] :param TTL: A number of seconds (TTL) for which the address may be cached [4 octets] :return: """ # Encrypt the values by packing and unpacking enc_StreamID = unpack('!H', CoreCryptoSymmetric.encrypt_for_hop(pack('!H', StreamID), kdf_dict))[0] enc_relay_payload_len = unpack('!H',CoreCryptoSymmetric.encrypt_for_hop(pack('!H', Cell.PAYLOAD_LEN - 11),kdf_dict))[0] enc_IPv4_address = unpack('!I', CoreCryptoSymmetric.encrypt_for_hop(pack('!I', int(IPv4Address(IPv4_address))), kdf_dict))[0] enc_TTL = unpack('!I',CoreCryptoSymmetric.encrypt_for_hop(pack('!I', TTL), kdf_dict))[0] # enc_digest = CoreCryptoSymmetric.encrypt_for_hop(digest, kdf_dict) relay_connected_cell_payload = RelayConnectedPayload(enc_IPv4_address, enc_TTL) relay_cell_payload = RelayCellPayload(RelayCellPayload.RELAY_CMD_ENUM['RELAY_CONNECTED'], 0, enc_StreamID, b'', enc_relay_payload_len, relay_connected_cell_payload) # Construct the actual cell relay_cell = Cell(CIRCID, Cell.CMD_ENUM['RELAY'], Cell.PAYLOAD_LEN, relay_cell_payload) return relay_cell
def parse_encoded_extended_cell(cell_bytes: bytes) -> Cell: cell_tuple = Parser.parse_basic_cell(cell_bytes) relay_cell_payload_tuple = Parser.parse_encoded_relay_cell(cell_bytes) part_fmt_str1 = '=H' part_tuple1 = unpack(part_fmt_str1, relay_cell_payload_tuple[5][0:2]) fmt_str = '=H' + str(part_tuple1[0]) + 's' relay_extended_payload_tuple = unpack(fmt_str, relay_cell_payload_tuple[5][0:2+part_tuple1[0]]) h_data_fmt_str = '='+str(CC.DH_LEN)+'s'+str(CC.HASH_LEN)+'s' h_data_tuple = unpack(h_data_fmt_str, relay_extended_payload_tuple[1]) server_h_data = TapSHData(h_data_tuple[0], h_data_tuple[1]) relay_extended_payload = RelayExtendedPayload(relay_extended_payload_tuple[0], server_h_data) relay_cell_payload = RelayCellPayload(relay_cell_payload_tuple[0], relay_cell_payload_tuple[1], relay_cell_payload_tuple[2], relay_cell_payload_tuple[3], relay_cell_payload_tuple[4], relay_extended_payload) extended_cell = Cell(cell_tuple[0], cell_tuple[1], cell_tuple[2], relay_cell_payload) return extended_cell
def build_extended_cell(y, gy, streamID: int, circ_id: int, gx: str, recognized) -> Cell: """ The method to build the extended Cell object :param y: :param gy: :param streamID: :param circ_id: :param gx: :param recognized: :return: The Extended Cell """ gxy = CoreCryptoDH.compute_dh_shared_key(y, gx) kdf_dict = CoreCryptoRSA.kdf_tor(gxy) server_h_data = TapSHData(gy, kdf_dict['KH']) # Construct extended2 payload extended_cell_payload_relay = RelayExtendedPayload(RelayExtendedPayload.TAP_S_HANDSHAKE_LEN, server_h_data) # Calculate digest from the extended2 payload payload_dict = { 'HLEN': extended_cell_payload_relay.HLEN, 'HDATA': extended_cell_payload_relay.HDATA } digest = CoreCryptoMisc.calculate_digest(payload_dict) # Construct the Relay cell with extended2 payload which is the payload for the Cell class extended_cell_payload = RelayCellPayload(RelayCellPayload.RELAY_CMD_ENUM['EXTENDED2'], recognized, streamID, digest, Cell.PAYLOAD_LEN - 11, extended_cell_payload_relay) # Construct the actual cell extended_cell = Cell(circ_id, Cell.CMD_ENUM['RELAY'], Cell.PAYLOAD_LEN, extended_cell_payload) return extended_cell
def populate(n=10, m=10): new_cells = [] forces = [] for k in range(n): new = Cell(rd.randrange(target_radius, width - target_radius), rd.randrange(target_radius, height - target_radius), target_radius) new.setColor(cell_color) new_cells.append(new) force = [] for i in range(m): force.append( (rd.randrange(min_force, max_force), rd.randrange(min_force, max_force))) forces.append(force) return new_cells, forces
def populate(n=10, m=5): new_cells = [] # Array of cells forces = [ ] # Array of Array of tuple => [[(x, y), (x, y)], [(x, y), (x, y)]] for k in range(10): cell = Cell(rd.randrange(10, width - 10), rd.randrange(10, height - 10), 10) cell.setColor(cell_color) new_cells.append(cell) force = [] for i in range(m): force.append( (rd.randrange(min_force, max_force), rd.randrange(min_force, max_force))) forces.append(force) return new_cells, forces
def create_circuit_hop1(self): # First create a CREATE2 Cell. create_data = { 'HTYPE': CellConstants.CREATE_HANDSHAKE_TYPE['TAP'], 'HLEN': CellConstants.TAP_C_HANDSHAKE_LEN, 'HDATA': "" } created_cell = Cell(self.get_rand_circ_id(), CellConstants.CMD_ENUM['CREATE2'], CellConstants.PAYLOAD_LEN, create_data)
def __init__(self, board): self.world = [] for row in range(len(board)): cells = [] for col in range(len(board[0])): cell = Cell([row, col], board[row][col]) cells.append(cell) self.world.append(cells) #add row of cells to world
def parse_encoded_connected_cell(cell_bytes: bytes)-> Cell: cell_tuple = Parser.parse_basic_cell(cell_bytes) relay_payload_tuple = Parser.parse_encoded_relay_cell(cell_bytes) relay_connected_tuple=unpack('=II',relay_payload_tuple[5][0:8]) relay_connected_obj=RelayConnectedPayload(relay_connected_tuple[0],relay_connected_tuple[1]) relay_payload_obj=RelayCellPayload(relay_payload_tuple[0],relay_payload_tuple[1],relay_payload_tuple[2],relay_payload_tuple[3],relay_payload_tuple[4],relay_connected_obj) cell=Cell(cell_tuple[0],cell_tuple[1],cell_tuple[2],relay_payload_obj) return cell
def build_create_cell_from_extend(circ_id: int, htype, hlen, hdata) -> Cell: """ The method used to build a Create cell from an Extend cell :param circ_id: The circuit ID :param htype: The Handshake type. TAP or ntor :param hlen: The Length of Handshake object :param hdata: The Handshake data object of type TapCHData :return: The create Cell object """ create_cell_payload = CreateCellPayload(htype, hlen, hdata) create_cell = Cell(circ_id, Cell.CMD_ENUM['CREATE2'], Cell.PAYLOAD_LEN, create_cell_payload) return create_cell
def build_extended_cell_from_created_cell(circ_id: int, hlen, hdata) -> Cell: """ The method to build the Extended Cell from a received Created Cell :param circ_id: The circuit ID :param hlen: The handshake len(from Created Cell) :param hdata: The handshake Data of type TapCHData(from Created Cell) :return: The Extended Cell """ relay_extended_cell_payload = RelayExtendedPayload(hlen, hdata) extended_cell_payload = RelayCellPayload(RelayCellPayload.RELAY_CMD_ENUM['RELAY_EXTENDED2'], 0, 0, b'', Cell.PAYLOAD_LEN - 11, relay_extended_cell_payload) # Construct the actual cell extended_cell = Cell(circ_id, Cell.CMD_ENUM['RELAY'], Cell.PAYLOAD_LEN, extended_cell_payload) return extended_cell
def build_create_cell(handshake_type: str, x_bytes: bytes, gx_bytes: bytes, circ_id: int, onion_key) -> Cell: """ The method used to build a Create/Create2 cell :param x_bytes: The diffie hellman private key as a bytes object :param gx_bytes: The diffie hellman public key as a bytes object :param circ_id: The circuit ID :param onion_key: The onion key of the next hop used in hybrid_encrypt method :return: The create Cell object """ client_h_data = CoreCryptoRSA.hybrid_encrypt(gx_bytes, onion_key) create_cell_payload = CreateCellPayload(CreateCellPayload.CREATE_HANDSHAKE_TYPE[handshake_type], CreateCellPayload.CREATE_HANDSHAKE_LEN[handshake_type], client_h_data) create_cell = Cell(circ_id, Cell.CMD_ENUM['CREATE2'], Cell.PAYLOAD_LEN, create_cell_payload) return create_cell
def parse_encoded_create_cell(cell_bytes: bytes) -> Cell: cell_tuple = Parser.parse_basic_cell(cell_bytes) hlen = CreateCellPayload.CREATE_HANDSHAKE_LEN['TAP'] payload_fmt_str = '=HH'+str(hlen)+'s' create_cell_payload_tuple = unpack(payload_fmt_str, cell_tuple[3][0:(2+2+hlen)]) h_data_fmt_str = '='+str(CC.PK_PAD_LEN)+'s'+str(CC.KEY_LEN)+'s'+str(CC.PK_ENC_LEN - CC.PK_PAD_LEN - CC.KEY_LEN)+'s'+str(CC.DH_LEN-(CC.PK_ENC_LEN-CC.PK_PAD_LEN-CC.KEY_LEN))+'s' h_data_tuple = unpack(h_data_fmt_str, create_cell_payload_tuple[2]) h_data = TapCHData(h_data_tuple[0], h_data_tuple[1], h_data_tuple[2], h_data_tuple[3]) create_cell_payload = CreateCellPayload(create_cell_payload_tuple[0], create_cell_payload_tuple[1], h_data) create_cell = Cell(cell_tuple[0], cell_tuple[1], cell_tuple[2], create_cell_payload) return create_cell
def build_created_cell(y_bytes: bytes, gy_bytes: bytes, circ_id: int, gx_bytes: bytes) -> Cell: """ The method used to build a created/created2 cell object :param y_bytes: The diffie hellman private key bytes of the receiver :param gy_bytes: The diffie hellman public key bytes of the receiver :param circ_id: The circuit ID :param gx_bytes: The diffie hellman public key bytes of the sender :return: The created Cell object """ gxy = CoreCryptoDH.compute_dh_shared_key(gx_bytes, y_bytes) kdf_dict = CoreCryptoRSA.kdf_tor(gxy) server_h_data = TapSHData(gy_bytes, kdf_dict['KH']) created_cell_payload = CreatedCellPayload(CreatedCellPayload.TAP_S_HANDSHAKE_LEN, server_h_data) created_cell = Cell(circ_id, Cell.CMD_ENUM['CREATED2'], Cell.PAYLOAD_LEN, created_cell_payload) return created_cell
def parse_encoded_data_cell(cell_bytes: bytes) -> Cell: cell_tuple = Parser.parse_basic_cell(cell_bytes) relay_cell_payload_tuple = Parser.parse_encoded_relay_cell(cell_bytes) relay_data_payload = relay_cell_payload_tuple[5] relay_cell_payload = RelayCellPayload(relay_cell_payload_tuple[0], relay_cell_payload_tuple[1], relay_cell_payload_tuple[2], relay_cell_payload_tuple[3], relay_cell_payload_tuple[4], relay_data_payload) relay_data_cell = Cell(cell_tuple[0], cell_tuple[1], cell_tuple[2], relay_cell_payload) return relay_data_cell
def parse_encoded_created_cell(cell_bytes: bytes) -> Cell: cell_tuple = Parser.parse_basic_cell(cell_bytes) hlen = CreatedCellPayload.TAP_S_HANDSHAKE_LEN payload_fmt_str = '=H'+str(hlen)+'s' created_cell_payload_tuple = unpack(payload_fmt_str, cell_tuple[3][0:(2+hlen)]) h_data_fmt_str = '='+str(CC.DH_LEN)+'s'+str(CC.HASH_LEN)+'s' h_data_tuple = unpack(h_data_fmt_str, created_cell_payload_tuple[1]) server_h_data = TapSHData(h_data_tuple[0], h_data_tuple[1]) created_cell_payload = CreatedCellPayload(created_cell_payload_tuple[0], server_h_data) created_cell = Cell(cell_tuple[0], cell_tuple[1], cell_tuple[2], created_cell_payload) return created_cell
def parse_encoded_extend_cell(cell_bytes: bytes) -> Cell: cell_tuple = Parser.parse_basic_cell(cell_bytes) relay_cell_payload_tuple = Parser.parse_encoded_relay_cell(cell_bytes) part_fmt_str1 = '=BBB' part_tuple1 = unpack(part_fmt_str1, relay_cell_payload_tuple[5][0:3]) part_fmt_str2 = '=BBB' + str(part_tuple1[2]) + 's' + 'HH' part_tuple2 = unpack( part_fmt_str2, relay_cell_payload_tuple[5][0:(3 + part_tuple1[2] + 2 + 2)]) fmt_str = '=BBB' + str(part_tuple1[2]) + 's' + 'HH' + str( part_tuple2[5]) + 's' relay_extend_payload_tuple = unpack( fmt_str, relay_cell_payload_tuple[5][0:(3 + part_tuple1[2] + 2 + 2 + part_tuple2[5])]) h_data_fmt_str = '=' + str(CC.PK_PAD_LEN) + 's' + str( CC.KEY_LEN) + 's' + str( CC.PK_ENC_LEN - CC.PK_PAD_LEN - CC.KEY_LEN) + 's' + str( CC.DH_LEN - (CC.PK_ENC_LEN - CC.PK_PAD_LEN - CC.KEY_LEN)) + 's' h_data_tuple = unpack(h_data_fmt_str, relay_extend_payload_tuple[6]) h_data = TapCHData(h_data_tuple[0], h_data_tuple[1], h_data_tuple[2], h_data_tuple[3]) relay_extend_payload = RelayExtendPayload( relay_extend_payload_tuple[0], relay_extend_payload_tuple[1], relay_extend_payload_tuple[2], relay_extend_payload_tuple[3], relay_extend_payload_tuple[4], relay_extend_payload_tuple[5], h_data) relay_cell_payload = RelayCellPayload(relay_cell_payload_tuple[0], relay_cell_payload_tuple[1], relay_cell_payload_tuple[2], relay_cell_payload_tuple[3], relay_cell_payload_tuple[4], relay_extend_payload) extend_cell = Cell(cell_tuple[0], cell_tuple[1], cell_tuple[2], relay_cell_payload) return extend_cell
def parse_encoded_begin_cell(cell_bytes: bytes) -> Cell: cell_tuple = Parser.parse_basic_cell(cell_bytes) relay_cell_payload_tuple = Parser.parse_encoded_relay_cell(cell_bytes) fmt_str = '=6sI' relay_begin_payload_tuple = unpack(fmt_str, relay_cell_payload_tuple[5][0:6+4]) relay_begin_payload = RelayBeginPayload(relay_begin_payload_tuple[0], relay_begin_payload_tuple[1]) relay_cell_payload = RelayCellPayload(relay_cell_payload_tuple[0], relay_cell_payload_tuple[1], relay_cell_payload_tuple[2], relay_cell_payload_tuple[3], relay_cell_payload_tuple[4], relay_begin_payload) begin_cell = Cell(cell_tuple[0], cell_tuple[1], cell_tuple[2], relay_cell_payload) return begin_cell
def __init__(self): self.width = 1000 self.height = 1000 self.max_width = 2000 self.max_height = 2000 self.screen = pygame.display.set_mode((self.width, self.height)) self.options = pymunk.pygame_util.DrawOptions(self.screen) self.space = pymunk.Space() self.space.damping = 0.7 first_cell = Cell(self) self.cells = [first_cell] self.space.add(first_cell.shape.body, first_cell.shape) self.molecules = [] self.camera_zoom = 0 self.camera_position = Vec2d(0, 0)
def build_begin_cell(addrport: bytes, flag_dict, circ_id: int, recognized: int, streamID: int, kdf_dict1: Dict, kdf_dict2: Dict, kdf_dict3: Dict) -> Cell: """ The method to build a Begin Cell :param addrport: :param flag_dict: :param circ_id: :param recognized: :param streamID: :return: The Begin Cell object """ flags = int(0) flags |= flag_dict['IPV6_PREF'] flags |= (flag_dict['IPV4_NOT_OK'] << 1) flags |= (flag_dict['IPV6_OK'] << 2) digest_dict = { 'addrPort': addrport, 'flags': flags, 'relayCMD': RelayCellPayload.RELAY_CMD_ENUM['RELAY_BEGIN'], 'recognized': recognized, 'streamID': streamID, 'relayPayloadLen': Cell.PAYLOAD_LEN - 11 } digest = b'' # CoreCryptoMisc.calculate_digest(digest_dict) # Encrypt the values by packing and unpacking enc_addrport = CoreCryptoSymmetric.encrypt_from_origin(addrport, kdf_dict1, kdf_dict2, kdf_dict3) enc_flags = unpack('!I', CoreCryptoSymmetric.encrypt_from_origin(pack('!I', flags), kdf_dict1, kdf_dict2, kdf_dict3))[0] enc_relay_cmd = RelayCellPayload.RELAY_CMD_ENUM['RELAY_BEGIN'] # unpack('!B', CoreCryptoSymmetric.encrypt_from_origin(pack('!B', RelayCellPayload.RELAY_CMD_ENUM['RELAY_BEGIN']), kdf_dict1, kdf_dict2, kdf_dict3))[0] enc_recognized = unpack('!H', CoreCryptoSymmetric.encrypt_from_origin(pack('!H', recognized), kdf_dict1, kdf_dict2, kdf_dict3))[0] enc_stream_id = unpack('!H', CoreCryptoSymmetric.encrypt_from_origin(pack('!H', streamID), kdf_dict1, kdf_dict2, kdf_dict3))[0] enc_relay_payload_len = unpack('!H', CoreCryptoSymmetric.encrypt_from_origin(pack('!H', Cell.PAYLOAD_LEN - 11), kdf_dict1, kdf_dict2, kdf_dict3))[0] enc_digest = CoreCryptoSymmetric.encrypt_from_origin(digest, kdf_dict1, kdf_dict2, kdf_dict3) relay_begin_payload = RelayBeginPayload(enc_addrport, enc_flags) relay_cell_payload = RelayCellPayload(enc_relay_cmd, enc_recognized, enc_stream_id, enc_digest, enc_relay_payload_len, relay_begin_payload) begin_cell = Cell(circ_id, Cell.CMD_ENUM['RELAY'], Cell.PAYLOAD_LEN, relay_cell_payload) return begin_cell
def run(self): pygame.init() count = 0 last_time = time.time() last_molecule_time = time.time() done = False while not done: self.screen.fill((0, 0, 0)) current_time = time.time() elapsed_time = current_time - last_time last_time = current_time self.space.step(elapsed_time) curr_molecule_time = time.time() elapsed_molecule_time = curr_molecule_time - last_molecule_time if elapsed_molecule_time > 2: init_molecule_pos = Vec2d( random.uniform(-2000, 2000), random.uniform(-2000, 2000) ) new_molecule = FoodMolecule(init_position=init_molecule_pos) self.molecules.append(new_molecule) self.space.add(new_molecule.shape.body, new_molecule.shape) last_molecule_time = time.time() for molecule in self.molecules: draw_pymunk_circle( molecule.shape, self.screen, scale=self.camera_zoom, camera_position=self.camera_position, ) for cell in self.cells: cell.move() for cell in self.cells: draw_pymunk_circle( cell.shape, self.screen, scale=self.camera_zoom, camera_position=self.camera_position, ) for cell in self.cells: for mitochondrion in cell.mitochondria: for snake_part in mitochondrion.snake: draw_pymunk_poly( snake_part, self.screen, relative_to=cell.shape.body.position, scale=self.camera_zoom, camera_position=self.camera_position, ) for ATP in cell.ATP: draw_pymunk_circle( ATP.shape, self.screen, relative_to=cell.shape.body.position, scale=self.camera_zoom, camera_position=self.camera_position, ) for food_molecule in cell.molecules: draw_pymunk_circle( food_molecule.shape, self.screen, relative_to=cell.shape.body.position, scale=self.camera_zoom, camera_position=self.camera_position, ) draw_pymunk_circle( cell.nucleus.shape, self.screen, relative_to=cell.shape.body.position, scale=self.camera_zoom, camera_position=self.camera_position, ) for cell in self.cells: cell.time_step() for cell in self.cells: new_cell = cell.split_check() if new_cell != None: self.cells.append(new_cell) self.space.add(new_cell.shape.body, new_cell.shape) keystate = pygame.key.get_pressed() if keystate[pygame.K_LEFT]: self.camera_position.x += 1 * (self.camera_zoom ** 10 + 1) if keystate[pygame.K_RIGHT]: self.camera_position.x -= 1 * (self.camera_zoom ** 10 + 1) if keystate[pygame.K_UP]: self.camera_position.y -= 1 * (self.camera_zoom ** 10 + 1) if keystate[pygame.K_DOWN]: self.camera_position.y += 1 * (self.camera_zoom ** 10 + 1) if keystate[pygame.K_a]: print("key pressed") if keystate[pygame.K_d]: print("key pressed") if keystate[pygame.K_w]: print("key pressed") if keystate[pygame.K_s]: print("key pressed") if keystate[pygame.K_z]: print("z key pressed") self.camera_zoom += 0.01 if keystate[pygame.K_x]: print("x key pressed") self.camera_zoom -= 0.01 for event in pygame.event.get(): if event.type == pygame.QUIT: done = True if event.type == pygame.KEYDOWN: if event.key == pygame.K_SPACE: cell = Cell(self) self.space.add(cell.shape.body, cell.shape) self.cells.append(cell) print("Space pressed") pygame.display.flip()
def test_cell_init_correct_location_not_alive(): location = [1, 2] cell = Cell(location, True) assert cell.location == [1, 2] assert cell.alive == True
def test_cell_spawn_alive_state(): location = [1, 2] cell = Cell(location, False) cell.spawn() assert cell.alive is True assert cell.location is location
def test_cell_correct_location_alive(): location = [3, 7] cell = Cell(location, False) assert cell.location == [3, 7] assert cell.alive == False
screen_size = width, height = 720, 480 # Color definitions bg_color = 10, 61, 98 fg_color = 250, 211, 144 cell_color = 120, 224, 143 target_color = 229, 80, 57 blue = 130, 204, 221 frame_cap = 30 # Max FPS physic_refresh_rate = 0.3 # Refresh rate for physic in seconds, can be float display_refresh_rate = 1 / frame_cap # Refresh rate for screen in seconds, can be float # Creation of initial cell target_radius = 10 target_cell = Cell(width / 2, height / 2, 10) # target_cell = Cell(rd.randrange(target_radius, width - target_radius), rd.randrange(target_radius, height - target_radius), target_radius) print("Target position: ", target_cell.getPos()) target_cell.setColor(target_color) # target_cell.enableFriction(True, 0.3) # target_cell.addForce((1000, 1000)) # Cell group, all cells must be in cells = [] cells.append(target_cell) screen = pygame.display.set_mode(screen_size) # Store last update timestamp last_physic_update = -1 last_display_update = -1
def __init__(self, dims: tuple): self.dims = dims self.data = np.ndarray(shape=dims, dtype=object) for xi in range(dims[0]): for yi in range(dims[1]): self.data[xi][yi] = Cell('?', self, xi, yi)