Esempio n. 1
0
    def build(self):
        """Build this world"""
        log.info("Building SuperFlat World")

        # Build Regions
        log_clock = Clock()
        regions = []
        for i in range(256):
            if log_clock.delay(1):
                log.info(f"[{int(i/256*100)}%] Building World")
            # Build Chunks
            region = Region(self)
            chunks = []
            chunk = Chunk(region)
            for x in range(8):
                chunk.blocks[0][x] = block.BedRock()
                chunk.blocks[1][x] = block.Dirt()
                chunk.blocks[2][x] = block.Dirt()
                chunk.blocks[3][x] = block.GrassBlock()
            chunks.append(chunk)

            for j in range(31):
                chunks.append(Chunk(region))

            region.chunks = chunks
            regions.append(region)


        self.regions = regions
        log.info("[100%]Building finished")
Esempio n. 2
0
    def __init__(self, game: Game):
        super().__init__(game)
        import texture
        self.bg = pyglet.sprite.Sprite(texture.gui.background, x=-24, y=-64)
        self.clock = Clock()
        self.rot_d = 0.01

        self.minecraft = pyglet.sprite.Sprite(texture.gui.minecraft)
        self.singlePlayer = SinglePlayer(self.game, "Singleplayer")
Esempio n. 3
0
    def __init__(self, world: World, server: socket.socket):
        self.x = 5
        self.y = 0
        self.world = world
        self.server = server
        self.server.settimeout(2)
        self.game = world.game
        self.unloaded = [[True for chunk in range(32)]
                         for region in range(256)]
        self.chunkImgs = [[None for y in range(32)] for x in range(256)]

        # Queues
        self.requestQueue = socketQueue()
        self.responseQueue = socketQueue()

        # Display
        self.info = string("test", 5, 10, 6)

        # OP initialize
        self.op_clock = Clock()
        self.mouse = [0, 0]
        self.pointing = [0, 0]

        # GL initialize
        pyglet.gl.glClearColor(0.7, 0.8, 1, 1)
        pyglet.gl.glEnable(pyglet.gl.GL_BLEND)
        pyglet.gl.glBlendFunc(pyglet.gl.GL_SRC_ALPHA,
                              pyglet.gl.GL_ONE_MINUS_SRC_ALPHA)

        # Run Threads
        threading.Thread(target=self.networkRequestThread,
                         name="Camera-NetworkRequestThread").start()
        threading.Thread(target=self.networkResponseThread,
                         name="Camera-NetworkResponseThread").start()
Esempio n. 4
0
 def __init__(self, game: Game, text: str, color=color.white, type=0):
     self.type = type
     img = gui.button if self.type else gui.button_half
     self.game = game
     self.text = text
     self.t_color = color
     self.__draw_text = None
     self.__draw_text_deep = None
     self.__clicking = False
     self.clock = Clock()
     super().__init__(img)
Esempio n. 5
0
class Menu(Scene):

    def __init__(self, game: Game):
        super().__init__(game)
        import texture
        self.bg = pyglet.sprite.Sprite(texture.gui.background, x=-24, y=-64)
        self.clock = Clock()
        self.rot_d = 0.01

        self.minecraft = pyglet.sprite.Sprite(texture.gui.minecraft)
        self.singlePlayer = SinglePlayer(self.game, "Singleplayer")

    def on_update(self):
        self.bg.scale = self.game.scale
        self.bg.x = -15 - self.game.scale*140
        rate = 1.7
        brate = rate * 1.2

        if self.game.width/856 > self.game.width/482:
            scale = self.game.scale

        else:
            scale = self.game.descale

        if scale > 3:
            scale = 3*rate
            brate = rate*1.3
        else:
            self.minecraft.scale = scale*rate
            self.singlePlayer.scale = scale*brate
        self.minecraft.position = (
            self.game.center[0] - self.minecraft.image.width/2*scale*rate,
            self.game.height - 64 - scale*40*rate
        )
        self.singlePlayer.position = (
            self.game.center[0] - 100*scale*brate,
            self.game.height - 64 - scale*85*rate - scale*20*brate
        )

        self.singlePlayer.refresh()
        if self.clock.delay(0.01):
            self.bg.rotation += self.rot_d
            if abs(self.bg.rotation) > 0.8:
                self.rot_d = - self.rot_d

    def on_draw(self):
        self.bg.draw()
        self.minecraft.draw()
        self.singlePlayer.draw()
        self.singlePlayer.drawText()
Esempio n. 6
0
    def __init__(self, game):
        super().__init__(game)
        self.blk = texture.gui.options_background
        self.scale = 2
        self.darkblk = texture.gui.options_background_dark
        self.size = (856, 484) if self.game.scale <= 1.2 else (1920, 1080)
        self.background = transform.PygameToGL(pygame.Surface((856, 484)))
        self.block_height = 16
        self.label_select_world = string(source=[{"text": "Select World", "color": 'white'}], x=self.size[0]/2, y=self.game.height)

        # Clocks
        self.auto_on_resize_clock = Clock()
        self.refresh_clock = Clock()
        self.btn_refresh_clock = Clock()
        self.draw_clock = Clock()
        # Button
        self.btn_cancel = btnCancel(self.game, 'Cancel', color=color.white, type=1)
        self.btn_create = btnCreate(self.game, "Create New World", color=color.white, type=1)
        self.btn_delete = btnDelete(self.game, "Delete", color=color.white, type=1)
        self.btn_play = btnPlay(self.game, "Play Selected World", color=color.white, type=1)
Esempio n. 7
0
class SelectWorld(Scene):
    def __init__(self, game):
        super().__init__(game)
        self.blk = texture.gui.options_background
        self.scale = 2
        self.darkblk = texture.gui.options_background_dark
        self.size = (856, 484) if self.game.scale <= 1.2 else (1920, 1080)
        self.background = transform.PygameToGL(pygame.Surface((856, 484)))
        self.block_height = 16
        self.label_select_world = string(source=[{"text": "Select World", "color": 'white'}], x=self.size[0]/2, y=self.game.height)

        # Clocks
        self.auto_on_resize_clock = Clock()
        self.refresh_clock = Clock()
        self.btn_refresh_clock = Clock()
        self.draw_clock = Clock()
        # Button
        self.btn_cancel = btnCancel(self.game, 'Cancel', color=color.white, type=1)
        self.btn_create = btnCreate(self.game, "Create New World", color=color.white, type=1)
        self.btn_delete = btnDelete(self.game, "Delete", color=color.white, type=1)
        self.btn_play = btnPlay(self.game, "Play Selected World", color=color.white, type=1)

    def on_resize(self):
        background = pygame.Surface((self.size[0]//3, self.size[1]//3))
        blk = transform.GLtoPygame(self.blk)
        dark_blk = transform.GLtoPygame(self.darkblk)
        width = blk.get_width()
        height = blk.get_height()
        self.block_height = height
        scale = 1
        blk = pygame.transform.scale(blk, (int(width*scale*self.game.scale), int(height*scale*self.game.scale)))
        dark_blk = pygame.transform.scale(dark_blk, (int(width*scale*self.game.scale), int(height*scale*self.game.scale)))

        b_width = blk.get_width()
        b_height = blk.get_height()
        bg_size = background.get_size()

        for y in range(int(self.game.height//b_height)):
            for x in range(int(self.game.width//b_width)):
                background.blit(dark_blk, (int(x * b_width), int(y * b_height)))

        for x in range(int(self.game.width//b_width)):
            background.blit(blk, (int(x * b_width), 0))
            background.blit(blk, (int(x * b_width), bg_size[1] - b_height*1,))
            background.blit(blk, (int(x * b_width), bg_size[1] - b_height*2,))

        self.background = transform.PygameToGL(background)




    def on_key_press(self, symbol, modifiers):
        if symbol == pyglet.window.key.ESCAPE:
            from Scenes.Menu import Menu
            self.game.change_scene(Menu(self.game))

    def on_update(self):
        if self.size != self.game.size:
            self.size = self.game.size
            self.on_resize()
        self.label_select_world.x = self.game.width / 2 - self.label_select_world.width * self.game.scale / 4
        self.label_select_world.y = self.game.height - self.block_height * self.game.scale * 2
        self.label_select_world.scale = self.game.scale * 2
        if self.refresh_clock.delay(0.1):
            self.label_select_world.reset()

        if self.auto_on_resize_clock.delay(0.5):
            self.on_resize()

        if self.game.mouse.y < self.block_height*5*self.game.scale or self.btn_refresh_clock.delay(0.07):
            # Buttons
            self.btn_cancel.scale = self.game.scale * 1.8
            self.btn_create.scale = self.game.scale * 1.8
            self.btn_delete.scale = self.game.scale * 1.8
            self.btn_play.scale = self.game.scale * 1.8
            self.btn_cancel.refresh()
            self.btn_create.refresh()
            self.btn_delete.refresh()
            self.btn_play.refresh()
            self.btn_cancel.position = (
                self.game.width / 2 + 10,
                self.block_height * self.game.scale * 0.5
            )
            self.btn_play.position = (
                self.game.width / 2 - self.btn_create.width - 10,
                self.block_height * self.game.scale * 0.5 + self.btn_create.height+5
            )
            self.btn_create.position = (
                self.game.width / 2 + 10,
                self.block_height * self.game.scale * 0.5 + self.btn_create.height + 5
            )
            self.btn_delete.position = (
                self.game.width / 2 - self.btn_create.width - 10,
                self.block_height * self.game.scale * 0.5
            )

    def on_draw(self):
        if self.draw_clock.delay(0.005):
            self.background.blit(0, 0, 0, self.size[0], self.size[1])
            self.label_select_world.draw()
            # Buttons

            self.btn_cancel.draw()
            self.btn_cancel.drawText()
            self.btn_create.draw()
            self.btn_create.drawText()
            self.btn_delete.draw()
            self.btn_delete.drawText()
            self.btn_play.draw()
            self.btn_play.drawText()