def __init__(self): # A Batch is a collection of vertex lists for batched rendering. self.batch = pyglet.graphics.Batch() # A TextureGroup manages an OpenGL texture. self.group = TextureGroup(image.load(TEXTURE_PATH).get_texture()) # A mapping from position to the texture of the block at that position. # This defines all the blocks that are currently in the world. self.world = {} # Same mapping as `world` but only contains blocks that are shown. self.shown = {} # Mapping from position to a pyglet `VertextList` for all shown blocks. self._shown = {} # Mapping from sector to a list of positions inside that sector. self.sectors = {} # Simple function queue implementation. The queue is populated with # _show_block() and _hide_block() calls self.queue = deque() self._initialize()
def __init__(self): # Collection of vertex lists to render in batches self.batch = pyglet.graphics.Batch() # A group to manage the OpenGL texture self.group = TextureGroup(image.load(TEXTURE_PATH).get_texture()) # A ObjRelMap from player position to the texture of the indicated block # at that position - this holds all the blocks currently sitting in the world self.world = {} # Same as above - but only holds the blocks that are visible self.shown = {} # ObjRelMap from player position to a pyglet VertexList for all visible blocks self._shown = {} # ObjRelMap from current sector to a list of coordinate positions # within that sector. self.sectors = {} # A simplistic function to queue implementation. This is populated with # _show_block() and _hide_block() calls self.queue = dequeue() self._initialize()
def __init__(self): # A Batch is a collection of vertex lists for batched rendering. self.batch = pyglet.graphics.Batch() # A TextureGroup manages an OpenGL texture. self.group = TextureGroup(image.load(TEXTURE_PATH).get_texture()) # A mapping from position to the instance of the block at that position. # This defines all the blocks that are currently in the world. self.world = {} # Same mapping as `world` but only contains blocks that are shown. self.shown = {} # Mapping from position to a pyglet `VertexList` for all shown blocks. self._shown = {} # Mapping from sector to a list of positions inside that sector. self.sectors = {} # A list of blocks the player can place. Hit num keys to cycle. self.inventory = [BRICK, GRASS, SAND, PATH] # The current block the user can place. Hit num keys to cycle. self.block = self.inventory[0] # Simple function queue implementation. The queue is populated with # _show_block() and _hide_block() calls self.queue = deque() self.generate_terrain()
def __init__(self): self.WORLDSIZE = 100 self.MIN_Y = -20 self.MOUNTHEIGHT = 2 #Generator blocks self.GRASS_BLOCK = GRASS self.DIRT_BLOCK = DIRT self.STONE_BLOCK = STONE self.BEDROCK_BLOCK = BEDROCK # A Batch is a collection of vertex lists for batched rendering. self.batch = pyglet.graphics.Batch() # A TextureGroup manages an OpenGL texture. self.group = TextureGroup(image.load(TEXTURE_PATH).get_texture()) # A mapping from position to the texture of the block at that position. # This defines all the blocks that are currently in the world. self.world = {} # Same mapping as `world` but only contains blocks that are shown. self.shown = {} self.position = (0,100,0) # Mapping from position to a pyglet `VertextList` for all shown blocks. self._shown = {} # Mapping from sector to a list of positions inside that sector. self.sectors = {} # Simple function queue implementation. The queue is populated with # _show_block() and _hide_block() calls self.queue = deque() self.blockname = "BRICKS"
def __init__(self, path): self.atlas = TextureAtlas() glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST) self.group = TextureGroup(self.atlas.texture) for image in os.listdir(path): setattr(self, image[:-4], self.add(os.path.join(path, image)))
def __init__(self, game): self.game = game self.batch = Batch() self.group = TextureGroup(self.game.textures.texture) self.sector = None self.overlay = None self.rendered = {} self.queue = deque()
def __init__(self): self.batch = pyglet.graphics.Batch() self.group = TextureGroup(image.load(txt_path).get_texture()) self.world = {} self.shown = {} self._shown = {} self.sectors = {} self.queue = deque() self._initialize()
def __init__(self, initialPos): self.batch = pyglet.graphics.Batch() # A collection of vertex lists for batched rendering. self.group = TextureGroup(image.load(Constants.TEXTURE_PATH).get_texture()) # A TextureGroup manages an OpenGL texture. self.blockSet = {} # A mapping from position to the texture of the block at that position. Defines all blocks currently in the world self.shownBlocks = {} # Same mapping as `self.blockSet` but only contains blocks that are shown. self._shown = {} # Mapping from position to a pyglet `VertextList` for all shown blocks. self.sectors = {} # Mapping from sector to a list of positions inside that sector. self.queue = deque() # Create queue to manage function calls to keep game running smooth. The queue is populated with_showBlock() and _hideBlock() calls. # self.queue is not a necessary feature but helps to improve game performance. self.GenerateWorld(initialPos)
def __init__(self, top, bottom, side, nombre=None, tag=None, durable=1): self.texture = [] self.tex_coords(top, bottom, side) self.nombre = nombre self.tag = tag self.__durabilidad = durable self.live = durable self.roto = False self.selected = False self.group = TextureGroup(image.load(TEXTURE_PATH).get_texture())
def __init__(self): # A Batch is a collection of vertex lists for batched rendering. self.batch = pyglet.graphics.Batch() self.hud_batch = pyglet.graphics.Batch() # A TextureGroup manages an OpenGL texture. texture = image.load(TEXTURE_PATH).get_texture() #possible to use image.load(file=filedescriptor) if necessary self.textured_normal_group = TextureGroup(texture, parent = normal_group) self.textured_colorkey_group = TextureGroup(texture, parent = colorkey_group) self.shown = {} #{(position,face):vertex_list(batch_element)} self.chunks = Chunkdict() self.entities = {} #{entity_id: (vertex_list,...,...)} self.hud_elements = {} #{hud_element_id: (vertex_list,element_data,corners)} self.queue = deque() self.blockface_update_buffer = SetQueue() self.occlusion_cache = collections.OrderedDict()
def __init__(self, gp): self.count = 0 self.batch = pyglet.graphics.Batch() self.group = TextureGroup(image.load(TEXTURE_PATH).get_texture()) self.world = {} self.shown = {} self._shown = {} self.sectors = {} self.queue = deque() self._initialize() self.quadcopter = QuadCopter(gp)
def __init__(self, world=None): self.batch = pyglet.graphics.Batch() self.group = TextureGroup(image.load(TEXTURE_PATH).get_texture()) if world is None: world = {} self.world = world self.shown = {} self._shown = {} self.sectors = {} self.queue = deque() if not world: self._initialize()
def loadTexture(self, path): """ This function loads textures if necessary and returns them as a object """ if not path in self._textures: self.log.debug("Loading texture: %s" % (path, )) try: self._textures[path] = TextureGroup( image.load(path).get_texture()) except Exception as e: self.log.error(e) return self._textures[path]
def __init__(self): self.batch = mbatch() #pyglet.graphics.Batch() self.group = TextureGroup( image.load(TEXTURE_PATH).get_texture()) # 纹理列表 self.world = {} # 地图 self.shown = {} # 显示的方块 self._shown = {} # 显示的纹理 self.pool = {} # 水池 self.sectors = {} self.areat = {} self.queue = deque() # 指令队列 print("Loading...") self.dfy = self._initialize() print("OK")
def __init__(self, gp): self.count = 0 self.batch = pyglet.graphics.Batch() self.group = TextureGroup(image.load(TEXTURE_PATH).get_texture()) self.world = {} self.sizes = {} self.colors = {} self.material = [] self.volumes = {} self.shown = {} self._shown = {} self.sectors = {} self.queue = deque() self._initialize() self.camera = Camera(gp)
def __init__(self, rng, width, height, autocamera=False): self.rng = rng self.autocamera = autocamera self.overlay_batch = pyglet.graphics.Batch() self.group = TextureGroup(image.load(TEXTURE_PATH).get_texture()) self.path = {} self.width = width self.height = height self.window = pyglet.window.Window(width=width, height=height) #self.window.maximize() self.xoffset = 0 self.yoffset = 0 self.camera_distance = max(15, self.rng.gamma(shape=1, scale=100)) self.camera_height = self.camera_distance * self.rng.rand() * 0.3 self.camera_angle = (-180 + 360 * self.rng.rand()) if self.autocamera: self._reset_moving_camera() self.rotation = (0, 0) self.boat_models = {} self.main_batch = pyglet.graphics.Batch() self.world = {} self.terrain_shape = {} self.element_type = {} self.shown = {} self._shown = {} self.position = (0, self.camera_height, 0) self.queue = deque() self.reset_world() self.label = pyglet.text.Label('', font_size=18, x=210, y=self.height - 10, anchor_x='left', anchor_y='top', color=(0, 0, 0, 255)) glEnable(GL_BLEND) glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
def __init__(self, world=None): # Batch of pyglet VertexLists; everything loaded into the batch is drawn self.batch = Batch() # TextureGroup for managing OpenGL textures. self.group = TextureGroup(image.load(TEXTURE_PATH).get_texture()) # All of the blocks in the world; key is a tuple of (x, y, z) position if world is None: self.world = {} else: self.world = world # Just the blocks that are visible, i.e. exposed on at least one side self.visible = {} # Mapping from position to a pyglet VertexList (only for visible blocks) self.vertices = {} # Mapping from chunks to block locations within those chunks. self.chunks = {} # The chunk in which the player is currently located. self.chunk = None # The player's position in the world, initially at the origin. self.position = (0, 2, 0) # The rotation of the player's view. # First element is in the xz plane, second in some rotation of the yz plane. # Up-down rotation is constrained to between -90 and 90 (straight up and down) self.rotation = (0, 0) # Initialize player motion in the xz plane. # For the first element, -1 and 1 are left and right. # For the second, -1 and 1 are down and up. # For the third, backwards and forwards. self.motion = [0, 0, 0] # A queue for function calls; this allows blocks to be added and removed # in a way that doesn't slow down the game loop self.queue = deque() # Place blocks in the world self._initialize()
def __init__(self): self.count = 0 self.batch = pyglet.graphics.Batch() self.group = TextureGroup(image.load(TEXTURE_PATH).get_texture()) self.world = {} self.shown = {} self._shown = {} self.sectors = {} self.queue = deque() self.targets = 0 maze = Maze3D(self) self.quadcopter = QuadCopter(self) self.quadcopter.position = (-15,-2,-2) self.quadcopter.angle = 90 self.start = None self.time = ''
def __init__(self): # A Batch is a collection of vertex lists for batched rendering. self.batch = pyglet.graphics.Batch() # A TextureGroup manages an OpenGL texture. self.group = TextureGroup(image.load(TEXTURE_PATH).get_texture()) # A mapping from position to the texture of the block at that position. # This defines all the blocks that are currently in the world. self.world = {} # Same mapping as `world` but only contains blocks that are shown. self.shown = {} # Mapping from position to a pyglet `VertextList` for all shown blocks. self._shown = {} # Mapping from sector to a list of positions inside that sector. self.sectors = {} # Simple function queue implementation. The queue is populated with # _show_block() and _hide_block() calls self.queue = deque() # True/False variable that tells the model class if the rocket has already # been loaded. This prevents it from being loaded twice. self.rocket_loaded = False # True/False variable that tells the model class if the rocket has been # launched. self.rocket_launched = False # stores the altitude of the rocket self.rocket_altitude = 0 # mode of the rocket "up" for going up and "down" for going down self.rocket_mode = "up" # Counts the number of calls to rocket_update. This variable will # help us slow down the update rate and keep frame rate high self.rocket_update_count = 0 self._initialize()
def __init__(self): # A Batch is a collection of vertex lists for batched rendering. self.batch = pyglet.graphics.Batch() # A TextureGroup manages an OpenGL texture. self.group = TextureGroup(image.load(TEXTURE_PATH).get_texture()) # A mapping from position to the texture of the block at that position. # This defines all the blocks that are currently in the world. self.world = {} # Same mapping as `world` but only contains blocks that are shown. self.shown = {} # Mapping from position to a pyglet `VertextList` for all shown blocks. self._shown = {} # Mapping from sector to a list of positions inside that sector. self.sectors = {} # Simple function queue implementation. The queue is populated with # _show_block() and _hide_block() calls self.queue = deque() self.mob_loaded = False self.mob_mode = "1" self.mob_x_position = 0 self.mob_z_position = 0 #need for when jumping self.mob_y_position = -1 self.mob_update_count = 0 # AI for running or following self.ai = AI_class.AI() self._initialize()
def __init__(self, recorder, agent=None): self.started = False if agent: self.agent = agent self.recorder = agent.recorder else: self.agent = None self.recorder = recorder self.batch = pyglet.graphics.Batch() self.group = TextureGroup(image.load(TEXTURE_PATH).get_texture()) # A mapping from position to the texture of the block at that position. # This defines all the blocks that are currently in the world. self.world = {} # Same mapping as `world` but only contains blocks that are shown. self.shown = {} # Mapping from position to a pyglet `VertextList` for all shown blocks. self._shown = {} # Simple function queue implementation. The queue is populated with # _show_block() and _hide_block() calls self.queue = deque()
def __init__(self): # A Batch is a collection of vertex lists for batched rendering. self.batch = pyglet.graphics.Batch() # A TextureGroup manages an OpenGL texture. self.group = TextureGroup(image.load(TEXTURE_PATH).get_texture()) # A mapping from position to the texture of the block at that position. # This defines all the blocks that are currently in the world. self.world = {} # Same mapping as `world` but only contains blocks that are shown. self.shown = {} # Mapping from position to a pyglet `VertextList` for all shown blocks. self._shown = {} # Mapping from sector to a list of positions inside that sector. self.sectors = {} # Simple function queue implementation. The queue is populated with # _show_block() and _hide_block() calls self.queue = deque() world = 2 """ 1 : Sh*t world generation 2 : Perlin Noise minecraftlike generation 3 : No water Perlin Generation """ if world == 1 : self._initialize_1() elif world == 2 : self._initialize_2() elif world == 3 : self._initialize_3() elif world == 4 : self._initialize_4() elif world == 5 : self._initialize_5()
def __init__(self, scaler=None): self.settings = { 'SECTOR_SIZE': 16, 'WALKING_SPEED': 5, 'FLYING_SPEED': 15, 'GRAVITY': 20.0, 'MAX_JUMP_HEIGHT': 1.0, 'TERMINAL_VELOCITY': 50, 'PLAYER_HEIGHT': 2, 'FACES': {(0, 1, 0), (0, -1, 0), (-1, 0, 0), (1, 0, 0), (0, 0, 1), (0, 0, -1)} } self.scaler = scaler self.batch = pyglet.graphics.Batch() self.group = TextureGroup(image.load(scaler.src).get_texture()) self.world = {} self.shown = {} self._shown = {} self.sectors = {} self.queue = deque() self.__initialize()
def __init__(self): # A Batch is a collection of vertex lists for batched rendering. self.batch = Batch() # A TextureGroup manages an OpenGL texture. self.group = TextureGroup(image.load(TEXTURE_PATH).get_texture()) # A mapping from position to the texture of the block at that position. # This defines all the blocks that are currently in the world. self.objects = {} # Same mapping as `world` but only contains blocks that are shown. self.shown = {} # Mapping from position to a pyglet `VertextList` for all shown blocks. self._shown = {} # Which sector the player is currently in. self.sector = None # Mapping from sector to a list of positions inside that sector. self.sectors = {} self.shader = None self.show_hide_queue = OrderedDict() self.init_gl() # self._initialize() self.init_shader()
def _show_block(self, position, block): """Private implementation of the `show_block()` method. Parameters ---------- position : tuple of len 3 The (x, y, z) position of the block to show. texture : list of len 3 The coordinates of the texture squares. Use `tex_coords()` to generate. """ x, y, z = position vertex_data = cube_vertices(x, y, z, 0.5) shade_data = cube_shade(1, 1, 1, 1) texture_data = block.texture if block.identifier not in self.texture_group: self.texture_group[block.identifier] = TextureGroup( image.load(block.texture_path).get_texture()) self._shown[position] = self.batch.add( 24, GL_QUADS, self.texture_group[block.identifier], ('v3f/static', vertex_data), ('c3f/static', shade_data), ('t2f/static', texture_data))
def __init__(self): # A TextureGroup manages an OpenGL texture. self.group = TextureGroup(image.load(TEXTURE_PATH).get_texture()) mapgen.initialize_map_generator() # The world is stored in sector chunks. self.sectors = {} self.sector_lock = threading.Lock() self.thread = None # Simple function queue implementation. The queue is populated with # _show_block() and _hide_block() calls # self.queue = deque() d = range(-SECTOR_SIZE,SECTOR_SIZE+1,SECTOR_SIZE) #d = range(-128,128+1,SECTOR_SIZE) for pos in itertools.product(d,(0,),d): s=Sector(pos, self.group, self) self.sectors[sectorize(pos)] = s s._initialize() for s in self.sectors: self.sectors[s].check_show()
def __init__(self, gp): self.count = 0 self.batch = pyglet.graphics.Batch() self.group = TextureGroup(image.load(TEXTURE_PATH).get_texture()) self.world = {} self.shown = {} self._shown = {} self.sectors = {} self.queue = deque() self.targets = 0 if GAME == 0: self._initialize() elif GAME == 30: maze = Maze3D(self) else: self.sponge(0,0,0,GAME) self.quadcopter = QuadCopter(gp, self) #self.quadcopter.position = (-3,-2,-2) #self.quadcopter.position = (-12,-2,-2) #self.quadcopter.angle = 90 self.start = None self.time = ''
def __init__(self, name): # Batch 是用于批处理渲染的顶点列表的集合 self.batch3d = pyglet.graphics.Batch() # 为了分开绘制3D物体和2D的 HUD, 我们需要两个 Batch self.batch2d = pyglet.graphics.Batch() # 纹理的集合 self.group = TextureGroup( image.load(os.path.join(path['texture'], 'block.png')).get_texture()) # 存档名 self.name = name # world 存储着世界上所有的方块 self.world = {} # 类似于 world, 但它只存储要显示的方块 self.shown = {} # Mapping from position to a pyglet `VertextList` for all shown blocks. self._shown = {} # 记录玩家改变的方块 self.change = {} # Mapping from sector to a list of positions inside that sector. self.sectors = {} # Simple function queue implementation. The queue is populated with # _show_block() and _hide_block() calls self.queue = deque()
def __init__(self, drone_3d_model, horizon_view_size=8, init_drone_z=5, task='no_collision', debug_mode=False): self.task = task self.debug_mode = debug_mode # When increase this, show more blocks in current view window self.horizon_view_size = horizon_view_size # A Batch is a collection of vertex lists for batched rendering self.batch = Batch() # Manages an OpenGL texture self.group = TextureGroup(image.load(TEXTURE_PATH).get_texture()) # A mapping from position to the texture for whole, global map self.whole_map = dict() # Same as `whole_map` but only contains the positions to show self.partial_map = dict() # A mapping from position to a pyglet `VertextList` in `partial_map` self._partial_map = dict() # A mapping from sector to a list of positions (contiguous sub-region) # using sectors for fast rendering self.sectors = dict() # Use deque to populate calling of `_show_block` and `_hide_block` self.queue = deque() # A graphics batch to draw drone 3D model self.drone_batch = pyglet.graphics.Batch() # Load drone triangular mesh and scene self.drone_name = os.path.basename(drone_3d_model) self.drone_mesh = trimesh.load(drone_3d_model) self.drone_scene = self.drone_mesh.scene() # Drawer stores drone scene geometry as vertex list in its model space self.drone_drawer = None # Store drone geometry hashes for easy retrival self.drone_vertex_list_hash = '' # Store drone geometry rendering mode, default gl.GL_TRIANGLES self.drone_vertex_list_mode = gl.GL_TRIANGLES # Store drone geometry texture self.drone_texture = None black = np.array([0, 0, 0, 255], dtype=np.uint8) red = np.array([255, 0, 0, 255], dtype=np.uint8) green = np.array([0, 255, 0, 255], dtype=np.uint8) blue = np.array([0, 0, 255, 255], dtype=np.uint8) for i, facet in enumerate(self.drone_mesh.facets): if i < 30: self.drone_mesh.visual.face_colors[facet] = black elif i < 42: self.drone_mesh.visual.face_colors[facet] = red elif i < 54: self.drone_mesh.visual.face_colors[facet] = green elif i < 66: self.drone_mesh.visual.face_colors[facet] = blue else: self.drone_mesh.visual.face_colors[facet] = black # Mark positions of bounding wall and obstacles in the map self._initialize(init_drone_z)
def __init__(self, given={}): #Process settings from the menu and create an object with the appropriate properties self.TEXTURES = (calcTextureCoords(1), calcTextureCoords(2), calcTextureCoords(3), calcTextureCoords(4), calcTextureCoords(5), calcTextureCoords(6), calcTextureCoords(7), calcTextureCoords(8), calcTextureCoords(9)) self.TEXTURE_COLORS = (None, (128, 255, 255, 255), (128, 180, 255, 255), (204, 128, 255, 255)) self.LOGENABLED = False self.LOG = "" if "PROX" in given: self.PROX = given["PROX"] else: self.PROX = True if given["PROX_RANGE"]: self.PROX_RANGE = int(given["PROX_RANGE"]) else: self.PROX_RANGE = 5 self.ROOT_COST = 10 if "FORK" in given: self.FORK_COST = given["FORK"] * self.ROOT_COST else: self.FORK_COST = 50 if "STARTE" in given: self.INIT_ENERGY = given["STARTE"] * self.ROOT_COST else: self.INIT_ENERGY = 500 if "REWARD" in given: self.ENERGY_REWARD = given["REWARD"] * self.ROOT_COST else: self.ENERGY_REWARD = 20 if "GOAL" in given: self.GOAL = given["GOAL"] * self.ROOT_COST else: self.GOAL = 20 if "REPLAY" in given: self.REPLAY = given["REPLAY"] else: self.REPLAY = False if "REPLAYFILE" in given: self.REPLAY_FILE = given["REPLAYFILE"] else: self.REPLAY_FILE = "logfile" self.TEXTURE_PATH = "roots.png" self.LOGNUTRIENTSTART = False self.TICKS_PER_SEC = 60 self.textureGroup = TextureGroup( image.load(self.TEXTURE_PATH).get_texture()) self.FACES = [ (0, 1, 0), (0, -1, 0), (-1, 0, 0), (1, 0, 0), (0, 0, 1), (0, 0, -1), ] self.LATFACES = [(-1, 0, 0), (1, 0, 0), (0, 0, 1), (0, 0, -1)] self.ABSORB = (self.TEXTURES[5], self.TEXTURES[6], self.TEXTURES[7], self.TEXTURES[8], self.TEXTURES[2]) self.STALK_TEXTURE = calcTextureCoords(0) self.FLOWER_TEX = self.TEXTURES[3] self.FLOWER_CENTER = self.TEXTURES[1] self.NUTRIENT_TEXTURE = self.TEXTURES[4] #the lower function makes a lowercase string if given["mode"].lower() == "2D mode": self.TWODMODE = True else: self.TWODMODE = False if given["DENSITY"]: self.DENSITY = given["DENSITY"] else: self.DENSITY = 5 if given["CLUSTER"]: self.CLUSTER = given["CLUSTER"] else: self.CLUSTER = 5 if given["CLUSTERP"]: self.CLUSTERP = int(given["CLUSTERP"]) else: self.CLUSTERP = 3 if given["CLUSTERTYPE"]: self.CLUSTERTYPE = given["CLUSTERTYPE"] else: self.CLUSTERP = "None" if given["players"]: self.players = given["players"] else: self.players = ["Human Player", "RandomPlayer"] if given["whatdo"]: if given["whatdo"] == 'Play': self.whatdo = 0 if given["whatdo"] == 'CPU best of 100': self.whatdo = 1 if given["whatdo"] == 'Breeding': self.whatdo = 2 else: self.whatdo = 0