Eclipse Wiki

Getting Started

6 min read

Here you will find out how to implement custom plants, trees and crops into the world of Eclipse. We will be implementing a Cinnamon Tree!

What you will need

You can add any new plant or tree to Eclipse’s world by defining it’s models, textures, blockstates and a little Oraxen magic. All you really need is:

  • Blockbench
  • Visual Studio Code

Project Setup

Before you even start touching your new creation, you must first make sure that your project is setup correctly.

  • Go to the plugins folder within the Server Host
  • Now you must locate the plants.yml file (plugins/Oraxen/items/plants.yml)

Explanation of the plants.yml:

  • plants.yml - define seeds, stages, and harvest for all custom plants
  • /pack/models/block/ - BlockBench - exported block models
  • /pack/models/item/ - BlockBench - exported item models
  • /pack/textures/block/ - PNG textures for each stage
  • /pack/textures/item/ - PNG textures for seeds and harvest

Here is what you should expect:

Folder Structure 

plugins/Oraxen/
└── items/
    └── plants.yml
└── pack/
    ├── models/
    │   ├── block/
    │   │   └── cinnamon_stage0.json -> cinnamon_stageN.json
    │   └── item/
    │   │   └── cinnamon_bark.json
    └── textures/
        ├── block/
        │   └── cinnamon_stage0.png -> cinnamon_stageN.png
        └── item/
            └── cinnamon_seed.png
            └── cinnamon_bark.png

Defining the Plant

Let’s break down and explain each property you’ll see when setting up a custom plant in Oraxen’s plants.yml. This will help you understand what every line does and how it impacts the plant’s behaviour.

Below is a minimal example illustrating seeds, growth stages and harvest:

#plants.yml
 
cinnamon_seed:
     displayname: "<gold>Cinnamon Seed"
     material: PAPER
     Mechanics:
         furniture:
             item: cinnamon_stage0
             barrier: false
             farmland_required: true
             evolution:
                 delay: 2000        # ticks between growth attempts
                 probability: 0.5   # 50% chance per tick
                 light_boost: true
                 next_stage: cinnamon_stage1
             drop:
                 silktouch: true
                 loots:
                     - oraxen_items: cinnamon_seed
                       probability: 1.0
     Pack:
         generate_model: true
         parent_model: item/generated
         textures:
             - plants/cinnamon/seed
 
cinnamon_stage0:
      material: PAPER
      excludeFromInventory: true
      Mechanics:
          furniture:
              barrier: false
              farmland_required: true
              evolution:
                  delay: 2000
                  probability: 0.5
                  light_boost: true
                  next_stage: cinnamon_stage1
             drop:
                  silktouch: true
                  loots:
                      - oraxen_item: cinnamon_seed
                        probability: 1.0
      Pack:
          generate_model: true
          model: plants/cinnamon/stage0
          
# Repeat for cinnamon_stage1 ... cinnamon_stageN-1, changing next_stage accordingly
 
cinnamon_stageN:
      material: Paper
      excludeFromInventory: true
      Mechanics:
          furniture:
              barrier: false
              farmland_required: true
              drop:
                  silktouch: true
                  loots:
                      - oraxen_item: cinnamon_bark
                        max_amount: 3
                        probability: 0.75
                      - oraxen_item: cinnamon_seed
                        max_amount: 2
                        probability: 0.5
      Pack:
         generate_model: false
         model: plants/cinnamon/stageN
 
cinnamon_bark:
      displayname: "<brown>Cinnamon Bark"
      material: PAPER
      Pack:
          generate_model: true
          parent_model: item/generated
          textures:
              - plants/cinnamon/bark

Item and Display Details

cinnamon_seed:

  • This is the uique ID for your seed item. Every Oraxen item starts with a key like this.

displayname:

  • The name shown to players, can include Minecraft color codes like <gold> or <brown>

material:

  • The base Minecraft item used if the custom resource pack isn’t applied (e.g., PAPER)

Mechanics Section

Mechanics:

  • This is where any functional properties go. For plants, you’ll use the furniture mechanic (or transparrent_block for armor stand block plants).

Furniture Mechanic Block

furniture: - Controls how the plant behaves when placed, grown and harvested.

  • item:
    • Which item is placed in the world when you plant the seed. Usually your first growth stage.
  • barrier:
    • If set to true, prevents placement under invalid conditions (usually leave as false)
  • farmland_required:
    • Ensures the crop can only be planted on farmland (like wheat, carrots, etc.)
  • evolution:
  • Controls how the plant grows to it’s next stage
    • delay:
      • How long (in ticks - 20 ticks = 1 second) before trying to grow to the next stage.
    • probability:
      • The chance (between 0 and 1) for growth to occur each tick (0.5 means 50%).
    • light_boost:
      • if true, growth gets faster with more light.
    • next_stage:
      • What Oraxen item ID is used for the next stage (e.g., cinnamon_stage1.) Set this for all stages except the final stage.
  • drop:
    • Controls what items are dropped when a crop is broken at this stage.
    • silktouch:
      • If true, allows Silk Touch to drop the block itself.
    • loots:
      • A list of item, with probability per item, given when broken
      • oraxen_item:
        • The Oraxen item to drop (can be seeds, product, etc.)
      • probability:
        • The chance of this drop (e.g., 1.0 = 100%)
      • max_amount:
        • Maximum number given for this loot (optional)

Pack Section

  • Pack:
    • Controls how the item/block appears in-game (model, texture).
    • generate_model:
      • if true, Oraxen will auto-generate a model (used for simple items). For grow stages, usually set to false because you provide a custom model from BlockBench.
    • parent_model:
      • Only for items, which Minecraft model type to inherit (e.g., item/generated for flat items)
    • textures:
      • List the path to PNG files for the item’s texture
      • You can use namespaced paths like plants/cinnamon/seed.
    • model:
      • For blocks/grow stages, path to the BlockBench-exported JSON file (plants/cinnamon/stage0)

Example Final Stage Properties

cinnamon_stageN: (your final stage)

  • Has the same structure as earlier stages but:
    • No next_stage (since it is fully grown)
    • The drop section will include your harvest items, like cinnamon_bark
    • You can drop multiple items with specific probabilities/quantities.

Harvest Item

cinnamon_bark:

  • Standard item entry. Used for what the player actually wants to get from this crop.
  • Usual properties: displayname, material, Pack for visuals

Creating Models and Textures

In order for our crop to be able to be seen we first need to give it a custom model and texture for each stage of it’s growth.

Block Models

  • In BlockBench, start a “Block/Item” project, choose “Block” and create either a cross-plane or a simple 3D tree trunk.
  • Assign each face the correct stage texture (stage0.png → stageN.png)
  • Export each as a JSON to /pack/models/block/ with matching names (/pack/cinnamon/stage0.json, etc.).

Item Models

  • For cinnamon_seed and cinnamon_bark, create an “Item” project in BlockBench.
  • Use the “generated” parent, assign seed.png and bark.png, before exporting to /pack/models/item/.

Textures

  • Design PNG’s (16x16 or 32x32) for each growth stage and item.
  • Place them under /pack/textures/block/plants/cinnamon/ and /pack/textures/item/plants/cinnamon/.

Reload and Test

Finally you have reached the end and created a Cinnamon Tree. Now all that is left is to see if it actually worked.

  • Run /oraxen reload all in Minecraft
  • Give yourself seeds (/oraxen give @p cinnamon_seed).
  • Plant on farmland. Watch as it grows.
  • Break at final stage to collect cinnamon bark and seeds. Adjust delay, probability, drop amounts and textures until you are Happy!

Tips for Trees vs Small Crops

Trees: Use more stages (5-8), larger models and consider separate leaf blocks or biome-appropriate trunk textures.

Small Crops: Keep stages distinct (3-5) and use flat cross-planes for performance.

Optimization: Use excludeFromInventory and simple models to reduce client overhead.

Backlinks