def __init__(self, MANAGER, WINDOW): super().__init__(MANAGER, WINDOW) w_shape = loads(CONFIG.get('window', 'shape')) self.bg_img = pygame.image.load(CONFIG.get( 'window', 'background_fp')).convert_alpha() self.bg_img = pygame.transform.scale(self.bg_img, w_shape)
def __init__(self, MANAGER, WINDOW): super().__init__(MANAGER, WINDOW) w_shape = loads(CONFIG.get('window', 'shape')) self.fps = CONFIG.getint('window', 'fps') # bg for background self.menu_bg = pygame.image.load(CONFIG.get( 'window', 'background_fp')).convert_alpha() self.menu_bg = pygame.transform.scale(self.menu_bg, w_shape)
def __init__(self, MANAGER, WINDOW): super().__init__(MANAGER, WINDOW) w_shape = loads(CONFIG.get('window', 'shape')) fps = CONFIG.getint('window', 'fps') ''' Initialize graphics ''' # Initializing in boids_instances.py caused errors bg_img = pygame.image.load(CONFIG.get( 'window', 'background_fp')).convert_alpha() tuna_img = pygame.image.load('images/tuna.png').convert_alpha() gw_shark_img = pygame.image.load( 'images/great_white_shark.png').convert_alpha() mine_img = pygame.image.load('images/mine.png').convert_alpha() bg_img = pygame.transform.scale(bg_img, w_shape) tuna_img = pygame.transform.scale(tuna_img, (70, 30)) gw_shark_img = pygame.transform.scale(gw_shark_img, (200, 150)) mine_img = pygame.transform.scale(mine_img, (90, 90)) panel = pygame.Rect(w_shape[0] * 0.95, 0, w_shape[0] * 0.05, w_shape[1]) panel_border = pygame.Rect(w_shape[0] * 0.95, -10, w_shape[0] * 0.10, w_shape[1] * 1.1) '''''' '''''' '''''' '''''' '' img_list = [tuna_img, mine_img, gw_shark_img] # alter w_shape to fit simulation area w_shape = (int(w_shape[0] * 0.95), w_shape[1]) simulation_area = pygame.Rect(0, 0, w_shape[0], w_shape[1]) # Get the addresses of instance lists preys = boids_i.preys obstacles = boids_i.obstacles predators = boids_i.predators # Turn locals to attributes self.__dict__.update(locals()) self.initialize()
''' Initializing instances with the purpose the be used in the boids_state ''' import pygame from objects import interface from main import CONFIG from json import loads from objects import tuna from objects import uw_mine from objects import shark # pygame.init() pygame.font.init() WINDOW_SHAPE = loads(CONFIG.get('window', 'shape')) font = CONFIG.get('general', 'font') font_size = int(WINDOW_SHAPE[0] * CONFIG.getfloat('boids_state', 'font_window_ratio')) font_color_buttons = loads(CONFIG.get('boids_state', 'font_color_buttons')) font_color_levers = loads(CONFIG.get('boids_state', 'font_color_levers')) ''' Define prey, obstacle and predator list here since the lever_with_fishclass levers needs the addresses ''' preys = [] obstacles = [] predators = [] ''' Mass slaughter button '''
class shark(general_fish.fish): eat_radius = CONFIG.getint('shark', 'eat_radius') obstacle_radius = CONFIG.getint('shark', 'obstacle_radius') hunt_radius = CONFIG.getint('shark', 'hunt_radius') f_hunt = CONFIG.getfloat('shark', 'f_hunt') f_repel_obstacle = CONFIG.getfloat('shark', 'f_repel_obstacle') f_repel_border = CONFIG.getfloat('shark', 'f_repel_border') def __init__(self, pos, img): super().__init__(pos, img) def draw(self, WINDOW): if (self.vel[0] > 0): new_image = pygame.transform.flip(self.img, 0, 1) new_image = pygame.transform.rotate( new_image, np.degrees(np.arctan2(*self.vel)) + 90) else: new_image = pygame.transform.rotate( self.img, np.degrees(np.arctan2(*self.vel)) + 90) img_center = new_image.get_rect(center=self.pos) WINDOW.blit(new_image, img_center) def percieve_obstacles(self, dist_vecs, dist_vecs_norm): obstacle_mask = (dist_vecs_norm < self.obstacle_radius) & (dist_vecs_norm != 0) # dirs for directions (directions represented as normalized vectors) self.obstacles_dirs = dist_vecs[obstacle_mask] / dist_vecs_norm[ obstacle_mask].reshape((-1, 1)) def percieve_preys(self, dist_vecs, dist_vecs_norm): self.eat_mask = (dist_vecs_norm < self.eat_radius) & (dist_vecs_norm != 0) far_mask = (dist_vecs_norm < self.hunt_radius) & (dist_vecs_norm != 0) self.prey_dirs = dist_vecs[far_mask] / dist_vecs_norm[far_mask].reshape( (-1, 1)) def eat(self, preys): if (any(self.eat_mask)): # Flipped eat mask array to perserve # order in preys matrix for i in np.nonzero(self.eat_mask)[0][::-1]: if (i < len(preys)): del (preys[i]) def hunt(self): if (self.prey_dirs.shape[0]): self.recalc_vel.append(self.f_hunt * self.prey_dirs.mean(axis=0)) else: self.vel = self.vel * 0.9 def avoid_obstacles(self): if (self.obstacles_dirs.shape[0]): self.recalc_vel.append(self.f_repel_obstacle * self.obstacles_dirs.mean(axis=0)) def stay_in_border(self, w_shape): if (self.pos[0] > w_shape[0] * 0.90): self.recalc_vel.append(np.array([-self.f_repel_border, 0])) if (self.pos[0] < w_shape[0] * 0.10): self.recalc_vel.append(np.array([self.f_repel_border, 0])) if (self.pos[1] > w_shape[1] * 0.90): self.recalc_vel.append(np.array([0, -self.f_repel_border])) if (self.pos[1] < w_shape[1] * 0.10): self.recalc_vel.append(np.array([0, self.f_repel_border])) def apply_behavior(self, state, i): ''' Applies all methods necessary to give a complete behavior The method takes in that boids_state object as an input. The boids state object carries dist_matrix and dist_matrix_norms as instance attributes. The percieve methods are then feeded with the appropriate slices of the matrices. An iterator value is also passed to this to slice. [:state.num_preys] slices info about preys [state.num_preys:state.obstacle_index] slices info about obstacles [state.obstacle_index:] slices info about predators ''' self.randval = state.randvals[i] offset_i = i + state.obstacle_index self.percieve_obstacles( dist_vecs=state.dist_matrix[offset_i] [state.num_preys:state.obstacle_index], dist_vecs_norm=state.dist_matrix_norms[offset_i] [state.num_preys:state.obstacle_index]) self.percieve_preys( dist_vecs=state.dist_matrix[offset_i][:state.num_preys], dist_vecs_norm=state.dist_matrix_norms[offset_i][:state.num_preys]) self.hunt() self.eat(state.preys) self.avoid_obstacles() self.stay_in_border(state.w_shape) self.motion()
def __init__(self, WINDOW, MANAGER): super().__init__(WINDOW, MANAGER) self.fps = CONFIG.getint('window', 'fps')
import pygame import numpy as np from main import CONFIG n_strong_f = CONFIG.getfloat('particles_state','nuclear_strong_force') n_weak_f = CONFIG.getfloat('particles_state', 'nuclear_weak_force') drag_f = CONFIG.getfloat('particles_state', 'drag_force') ''' I wrote most of this code early on and didn't really comment. Now I dont really get it, so I wont bother commenting ''' class particle: def __init__(self, pos): pos = np.array(pos) vel = np.zeros((2)) acc = np.zeros((2)) x0 = np.array([20,20]) friends = [] friends_dist_vecs = [] self.__dict__.update(locals()) def draw(self, WINDOW): pygame.draw.circle( WINDOW, (255,255,255), self.pos.astype('int'), 5 )
class tuna(general_fish.fish): repel_radius = CONFIG.getint('tuna', 'repel_radius') attract_radius = CONFIG.getint('tuna', 'attract_radius') obstacle_radius = CONFIG.getint('tuna', 'obstacle_radius') foe_radius = CONFIG.getint('tuna', 'foe_radius') f_attract_friends = CONFIG.getfloat('tuna', 'f_attract_friends') f_repel_friends = CONFIG.getfloat('tuna', 'f_repel_friends') f_repel_obstacles = CONFIG.getfloat('tuna', 'f_repel_obstacles') f_repel_foes = CONFIG.getfloat('tuna', 'f_repel_foes') def __init__(self, pos, img): super().__init__(pos, img) def draw(self, WINDOW): ''' Calculates orientation and blits instance to WINDOW. ''' # The in if (self.vel[0] < 0): blit_image = pygame.transform.flip(self.img, 0, 1) blit_image = pygame.transform.rotate( blit_image, np.degrees(np.arctan2(*self.vel)) - 90) else: blit_image = pygame.transform.rotate( self.img, np.degrees(np.arctan2(*self.vel)) - 90) # Get a new rect with the center of the old rect. img_center = blit_image.get_rect(center=self.pos) WINDOW.blit(blit_image, img_center) def percieve_friends(self, dist_vecs, dist_vecs_norm, vel_vecs): ''' Slices dist_vecs and dist_vecs_norms with respect to all tunas to get directions to all tunas ''' close_mask = (dist_vecs_norm < self.repel_radius) & (dist_vecs_norm != 0) medium_mask = (dist_vecs_norm < self.attract_radius) & (dist_vecs_norm != 0) ''' dirs for directions (directions represented as unit vectors) ''' self.friends_close_dirs = dist_vecs[close_mask] / dist_vecs_norm[ close_mask].reshape((-1, 1)) self.friends_medium_dirs = dist_vecs[medium_mask] / dist_vecs_norm[ medium_mask].reshape((-1, 1)) self.friends_vels = vel_vecs[medium_mask] def percieve_obstacles(self, dist_vecs, dist_vecs_norm): ''' Slices dist_vecs and dist_vecs_norms with respect to obstacles to get directions to all obstacles ''' medium_mask = (dist_vecs_norm < self.obstacle_radius) & (dist_vecs_norm != 0) self.obstacles_dirs = dist_vecs[medium_mask] / dist_vecs_norm[ medium_mask].reshape((-1, 1)) def percieve_foes(self, dist_vecs, dist_vecs_norm): ''' Slices dist_vecs and dist_vecs_norms with respect to foes to get directions to all foes (sharks) ''' far_mask = (dist_vecs_norm < self.foe_radius) & (dist_vecs_norm != 0) self.foes_dirs = dist_vecs[far_mask] / dist_vecs_norm[far_mask].reshape( (-1, 1)) def attraction(self): ''' Cohesion rule ''' if (self.friends_medium_dirs.shape[0]): self.recalc_vel.append(self.f_attract_friends * self.friends_medium_dirs.mean(axis=0)) def repulsion(self): ''' Separation rule ''' # Force norm from tunas within inner tuna radius if (self.friends_close_dirs.shape[0]): self.recalc_vel.append(self.f_repel_friends * self.friends_close_dirs.mean(axis=0)) # Force norm from obstacle within obstacle radius if (self.obstacles_dirs.shape[0]): self.recalc_vel.append(self.f_repel_obstacles * self.obstacles_dirs.mean(axis=0)) # Force norm from sharks within foe radius if (self.foes_dirs.shape[0]): self.recalc_vel.append(self.f_repel_foes * self.foes_dirs.mean(axis=0)) def match_vel(self): ''' Alignment rule ''' if (self.friends_medium_dirs.shape[0] > 1): self.recalc_vel.append( self.friends_vels.mean(axis=0) * 0.20 + self.vel * 0.80 - self.vel) def apply_behavior(self, state, i): ''' Applies all methods necessary to give a complete behavior The method takes in that boids_state object as an input. The boids state object carries dist_matrix and dist_matrix_norms as instance attributes. The percieve methods are then feeded with the appropriate slices of the matrices. An iterator value is also passed to this to slice. [:state.num_preys] slices info about preys [state.num_preys:state.obstacle_index] slices info about obstacles [state.obstacle_index:] slices info about predators ''' self.percieve_friends( dist_vecs=state.dist_matrix[i][:state.num_preys], dist_vecs_norm=state.dist_matrix_norms[i][:state.num_preys], vel_vecs=state.vel_vecs[:state.num_preys]) self.percieve_obstacles(dist_vecs=state.dist_matrix[i] [state.num_preys:state.obstacle_index], dist_vecs_norm=state.dist_matrix_norms[i] [state.num_preys:state.obstacle_index]) self.percieve_foes( dist_vecs=state.dist_matrix[i][state.obstacle_index:], dist_vecs_norm=state.dist_matrix_norms[i][state.obstacle_index:]) self.attraction() self.repulsion() self.match_vel() self.wrap_x(state.w_shape) self.avoid_y_borders(state.w_shape) self.randval = state.randvals[i] self.motion()
def __init__(self, MANAGER, WINDOW, POOL, QUEUE): super().__init__(MANAGER, WINDOW) fps = CONFIG.getint('window', 'fps') particles_list = [] self.__dict__.update(locals())
''' Initializing instances with the purpose the be used in the menu_state ''' import pygame from objects import interface from main import CONFIG from json import loads from objects import tuna pygame.font.init() WINDOW_SHAPE = loads(CONFIG.get('window', 'shape')) font = CONFIG.get('general', 'font') text_x_pos = WINDOW_SHAPE[0] * CONFIG.getfloat('menu_state', 'text_x_ratio') font_size = int(WINDOW_SHAPE[0] * CONFIG.getfloat('menu_state', 'font_window_ratio')) font_color = loads(CONFIG.get('menu_state', 'font_color')) ''' text_list are for text objects without any further functionality ''' text_list = [ interface.text_float( text='Boids & Particle Physics Simulator', pos=(text_x_pos, WINDOW_SHAPE[1] * 0.05), color=font_color, font=font, font_size=int(font_size * 1.8), ), ] '''