[WIP][WGEN] InfiniteObjects for Bukkit - Procedural "BO2"s!

Discussion in 'WIP and Development Status' started by DDoS, May 19, 2013.

Thread Status:
Not open for further replies.
  1. Offline

    DDoS

    Well, these aren't BO2's at all. They're defined using configurations, and are designed to be as unrestrictive as possible.

    This is a port of an official plugin for the Spout platform (not SpoutPlugin). The plugin, which I wrote myself, is mostly working (it's pretty much Beta now), but, due to Spout being a WIP, I doesn't have much of a use. So I ported it. This is not an official port. but it's from the same author (so almost).

    Once I'm done writing the documentation and adding a few missing features, I'll make an official release.

    So, InfiniteObjects allows you do define procedural BO2 like world features, called iWGOs (for "infinite World Generator Objects"). Why "infinite"? Because these are fully random, and one iWGO can output a nearly infinite number of world objects (the actual number depends on the iWGO itself).

    This plugin is a developer tool. It won't generate anything on its own, it only loads and makes accessible to other plugins iWGOs, which can be used very easily; although you can place them manually with a command, which is useful when working on them. Functionality for the InfiniteObjects can also be extended by other plugins, for limitless possibilities.

    Here are some demo iWGOs I made:

    Huge tree:

    [​IMG]

    [​IMG]

    Both of these were generated from the same file, one after the other. As you can see, they're different.

    The configuration used:

    Code:
    name: huge_tree
     
    variables:
      height: ranI=25-30
      minLeafHeight: height - ranI(3, 5)
     
    setters:
      leaves:
        type: random-inner-outer
        properties:
          inner:
            material: Leaves
            odd: 100
          outer:
            material: Leaves
            odd: 75
      wood:
        type: simple
        properties:
          material: Log
     
    conditions:
      ground:
        type: cuboid
        properties:
          mode: include
          size:
            x: 2
            y: 1
            z: 2
          position:
            x: 0
            y: -1
            z: 0
          check:
            - Grass
            - Dirt
      main:
        type: cuboid
        properties:
          mode: exclude
          size:
            x: 6
            y: height
            z: 6
          position:
            x: -2
            y: 0
            z: -2
          check:
            - Water
            - Grass
            - Dirt
            - Stone
            - Log
            - Leaves
     
    instructions:
      leafPod:
        type: shape
        variables:
          angle: ranF(0, 2) * PI
          offsetX: sin(angle) * 6
          offsetZ: cos(angle) * 6
        properties:
          shapes:
            leafPod:
              type: sphere
              properties:
                size:
                  radiusX: ranI=2-3
                  radiusY: ranI=2-3
                  radiusZ: ranI=2-3
                position:
                  x: offsetX
                  y: minLeafHeight
                  z: offsetZ
                material: leaves
            branch:
              type: line
              properties:
                size:
                  lengthX: offsetX
                  lengthY: 3
                  lengthZ: offsetZ
                position:
                  x: 0
                  y: minLeafHeight - 3
                  z: 0
                material: wood
      leafPods:
        type: repeat
        properties:
          repeat: leafPod
          times: ranI=6-8
          increment:
            minLeafHeight: -ranI(1, 3)
      main:
        type: shape
        properties:
          shapes:
            canopy:
              type: sphere
              properties:
                size:
                  radiusX: ranI=4-5
                  radiusY: ranI=2-3
                  radiusZ: ranI=4-5
                position:
                  x: 0
                  y: height - 2
                  z: 0
                material: leaves
            trunk:
              type: cuboid
              properties:
                size:
                  x: 2
                  y: height
                  z: 2
                position:
                  x: 0
                  y: 0
                  z: 0
                material: wood
      top:
        type: block
        properties:
          position:
            x: 0
            y: height
            z: 0
          material: wood
          outer: true
    
    Abandoned house:

    [​IMG]
    [​IMG]

    Its not that good looking, but it's just a demo.

    The configuration used:

    Code:
    name: abandoned_house
     
    variables:
      length: ranI(5, 8) * 2
      height: ranI=7-10
      width: ranI=10-15
      roofFold: length / 2
      roofHeight: ranI=4-6
      i: 0
     
    setters:
      walls:
        type: random-inner-outer
        properties:
          inner:
            material: Air
            odd: 100
          outer:
            material: Smooth_Brick
            data: 2
            odd: 90
      floor:
        type: random-simple
        properties:
          material: Wood
          data: 1
          odd: 90
      roof:
        type: random-simple
        properties:
          material: Wood
          odd: 80
      foundations:
        type: simple
        properties:
          material: Mossy_Cobblestone
      air:
        type: simple
        properties:
          material: Air
      stairs:
        type: simple
        properties:
          material: Cobblestone_stairs
          data: 2
     
    conditions:
      gound:
        type: cuboid
        properties:
          mode: include
          size:
            x: length + 2
            y: 1
            z: width + 2
          position:
            x: -1
            y: -2
            z: -1
          check:
            - Grass
            - Dirt
            - Stone
            - Sand
            - Sandstone
     
      space:
        type: cuboid
        properties:
          mode: exclude
          size:
            x: length
            y: height - 2 + roofHeight
            z: width
          position:
            x: 0
            y: 2
            z: 0
          check:
            - Grass
            - Dirt
            - Stone
            - Sand
            - Sandstone
     
    instructions:
      main:
        type: shape
        properties:
          shapes:
            space:
              type: cuboid
              properties:
                size:
                  x: length
                  y: height + roofHeight + 2
                  z: width
                position:
                  x: 0
                  y: 0
                  z: 0
                material: air
            walls:
              type: cuboid
              properties:
                size:
                  x: length
                  y: height
                  z: width
                position:
                  x: 0
                  y: -1
                  z: 0
                material: walls
            foundations:
              type: cuboid
              properties:
                size:
                  x: length + 2
                  y: 1
                  z: width + 2
                position:
                  x: -1
                  y: -1
                  z: -1
                material: foundations
            floor:
              type: cuboid
              properties:
                size:
                  x: length - 2
                  y: 1
                  z: width - 2
                position:
                  x: 1
                  y: 0
                  z: 1
                material: floor
            roofSpace:
              type: cuboid
              properties:
                size:
                  x: length
                  y: 1
                  z: width
                position:
                  x: 0
                  y: height - 2
                  z: 0
                material: air
            entrance:
              type: cuboid
              properties:
                size:
                  x: 2
                  y: 4
                  z: 1
                position:
                  x: length / 2 - 1
                  y: 0
                  z: 0
                material: air
      roofSegments:
        type: shape
        properties:
          shapes:
            roofSegment1:
              type: line
              properties:
                size:
                  lengthX: roofFold
                  lengthY: roofHeight
                  lengthZ: 0
                position:
                  x: 0
                  y: height - 2
                  z: i
                material: roof
            roofSegment2:
              type: line
              properties:
                size:
                  lengthX: roofFold - length + 1
                  lengthY: roofHeight
                  lengthZ: 0
                position:
                  x: length - 1
                  y: height - 2
                  z: i
                material: roof
      roof:
        type: repeat
        properties:
          repeat: roofSegments
          times: width - 1
          increment:
            i: 1
      roofWallSegments1:
        type: shape
        properties:
          shapes:
            roofWallSegment1:
              type: cuboid
              properties:
                size:
                  x: 1
                  y: roofHeight / roofFold * i
                  z: 1
                position:
                  x: i
                  y: height - 2
                  z: 0
                material: walls
            roofWallSegment2:
              type: cuboid
              properties:
                size:
                  x: 1
                  y: roofHeight / roofFold * i
                  z: 1
                position:
                  x: i
                  y: height - 2
                  z: width - 1
                material: walls
      roofWall1:
        type: repeat
        properties:
          repeat: roofWallSegments1
          times: roofFold - 1
          increment:
            i: 1
      roofWallSegments2:
        type: shape
        properties:
          shapes:
            roofWallSegment1:
              type: cuboid
              properties:
                size:
                  x: 1
                  y: roofHeight / (roofFold - length) * i
                  z: 1
                position:
                  x: length + i - 1
                  y: height - 2
                  z: 0
                material: walls
            roofWallSegment2:
              type: cuboid
              properties:
                size:
                  x: 1
                  y: roofHeight / (roofFold - length) * i
                  z: 1
                position:
                  x: length + i - 1
                  y: height - 2
                  z: width - 1
                material: walls
      roofWall2:
        type: repeat
        properties:
          repeat: roofWallSegments2
          times: length - roofFold - 1
          increment:
            i: -1
      stair1:
        type: block
        properties:
          position:
            x: length / 2 - 1
            y: 0
            z: 0
          material: stairs
      stair2:
        type: block
        properties:
          position:
            x: length / 2
            y: 0
            z: 0
          material: stairs
    
    As you can see, the complexity is higher for the second iWGO. That's because it has more details and randomness. The size of the house and roof can all change. The complexity can also be explained by the shape of the roof, which is not as a whole, a basic geometric shape (sphere, cuboid, line, cone).

    For now, if you want to test the plugin, you'll need to compile it yourself for the source, available here:

    https://github.com/DDoS/InfiniteObjects-Bukkit
     
Thread Status:
Not open for further replies.

Share This Page