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:

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

The configuration used:

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:

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

The configuration used:

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