마인크래프트/모드/개발

{{{#!wiki style="margin: -0px -10px -5px; min-height:calc(1.5em + 5px)" {{{#!folding [ 펼치기 · 접기 ] {{{#!wiki style="margin: -5px -1px -11px; word-break:keep-all"	<colbgcolor=darkgreen><colcolor=#fff> 기본 플레이
시스템	세계 ( 시드) · 게임 모드 · 난이도 · 게임 규칙 · 엔딩 · 죽음 메시지 · 스플래시 · 명령어 · NBT · 런처
인게임	아이템 · 몹 ( 플레이어) · 개체 · 날씨 · 차원 · 생물군계 · 구조물 · 마법 부여 · 상태 효과 · 조작법 · 피해 · 업적
도움말	튜토리얼 · 팁 ( 탐험 · 파밍 · 회로) · 재생 가능한 자원 · 브릿징 · PVP · 파쿠르 · 스피드런 · 건축 ( 맵아트)
시리즈 및 매체
출시 에디션	자바 에디션 ( 업데이트 · 거리 효과) · 베드락 에디션 ( 업데이트) · 포켓 에디션* · 콘솔 에디션* · 파이 에디션*
파생 게임	마인크래프트 던전스* · 마인크래프트 레전드* · 마인크래프트 에듀케이션 · 마인크래프트: 스토리 모드* · 마인크래프트 어스*
미디어	OST · 관련 서적 · 레고 · 영화 · 애니메이션 · Minecraft Live · Minecraft Now · Minecraft Monthly
유저 콘텐츠
창작 요소	2차 창작 · 망토 · 맵 · 모드 ( 개발 · 팁 · 모드팩) · 애드온 · 팩 ( 리소스 팩 · 데이터 팩) · 외부 프로그램 · 핵
멀티 콘텐츠	멀티플레이 · 서버 · 플러그인 · Realms · EULA
개발	개발 기초 · 모드 개발 · 플러그인 개발
기타
이야깃거리	여담 · 커뮤니티 · 사건 사고 · 문제점 · 용어 · 지원 언어 · 머나먼 땅 · 이미테이션 게임 · 히로빈
관련 문서	나무위키 마인크래프트 프로젝트 · 마인크래프트로 분류된 문서 · 마인크래프트의 하위 문서
* 표시는 서비스가 종료되었거나 개발이 중단되었다는 표시이다.		}}}}}}}}}

1. 개요

2. 개발 도구 설치

2.1. 자바 표준 개발환경 구축

2.2. Forge API

• 마인크래프트 1.7.10 까지는 Src 파일
• 마인크래프트 1.8 부터는 Mdk 파일

setupDecompWorkspace : 디컴파일된 개발환경 구축
eclipse : 구축된 개발환경을 이클립스의 개발방식으로 정돈
build : 모드를 컴파일한다
runClient : 마인크래프트에 모드를 적용해 실행시킨다

2.3. Fabric API

2.4. 개발 도구 통합과 마인크래프트 설치

3. 패키지

#!syntax java
wiki.namu.mymod

assets : 모든 필요한 리소스들이 여기에 들어간다. 모드의 소스폴더와는 다른 resources라는 폴더에 생성한다.
assets.<모드 ID> : 아래와 같은 다양한 폴더들이 들어가는 상위폴더이다.
assets.<모드 ID>.textures : 아이템, 블록 등의 텍스쳐 파일을 넣는다.
assets.<모드 ID>.models : 웨이브 프론트를 이용해 3D 모델을 삽입할 때 사용할 obj 파일들이 들어간다.
assets.<모드 ID>.lang : 아이템, 블록 등의 이름을 정의할 lang파일들이 들어간다.
assets.<모드 ID>.blockstates : 블럭의 상태에 따른 3D 모델을 지정하는 파일을 넣는다.
assets.<모드 ID>.shaders : 셰이더 파일들이 들어간다.
assets.<모드 ID>.sounds : 각종 효과음으로 ogg 파일이 들어간다.

data.<모드 ID>.advancements : 발전 과제의 데이터를 저장하는 파일들을 모아놓은 패키지다.
data.<모드 ID>.loot_tables : 블럭, 몬스터의 드랍 아이템, 낚시를 할 때 낚이는 아이템, 폐광, 던전 등의 구조물 내에 생성되는
상자에서 발견되는 아이템 등을 설정하는 파일들을 모아놓은 패키지다.
data.<모드 ID>.recipes : 조합법 데이터를 모아놓은 패키지다.
data.<모드 ID>.tags : 여러 아이템이나 블럭을 하나로 묶은 태그에 대한 정보를 모아놓은 패키지다.
data.<모드 ID>.structures : 여러 생성 구조물의 정보를 모아놓은 패키지다.

4. 이름 등록 (GameRegistry)

#!syntax json
{
    "item.modnamu.namu_item": "나무 아이템",
    "block.modnamu.namu_block": "나무 블럭"
}

5. 메인 클래스

#!syntax java
import cpw.mods.fml.common.Mod;

@Mod(modid=<모드 아이디>, name=<모드 이름>, version=<모드 버전>)

#!syntax java
@Instance(value = <모드 아이디>)
public static MyMod myMod;

#!syntax java
@EventHandler
public void event(FML...Event event) {}

#!syntax java
import cpw.mods.fml.common.Mod.EventHandler;
import cpw.mods.fml.common.event.*;

//클래스 내부

@EventHandler
public void preInit(FMLPreInitializationEvent event) {}

@EventHandler
public void init(FMLInitializationEvent event) {}

@EventHandler
public void postInit(FMLPostInitializationEvent event) {}

#!syntax java
package wiki.namu.mymod;

import cpw.mods.fml.common.Mod;
import cpw.mods.fml.common.Mod.EventHandler;
import cpw.mods.fml.common.Mod.Instance;
import cpw.mods.fml.common.event.*;

@Mod(modid=NamuMain.MODID, name=NamuMain.NAME, version=NamuMain.VERSION)
public class NamuMain {
	public static final String MODID = "modNamu";
	public static final String NAME = "project Namu";
	public static final String VERSION = "testing";
	
	@Instance(value=NamuMain.MODID)
	public static NamuMain namuobj;
	
	@EventHandler
	public void preInit(FMLPreInitializationEvent event) {
		// 모드 로딩 중 init() 보다 먼저 호출되는 이벤트, 모드 설정을 불러오는 부분
	}

	@EventHandler
	public void init(FMLInitializationEvent event) {
		// 모드 로딩 중간에 호출되는 이벤트, 조합법과 광물을 추가하는 부분
	}

	@EventHandler
	public void postInit(FMLPostInitializationEvent event) {
		// 모드 로딩 중 init() 이후에 호출되는 이벤트, 다른 모드와 상호작용함으로써 호환성을 높이는 부분
	}
}

FMLCommonSetupEvent : 이전의 preInit과 비슷한 역할을 한다. 아이템, 블럭 등의 여러 오브젝트를 
등록하는 RegistryEvent.Register가 호출된 뒤에 호출되며, 이 후에 FMLClientSetupEvent와 
FMLDedicatedServerSetupEvent가 호출된다. 이 때에는 모드 설정 파일을 불러오거나 월드 생성 옵션
등을 설정하는 등의 작업을 하면 좋다.
FMLClientSetupEvent : FMLCommonSetupEvent가 호출된 뒤에 호출된다. 이 이벤트가 호출되는
때에는 클라이언트 사이드에서 수행되는 여러 작업을 한다.
FMLDedicatedServerSetupEvent : FMLClientSetupEvent와 비슷하지만 서버 사이드에서 수행되는
작업을 수행한다는 점이 다르다.
InterModEnqueueEvent : FMLClientSetupEvent와 FMLDedicatedServerSetupEvent 뒤에 호출되는
이벤트로, 다른 모드와의 호환성을 위해 여러가지 정보를 보내는 일을 수행한다. InterModComms.sendTo
메소드를 사용해 정보를 보낼 수 있다.
InterModProcessEvent : InterModEnqueueEvent 뒤에 호출되며, 다른 모드들이 InterModEnqueueEvent
에서 보낸 정보를 받는 일을 수행한다. InterModComms.getMessages 메소드로 정보를 받을 수 있다.

#!syntax java
import net.minecraftforge.fml.Logging;
import net.minecraftforge.fml.event.lifecycle.FMLClientSetupEvent;
import net.minecraftforge.fml.event.lifecycle.FMLCommonSetupEvent;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

//클래스 내부

/* 디버깅을 위해서 모드의 각 클래스마다 org.apache.logging.log4j.Logger 인스턴스를 만들어놓는 것이
좋다. Logger 인스턴스는 org.apache.logging.log4j.LogManager.getLogger() 메소드를 호출하여 만들 수 있다. */
private static final Logger LOGGER = LogManager.getLogger();

private void setup(final FMLCommonSetupEvent event)
{
	LOGGER.info(Logging.LOADING, "Setup method registered");
}
	
private void clientRegistries(final FMLClientSetupEvent event)
{
	LOGGER.info(Logging.LOADING, "Client setup method registered");
}

#!syntax java
FMLJavaModLoadingContext.get().getModEventBus().addListener(this::setup);
FMLJavaModLoadingContext.get().getModEventBus().addListener(this::clientRegistries);

#!syntax java
package wiki.namu.mymod;

import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.fml.Logging;
import net.minecraftforge.fml.common.Mod;
import net.minecraftforge.fml.event.lifecycle.FMLClientSetupEvent;
import net.minecraftforge.fml.event.lifecycle.FMLCommonSetupEvent;
import net.minecraftforge.fml.javafmlmod.FMLJavaModLoadingContext;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

@Mod(NamuMain.MODID)
public class NamuMain
{
	public static NamuMain instance;
	public static final String MODID = "modnamu";
	private static final Logger LOGGER = LogManager.getLogger();
	
	public NamuMain()
	{
		instance = this;
		
		FMLJavaModLoadingContext.get().getModEventBus().addListener(this::setup);
		FMLJavaModLoadingContext.get().getModEventBus().addListener(this::clientRegistries);
		
		MinecraftForge.EVENT_BUS.register(this);
	}
	
	private void setup(final FMLCommonSetupEvent event)
	{
		LOGGER.info(Logging.LOADING, "Setup method registered");
	}
	
	private void clientRegistries(final FMLClientSetupEvent event)
	{
		LOGGER.info(Logging.LOADING, "Client setup method registered");
	}
}

6. 클라이언트와 서버 사이드

6.1. @SideOnly

#!syntax java
@SideOnly(value = Side.CLIENT)
public void registerBlockIcons(IIconRegister p_149651_1_)
{
    this.blockIcon = p_149651_1_.registerIcon(this.getTextureName());
    // 마인크래프트 내 Block 클래스에서 실제 블록의 텍스쳐를 등록하는 메소드이며, 이 메소드는 클라이언트 사이드에서만 수행되어야 한다.
}

• world.isRemote() : 해당 월드의 사이드를 알아낸다
• FMLCommonHandler.getSide() : 이 메소드가 실행되는 시점의 사이드를 알아낸다.

6.2. 프록시

#!syntax java
@SidedProxy(clientSide="<Client의 위치>", serverSide="<Common의 위치>" )
public static CommonProxyClass objCommonProxy;

#!syntax java
//메인 클래스 내부
@SidedProxy(clientSide="wiki.bluesky.main.ClientProxyClass", serverSide="wiki.bluesky.main.CommonProxyClass")
public static CommonProxyClass objCommonProxy;

#!syntax java
package wiki.namu.mymod;
public class ClientProxyClass extends CommonProxyClass {}

#!syntax java
package wiki.namu.mymod;
public class CommonProxyClass {}

#!syntax java
private static final IProxy proxy = DistExecutor.runForDist(() → ClientProxy::new, () → ServerProxy::new);

7. 블록 만들기

#!syntax java
//블록을 만들고 해당 블록을 어떠한 크리에이티브 탭에 추가할지 정하기.

//메인 클래스 안에서 값을 관리하기

//생성한 Block의 객체에 자식 객체를 넣었다. 어떻게 이런 구문이 정상작동 하는지는 후술.
public Block namuBlock = new BlockNamu(Material.glass).setCreativeTab(CreativeTabs.tabBlock);

//새로운 블록 클래스 안에서 관리하기
public BlockNamu(Material mat) {
		super(mat);
		setCreativeTab(CreativeTabs.tabBlock); //블록 클래스 안에서 부모의 setCreativeTabs를 호출한다.
	}

#!syntax java
import net.minecraft.*;

@SubscribeEvent
	public static void registerBlock(RegistryEvent.Register<Block> e){			
                            e.getRegistry().register(<블록 인스턴스>);	
         }

#!syntax java
    ModelLoader.setCustomModelResourceLocation(Item.getItemFromBlock(<블록 인스턴스>), 0, new ModelResourceLocation(<블록 인스턴스>.getRegistryName(), "inventory"));

Block setUnlocalizedName(String) : 블록의 지역화되지 않은 이름을 설정한다.
Block setCreativeTab(CreativeTabs) : 크리에이티브 모드의 탭에 해당 블록을 추가한다.
Block setBlockHardness(float) : 블록의 강도를 설정.
Block setResistance(float) : 블록의 폭발 저항력을 설정.
Block setHarvestLevel(String, int) : 문자열로 해당 도구의 클래스를, 정수로 채취 가능한 레벨을 설정한다.
Block setBlockUnbreakable() : 해당 블록을 기반암, 포탈과 같이 채굴할 수 없게 만든다. setBlockHardness(-1.0F) 함수를 호출하는것과 같은 기능을 한다.

void onBlockDestroyedByPlayer(World, BlockPos, IBlockState) : 플래이어에 의해서 블록이 파괴될 경우에 호출된다.
void onBlockActivated(World, BlockPos, IBlockState, EntityPlayer, EnumHand, EnumFacing, float, float, float) : 플래이어의 우클릭에 반응하여 호출한다.
void onEntityWalk(World, BlockPos, Entity) : 엔티티가 해당 블록 위에서 걸어다니고 있을 경우 호출된다.
void onBlockAdded(World, BlockPos, IBlockState) : 월드에 블록이 추가되었을 경우 호출된다.
void onBlockClicked(World, BlockPos, EntityPlayer) : 플래이어가 좌클릭으로 때릴 경우에 호출된다.
void onBlockExploded(World, BlockPos, Explosion) : 블록이 폭발로 인해 파괴될 경우에 호출된다.
void onEntityCollidedWithBlock(World, BlockPos, IBlockState, Entity) : 엔티티가 블록에 접촉한 경우 호출된다.

추가 중.

#!syntax java
package wiki.namu.mymod;

import net.minecraft.block.Block;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.event.RegistryEvent;
import net.minecraftforge.eventbus.api.SubscribeEvent;
import net.minecraftforge.fml.Logging;
import net.minecraftforge.fml.common.Mod;
import net.minecraftforge.fml.event.lifecycle.FMLClientSetupEvent;
import net.minecraftforge.fml.event.lifecycle.FMLCommonSetupEvent;
import net.minecraftforge.fml.javafmlmod.FMLJavaModLoadingContext;
import net.minecraftforge.registries.ForgeRegistry;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

@Mod(NamuMain.MODID)
public class NamuMain
{
	public static NamuMain instance;
	public static final String MODID = "modnamu";
	private static final Logger LOGGER = LogManager.getLogger();
	
	// 생략...
	
	@Mod.EventBusSubscriber(bus = Mod.EventBusSubscriber.Bus.MOD)
	public static class RegistryEvents
	{
		private static final Logger LOGGER_REG = LogManager.getLogger();
		
		@SubscribeEvent
		public static void registerBlocks(final RegistryEvent.Register<Block> event)
		{
			LOGGER_REG.info(ForgeRegistry.REGISTRIES, "Blocks registered");
		}
	}
}

#!syntax java
public static final Block NAMU_BLOCK = new Block(Block.Properties.create(Material.ROCK)).setRegistryName(MODID, "namu_block");

#!syntax java
public static final Block NAMU_BLOCK = new Block(Block.Properties.create(Material.ROCK)
				.hardnessAndResistance(2.5f, 3.5f)){
			@Override
			public ToolType getHarvestTool(BlockState state)
			{
				return ToolType.PICKAXE;
			}
			
			@Override
			public int getHarvestLevel(BlockState state)
			{
				return 1;
			}
		}.setRegistryName(MODID, "namu_block");

#!syntax java
		public static final Item NAMU_BLOCK_ITEM = new BlockItem(NAMU_BLOCK, new Item.Properties().group(ItemGroup.BUILDING_BLOCKS))
				.setRegistryName(NAMU_BLOCK.getRegistryName());

#!syntax java
package wiki.namu.mymod;

import net.minecraft.block.Block;
import net.minecraft.block.BlockState;
import net.minecraft.block.material.Material;
import net.minecraft.item.BlockItem;
import net.minecraft.item.Item;
import net.minecraft.item.ItemGroup;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.common.ToolType;
import net.minecraftforge.event.RegistryEvent;
import net.minecraftforge.eventbus.api.SubscribeEvent;
import net.minecraftforge.fml.Logging;
import net.minecraftforge.fml.common.Mod;
import net.minecraftforge.fml.event.lifecycle.FMLClientSetupEvent;
import net.minecraftforge.fml.event.lifecycle.FMLCommonSetupEvent;
import net.minecraftforge.fml.javafmlmod.FMLJavaModLoadingContext;
import net.minecraftforge.registries.ForgeRegistry;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

@Mod(NamuMain.MODID)
public class NamuMain
{
	public static NamuMain instance;
	public static final String MODID = "modnamu";
	private static final Logger LOGGER = LogManager.getLogger();
	
	public NamuMain()
	{
		instance = this;
		
		FMLJavaModLoadingContext.get().getModEventBus().addListener(this::setup);
		FMLJavaModLoadingContext.get().getModEventBus().addListener(this::clientRegistries);
		
		MinecraftForge.EVENT_BUS.register(this);
	}
	
	private void setup(final FMLCommonSetupEvent event)
	{
		LOGGER.info(Logging.LOADING, "Setup method registered");
	}
	
	private void clientRegistries(final FMLClientSetupEvent event)
	{
		LOGGER.info(Logging.LOADING, "Client setup method registered");
	}
	
	@Mod.EventBusSubscriber(bus = Mod.EventBusSubscriber.Bus.MOD)
	public static class RegistryEvents
	{
		private static final Logger LOGGER_REG = LogManager.getLogger();
		
		public static final Block NAMU_BLOCK = new Block(Block.Properties.create(Material.ROCK)
				.hardnessAndResistance(2.5f, 3.5f)){
			@Override
			public ToolType getHarvestTool(BlockState state)
			{
				return ToolType.PICKAXE;
			}
			
			@Override
			public int getHarvestLevel(BlockState state)
			{
				return 1;
			}
		}.setRegistryName(MODID, "namu_block");
		
		public static final Item NAMU_BLOCK_ITEM = new BlockItem(NAMU_BLOCK, new Item.Properties().group(ItemGroup.BUILDING_BLOCKS))
				.setRegistryName(NAMU_BLOCK.getRegistryName());
		
		@SubscribeEvent
		public static void registerItems(final RegistryEvent.Register<Item> event)
		{
			event.getRegistry().registerAll(
					NAMU_BLOCK_ITEM
			);
			LOGGER_REG.info(ForgeRegistry.REGISTRIES, "Items registered");
		}
		
		@SubscribeEvent
		public static void registerBlocks(final RegistryEvent.Register<Block> event)
		{
			event.getRegistry().registerAll(
					NAMU_BLOCK
			);
			LOGGER_REG.info(ForgeRegistry.REGISTRIES, "Blocks registered");
		}
	}
}

#!syntax json
{
  "parent": "block/cube_all",
  "textures": {
    "all": "modnamu:block/namu_block"
  }
}

#!syntax json
{
  "parent": "modnamu:block/namu_block"
}

#!syntax json
{
  "variants": {
    "": {
      "model": "modnamu:block/namu_block"
    }
  }
}

#!syntax json
{
  "type": "minecraft:block",
  "pools": [
    {
      "rolls": 1,
      "entries": [
        {
          "type": "minecraft:item",
          "name": "modnamu:namu_block"
        }
      ],
      "conditions": [
        {
          "condition": "minecraft:survives_explosion"
        }
      ]
    }
  ]
}

#!syntax json
"rolls": {
  "min": 1,
  "max": 6
}

#!syntax json
{
  "block.modnamu.namu_block": "Namu Block"
}

7.1. 나무 만들기

#!syntax java
public static final Block NAMU_LOG = new LogBlock(MaterialColor.DIAMOND, Block.Properties.create(Material.WOOD, MaterialColor.CLAY).hardnessAndResistance(2.0F).sound(SoundType.WOOD))
		.setRegistryName(MODID, "namu_log");
public static final Block NAMU_LEAVES = new LeavesBlock(Block.Properties.create(Material.LEAVES).hardnessAndResistance(0.2F).tickRandomly().sound(SoundType.PLANT))
		.setRegistryName(MODID, "namu_leaves");

#!syntax json
{
  "parent": "block/leaves",
  "textures": {
    "all": "modnamu:block/namu_leaves"
  }
}

#!syntax json
{
  "parent": "block/cube_column",
  "textures": {
    "end": "modnamu:block/namu_log_top",
    "side": "modnamu:block/namu_log"
  }
}

#!syntax json
{
  "variants": {
    "": {
      "model": "modnamu:block/namu_leaves"
    }
  }
}

#!syntax java
{
  "variants": {
    "axis=y": {
      "model": "modnamu:block/namu_log"
    },
    "axis=z": {
      "model": "modnamu:block/namu_log",
      "x": 90
    },
    "axis=x": {
      "model": "modnamu:block/namu_log",
      "x": 90,
      "y": 90
    }
  }
}

#!syntax java
AbstractTreeFeature<NoFeatureConfig> getTreeFeature(Random random)

#!syntax java
boolean place(Set<BlockPos> changedBlocks, IWorldGenerationReader worldIn, Random rand, BlockPos position, MutableBoundingBox box)

#!syntax java
package wiki.namu.mymod.world.gen;

import com.mojang.datafixers.Dynamic;
import net.minecraft.block.BlockState;
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.math.MutableBoundingBox;
import net.minecraft.world.gen.IWorldGenerationReader;
import net.minecraft.world.gen.feature.AbstractTreeFeature;
import net.minecraft.world.gen.feature.NoFeatureConfig;
import net.minecraftforge.common.IPlantable;
import wiki.namu.mymod.NamuMain;
import java.util.Random;
import java.util.Set;
import java.util.function.Function;

public class NamuTreeFeature extends AbstractTreeFeature<NoFeatureConfig>
{
	private static final BlockState LOG = NamuMain.RegistryEvents.NAMU_LOG.getDefaultState();
	private static final BlockState LEAF = NamuMain.RegistryEvents.NAMU_LEAVES.getDefaultState();
	private static final int minimumHeight = 5;
	
	public NamuTreeFeature(Function<Dynamic<?>, ? extends NoFeatureConfig> deserializeFunction, boolean doBlockNofityOnPlace)
	{
		super(deserializeFunction, doBlockNofityOnPlace);
	}
	
	@Override
	public boolean place(Set<BlockPos> changedBlocks, IWorldGenerationReader worldIn, Random rand, BlockPos position, MutableBoundingBox box)
	{
		int height = minimumHeight + rand.nextInt(4);
		boolean place = true;
		
		// 생성 위치가 블록 설치 가능 범위 내에 있는지 확인
		if(position.getY() >= 1 && position.getY() + height + 1 <= worldIn.getMaxHeight())
		{
			// 주변에 충분한 공간이 있는지 확인
			for(int y = position.getY(); y <= position.getY() + height + 1; y++)
			{
				int margin = 1;
				if(y == position.getY())
					margin = 0;
				if(y >= position.getY() + height + 1 - 2)
					margin = 2;
				
				BlockPos.MutableBlockPos marginPos = new BlockPos.MutableBlockPos();
				for(int x = position.getX() - margin; x <= position.getX() + margin; x++)
					for(int z = position.getZ() - margin; z <= position.getZ() + margin; z++)
						if(!func_214587_a(worldIn, marginPos.setPos(x, y, z))) // 해당 위치의 블록이 공기거나 나무가 자랄 수 있는 블록인지 확인
							place = false;
			}
			
			if(!place)
				return false;
			else if(isSoil(worldIn, position.down(), getSapling()) && position.getY() + height + 1 < worldIn.getMaxHeight())
			{
				// 나무 생성
				setDirtAt(worldIn, position.down(), position);
				int[] widths = {1, 2, 2, 3};
				
				for(int y = position.getY() + height - 3; y <= position.getY() + height; y++)
				{
					int relY = y - position.getY() - height;
					int width = widths[Math.abs(relY)];
					for(int x = position.getX() - width; x <= position.getX() + width; x++)
					{
						int relX = x - position.getX();
						for(int z = position.getZ() - width; z <= position.getZ() + width; z++)
						{
							int relZ = z - position.getZ();
							if(Math.abs(relX) != width || Math.abs(relZ) != width || (rand.nextInt(2) != 0 && relY != 0))
							{
								BlockPos placePos = new BlockPos(x, y, z);
								if(isAirOrLeaves(worldIn, placePos))
									setLogState(changedBlocks, worldIn, placePos, LEAF, box);
							}
						}
					}
				}
				
				for(int y = 0; y < height; y++)
				{
					if(isAirOrLeaves(worldIn, position.up(y)))
						setLogState(changedBlocks, worldIn, position.up(y), LOG, box);
				}
				
				return true;
			}
			else
				return false;
		}
		else
			return false;
	}
}

static boolean func_214587_a(IWorldGenerationBaseReader p_214587_0_, BlockPos p_214587_1_) : 세계 내의 해당 위치에서
나무가 생성될 수 있는지 반환하는 AbstractTreeFeature<NoFeatureConfig>의 정적 메소드다.
static boolean isSoil(IWorldGenerationBaseReader reader, BlockPos pos, net.minecraftforge.common.IPlantable sapling) :
세계 내의 해당 위치의 블록이 흙인지 확인하여 반환하는 AbstractTreeFeature<NoFeatureConfig>의 정적 메소드다.
IPlantable 인스턴스는  AbstractTreeFeature<NoFeatureConfig> 클래스의 getSapling() 인스턴스 메소드의 리턴값으로 주면 된다.
void setDirtAt(IWorldGenerationReader reader, BlockPos pos, BlockPos origin) : 해당 위치의 잔디를 흙으로 바꾼다.
이 때, pos는 바꿀 흙 블록의 위치, origin은 나무 기둥이 시작되는 위치다.
static boolean isAirOrLeaves(IWorldGenerationBaseReader p_214572_0_, BlockPos p_214572_1_) : 세계 내의 해당 위치의 블록이
공기 또는 잎인지 확인한다.
void setLogState(Set<BlockPos> changedBlocks, IWorldWriter worldIn, BlockPos p_208520_3_, BlockState p_208520_4_, MutableBoundingBox p_208520_5_) :
해당 위치의 블록을 자신이 생성할 블록으로 바꾼다.
나머지 파라미터는 place 메소드의 파라미터를 그대로 넣으면 되고, BlockPos는 생성할 블록의 위치,
BlockState는 생성할 블록의 BlockState를 넣으면 된다.

#!syntax java
package wiki.namu.mymod.block.tree;

import net.minecraft.block.trees.Tree;
import net.minecraft.world.gen.feature.AbstractTreeFeature;
import net.minecraft.world.gen.feature.NoFeatureConfig;
import wiki.namu.mymod.world.gen.NamuTreeFeature;
import java.util.Random;

public class NamuTree extends Tree
{
	@Override
	public AbstractTreeFeature<NoFeatureConfig> getTreeFeature(Random random)
	{
		return new NamuTreeFeature(NoFeatureConfig::deserialize, true);
	}
}

#!syntax java
package wiki.namu.mymod.block;

import net.minecraft.block.SaplingBlock;
import net.minecraft.block.trees.Tree;

public class ModSaplingBlock extends SaplingBlock
{
	public ModSaplingBlock(Tree tree, Properties properties)
	{
		super(tree, properties);
	}
}

#!syntax java
public static final Block NAMU_SAPLING = new ModSaplingBlock(new NamuTree(), Block.Properties.create(Material.PLANTS).doesNotBlockMovement().tickRandomly().hardnessAndResistance(0).sound(SoundType.PLANT))
		.setRegistryName(MODID, "namu_sapling");

#!syntax java
public class NamuTreeFeature extends AbstractTreeFeature<NoFeatureConfig>
{
	//...

	public NamuTreeFeature(Function<Dynamic<?>, ? extends NoFeatureConfig> deserializeFunction, boolean doBlockNofityOnPlace)
	{
		super(deserializeFunction, doBlockNofityOnPlace);
		this.setSapling((IPlantable)NamuMain.RegistryEvents.NAMU_SAPLING);
	}
        //...

}

#!syntax json
{
  "parent": "block/cross",
  "textures": {
    "cross": "modnamu:block/namu_sapling"
  }
}

#!syntax json
{
  "variants": {
    "": {
      "model": "modnamu:block/namu_sapling"
    }
  }
}

#!syntax json
{
  "replace": false,
  "values": [
    "modnamu:namu_leaves"
  ]
}

#!syntax json
{
  "replace": false,
  "values": [
    "modnamu:namu_log"
  ]
}

7.2. 유체 블록 만들기

#!syntax java
package wiki.bluesky.common.fluids;

/**
* 이 클래스는 Fluid 클래스를 상속받아 만들어졌으며, 유체의 개념과 특성을 정의할 수 있습니다.
* 이 클래스의 변수들은 기본적으로 마인크래프트 물의 값을 Default로 갖습니다.
* @Author Estiv
*/

import net.minecraftforge.fluids.Fluid; // 나무즙 클래스의 부모 클래스가 될 Fluid 클래스

public class FluidNamuJuice extends Fluid {

       FluidNamuJuice() {
              super("NamuJuice");  //  Fluid 클래스의 생성자의 인자는 'String fluidName' 이며, 액체의 이름(UnlocalizedName)을 결정짓는다.
       }

       setDensity(1000); // 액체의 밀도를 정의하는 함수, 마인크래프트 물의 밀도는 1000의 값을 갖는다. 단위는 킬로그램/세제곱미터이다. 음수를 입력할 경우 공기보다 가벼운 것으로 처리된다. 
       setTemperature(295); // 유체의 온도를 정의하는 함수, 기본 295의 값을 갖는다. 켈빈 온도이므로 설정하기 원하는 온도에 273을 더해야 한다.  (예: 액체 온도가 100℃면 373K 이다.)
       setLuminosity(0); // 유체가 얼마나 빛을 발산하는가를 정의하는 함수, 기본 0의 값을 가지며 0~15사이의 값이 유효하다.
       setViscosity(1000); // 유체의 점성을 정의하는 함수, 확산 속도에 영향을 주며 기본 1000의 값을 갖는다.

       setGaseous(false); // 유체가 액체인지, 기체인지를 결정짓는 함수. true를 입력할 경우 유체는 위로 솟는 기체의 특성을 갖게되며, 기본 false의 값을 갖는다.

}

#!syntax java
package wiki.namu.mymod;

import cpw.mods.fml.common.event.FMLInitializationEvent;
import net.minecraftforge.fluids.Fluid;
import net.minecraftforge.fluids.FluidRegistry;

public class CommonProxyClass {

       public void init(FMLInitializationEvent event) {
              Fluid namuJuice = new FluidNamuJuice();
              FluidRegistry.registerFluid(namuJuice); // 자신이 만든 새로운 Fluid를 등록시키는 메소드이다.
       }
}

#!syntax java
package wiki.namu.mymod.common.blocks;

/**
* 이 블록은 현재 지정된 Texture가 없습니다.
* @Author Estiv
*/

import net.minecraftforge.fluids.BlockFluidClassic; // 유체 블록 클래스의 부모가 되는 클래스.
import net.minecraftforge.fluids.Fluid;
import net.minecraft.block.material.Material;

public class BlockFluidNamuJuice extends BlockFluidClassic {
       BlockFluidNamuJuice(Fluid fluid) {
              super(fluid, Material.water); // 유체 블록의 생성자. 요구 인자는 Fluid, Material 인스턴스이며, Material은 블록의 기본 재질을 결정한다.
       }
}

#!syntax java
package wiki.namu.mymod;

import cpw.mods.fml.common.event.FMLInitializationEvent;
import cpw.mods.fml.common.registry.GameRegistry;

import net.minecraftforge.fluids.Fluid;
import net.minecraftforge.fluids.FluidRegistry; // 유체는 별도의 레지스트리를 가지므로 import로 따로 호출해준다.
import net.minecraft.block.Block;

import wiki.namu.mymod.common.blocks.BlockFluidNamuJuice;

public class CommonProxyClass {

       public void init(FMLInitializationEvent event) {
              Fluid namuJuice = new FluidNamuJuice();
              FluidRegistry.registerFluid(namuJuice);  // 나무즙 유체 추가

              Block blockNamuJuice = new BlockFluidNamuJuice(namuJuice);
              GameRegistry.registerBlock(blockNamuJuice, "blockNamuJuice"); // 나무즙 유체 *블록* 추가 
       }
}

7.2.1. 유체 컨테이너 만들기

7.3. 블록 엔티티 추가

7.3.1. 블록 구현

7.3.2. 블록 엔티티 구현

7.3.3. 컨테이너 추가

7.3.4. GUI 추가

7.3.5. 텍스처 추가

7.3.6. 전력(포지 에너지) 추가

8. 크리에이티브 탭 만들기

#!syntax java
CreativeTabs tabs = new CreativeTabs("tab Namu") {
		public Item getTabIconItem() {
			return Items.bed;
			 //아이콘을 블록으로 하고 싶다면 Item.getItemFromBlock 함수를 통해 블록을 아이템으로 변경 후 리턴하면 된다.
		}
	};

#!syntax java
package wiki.namu.mymod.item;

import net.minecraft.item.ItemGroup;
import net.minecraft.item.ItemStack;
import wiki.namu.mymod.NamuMain;

public final class NamuItemGroups
{
	private NamuItemGroups() {}
	
	public static final ItemGroup NAMU = new ItemGroup("namu") {
		@Override
		public ItemStack createIcon() { return new ItemStack(NamuMain.RegistryEvents.NAMU_BLOCK); }
	};
}

#!syntax json
{
  "block.modnamu.namu_block": "Namu Block",
  "itemGroup.namu": "Namu"
}

#!syntax java
public static final Item NAMU_BLOCK_ITEM = new BlockItem(NAMU_BLOCK, new Item.Properties().group(NamuItemGroups.NAMU))
				.setRegistryName(NAMU_BLOCK.getRegistryName());

9. 아이템 만들기

#!syntax java
public class EGTItem extends Item{
     public EGTItem(String name) {
		this.setUnlocalizedName(name);
		this.setRegistryName(name);
		
	}
}

10. 인챈트 만들기

#!syntax java
protected Enchantment(Enchantment.Rarity rarityIn, EnchantmentType typeIn, EquipmentSlotType[] slots)

Enchantment.Rarity : 인챈트의 레어도로, 인챈트가 등장할 확률을 정해준다. COMMON, UNCOMMON, RARE, VERY_RARE의 네가지 레어도가 있다.
EnchantmentType : 마법 부여대에서 해당 인챈트를 할 수 있는 아이템의 종류를 정해준다.
EquipmentSlotType : 해당 인챈트를 할 수 있는 장비를 장착할 수 있는 슬롯을 정해준다. 총 6개의 슬롯 타입이 있다.
    - MAINHAND : 오른손에 들 수 있는 아이템이다.
    - OFFHAND : 왼손에 들 수 있는 아이템이다. 거의 쓸 일은 없다고 보면 된다.
    - FEET : 발에 낄 수 있는 아이템이다.
    - LEGS : 다리에 낄 수 있는 아이템이다.
    - CHEST : 몸통에 낄 수 있는 아이템이다.
    - HEAD : 머리에 낄 수 있는 아이템이다.

int getMinLevel() : 인챈트의 최소 레벨을 리턴한다. 기본값은 1이다. 웬만해서는 오버라이드하여 바꿀 필요가 없다.
int getMaxLevel() : 인챈트의 최대 레벨을 리턴한다. 기본값은 1이다.
int getMinEnchantability(int enchantmentLevel) : 각 인챈트 레벨마다 필요한 최소 플레이어 레벨을 리턴한다. 기본값은 레벨*10+1이다.
int func_223551_b(int p_223551_1_) : 이름이 이상하게 되어있지만 getMaxEnchantability라고 보면 된다. 각 인챈트 레벨마다 필요한
최대 플레이어 레벨을 리턴한다. 기본값은 최소값+5 이다.
int calcModifierDamage(int level, DamageSource source) : 해당 인챈트가 적용된 장비를 장착하고 있을 때, 인챈트 레벨에 따른
플레이어가 받는 데미지 감소량을 리턴한다. DamageSource 종류에 따라 서로 다른 값을 리턴할 수 있으며, 데미지 감소량은 리턴값*4%이다.
float calcDamageByCreature(int level, CreatureAttribute creatureType) : 해당 인챈트가 적용된 장비로 다른 몹이나 플레이어를 때렸을
때 들어가는 추가 데미지를 리턴한다.
boolean canApplyTogether(Enchantment ench) : 파라미터로 전달받은 인챈트를 해당 인챈트와 함께 적용할 수 있는지 리턴한다. 예를
들어 활의 무한 인챈트와 수선 인챈트는 함께 적용할 수 없으므로 무한 인챈트의 구현 클래스인 InfinityEnchantment의 해당 메소드는 수선
인챈트를 파라미터로 받았을 때 false를 리턴한다.
boolean canApply(ItemStack stack) : 파라미터로 받은 아이템 스택 내의 아이템에 해당 인챈트를 모루에서 적용할 수 있는지 리턴한다.
예를 들어 날카로움은 마법 부여대에서 도끼에 적용할 수 없지만 모루에서는 적용할 수 있다. 따라서 해당 인챈트 클래스의 canApply 메소드는
AxeItem을 상속하는 아이템을 가지는 ItemStack 인스턴스를 받았을 때 true를 리턴한다.
void onEntityDamaged(LivingEntity user, Entity target, int level) : 해당 인챈트가 적용된 아이템을 사용한 user가 target에게
데미지를 입혔을 때 자동으로 호출되는 메소드다. 주의할 점은, 활로 화살을 쏘아 맞춘 경우 활로 '직접' 때린 것이 아니기 때문에
이 메소드가 호출되지 않는다.
void onUserHurt(LivingEntity user, Entity attacker, int level) : 해당 인챈트가 적용된 아이템을 장비한 user가 attacker에게
데미지를 받았을 때 자동으로 호출되는 메소드다.
boolean isTreasureEnchantment() : 해당 인챈트가 수선, 차가운 걸음과 같이 마법 부여대에서 뜨지 않는 보물 마법부여인지 리턴한다.
boolean isCurse() : 해당 인챈트가 귀속 저주, 소실 저주와 같이 마법 부여대에서 뜨지 않는 저주 마법부여인지 리턴한다.

#!syntax java
package wiki.namu.mymod.enchantment;

import net.minecraft.enchantment.Enchantment;
import net.minecraft.enchantment.EnchantmentType;
import net.minecraft.enchantment.Enchantments;
import net.minecraft.entity.Entity;
import net.minecraft.entity.LivingEntity;
import net.minecraft.inventory.EquipmentSlotType;
import net.minecraft.item.AxeItem;
import net.minecraft.item.ItemStack;
import net.minecraft.potion.EffectInstance;
import net.minecraft.potion.Effects;

public class FrostEnchantment extends Enchantment
{
	public FrostEnchantment(Rarity rarityIn, EquipmentSlotType... slots)
	{
		super(rarityIn, EnchantmentType.WEAPON, slots);
	}

	@Override
	public int getMaxLevel()
	{
		return 3;
	}
	
	@Override
	public int getMinEnchantability(int enchantmentLevel)
	{
		return 5 + 7 * enchantmentLevel;
	}
	
	@Override
	public int func_223551_b(int enchantmentLevel) //getMaxEnchantability 기본값은 min + 5
	{
		return getMinEnchantability(enchantmentLevel) + 10;
	}
	
	@Override
	public boolean canApplyTogether(Enchantment ench) //발화 인챈트와 함께 걸 수 없다
	{
		return super.canApplyTogether(ench) && ench != Enchantments.FIRE_ASPECT;
	}
	
	@Override
	public boolean canApply(ItemStack stack)
	{
		return stack.getItem() instanceof AxeItem;
	}
	
	@Override
	public void onEntityDamaged(LivingEntity user, Entity target, int level)
	{
		if(target instanceof  LivingEntity)
		{
			((LivingEntity)target).addPotionEffect(
					new EffectInstance(Effects.SLOWNESS, 20 * 2 * level, level - 1)
			);
		}
		super.onEntityDamaged(user, target, level);
	}
}

#!syntax java
package wiki.namu.mymod.enchantment;

import net.minecraft.enchantment.Enchantment;
import net.minecraft.enchantment.EnchantmentHelper;
import net.minecraft.enchantment.EnchantmentType;
import net.minecraft.entity.LivingEntity;
import net.minecraft.entity.projectile.AbstractArrowEntity;
import net.minecraft.entity.projectile.ArrowEntity;
import net.minecraft.inventory.EquipmentSlotType;
import net.minecraft.item.BowItem;
import net.minecraft.item.CrossbowItem;
import net.minecraft.item.ItemStack;
import net.minecraft.potion.EffectInstance;
import net.minecraft.potion.Effects;
import net.minecraftforge.event.entity.EntityJoinWorldEvent;
import net.minecraftforge.eventbus.api.SubscribeEvent;
import net.minecraftforge.fml.common.Mod;
import wiki.namu.mymod.NamuMain;

@Mod.EventBusSubscriber(modid = NamuMain.MODID, bus = Mod.EventBusSubscriber.Bus.FORGE)
public class WithersArrowEnchantment extends Enchantment
{
	public WithersArrowEnchantment(Rarity rarityIn, EquipmentSlotType... slots)
	{
		super(rarityIn, EnchantmentType.BOW, slots);
	}
	
	@Override
	public Rarity getRarity()
	{
		return Rarity.VERY_RARE;
	}
	
	@Override
	public int getMaxLevel()
	{
		return 2;
	}
	
	@Override
	public int getMinEnchantability(int enchantmentLevel)
	{
		return enchantmentLevel * 30;
	}
	
	@Override
	public int func_223551_b(int enchantmentLevel) //getMaxEnchantability
	{
		return getMinEnchantability(enchantmentLevel) + 50;
	}
	
	@Override
	public boolean isTreasureEnchantment()
	{
		return true;
	}
	
	@SubscribeEvent
	public static void onEntityJoinWorld(EntityJoinWorldEvent event)
	{
		if(!(event.getEntity() instanceof ArrowEntity))
			return;
		
		ArrowEntity arrow = (ArrowEntity)event.getEntity();
		if(!(arrow.getShooter() instanceof LivingEntity))
			return;
		
		LivingEntity shooter = (LivingEntity)arrow.getShooter();
		ItemStack heldOnMainHand = shooter.getHeldItemMainhand();
		ItemStack heldOnOffHand = shooter.getHeldItemOffhand();
		int levelOnMainHand = EnchantmentHelper.getEnchantmentLevel(NamuMain.RegistryEvents.WITHERS_ARROW, heldOnMainHand);
		int levelOnOffHand = EnchantmentHelper.getEnchantmentLevel(NamuMain.RegistryEvents.WITHERS_ARROW, heldOnOffHand);
		int level = 0;
		
		if(heldOnMainHand.getItem() instanceof CrossbowItem)
			return;
		
		if(heldOnMainHand.getItem() instanceof BowItem)
		{
			if(levelOnMainHand <= 0)
				return;
			level = levelOnMainHand;
		}
		else if(heldOnOffHand.getItem() instanceof BowItem)
		{
			if(levelOnOffHand <= 0)
				return;
			level = levelOnOffHand;
		}
		
		if(level <= 0)
			return;
		arrow.addEffect(new EffectInstance(Effects.WITHER, 20 * (4 * level + 1), 1));
		arrow.pickupStatus = AbstractArrowEntity.PickupStatus.DISALLOWED;
	}
}

#!syntax java
public static final Enchantment FROST = new FrostEnchantment(Enchantment.Rarity.RARE, EquipmentSlotType.MAINHAND)
				.setRegistryName(MODID, "frost");
public static final Enchantment WITHERS_ARROW = new WithersArrowEnchantment(Enchantment.Rarity.VERY_RARE, EquipmentSlotType.MAINHAND)
				.setRegistryName(MODID, "withers_arrow");

#!syntax java
@SubscribeEvent
public static void registerEnchantments(final RegistryEvent.Register<Enchantment> event)
{
	event.getRegistry().registerAll(
			FROST,
			WITHERS_ARROW
	);
	LOGGER_REG.info(ForgeRegistry.REGISTRIES, "Enchantments registered");
}

#!syntax json
{
  ...
  "enchantment.modnamu.frost": "Frost",
  "enchantment.modnamu.withers_arrow": "Wither's Arrow"
}

11. 상태이상(포션 효과 추가)

12. 키 바인딩(조작키 추가)

#!syntax java
public KeyBinding(String description, int keyCode, String category)

description : 키가 눌렸을 때 어떤 일을 수행하는지 알려준다.
다른 모드와의 중복을 피하기 위해 <모드 아이디>.key.<이름>으로 짓는 것이 좋다.
이름은 다른 오브젝트의 이름과 마찬가지로 소문자와 언더바를 사용한다.
keyCode : 해당하는 키의 코드이다. org.lwjgl.glfw 패키지 내의 GLFW 클래스에 정의되어 있는 것을 사용한다.
category : 해당 키 바인딩의 카테고리이다.
같은 카테고리를 가진 키 바인딩은 마인크래프트 설정 내에서 같은 카테고리에 묶이게 된다.
key.categories.<모드 아이디>.<세부 카테고리>로 짓는 것이 좋다.

#!syntax java
import net.minecraft.client.settings.KeyBinding;

import static wiki.namu.mymod.NamuMain.MODID;
import static org.lwjgl.glfw.GLFW.*;

//...

public static final KeyBinding SET_SPAWN = new KeyBinding(MODID + ".key.set_spawn", GLFW_KEY_J, "key.categories." + MODID);

#!syntax java
public static final KeyBinding KILL = new KeyBinding(MODID + ".key.kill", GLFW_KEY_K, "key.categories." + MODID);

#!syntax java
private void clientRegistries(final FMLClientSetupEvent event)
{
	LOGGER.info(Logging.LOADING, "Client setup method registered");
	ClientRegistry.registerKeyBinding(SET_SPAWN);
	ClientRegistry.registerKeyBinding(KILL);
}

#!syntax java
package wiki.namu.mymod.input;

import net.minecraft.client.settings.KeyBinding;
import net.minecraftforge.api.distmarker.Dist;
import net.minecraftforge.api.distmarker.OnlyIn;
import net.minecraftforge.client.event.InputEvent;
import net.minecraftforge.eventbus.api.SubscribeEvent;
import net.minecraftforge.fml.common.Mod;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.Marker;
import org.apache.logging.log4j.MarkerManager;
import wiki.namu.mymod.NamuMain;

import static wiki.namu.mymod.input.NamuKeyBindng.SET_SPAWN;
import static wiki.namu.mymod.input.NamuKeyBindng.KILL;

@Mod.EventBusSubscriber(modid = NamuMain.MODID, bus = Mod.EventBusSubscriber.Bus.FORGE)
public class NamuKeyInputHandler
{
	public static final Logger LOGGER = LogManager.getLogger();
	public static final Marker INPUT = MarkerManager.getMarker("INPUT");
	
	@OnlyIn(Dist.CLIENT)
	@SubscribeEvent(receiveCanceled = true)
	public static void onKeyInput(InputEvent.KeyInputEvent event)
	{
		if(SET_SPAWN.isPressed())
		{
			LOGGER.debug(INPUT, "Key binding = " + SET_SPAWN.getKeyDescription());
			// 해당하는 키가 눌렸을 때 수행할 작업을 여기에 작성
			// 명령어 수행 등 서버 사이드에서 수행되어야 할 작업은 서버에 패킷을 보내서 수행
		}
		if(KILL.isPressed())
		{
			LOGGER.debug(INPUT, "Key binding = " + KILL.getKeyDescription());
		}
	}
}

#!syntax json
{
  "key.categories.modnamu": "Namu Mod",
  "modnamu.key.set_spawn": "Set Spawnpoint",
  "modnamu.key.kill": "Suicide"
}

[23:29:12.030] [Client thread/DEBUG] [wi.na.my.in.NamuKeyInputHandler/INPUT]: Key binding = modnamu.key.set_spawn
[23:29:13.013] [Client thread/DEBUG] [wi.na.my.in.NamuKeyInputHandler/INPUT]: Key binding = modnamu.key.kill

13. 월드 생성 추가

13.1. 광물 생성

#!syntax java
void addFeature(GenerationStage.Decoration decorationStage, ConfiguredFeature<?> featureIn)

decorationStage : 해당 바이옴 특성의 종류를 나타낸다.
광물 생성의 경우 GenerationStage.Decoration.UNDERGROUND_ORES를 사용한다.
featureIn : 해당 바이옴 특성의 설정이다.
직접 ConfiguredFeature 클래스를 인스턴스화 할 수도 있지만 Biome.createDecoratedFeature() 메소드로 만드는 것이 편하다

#!syntax java
static <F extends IFeatureConfig, D extends IPlacementConfig> ConfiguredFeature<?> createDecoratedFeature(Feature<F> featureIn, F config, Placement<D> placementIn, D placementConfig)

featureIn : 해당 특성이 생성할 것을 나타낸다.
일반적인 광물의 경우 Feature.ORE을 사용한다(예외적으로, 에메랄드는 Feature.EMERALD_ORE 사용).
config : 해당 특성이 생성할 오브젝트와 생성 위치 등을 설정한다.
일반적인 광물의 경우 OreFeatureConfig 인스턴스를 사용한다.
placementIn : 해당 특성이 생성할 오브젝트의 분포를 나타낸다.
Placement 클래스 내에 여러가지 분포가 정의되어 있으며, 바닐라 광물은 청금석과 에메랄드를 제외하면 Placement.COUNT_RANGE를 사용한다.
placementConfig : 오브젝트의 분포 설정이다. 일반적으로 광물은 CountRangeConfig 인스턴스를 사용한다.

#!syntax java
OreFeatureConfig(OreFeatureConfig.FillerBlockType target, BlockState state, int size)

target : 광물이 제거하고 대신 생성될 블록의 타입이다.
돌을 의미하는 NATURAL_STONE과 네더랙을 의미하는 NETHERRACK 두가지 타입이 있으며, 무슨 이유에서인지 아직 엔드 돌은 없다.
state : 생성할 광물 블록의 BlockState다. 해당 블록의 getDefaultState() 메소드를 사용하여 얻는다.
size : 한 번에 생성할 광물의 최대 개수이다.

#!syntax java
CountRangeConfig(int count, int bottomOffset, int topOffset, int maximum)

count : 한 청크 내에서 광물 생성을 시도할 횟수이다.
bottomOffset : 광물이 생성될 최소 y 좌표와 비슷한 의미이다. 하지만 완전히 일치하지는 않는데, 그 이유는 광물 생성 알고리즘에서 설명한다.
topOffset : 광물이 생성될 최대 y 좌표의 감소량이다. 이 역시 정확한 의미는 광물 생성 알고리즘에서 설명한다.
maximum : 광물이 생성될 y 좌표의 범위이다. 실제로는 maximum - topOffset 만큼의 범위에서 생성된다.

#!syntax java
package wiki.namu.mymod.world;

import net.minecraft.world.biome.Biome;
import net.minecraft.world.gen.GenerationStage;
import net.minecraft.world.gen.feature.Feature;
import net.minecraft.world.gen.feature.OreFeatureConfig;
import net.minecraft.world.gen.placement.CountRangeConfig;
import net.minecraft.world.gen.placement.Placement;
import net.minecraftforge.fml.Logging;
import net.minecraftforge.registries.ForgeRegistries;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import wiki.namu.mymod.NamuMain;

public class NamuOreGeneration
{
	private static final Logger LOGGER = LogManager.getLogger();
	
	public static void init()
	{
		ForgeRegistries.BIOMES.forEach(biome → {
			biome.addFeature(
					GenerationStage.Decoration.UNDERGROUND_ORES,
					Biome.createDecoratedFeature(
							Feature.ORE,
							new OreFeatureConfig(OreFeatureConfig.FillerBlockType.NATURAL_STONE, NamuMain.RegistryEvents.NAMU_BLOCK.getDefaultState(), 15),
							Placement.COUNT_RANGE,
							new CountRangeConfig(20, 1, 0, 64)
					)
			);
			LOGGER.debug(Logging.LOADING, "Additional ore generation of block "
					+ NamuMain.RegistryEvents.NAMU_BLOCK.getRegistryName().toString() + " in biome "
					+ biome.getRegistryName().toString() + " is registered");
		});
	}
}

#!syntax java
public Stream<BlockPos> func_212852_a_(Random p_212852_1_, CountRangeConfig p_212852_2_, BlockPos p_212852_3_) {
   return IntStream.range(0, p_212852_2_.count).mapToObj((p_215061_3_) → {
      int i = p_212852_1_.nextInt(16);
      int j = p_212852_1_.nextInt(p_212852_2_.maximum - p_212852_2_.topOffset) + p_212852_2_.bottomOffset;
      int k = p_212852_1_.nextInt(16);
      return p_212852_3_.add(i, j, k);
   });
}

COUNT_RANGE : 일반적으로 광물 생성에 사용되며, 범위 사이에서 y 좌표에 따라 거의 균일하게 생성된다.
COUNT_BIASED_RANGE : 범위 사이에서 y 좌표가 낮아질 수록 생성 빈도가 높아진다.
COUNT_VERY_BIASED_RANGE : 범위 사이에서 y 좌표가 낮아질 수록 생성 빈도가 매우 높아진다.
RANDOM_COUNT_RANGE : COUNT_RANGE와 비슷하지만 한 청크당 생성 시도 횟수가 랜덤으로 결정된다.
따라서 운이 없으면 그 청크 내에 광물이 생성되지 않을 수도 있다.

#!syntax java
private void setup(final FMLCommonSetupEvent event)
{
	LOGGER.info(Logging.LOADING, "Setup method registered");
	NamuOreGeneration.init();
}

13.1.1. 사용자 정의 광물 배치 패턴 설정

#!syntax java
<T> Dynamic<T> serialize(DynamicOps<T> p_214719_1_)

#!syntax java
Dynamic(final DynamicOps<T> ops, @Nullable final T value)

#!syntax java
package wiki.namu.mymod.world.placement;

import com.google.common.collect.ImmutableMap;
import com.mojang.datafixers.Dynamic;
import com.mojang.datafixers.types.DynamicOps;
import net.minecraft.world.gen.placement.IPlacementConfig;

public class CamelPlacementConfig implements IPlacementConfig
{
	public final int count; //한 청크 당 생성 시도 횟수
	public final int lowerControlLine; //아래쪽 기준선
	public final int upperControlLine; //위쪽 기준선
	public final int lowerWidth; //아래쪽 기준선을 중심으로 양쪽으로 광물을 생성할 범위
	public final int upperWidth; //위쪽 기준선을 중심으로 양쪽으로 광물을 생성할 범위
	
	public CamelPlacementConfig(int count, int lowerControlLine, int upperControlLine, int lowerWidth, int upperWidth)
	{
		this.count = count;
		this.lowerControlLine = lowerControlLine;
		this.upperControlLine = upperControlLine;
		this.lowerWidth = lowerWidth;
		this.upperWidth = upperWidth;
	}
	
	@Override
	public <T> Dynamic<T> serialize(DynamicOps<T> ops)
	{
		return new Dynamic<>(ops, ops.createMap(ImmutableMap.of(
				ops.createString("count"), ops.createInt(count),
				ops.createString("lower_control_line"), ops.createInt(lowerControlLine),
				ops.createString("upper_control_line"), ops.createInt(upperControlLine),
				ops.createString("lower_width"), ops.createInt(lowerWidth),
				ops.createString("upper_width"), ops.createInt(upperWidth))));
	}
}

#!syntax java
public static CamelPlacementConfig deserialize(Dynamic<?> dynamic)
{
	int count = dynamic.get("count").asInt(0);
	int lowerControlLine = dynamic.get("lower_control_line").asInt(0);
	int upperControlLine = dynamic.get("upper_control_line").asInt(0);
	int lowerWidth = dynamic.get("lower_width").asInt(0);
	int upperWidth = dynamic.get("upper_width").asInt(0);
	return new CamelPlacementConfig(count, lowerControlLine, upperControlLine, lowerWidth, upperWidth);
}

#!syntax java
Stream<BlockPos> func_212852_a_(Random p_212852_1_, DC p_212852_2_, BlockPos p_212852_3_)

#!syntax java
package wiki.namu.mymod.world.placement;

import com.mojang.datafixers.Dynamic;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.gen.placement.SimplePlacement;

import java.util.Random;
import java.util.function.Function;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class CamelPlacement extends SimplePlacement<CamelPlacementConfig>
{
	public CamelPlacement(Function<Dynamic<?>, ? extends CamelPlacementConfig> configFactoryIn)
	{
		super(configFactoryIn);
	}
	
	@Override
	public Stream<BlockPos> func_212852_a_(Random random, CamelPlacementConfig config, BlockPos pos)
	{
		return IntStream.range(0, config.count).mapToObj((num) → {
			int i = random.nextInt(16);
			int j;
			int location = random.nextInt(2);
			switch(location)
			{
			case 0:
				j = config.lowerControlLine + random.nextInt(config.lowerWidth * 2 + 1) - config.lowerWidth;
				break;
			case 1:
				j = config.upperControlLine + random.nextInt(config.upperWidth * 2 + 1) - config.upperWidth;
				break;
			default:
				j = 0;
			}
			int k = random.nextInt(16);
			return pos.add(i, j, k);
		});
	}
}

#!syntax java
public static final Placement<CamelPlacementConfig> CAMEL_PLACEMENT = new CamelPlacement(CamelPlacementConfig::deserialize);

#!syntax java
public static void init()
{
	ForgeRegistries.BIOMES.forEach(biome → {
		biome.addFeature(
				GenerationStage.Decoration.UNDERGROUND_ORES,
				Biome.createDecoratedFeature(
						Feature.ORE,
						new OreFeatureConfig(OreFeatureConfig.FillerBlockType.NATURAL_STONE, NamuMain.RegistryEvents.NAMU_BLOCK.getDefaultState(), 15),
						CAMEL_PLACEMENT,
						new CamelPlacementConfig(20, 20, 50, 5, 6)
				)
		);
		LOGGER.debug(Logging.LOADING, "Additional ore generation of block "
				+ NamuMain.RegistryEvents.NAMU_BLOCK.getRegistryName().toString() + " in biome "
				+ biome.getRegistryName().toString() + " is registered");
	});
}

13.2. 구조물 생성

13.3. 바이옴 추가

13.4. 차원 추가

14. GUI

15. 각종 팁

15.1. 1.8 이후용 팁

• 1.7.10 및 이전 버전에서 사용되던 코드는, 1.8 이후에서는 대부분 호환되지 않는다.
• cpw가 포지 팀에서 탈퇴하여 cpw.mods.fml.common.*; 따위의 임포트는 오류를 내고, net.minecraftforge.fml.common.*; 로 임포트해야 한다.
• 아이템과 블록의 텍스쳐 및 모델 지정 방식이 변경되어 텍스쳐 제작으로 끝나지 않고, json 파일로 모델을 만들어야 한다. 그러나 json을 사용하지 않고 코드상에서 아이템과 블록의 모델을 추가하는것은 여전히 가능하다.[17]
• x, y, z 3개의 int 값으로 표현되던 좌표가 대부분 BlockPos 로 교체되었다.
• 블록의 방향, 면 등을 나타내기 위한 포지 클래스인 ForgeDirection은 바닐라에 새로 생긴 EnumFacing으로 대체되었다. 알 수 없는 방향을 나타내던 값인 ForgeDirection.UNKNOWN 은 null을 대신 사용해야 하므로 null 체크에 유의할 것.
• 블록의 상태를 나타내기 위한 정수값인 메타데이터가 IBlockState로 대체되었다. 블록 종류 또한 World.getBlock(int x, int y, int z) 대신 IBlockState.getBlock() 함수를 이용해서 구해야 한다.
• 1.12부터는 제작대 조합법, 포션, 바이옴, 사운드도 아이템과 블록처럼 레지스트리 이름을 설정하고나서 등록해야한다.

15.2. 1.13 이후용 팁

• 1.7.10 → 1.8과 마찬가지로, 1.12.2에서 사용되던 코드는 1.13 이후에서는 대부분 호환되지 않는다.
• 이전 버전들에 비해 JSON 파일을 만들어야 할 필요가 상당히 많아졌으며 특히 대규모 모드의 경우 수천개 이상의 JSON 파일이 필요할 수 있다. 블록과 아이템의 모델은 물론이고, 제작대 조합법 및 화로 레시피, 블록과 몹의 드롭 아이템, 아이템 태그(광석 사전 대체재) 등을 일일이 JSON 파일로 작성해야 하기 때문.[18] 물론 수많은 JSON 파일을 만드는 대신 코드상에서 자동 생성하는 방법도 여전히 가능하지만 코딩 난이도가 다소 어려우며, 코드상에서 레시피를 추가하면 데이터팩을 통한 아이템 제작법 변경이 어려워지므로 수많은 아이템의 레시피를 일정한 규칙으로 반복 생성해야 하는 경우가 아니라면 권장되지 않는다.
• 1.13부터는 Flattening 이라는 아이템/블록 데이터 시스템의 변경으로 인해 내부적으로 사용되던 숫자 ID와 개수 제한(아이템의 경우 32767개, 블록의 경우 4096개)이 제거되었으며, 아이템과 블록의 메타데이터도 삭제되었다. 염료나 양털같이 메타데이터로 구분되던 아이템은 별개의 아이템으로 나누어서 등록해야 한다.
• 광석사전은 바닐라에 유사한 기능인 아이템/블록 태그(Tag) 시스템이 추가됨에 따라 삭제되었다. 기존의 광석 사전과 달리 아이템 이름 형식 또한 다르므로 기존의 광석 사전에 "oreNamu"라고 등록되어 있던 아이템이 있다면, "forge:ores/namu" 태그를 생성한 후 등록시켜야 한다. 패브릭의 경우 이름공간만 패브릭으로 바꾸어 "fabric:ores/namu"로 등록하면 된다. 참고로 광석은 ores/, 조각은 nuggets/, 주괴는 ingots/, 보석은 gems/, 가루는 dusts/ 를 앞에 붙여야 한다. 타 모드와 공유하지 않고 자신의 모드에서 내부적으로 사용할 태그라면 "namumod:ores/namu"와 같이 자신의 모드 이름을 forge 대신 붙이면 된다. 또한 모드의 데이터팩에 태그의 json 파일을 생성해야 한다. {{{#!syntax java
  public static Tag<Item> namuOre = new ItemTags.Wrapper(new ResourceLocation ("forge:ores/namu"));
  }}} 태그의 JSON 파일의 코드이다. 여러개의 아이템을 한 태그에 지정하는 것도 가능하다. 파일 경로와 이름은 resources[19]/data/forge/tags/blocks/ores/namu.json (블록 태그), resources/data/forge/tags/items/ores/namu.json (아이템 태그)로 지정하면 된다. 블록과 아이템 태그는 별개이므로 둘 다 지정해야 인벤토리의 블록이 인식되지 않는 문제를 방지할 수 있다. {{{#!syntax json

15.3. Access Transformer

minecraft {
    // accessTransformer = file('src/main/resources/META-INF/accesstransformer.cfg') 대부분 이런 식으로 주석 처리되어 있다.
} 

public net.minecraft.entity.Entity field_12345_a

#!syntax java
private boolean isItemStackEqual(ItemStack other) {
    ...
}

B - byte,
C - char,
D - double,
F - float,
I - integer,
J - long,
S - short,
Z - boolean

public net.minecraft.item.ItemStack func_77959_d(Lnet/minecraft/item/ItemStack;)Z

15.4. 기타 팁

• 리플렉션(Reflection)을 사용하면 private 등 접근 제한자로 인해 일반적으로는 접근할 수 없는 필드나 메소드에 접근할 수 있다. 그러나 마인크래프트는 난독화되지 않은 개발 환경과 난독화된 버전으로 나뉘므로, 리플렉션을 사용한 코드가 양쪽에서 오류없이 동작하도록 하려면 포지에서 제공하는 ObfuscationReflectionHelper 라는 클래스를 활용하는 것이 유용하다. 또한 private로 설정된 필드와 메소드중에는 함부로 접근하면 문제가 생길 수 있기 때문에 제한한 것들도 있으므로 유의해서 사용해야 한다. 또한 리플렉션을 이용하면 해당 모드의 API나 IMC[20]를 사용하지 않고도 타 모드의 기능을 건들일 수 있다. 그러나 해당 모드가 설치되지 않으면 클래스를 찾지 못하여 오류가 발생하므로 해당 모드가 설치된 경우에만 동작하게 해야 한다. Reflection 사용시 성능이 떨어진다는 주장도 있으나 Reflection은 처음 JVM에서 로딩시에만 오버헤드가 발생할 뿐, 추가로 호출 시 별 차이 없다. 성능 테스트 환경을 불합리하게 설정 또는 오버헤드가 발생되게끔 사용해서 성능이 떨어지는것이다.
  
  게임 버전 1.17 이후부터는 자바 16 이상을 사용함에 따라 리플렉션을 사용하여도 접근 제한자로 제한된 필드와 메소드에 접근하기 어렵게 되었다. Access Transformer 등 다른 방법을 사용하는 것이 권장된다.
• 애드온 등 타 모드를 지원하는 모드를 개발할 경우 소스코드 폴더 내에 타 모드의 API를 넣는 대신 Java Build Path를 이용하여 빌드 경로에 API를 대신 포함시키는 것이 권장된다. 모드 JAR 파일 내에 타 모드의 API가 포함되어 있을 때 해당 모드의 API가 업데이트되면 충돌이 발생할 수 있다.
• 바닐라 또는 타 모드의 소스코드를 수정할 필요가 있다면 소스코드를 직접 뜯어고치는 대신 ASM을 사용하는 것이 권장된다. ASM은 자바 바이트코드를 조작하여 소스코드를 수정한 효과를 내는 기능이다. 그러나 자바 바이트코드에 대한 이해가 필요하며, 타 모드와의 호환성 문제가 발생하거나 디버깅이 어려워질 수 있으므로 반드시 필요한 경우에만 사용하는 것이 권장된다. Mixin API를 사용하면 보다 손쉽게 ASM을 사용 가능하며, 특히 패브릭 개발 환경에서는 기본적으로 Mixin을 지원한다.

16. 자바가 뭐예요?

16.1. 모드메이커

16.2. MCreator

17. 관련 문서

• 마인크래프트/개발