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)
