Python chunk.Chunk类代码示例

    def load_chunk(self, x, z):
        """
        Retrieve a ``Chunk`` synchronously.

        This method does lots of automatic caching of chunks to ensure that
        disk I/O is kept to a minimum.
        """

        if (x, z) in self.chunk_cache:
            return self.chunk_cache[x, z]
        elif (x, z) in self.dirty_chunk_cache:
            return self.dirty_chunk_cache[x, z]

        chunk = Chunk(x, z)
        self.serializer.load_chunk(chunk)

        if chunk.populated:
            self.chunk_cache[x, z] = chunk
        else:
            self.populate_chunk(chunk)
            chunk.populated = True
            chunk.dirty = True

            self.dirty_chunk_cache[x, z] = chunk

        self.postprocess_chunk(chunk)

        return chunk

    def load_chunk(self, x, z):
        """
        As the bot goes through the world, it would be helpful for it to keep records
        of chunks it has been to.
        """

        if (x, z) in self.chunk_cache:
            return self.chunk_cache[x, z]
        elif (x, z) in self.dirty_chunk_cache:
            return self.dirty_chunk_cache[x, z]

        # chuck is not in memory, check if it is on the disk
        chunk = Chunk(x, z)

        first, second, filename = names_for_chunk(x, z)
        f = self.folder.child(first).child(second)
        if not f.exists():
            f.makedirs()
        f = f.child(filename)
        if f.exists() and f.getsize():
            chunk.load_from_tag(read_from_file(f.open("r")))
            self.chunk_cache[x, z] = chunk
            return chunk

        print "attempting to load a chunk that is not available"
        raise Exception

    def test_ascend_zero(self):
        """
        ``ascend()`` can take a count of zero to ensure that the client is
        standing on solid ground.
        """

        self.p.location.pos = self.p.location.pos._replace(y=16)
        c = Chunk(0, 0)
        c.set_block((0, 0, 0), 1)
        self.p.chunks[0, 0] = c
        self.p.ascend(0)
        self.assertEqual(self.p.location.pos.y, 16)

    def test_ascend_one_up(self):
        """
        ``ascend()`` moves players upwards.
        """

        self.p.location.pos = self.p.location.pos._replace(y=16)
        c = Chunk(0, 0)
        c.set_block((0, 0, 0), 1)
        c.set_block((0, 1, 0), 1)
        self.p.chunks[0, 0] = c
        self.p.ascend(1)
        self.assertEqual(self.p.location.pos.y, 32)

    def test_ascend_zero_up(self):
        """
        Even with a zero count, ``ascend()`` will move the player to the
        correct elevation.
        """

        self.p.location.pos = self.p.location.pos._replace(y=16)
        c = Chunk(0, 0)
        c.set_block((0, 0, 0), 1)
        c.set_block((0, 1, 0), 1)
        self.p.chunks[0, 0] = c
        self.p.ascend(0)
        self.assertEqual(self.p.location.pos.y, 32)

 def test_single_block_damage_packet(self):
     chunk = Chunk(2, 1)
     chunk.populated = True
     chunk.set_block((2, 4, 8), 1)
     chunk.set_metadata((2, 4, 8), 2)
     packet = chunk.get_damage_packet()
     self.assertEqual(packet, '\x35\x00\x00\x00\x22\x04\x00\x00\x00\x18\x01\x02')

    def setUp(self):
        self.f = FallablesMockFactory()
        self.p = retrieve_plugins(IDigHook, parameters={"factory": self.f})

        if "alpha_sand_gravel" not in self.p:
            raise unittest.SkipTest("Plugin not present")

        self.hook = self.p["alpha_sand_gravel"]
        self.c = Chunk(0, 0)

    def make_chunk(self, x, z, seed, generators):
        """
        Create a chunk using the given parameters.
        """

        generators = retrieve_sorted_plugins(ITerrainGenerator, generators)

        chunk = Chunk(x, z)

        for stage in generators:
            stage.populate(chunk, seed)

        chunk.regenerate()

        return {
            "blocks": chunk.blocks.tostring(),
            "metadata": chunk.metadata.tostring(),
            "skylight": chunk.skylight.tostring(),
            "blocklight": chunk.blocklight.tostring(),
            "heightmap": chunk.heightmap.tostring(),
        }

def full_chunk_test():
    # compare two full chunks
    chunk1 = Chunk(0, 0)
    chunk2 = Chunk(0, 0)
    randomize_chunk(chunk1)
    packet1 = chunk1.save_to_packet()
    p, l = parse_packets(packet1)
    header, payload = p[0]
    chunk2.load_from_packet(payload)
    packet2 = chunk2.save_to_packet()
    compare_chunks(chunk1, chunk2)

 def test_get_damage_packet_single(self):
     # Create a chunk.
     c = Chunk(0, 0)
     # Damage the block.
     c.populated = True
     c.set_block((0, 0, 0), 1)
     # Enable warning-to-error for DeprecationWarning, then see whether
     # retrieving damage causes a warning-to-error to be raised. (It
     # shouldn't.)
     warnings.simplefilter("error", DeprecationWarning)
     c.get_damage_packet()
     # ...And reset the warning filters.
     warnings.resetwarnings()

    def load_chunk(self, x, z):
        """
        Retrieve a ``Chunk`` synchronously.

        This method does lots of automatic caching of chunks to ensure that
        disk I/O is kept to a minimum.
        """

        if (x, z) in self.chunk_cache:
            return self.chunk_cache[x, z]
        elif (x, z) in self.dirty_chunk_cache:
            return self.dirty_chunk_cache[x, z]

        chunk = Chunk(x, z)

        first, second, filename = names_for_chunk(x, z)
        f = self.folder.child(first).child(second)
        if not f.exists():
            f.makedirs()
        f = f.child(filename)
        if f.exists() and f.getsize():
            chunk.load_from_tag(read_from_file(f.open("r")))

        if chunk.populated:
            self.chunk_cache[x, z] = chunk
        else:
            self.populate_chunk(chunk)
            chunk.populated = True
            chunk.dirty = True

            self.dirty_chunk_cache[x, z] = chunk

        # Apply the current season to the chunk.
        if self.season:
            self.season.transform(chunk)

        # Since this chunk hasn't been given to any player yet, there's no
        # conceivable way that any meaningful damage has been accumulated;
        # anybody loading any part of this chunk will want the entire thing.
        # Thus, it should start out undamaged.
        chunk.clear_damage()

        return chunk

class TestLightmaps(unittest.TestCase):

    def setUp(self):
        self.c = Chunk(0, 0)

    def test_trivial(self):
        pass

    def test_boring_skylight_values(self):
        # Fill it as if we were the boring generator.
        for x, z in product(xrange(16), repeat=2):
            self.c.set_block((x, 0, z), 1)
        self.c.regenerate()

        # Make sure that all of the blocks at the bottom of the ambient
        # lightmap are set to 15 (fully illuminated).
        # Note that skylight of a solid block is 0, the important value
        # is the skylight of the transluscent (usually air) block above it.
        for i in xrange(1, 32768, 128):
            self.assertEqual(self.c.skylight[i], 0xf)

    def test_skylight_spread(self):
        # Fill it as if we were the boring generator.
        for x, z in product(xrange(16), repeat=2):
            self.c.set_block((x, 0, z), 1)
        # Put a false floor up to block the light.
        for x, z in product(xrange(1, 15), repeat=2):
            self.c.set_block((x, 2, z), 1)
        self.c.regenerate()

        # Test that a gradient emerges.
        for x, z in product(xrange(16), repeat=2):
            flipx = x if x > 7 else 15 - x
            flipz = z if z > 7 else 15 - z
            target = max(flipx, flipz)
            self.assertEqual(self.c.skylight[(x * 16 + z) * 128 + 1], target,
                            "%d, %d" % (x, z))

    def test_skylight_arch(self):
        """
        Indirect illumination should work.
        """

        # Floor.
        for x, z in product(xrange(16), repeat=2):
            self.c.set_block((x, 0, z), 1)

        # Arch of bedrock, with an empty spot in the middle, which will be our
        # indirect spot.
        for x, y, z in product(xrange(2), xrange(1, 3), xrange(3)):
            self.c.set_block((x, y, z), 1)
        self.c.set_block((1, 1, 1), 0)

        # Illuminate and make sure that our indirect spot has just a little
        # bit of illumination.
        self.c.regenerate()

        self.assertEqual(self.c.skylight[(1 * 16 + 1) * 128 + 1], 14)

    def test_skylight_arch_leaves(self):
        """
        Indirect illumination with dimming should work.
        """

        # Floor.
        for x, z in product(xrange(16), repeat=2):
            self.c.set_block((x, 0, z), 1)

        # Arch of bedrock, with an empty spot in the middle, which will be our
        # indirect spot.
        for x, y, z in product(xrange(2), xrange(1, 3), xrange(3)):
            self.c.set_block((x, y, z), 1)
        self.c.set_block((1, 1, 1), 0)

        # Leaves in front of the spot should cause a dimming of 1.
        self.c.set_block((2, 1, 1), 18)

        # Illuminate and make sure that our indirect spot has just a little
        # bit of illumination.
        self.c.regenerate()

        self.assertEqual(self.c.skylight[(1 * 16 + 1) * 128 + 1], 13)

    def test_skylight_arch_leaves_occluded(self):
        """
        Indirect illumination with dimming through occluded blocks only should
        work.
        """

        # Floor.
        for x, z in product(xrange(16), repeat=2):
            self.c.set_block((x, 0, z), 1)

        # Arch of bedrock, with an empty spot in the middle, which will be our
        # indirect spot.
        for x, y, z in product(xrange(3), xrange(1, 3), xrange(3)):
            self.c.set_block((x, y, z), 1)
        self.c.set_block((1, 1, 1), 0)

        # Leaves in front of the spot should cause a dimming of 1, but since
#.........这里部分代码省略.........

class TestAlphaSandGravelDig(unittest.TestCase):

    def setUp(self):
        self.f = FallablesMockFactory()
        self.p = retrieve_plugins(IDigHook, parameters={"factory": self.f})

        if "alpha_sand_gravel" not in self.p:
            raise unittest.SkipTest("Plugin not present")

        self.hook = self.p["alpha_sand_gravel"]
        self.c = Chunk(0, 0)

    def test_trivial(self):
        pass

    def test_floating_sand(self):
        """
        Sand placed in midair should fall down to the ground.
        """

        self.c.set_block((0, 1, 0), blocks["sand"].slot)

        self.hook.dig_hook(self.c, 0, 0, 0, blocks["air"].slot)

        self.assertEqual(self.c.get_block((0, 1, 0)), blocks["air"].slot)
        self.assertEqual(self.c.get_block((0, 0, 0)), blocks["sand"].slot)

    def test_sand_on_snow(self):
        """
        Sand placed on snow should replace the snow.

        Test for #298.
        """

        self.c.set_block((0, 1, 0), blocks["sand"].slot)
        self.c.set_block((0, 0, 0), blocks["snow"].slot)

        self.hook.dig_hook(self.c, 0, 2, 0, blocks["snow"].slot)

        self.assertEqual(self.c.get_block((0, 1, 0)), blocks["air"].slot)
        self.assertEqual(self.c.get_block((0, 0, 0)), blocks["sand"].slot)

    def test_sand_on_water(self):
        """
        Sand placed on water should replace the water.

        Test for #317.
        """

        self.c.set_block((0, 1, 0), blocks["sand"].slot)
        self.c.set_block((0, 0, 0), blocks["spring"].slot)

        self.hook.dig_hook(self.c, 0, 2, 0, blocks["spring"].slot)

        self.assertEqual(self.c.get_block((0, 1, 0)), blocks["air"].slot)
        self.assertEqual(self.c.get_block((0, 0, 0)), blocks["sand"].slot)

class TestLightmaps(unittest.TestCase):

    def setUp(self):
        self.c = Chunk(0, 0)

    def test_trivial(self):
        pass

    def test_boring_skylight_values(self):
        # Fill it as if we were the boring generator.
        self.c.blocks[:, :, 0].fill(1)
        self.c.regenerate()

        # Make sure that all of the blocks at the bottom of the ambient
        # lightmap are set to 15 (fully illuminated).
        # Note that skylight of a solid block is 0, the important value
        # is the skylight of the transluscent (usually air) block above it.
        reference = empty((16, 16))
        reference.fill(15)

        assert_array_equal(self.c.skylight[:, :, 1], reference)

    def test_skylight_spread(self):
        # Fill it as if we were the boring generator.
        self.c.blocks[:, :, 0].fill(1)
        # Put a false floor up to block the light.
        self.c.blocks[1:15, 1:15, 3].fill(1)
        self.c.regenerate()

        # Put a gradient on the reference lightmap.
        reference = empty((16, 16))
        reference.fill(15)
        top = 1
        bottom = 15
        glow = 14
        while top < bottom:
            reference[top:bottom, top:bottom] = glow
            top += 1
            bottom -= 1
            glow -= 1

        assert_array_equal(self.c.skylight[:, :, 1], reference)

    def test_skylight_arch(self):
        """
        Indirect illumination should work.
        """

        # Floor.
        self.c.blocks[:, :, 0].fill(1)

        # Arch of bedrock, with an empty spot in the middle, which will be our
        # indirect spot.
        self.c.blocks[0:2, 0:3, 1:3].fill(1)
        self.c.blocks[1, 1, 1] = 0

        # Illuminate and make sure that our indirect spot has just a little
        # bit of illumination.
        self.c.regenerate()

        self.assertEqual(self.c.skylight[1, 1, 1], 14)

    def test_skylight_arch_leaves(self):
        """
        Indirect illumination with dimming should work.
        """

        # Floor.
        self.c.blocks[:, :, 0].fill(1)

        # Arch of bedrock, with an empty spot in the middle, which will be our
        # indirect spot.
        self.c.blocks[0:2, 0:3, 1:3].fill(1)
        self.c.blocks[1, 1, 1] = 0

        # Leaves in front of the spot should cause a dimming of 1.
        self.c.blocks[2, 1, 1] = 18

        # Illuminate and make sure that our indirect spot has just a little
        # bit of illumination.
        self.c.regenerate()

        self.assertEqual(self.c.skylight[1, 1, 1], 13)

    def test_skylight_arch_leaves_occluded(self):
        """
        Indirect illumination with dimming through occluded blocks only should
        work.
        """

        # Floor.
        self.c.blocks[:, :, 0].fill(1)

        # Arch of bedrock, with an empty spot in the middle, which will be our
        # indirect spot.
        self.c.blocks[0:3, 0:3, 1:3].fill(1)
        self.c.blocks[1, 1, 1] = 0

        # Leaves in front of the spot should cause a dimming of 1, but since
        # the leaves themselves are occluded, the total dimming should be 2.
#.........这里部分代码省略.........

    def request_chunk(self, x, z):
        """
        Request a ``Chunk`` to be delivered later.

        :returns: ``Deferred`` that will be called with the ``Chunk``
        """

        if (x, z) in self.chunk_cache:
            returnValue(self.chunk_cache[x, z])
        elif (x, z) in self.dirty_chunk_cache:
            returnValue(self.dirty_chunk_cache[x, z])
        elif (x, z) in self._pending_chunks:
            # Rig up another Deferred and wrap it up in a to-go box.
            retval = yield self._pending_chunks[x, z].deferred()
            returnValue(retval)

        chunk = Chunk(x, z)
        yield maybeDeferred(self.serializer.load_chunk, chunk)

        if chunk.populated:
            self.chunk_cache[x, z] = chunk
            self.postprocess_chunk(chunk)
            #self.factory.scan_chunk(chunk)
            returnValue(chunk)

        if self.async:
            from ampoule import deferToAMPProcess
            from bravo.remote import MakeChunk

            d = deferToAMPProcess(MakeChunk,
                x=x,
                z=z,
                seed=self.seed,
                generators=configuration.getlist(self.config_name, "generators")
            )

            # Get chunk data into our chunk object.
            def fill_chunk(kwargs):
                chunk.blocks = fromstring(kwargs["blocks"],
                    dtype=uint8).reshape(chunk.blocks.shape)
                chunk.heightmap = fromstring(kwargs["heightmap"],
                    dtype=uint8).reshape(chunk.heightmap.shape)
                chunk.metadata = fromstring(kwargs["metadata"],
                    dtype=uint8).reshape(chunk.metadata.shape)
                chunk.skylight = fromstring(kwargs["skylight"],
                    dtype=uint8).reshape(chunk.skylight.shape)
                chunk.blocklight = fromstring(kwargs["blocklight"],
                    dtype=uint8).reshape(chunk.blocklight.shape)

                return chunk
            d.addCallback(fill_chunk)
        else:
            # Populate the chunk the slow way. :c
            for stage in self.pipeline:
                stage.populate(chunk, self.seed)

            chunk.regenerate()
            d = succeed(chunk)

        # Set up our event and generate our return-value Deferred. It has to
        # be done early becaues PendingEvents only fire exactly once and it
        # might fire immediately in certain cases.
        pe = PendingEvent()
        # This one is for our return value.
        retval = pe.deferred()
        # This one is for scanning the chunk for automatons.
        #pe.deferred().addCallback(self.factory.scan_chunk)
        self._pending_chunks[x, z] = pe

        def pp(chunk):
            chunk.populated = True
            chunk.dirty = True

            self.postprocess_chunk(chunk)

            self.dirty_chunk_cache[x, z] = chunk
            del self._pending_chunks[x, z]

            return chunk

        # Set up callbacks.
        d.addCallback(pp)
        d.chainDeferred(pe)

        # Because multiple people might be attached to this callback, we're
        # going to do something magical here. We will yield a forked version
        # of our Deferred. This means that we will wait right here, for a
        # long, long time, before actually returning with the chunk, *but*,
        # when we actually finish, we'll be ready to return the chunk
        # immediately. Our caller cannot possibly care because they only see a
        # Deferred either way.
        retval = yield retval
        returnValue(retval)