Initial commit

Java/Microcraft/src/com/jdh/microcraft/gui/ChestMenu.java

@@ -0,0 +1,106 @@
+package com.jdh.microcraft.gui;
+
+import com.jdh.microcraft.entity.EntityPlayer;
+import com.jdh.microcraft.entity.furniture.EntityChest;
+import com.jdh.microcraft.item.ItemStack;
+import com.jdh.microcraft.util.ControlHandler;
+
+import java.util.List;
+
+public class ChestMenu extends Menu {
+    private class ChestPlayerInventoryMenu extends PlayerInventoryMenu {
+        public ChestPlayerInventoryMenu(EntityPlayer player) {
+            super(player, false);
+            this.focused = true;
+        }
+
+    }
+
+    private class ChestInventoryMenu extends InventoryMenu {
+        public ChestInventoryMenu(EntityChest chest) {
+            super(chest.inventory, false);
+            this.focused = false;
+        }
+
+        @Override
+        public String getName() {
+            return "CHEST";
+        }
+    }
+
+    private final ChestPlayerInventoryMenu playerMenu;
+    private final ChestInventoryMenu chestMenu;
+    private final List<Menu> submenus;
+
+    public ChestMenu(EntityPlayer player, EntityChest chest) {
+        this.playerMenu = new ChestPlayerInventoryMenu(player);
+        this.chestMenu = new ChestInventoryMenu(chest);
+        this.submenus = List.of(this.playerMenu, this.chestMenu);
+    }
+
+    @Override
+    public void init() {
+        super.init();
+        for (Menu m : this.submenus) {
+            m.init();
+        }
+    }
+
+    @Override
+    public void destroy() {
+        super.destroy();
+        for (Menu m : this.submenus) {
+            m.destroy();
+        }
+    }
+
+    @Override
+    public void tick() {
+        super.tick();
+
+        if (ControlHandler.MENU_LEFT.pressedTick() && !this.playerMenu.focused) {
+            this.playerMenu.focused = true;
+            this.chestMenu.focused = false;
+        }
+
+        if (ControlHandler.MENU_RIGHT.pressedTick() && !this.chestMenu.focused) {
+            this.playerMenu.focused = false;
+            this.chestMenu.focused = true;
+        }
+
+        boolean drop = ControlHandler.DROP.pressedTick();
+        if (ControlHandler.MENU_SELECT.pressedTick() || drop) {
+            InventoryMenu from = this.playerMenu.focused ? this.playerMenu : this.chestMenu,
+                to = from == this.playerMenu ? this.chestMenu : this.playerMenu;
+
+            List<ItemStack> fromItems = from.getItems();
+            if (from.selectedIndex >= 0 && from.selectedIndex < fromItems.size()) {
+                ItemStack s = fromItems.get(from.selectedIndex);
+
+                if (s.instance.item.isDroppable()) {
+                    to.inventory.add(from.inventory.remove(s.instance.item, drop ? 1 : s.size));
+                }
+            }
+        }
+
+        for (Menu m : this.submenus) {
+            m.tick();
+        }
+    }
+
+    @Override
+    public void update() {
+        super.update();
+        for (Menu m : this.submenus) {
+            m.update();
+        }
+    }
+
+    @Override
+    public void render() {
+        super.render();
+        for (Menu m : this.submenus) {
+            m.render();
+        }
+    }
+}

Java/Microcraft/src/com/jdh/microcraft/gui/ColorSelectMenu.java

@@ -0,0 +1,184 @@
+package com.jdh.microcraft.gui;
+
+import com.jdh.microcraft.Global;
+import com.jdh.microcraft.entity.mob.EntityHumanoid;
+import com.jdh.microcraft.gfx.Color;
+import com.jdh.microcraft.gfx.Font;
+import com.jdh.microcraft.gfx.Renderer;
+import com.jdh.microcraft.sound.Sound;
+import com.jdh.microcraft.util.ControlHandler;
+import com.jdh.microcraft.util.FMath;
+
+public class ColorSelectMenu extends Menu {
+    private static final String[] TITLE = new String[]{
+        "CHOOSE YOUR",
+        Font.Colors.YELLOW + "APPEARANCE"
+    };
+
+    private static final String[] LABELS = new String[]{
+        "OUTLINE/HAIR", "PANTS", "SHIRT", "SKIN"
+    };
+
+    private static final String[] COLOR_LABELS = new String[]{
+        "R", "G", "B"
+    };
+
+    private static final String[] INSTRUCTIONS = new String[] {
+        Font.Colors.GREY + "(" + Font.Colors.YELLOW + "X" + Font.Colors.GREY + " TO DECREASE/" +
+            Font.Colors.YELLOW + "C" + Font.Colors.GREY + " TO INCREASE)",
+        Font.Colors.GREY + "(" + Font.Colors.YELLOW + "R" + Font.Colors.GREY + " TO RANDOMIZE" +
+            Font.Colors.GREY + ")",
+        "",
+        Font.Colors.GREY + "PRESS " + Font.Colors.YELLOW + "ENTER"
+    };
+
+    public int[] colors;
+    private int colorIndex, rgbIndex;
+
+    public ColorSelectMenu() {
+        this.colorIndex = 0;
+        this.rgbIndex = 0;
+        this.randomize();
+    }
+
+    private void randomize() {
+        this.colors = new int[]{
+            Color.randomRGB(0, 2),
+            Color.randomRGB(0, 5),
+            Color.randomRGB(0, 5),
+            Color.randomRGB(0, 5)
+        };
+    }
+
+    // updates currently selected color component by the specified change (d)
+    private void updateCurrentComponent(int d) {
+        int rgb = this.colors[this.colorIndex];
+        int[] components = {
+            Color.getRGBComponent(rgb, 0),
+            Color.getRGBComponent(rgb, 1),
+            Color.getRGBComponent(rgb, 2)
+        };
+        components[2 - this.rgbIndex] = FMath.clamp(components[2 - this.rgbIndex] + d, 0, 5);
+        this.colors[this.colorIndex] = Color.getRGB(
+            components[2],
+            components[1],
+            components[0]
+        );
+    }
+
+    @Override
+    public void tick() {
+        super.tick();
+
+        if (ControlHandler.MENU_UP.pressedTick() && this.colorIndex > 0) {
+            this.colorIndex--;
+        }
+
+        if (ControlHandler.MENU_DOWN.pressedTick() && this.colorIndex < (LABELS.length - 1)) {
+            this.colorIndex++;
+        }
+
+        if (ControlHandler.MENU_LEFT.pressedTick() && this.rgbIndex > 0) {
+            this.rgbIndex--;
+        }
+
+        if (ControlHandler.MENU_RIGHT.pressedTick() && this.rgbIndex < (COLOR_LABELS.length - 1)) {
+            this.rgbIndex++;
+        }
+
+        if (ControlHandler.MENU_INCREASE.pressedTick()) {
+            this.updateCurrentComponent(+1);
+        }
+
+        if (ControlHandler.MENU_DECREASE.pressedTick()) {
+            this.updateCurrentComponent(-1);
+        }
+
+        if (ControlHandler.MENU_QUIT.pressedTick()) {
+            Global.mainMenu.menu = Global.mainMenu.mainMenu;
+        }
+
+        if (ControlHandler.MENU_SELECT.pressedTick()) {
+            Sound.CRAFT.play();
+            Global.mainMenu.menu = Global.mainMenu.difficultySelectMenu;
+        }
+
+        if (ControlHandler.MENU_RANDOMIZE.pressedTick()) {
+            this.randomize();
+        }
+    }
+
+    @Override
+    public void render() {
+        super.render();
+
+        int y = 8;
+        for (String s : TITLE) {
+            Font.render(s, (Renderer.WIDTH - Font.width(s)) / 2, y, 555);
+            y += 8;
+        }
+
+        y += 8;
+
+        int px = (Renderer.WIDTH - 16) / 2, py = y,
+            sx = EntityHumanoid.BASE_SPRITE_X, sy = EntityHumanoid.BASE_SPRITE_Y;
+
+        boolean flip = (Global.ticks / 15) % 2 == 0;
+        for (int i = 0; i <= 1; i++) {
+            for (int j = 0; j <= 1; j++) {
+                Renderer.render(
+                    sx + (flip ? (1 - i) : i), sy + j,
+                    px + (i * 8), py + (j * 8),
+                    Color.get(colors[0], colors[1], colors[2], colors[3]),
+                    flip ? Renderer.FLIP_X : Renderer.FLIP_NONE
+                );
+            }
+        }
+        y += 24;
+
+        // labels/colors
+        int maxWidth = 0;
+        for (String label : LABELS) {
+            int w = Font.width(label);
+            if (w > maxWidth) {
+                maxWidth = w;
+            }
+        }
+
+        for (int i = 0; i < 4; i++) {
+            int x = (Renderer.WIDTH - (maxWidth + 8 + (24 * 3) + 4 + 8)) / 2;
+
+            if (i == this.colorIndex) {
+                Font.render(">", x - 8, y, 555);
+            }
+
+            Font.render(LABELS[i], x, y, i == this.colorIndex ? 555 : 333);
+
+            x += maxWidth + 8;
+            for (int j = 0; j < 3; j++) {
+                Font.render(COLOR_LABELS[j], x, y, (i == this.colorIndex && j == this.rgbIndex) ? 550 : 333);
+                Renderer.fill(
+                    x + 12, y, 8, 8,
+                    Color.getRGBComponent(this.colors[i], 2 - j) * (int) Math.pow(10, 2 - j)
+                );
+                x += 24;
+            }
+
+            x += 4;
+            Renderer.fill(x, y, 8, 8, this.colors[i]);
+            x += 8;
+
+            if (i == this.colorIndex) {
+                Font.render("<", x, y, 555);
+            }
+
+            y += 12;
+        }
+        y += 8;
+
+        for (String s : INSTRUCTIONS) {
+            Font.render(s, (Renderer.WIDTH - Font.width(s)) / 2, y, 555);
+            y += 8;
+        }
+    }
+}

Java/Microcraft/src/com/jdh/microcraft/gui/DialogMenu.java

@@ -0,0 +1,97 @@
+package com.jdh.microcraft.gui;
+
+import com.jdh.microcraft.Global;
+import com.jdh.microcraft.gfx.Font;
+import com.jdh.microcraft.gfx.Renderer;
+import com.jdh.microcraft.util.Keyboard;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class DialogMenu extends Menu {
+    protected final String title;
+    protected final String[] lines;
+    protected final int w;
+    protected final int h;
+    protected final Runnable onClose;
+    protected final int x, y;
+
+    public DialogMenu(String title, String[] lines, int w, int h, Runnable onClose) {
+        this.title = title;
+        this.lines = lines;
+        this.w = w;
+        this.h = h;
+        this.x = (Renderer.WIDTH - (this.w * 8)) / 2;
+        this.y = (Renderer.HEIGHT - (this.h * 8)) / 2;
+        this.onClose = onClose;
+        this.focused = true;
+    }
+
+    protected boolean shouldCenterText() {
+        return false;
+    }
+
+    protected boolean showPressAnyKey() {
+        return true;
+    }
+
+    protected boolean shouldAlignToMaxWidth() {
+        return false;
+    }
+
+    protected String[] getLines() {
+        return this.lines;
+    }
+
+    @Override
+    public void render() {
+        super.render();
+
+        this.renderMenu(title, x, y, this.w, this.h);
+
+        List<String> allLines = new ArrayList<>(Arrays.asList(this.getLines()));
+
+        if (this.showPressAnyKey()) {
+            allLines.add(" ");
+            allLines.add(Font.Colors.GREY + "PRESS ANY KEY");
+        }
+
+        int maxWidth = 0;
+        for (String line : this.getLines()) {
+            maxWidth = Math.max(maxWidth, Font.width(line));
+        }
+
+        for (int i = 0; i < allLines.size(); i++) {
+            String s = allLines.get(i);
+
+            int tx;
+            if (this.shouldCenterText() ||
+                (this.shouldAlignToMaxWidth() && i == (allLines.size() - 1))) {
+                tx = x + (((this.w * 8) - Font.width(s)) / 2);
+            } else if (this.shouldAlignToMaxWidth()) {
+                tx = x + (((this.w * 8) - maxWidth) / 2);
+            } else {
+                tx = x + 8;
+            }
+
+            Font.render(s, tx, y + ((i + 1) * 8), 555, -1);
+        }
+    }
+
+    @Override
+    public void tick() {
+        super.tick();
+
+        if (this.showPressAnyKey()) {
+            for (Keyboard.Key k : Keyboard.keys) {
+                if (k.pressedTick) {
+                    if (Global.game != null) {
+                        Global.game.setMenu(null);
+                    }
+                    this.onClose.run();
+                }
+            }
+        }
+    }
+}

Java/Microcraft/src/com/jdh/microcraft/gui/DifficultySelectMenu.java

@@ -0,0 +1,99 @@
+package com.jdh.microcraft.gui;
+
+import com.jdh.microcraft.Global;
+import com.jdh.microcraft.gfx.Font;
+import com.jdh.microcraft.gfx.Renderer;
+import com.jdh.microcraft.util.ControlHandler;
+
+public class DifficultySelectMenu extends Menu {
+    private static final String[] TITLE = {
+        Font.Colors.WHITE + "CHOOSE YOUR",
+        Font.Colors.RED + "DIFFICULTY"
+    };
+
+    private static final String[] INSTRUCTIONS = new String[] {
+        Font.Colors.GREY + "PRESS " + Font.Colors.YELLOW + "ENTER" + Font.Colors.GREY + " TO START!"
+    };
+
+    private static final int COUNT = 5;
+
+    private static final String[] DIFFICULTY_NAMES = {
+        "TOO EASY",
+        "EASY",
+        "NORMAL",
+        "KINDA HARD",
+        "HARD"
+    };
+
+    private static final double[] DIFFICULTY_VALUES = {
+        0.70,
+        0.85,
+        1.0,
+        1.15,
+        1.30
+    };
+
+    private int index;
+
+    public DifficultySelectMenu() {
+        this.index = 2;
+    }
+
+    public double getSelectedDifficulty() {
+        return DIFFICULTY_VALUES[this.index];
+    }
+
+    @Override
+    public void tick() {
+        super.tick();
+
+        if (ControlHandler.MENU_UP.pressedTick() && this.index > 0) {
+            this.index--;
+        }
+
+        if (ControlHandler.MENU_DOWN.pressedTick() && this.index < (COUNT - 1)) {
+            this.index++;
+        }
+
+        if (ControlHandler.MENU_QUIT.pressedTick()) {
+            Global.mainMenu.menu = Global.mainMenu.colorSelectMenu;
+        }
+
+        if (ControlHandler.MENU_SELECT.pressedTick()) {
+            Global.setState(Global.StateType.GAME);
+        }
+    }
+
+    @Override
+    public void render() {
+        super.render();
+
+        int y = 8;
+        for (String s : TITLE) {
+            Font.render(s, (Renderer.WIDTH - Font.width(s)) / 2, y, 555);
+            y += 8;
+        }
+
+        y += 32;
+
+        int maxWidth = 0;
+        for (String s : DIFFICULTY_NAMES) {
+            maxWidth = Math.max(maxWidth, Font.width(s));
+        }
+
+        for (int i = 0; i < COUNT; i++) {
+            String s = DIFFICULTY_NAMES[i];
+            Font.render(
+                s,
+                (Renderer.WIDTH - Font.width(s)) / 2, y + (i * 8),
+                i == this.index ? 555 : 333);
+        }
+
+        Font.render(">", ((Renderer.WIDTH - maxWidth) / 2) - 8, y + (this.index * 8), 555);
+        Font.render("<", (Renderer.WIDTH + maxWidth) / 2, y + (this.index * 8), 555);
+
+        for (String s : INSTRUCTIONS) {
+            Font.render(s, (Renderer.WIDTH - Font.width(s)) / 2, Renderer.HEIGHT - 8, 555);
+        }
+    }
+}

Java/Microcraft/src/com/jdh/microcraft/gui/FocusMenu.java

@@ -0,0 +1,31 @@
+package com.jdh.microcraft.gui;
+
+import com.jdh.microcraft.Global;
+import com.jdh.microcraft.util.Window;
+
+public class FocusMenu extends DialogMenu {
+    private final Menu oldMenu;
+
+    public FocusMenu(Menu oldMenu) {
+        super("", new String[] { " ", "CLICK TO FOCUS!" }, 16, 5, () -> {});
+        this.oldMenu = oldMenu;
+    }
+
+    @Override
+    protected boolean shouldCenterText() {
+        return true;
+    }
+
+    @Override
+    protected boolean showPressAnyKey() {
+        return false;
+    }
+
+    @Override
+    public void update() {
+        super.update();
+        if (Window.hasFocus()) {
+            Global.game.setMenu(this.oldMenu);
+        }
+    }
+}

Java/Microcraft/src/com/jdh/microcraft/gui/HUD.java

@@ -0,0 +1,74 @@
+package com.jdh.microcraft.gui;
+
+import com.jdh.microcraft.Global;
+import com.jdh.microcraft.entity.EntityPlayer;
+import com.jdh.microcraft.gfx.Color;
+import com.jdh.microcraft.gfx.Font;
+import com.jdh.microcraft.gfx.Renderer;
+
+public class HUD extends Menu {
+    private static final int HEALTH_SPRITE_X = 10, HEALTH_SPRITE_Y = 11;
+    private static final int STAMINA_SPRITE_X = 10, STAMINA_SPRITE_Y = 12;
+
+    private final EntityPlayer player;
+
+    public HUD(EntityPlayer player) {
+        this.player = player;
+        this.focused = true;
+    }
+
+    @Override
+    public void render() {
+        Renderer.fill(0, Renderer.HEIGHT - 16, Renderer.WIDTH, 16, 000);
+
+        // health
+        for (int i = 0; i < this.player.getMaxHealth(); i++) {
+            boolean flashing = this.player.health <= 2 && ((Global.frames / 10) % 2) == 0;
+            Renderer.render(
+                HEALTH_SPRITE_X, HEALTH_SPRITE_Y,
+                2 + (i * 8), Renderer.HEIGHT - 16,
+                i < this.player.health ?
+                    (flashing ?
+                        Color.get(311, 511, 533, 555) :
+                        Color.get(100, 400, 511, 533)
+                    ) :
+                    Color.get(100, 111, 222, 333),
+                Renderer.FLIP_NONE
+            );
+        }
+
+        // stamina
+        for (int i = 0; i < this.player.getMaxStamina(); i++) {
+            boolean flashing = this.player.staminaRechargeDelayTicks > 0 && Global.frames % 3 == 0;
+            Renderer.render(
+                STAMINA_SPRITE_X, STAMINA_SPRITE_Y,
+                2 + (i * 8), Renderer.HEIGHT - 8,
+                i < this.player.stamina ?
+                    Color.get(110, 331, 441, 551) :
+                    (flashing ?
+                        Color.get(333, 444, 555, 555) :
+                        Color.get(110, 222, 333, 444)),
+                Renderer.FLIP_NONE
+            );
+        }
+
+        // equipped item
+        if (player.equipped != null) {
+            this.player.equipped.instance.item.renderIcon(
+                this.player.equipped.instance,
+                Renderer.WIDTH - 100, Renderer.HEIGHT - 12
+            );
+
+            int xx = Renderer.WIDTH - 90;
+            if (player.equipped.size > 1) {
+                String s = Integer.toString(player.equipped.size);
+                Font.render(s, xx, Renderer.HEIGHT - 12, 444);
+                xx += Font.width(s) + 8;
+            }
+            Font.render(
+                this.player.equipped.instance.item.getName(),
+                xx, Renderer.HEIGHT - 12, 555
+            );
+        }
+    }
+}

Java/Microcraft/src/com/jdh/microcraft/gui/InventoryMenu.java

@@ -0,0 +1,40 @@
+package com.jdh.microcraft.gui;
+
+import com.jdh.microcraft.item.Inventory;
+import com.jdh.microcraft.item.Item;
+import com.jdh.microcraft.item.ItemStack;
+import com.jdh.microcraft.util.ControlHandler;
+
+import java.util.Comparator;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class InventoryMenu extends ItemSelectMenu {
+    protected final Inventory inventory;
+
+    public InventoryMenu(Inventory inventory, boolean leftSide) {
+        super(leftSide, ControlHandler.MENU_UP, ControlHandler.MENU_DOWN);
+        this.inventory = inventory;
+    }
+
+    @Override
+    public List<ItemStack> getItems() {
+        // give a sorted list of items with POW GLOVE always on top
+        return inventory.stacks.stream()
+            .filter(s -> s.instance.item.showInMenu())
+            .sorted(Comparator
+                .<ItemStack, Boolean>comparing(s -> s.instance.item.id != Item.GLOVE.id)
+                .thenComparing(s -> s.instance.item.getName()))
+            .collect(Collectors.toList());
+    }
+
+    @Override
+    public int getItemTextColor(int index) {
+        return 555;
+    }
+
+    @Override
+    public String getName() {
+        return "INVENTORY";
+    }
+}

Java/Microcraft/src/com/jdh/microcraft/gui/ItemListMenu.java

@@ -0,0 +1,62 @@
+package com.jdh.microcraft.gui;
+
+import com.jdh.microcraft.gfx.Color;
+import com.jdh.microcraft.gfx.Font;
+import com.jdh.microcraft.item.ItemStack;
+import com.jdh.microcraft.util.FMath;
+
+import java.util.List;
+
+public abstract class ItemListMenu extends Menu {
+    public final int x, y, width, height;
+    private int offset = 0;
+
+    public ItemListMenu(int x, int y, int width, int height) {
+        this.x = x;
+        this.y = y;
+        this.width = width;
+        this.height = height;
+    }
+
+    protected void setOffset(int offset) {
+        this.offset = FMath.clamp(offset, 0,this.getItems().size());
+    }
+
+    public int getOffset() {
+        return offset;
+    }
+
+    @Override
+    public void render() {
+        super.render();
+
+        List<ItemStack> items = this.getItems();
+
+        this.renderMenu(this.getName(), this.x, this.y, this.width, this.height);
+
+        // render item list
+        for (int i = 0, j = offset; i < this.height - 2 && j < items.size(); i++, j++) {
+            int yy = this.y + ((i + 1) * 8);
+            ItemStack stack = items.get(j);
+            int color = this.getItemTextColor(j);
+            stack.instance.item.renderIcon(stack.instance, x + 8, yy);
+
+            int xx = x + 16;
+            if (stack.size > 1) {
+                String s = Integer.toString(stack.size);
+                Font.render(s, xx, yy, Color.add(color, -111));
+                xx += Font.width(s) + 8;
+            }
+
+            Font.render(this.getItemName(j), xx, yy, color);
+        }
+    }
+
+    public abstract List<ItemStack> getItems();
+
+    public abstract String getItemName(int index);
+
+    public abstract int getItemTextColor(int index);
+
+    public abstract String getName();
+}

Java/Microcraft/src/com/jdh/microcraft/gui/ItemSelectMenu.java

@@ -0,0 +1,75 @@
+package com.jdh.microcraft.gui;
+
+import com.jdh.microcraft.gfx.Font;
+import com.jdh.microcraft.gfx.Renderer;
+import com.jdh.microcraft.item.ItemStack;
+import com.jdh.microcraft.util.Control;
+import com.jdh.microcraft.util.FMath;
+
+import java.util.List;
+
+public abstract class ItemSelectMenu extends ItemListMenu {
+    private static final int WIDTH = 14, HEIGHT = (Renderer.HEIGHT - 32) / 8;
+
+    protected final boolean leftSide;
+    protected final Control up, down;
+    protected int selectedIndex = 0;
+
+    public ItemSelectMenu(boolean leftSide, Control up, Control down) {
+        super(
+            leftSide ? 8 : (8 + WIDTH * 8 + 16), 8,
+            14, (Renderer.HEIGHT - 32) / 8
+        );
+        this.leftSide = leftSide;
+        this.up = up;
+        this.down = down;
+    }
+
+    protected void updateOffset()  {
+        if (this.selectedIndex < this.getOffset()) {
+            this.setOffset(this.selectedIndex);
+        }
+
+        if (this.selectedIndex >= this.getOffset() + (HEIGHT - 2)) {
+            this.setOffset(this.selectedIndex - (HEIGHT - 2) + 1);
+        }
+    }
+
+    @Override
+    public void tick() {
+        super.tick();
+        List<ItemStack> items = this.getItems();
+
+        if (this.focused) {
+            if (this.up.pressedTick() && this.selectedIndex > 0) {
+                this.selectedIndex--;
+            }
+
+            if (this.down.pressedTick() && this.selectedIndex < (items.size() - 1)) {
+                this.selectedIndex++;
+            }
+        }
+
+        // clamp selection index if its gone out of bounds
+        this.selectedIndex = FMath.clamp(this.selectedIndex, 0, items.size() - 1);
+        this.updateOffset();
+    }
+
+    @Override
+    public void render() {
+        super.render();
+
+        // render selection indicator
+        if (this.selectedIndex != -1) {
+            int color = this.focused ? 555 : 333;
+            int yy = this.y + (((this.selectedIndex - this.getOffset()) + 1) * 8);
+            Font.render(">", this.x, yy, color, Menu.MENU_BG_COLOR);
+            Font.render("<", this.x + ((WIDTH - 1) * 8), yy, color, Menu.MENU_BG_COLOR);
+        }
+    }
+
+    @Override
+    public String getItemName(int index) {
+        return this.getItems().get(index).instance.item.getName();
+    }
+}

Java/Microcraft/src/com/jdh/microcraft/gui/LoseMenu.java

@@ -0,0 +1,14 @@
+package com.jdh.microcraft.gui;
+
+import com.jdh.microcraft.Global;
+import com.jdh.microcraft.gfx.Font;
+
+public class LoseMenu extends DialogMenu {
+    public LoseMenu() {
+        super(":(", new String[]{
+            "",
+            "YOU " + Font.Colors.RED + "DIED",
+            "SCORE: " + Font.Colors.YELLOW + Global.game.score,
+        }, 22, 8, () -> Global.setState(Global.StateType.MENU));
+    }
+}

Java/Microcraft/src/com/jdh/microcraft/gui/Menu.java

@@ -0,0 +1,75 @@
+package com.jdh.microcraft.gui;
+
+import com.jdh.microcraft.gfx.Color;
+import com.jdh.microcraft.gfx.Font;
+import com.jdh.microcraft.gfx.Renderer;
+
+public class Menu {
+    public boolean focused = false;
+
+    private static final int MENU_SPRITES_X = 11, MENU_SPRITES_Y = 11;
+    public static final int MENU_BG_COLOR = 115;
+
+    protected void renderMenu(String title, int x, int y, int wt, int ht) {
+        int color = this.focused ?
+            Color.get(111, 333, MENU_BG_COLOR, 444) :
+            Color.get(000, 111, MENU_BG_COLOR, 222);
+
+        // corners
+        Renderer.render(MENU_SPRITES_X, MENU_SPRITES_Y,
+            x, y, color, Renderer.FLIP_NONE);
+        Renderer.render(MENU_SPRITES_X, MENU_SPRITES_Y,
+            x + ((wt - 1) * 8), y, color, Renderer.FLIP_X);
+        Renderer.render(MENU_SPRITES_X, MENU_SPRITES_Y,
+            x, y + ((ht - 1) * 8), color, Renderer.FLIP_Y);
+        Renderer.render(MENU_SPRITES_X, MENU_SPRITES_Y,
+            x + ((wt - 1) * 8), y + ((ht - 1) * 8), color, Renderer.FLIP_XY);
+
+        // vertical sides
+        for (int i = 0; i < (ht - 2); i++) {
+            Renderer.render(MENU_SPRITES_X, MENU_SPRITES_Y + 1,
+                x, y + ((i + 1) * 8), color, Renderer.FLIP_NONE);
+            Renderer.render(MENU_SPRITES_X, MENU_SPRITES_Y + 1,
+                x + ((wt - 1) * 8), y + ((i + 1) * 8), color, Renderer.FLIP_X);
+        }
+
+        // horizontal sides
+        for (int i = 0; i < (wt - 2); i++) {
+            Renderer.render(MENU_SPRITES_X + 1, MENU_SPRITES_Y,
+                x + ((i + 1) * 8), y, color, Renderer.FLIP_NONE);
+            Renderer.render(MENU_SPRITES_X + 1, MENU_SPRITES_Y,
+                x + ((i + 1) * 8), y + ((ht - 1) * 8), color, Renderer.FLIP_Y);
+        }
+
+        // center
+        Renderer.fill(
+            x + 8, y + 8,
+            (wt - 2) * 8, (ht - 2) * 8,
+            MENU_BG_COLOR
+        );
+
+        // title
+        int titleX = x + (((wt * 8) / 2) - (Font.width(title) / 2));
+        Font.render(title, titleX, y, this.focused ? 551 : 331, MENU_BG_COLOR);
+    }
+
+    public void init() {
+
+    }
+
+    public void destroy() {
+
+    }
+
+    public void tick() {
+
+    }
+
+    public void update() {
+
+    }
+
+    public void render() {
+
+    }
+}

Java/Microcraft/src/com/jdh/microcraft/gui/PauseMenu.java

@@ -0,0 +1,54 @@
+package com.jdh.microcraft.gui;
+
+import com.jdh.microcraft.Global;
+import com.jdh.microcraft.gfx.Font;
+import com.jdh.microcraft.util.ControlHandler;
+
+public class PauseMenu extends DialogMenu {
+    private boolean onYes;
+
+    public PauseMenu() {
+        super("", new String[]{}, 20, 4,  () -> {});
+        this.onYes = false;
+    }
+
+    @Override
+    protected boolean showPressAnyKey() {
+        return false;
+    }
+
+    @Override
+    protected boolean shouldCenterText() {
+        return true;
+    }
+
+    @Override
+    protected String[] getLines() {
+        return new String[] {
+            "EXIT TO MAIN MENU?",
+            (this.onYes ? Font.Colors.YELLOW : Font.Colors.GREY) + "YES" +
+                (this.onYes ? Font.Colors.GREY : Font.Colors.YELLOW) + " NO"
+        };
+    }
+
+    @Override
+    public void tick() {
+        super.tick();
+
+        if (ControlHandler.MENU_SELECT.pressedTick()) {
+            if (this.onYes) {
+                Global.setState(Global.StateType.MENU);
+            } else {
+                Global.game.setMenu(null);
+            }
+        }
+
+        if (ControlHandler.MENU_LEFT.pressedTick() && !this.onYes) {
+            this.onYes = true;
+        }
+
+        if (ControlHandler.MENU_RIGHT.pressedTick() && this.onYes) {
+            this.onYes = false;
+        }
+    }
+}

Java/Microcraft/src/com/jdh/microcraft/gui/PlayerInventoryMenu.java

@@ -0,0 +1,119 @@
+package com.jdh.microcraft.gui;
+
+import com.jdh.microcraft.Global;
+import com.jdh.microcraft.entity.EntityPlayer;
+import com.jdh.microcraft.gui.crafting.InventoryCraftingMenu;
+import com.jdh.microcraft.item.ItemStack;
+import com.jdh.microcraft.item.armor.*;
+import com.jdh.microcraft.sound.Sound;
+import com.jdh.microcraft.util.ControlHandler;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+public class PlayerInventoryMenu extends InventoryMenu {
+    private class PlayerArmorMenu extends ItemListMenu {
+        public PlayerArmorMenu() {
+            super(
+                PlayerInventoryMenu.this.x + (PlayerInventoryMenu.this.width + 2) * 8,
+                PlayerInventoryMenu.this.y,
+                14, 6
+            );
+        }
+
+        @Override
+        public List<ItemStack> getItems() {
+            return Arrays.stream(PlayerInventoryMenu.this.player.armor)
+                .filter(Objects::nonNull)
+                .collect(Collectors.toList());
+        }
+
+        @Override
+        public String getItemName(int index) {
+            return this.getItems().get(index).instance.item.getName();
+        }
+
+        @Override
+        public int getItemTextColor(int index) {
+            return 444;
+        }
+
+        @Override
+        public String getName() {
+            return "ARMOR";
+        }
+    }
+
+    private final PlayerArmorMenu armorMenu;
+    private final EntityPlayer player;
+    private final boolean showArmor;
+
+    public PlayerInventoryMenu(EntityPlayer player, boolean showArmor) {
+        super(player.inventory, true);
+        this.player = player;
+        this.showArmor = showArmor;
+        this.focused = true;
+        this.armorMenu = new PlayerArmorMenu();
+
+        List<ItemStack> items = this.getItems();
+        int selected = items.indexOf(this.player.equipped);
+        this.selectedIndex = selected == -1 ? 0 : selected;
+        this.updateOffset();
+    }
+
+    @Override
+    public void tick() {
+        super.tick();
+
+        List<ItemStack> items = this.getItems();
+        ItemStack selectedItem = this.selectedIndex >= 0 && this.selectedIndex < items.size() ?
+            items.get(this.selectedIndex) : null;
+        this.player.equipped = selectedItem;
+
+        if (this.showArmor) {
+            if (ControlHandler.MENU_EQUIP.pressedTick() &&
+                selectedItem != null &&
+                selectedItem.instance.item instanceof ItemArmor) {
+                ItemArmor armor = (ItemArmor) selectedItem.instance.item;
+
+                if (this.player.armor[armor.slot] == selectedItem) {
+                    this.player.armor[armor.slot] = null;
+                } else {
+                    Sound.EQUIP.play();
+                    this.player.armor[armor.slot] = selectedItem;
+                }
+            }
+
+            this.armorMenu.tick();
+        }
+
+        if (ControlHandler.DROP.pressedTick() &&
+            selectedItem != null &&
+            selectedItem.instance.item.isDroppable()) {
+            this.player.drop(selectedItem);
+        }
+
+        if (ControlHandler.TOGGLE_CRAFTING.pressedTick()) {
+            // direct inventory -> crafting transition
+            Global.game.setMenu(new InventoryCraftingMenu(this.player));
+        }
+    }
+
+    @Override
+    public void render() {
+        super.render();
+
+        if (this.showArmor) {
+            this.armorMenu.render();
+        }
+    }
+
+    @Override
+    public void update() {
+        if (this.showArmor) {
+            this.armorMenu.update();
+        }
+    }
+}

Java/Microcraft/src/com/jdh/microcraft/gui/TransitionMenu.java

@@ -0,0 +1,44 @@
+package com.jdh.microcraft.gui;
+
+import com.jdh.microcraft.Global;
+import com.jdh.microcraft.gfx.Renderer;
+import com.jdh.microcraft.util.FMath;
+
+public class TransitionMenu extends Menu {
+    private static final int TIME = 10;
+
+    // time to live
+    private int ticks;
+
+    public TransitionMenu() {
+        this.ticks = 0;
+    }
+
+    @Override
+    public void tick() {
+        super.tick();
+
+        if (++this.ticks == TIME) {
+            Global.game.setMenu(null);
+        }
+    }
+
+    @Override
+    public void render() {
+        super.render();
+
+        for (int y = 0; y < Renderer.HEIGHT / 8; y++) {
+            for (int x = 0; x < Renderer.WIDTH / 8; x++) {
+                int distance = (int) (
+                    FMath.norm(
+                        ((double) (x * 8) - (double) (Renderer.WIDTH / 2)) / (Renderer.WIDTH / 2),
+                        ((double) (y * 8) - (double) (Renderer.HEIGHT / 2)) / (Renderer.HEIGHT / 2)
+                    ) * TIME);
+
+                if (distance > this.ticks) {
+                    Renderer.fill(x * 8, y * 8, 8, 8, 000);
+                }
+            }
+        }
+    }
+}

Java/Microcraft/src/com/jdh/microcraft/gui/WelcomeMenu.java

@@ -0,0 +1,17 @@
+package com.jdh.microcraft.gui;
+
+import com.jdh.microcraft.gfx.Font;
+
+public class WelcomeMenu extends DialogMenu {
+    public WelcomeMenu() {
+        super("WELCOME", new String[]{
+            "",
+            "YOU MUST DEFEAT ",
+            "THE EVIL " + Font.Colors.RED + "AIR WIZARD!",
+            "",
+            "ONE SHOULD GO " + Font.Colors.GREEN + "DOWN",
+            "BEFORE MAKING A",
+            "WAY" + Font.Colors.YELLOW + " UP",
+        }, 22, 11, () -> {});
+    }
+}

Java/Microcraft/src/com/jdh/microcraft/gui/WinMenu.java

@@ -0,0 +1,25 @@
+package com.jdh.microcraft.gui;
+
+import com.jdh.microcraft.Global;
+import com.jdh.microcraft.gfx.Font;
+
+public class WinMenu extends DialogMenu {
+    private int ticks;
+
+    public WinMenu() {
+        super("YAY!", new String[]{
+            "",
+            "YOU WIN! ",
+            "THE EVIL " + Font.Colors.RED + "AIR WIZARD",
+            "HAS BEEN " + Font.Colors.YELLOW + "BESTED.",
+            "SCORE: " + Font.Colors.YELLOW + Global.game.score,
+        }, 22, 10, () -> Global.setState(Global.StateType.MENU));
+    }
+
+    @Override
+    public void tick() {
+        if (++this.ticks > 120) {
+            super.tick();
+        }
+    }
+}

Java/Microcraft/src/com/jdh/microcraft/gui/crafting/AnvilCraftingMenu.java

@@ -0,0 +1,21 @@
+package com.jdh.microcraft.gui.crafting;
+
+import com.jdh.microcraft.entity.EntityPlayer;
+import com.jdh.microcraft.entity.furniture.EntityAnvil;
+import com.jdh.microcraft.item.crafting.Recipe;
+
+public class AnvilCraftingMenu extends FurnitureCraftingMenu {
+    public AnvilCraftingMenu(EntityPlayer player, EntityAnvil anvil) {
+        super(player, anvil);
+    }
+
+    @Override
+    public int getStation() {
+        return Recipe.STATION_ANVIL;
+    }
+
+    @Override
+    public String getName() {
+        return "ANVIL";
+    }
+}

Java/Microcraft/src/com/jdh/microcraft/gui/crafting/BenchCraftingMenu.java

@@ -0,0 +1,21 @@
+package com.jdh.microcraft.gui.crafting;
+
+import com.jdh.microcraft.entity.EntityPlayer;
+import com.jdh.microcraft.entity.furniture.EntityCraftingBench;
+import com.jdh.microcraft.item.crafting.Recipe;
+
+public class BenchCraftingMenu extends FurnitureCraftingMenu {
+    public BenchCraftingMenu(EntityPlayer player, EntityCraftingBench bench) {
+        super(player, bench);
+    }
+
+    @Override
+    public int getStation() {
+        return Recipe.STATION_ALL_CRAFTING;
+    }
+
+    @Override
+    public String getName() {
+        return "CRAFTING";
+    }
+}

Java/Microcraft/src/com/jdh/microcraft/gui/crafting/CraftingMenu.java

@@ -0,0 +1,236 @@
+package com.jdh.microcraft.gui.crafting;
+
+import com.jdh.microcraft.entity.EntityPlayer;
+import com.jdh.microcraft.gui.ItemListMenu;
+import com.jdh.microcraft.gui.ItemSelectMenu;
+import com.jdh.microcraft.gui.Menu;
+import com.jdh.microcraft.item.Item;
+import com.jdh.microcraft.item.ItemInstance;
+import com.jdh.microcraft.item.ItemStack;
+import com.jdh.microcraft.item.crafting.Recipe;
+import com.jdh.microcraft.sound.Sound;
+import com.jdh.microcraft.util.Control;
+import com.jdh.microcraft.util.ControlHandler;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public abstract class CraftingMenu extends Menu {
+    private class CraftingList extends ItemSelectMenu {
+        private final Control craft;
+
+        public CraftingList(Control up, Control down, Control craft) {
+            super(true, up, down);
+            this.craft = craft;
+            this.focused = true;
+        }
+
+        public Recipe getSelectedRecipe() {
+            if (CraftingMenu.this.recipes.size() == 0) {
+                return null;
+            }
+
+            return CraftingMenu.this.recipes.get(this.selectedIndex);
+        }
+
+        private boolean canCraft(int index) {
+            return this.selectedIndex < CraftingMenu.this.recipes.size() &&
+                CraftingMenu.this.recipes.get(index)
+                    .canMake(CraftingMenu.this.player.inventory, CraftingMenu.this.getStation());
+        }
+
+        @Override
+        public void tick() {
+            super.tick();
+
+            if (this.craft.pressedTick() && this.canCraft(this.selectedIndex)) {
+                ItemStack result = this.getSelectedRecipe().make(CraftingMenu.this.player.inventory);
+                CraftingMenu.this.player.inventory.add(result);
+                CraftingMenu.this.onCraft(result);
+            }
+        }
+
+        @Override
+        public List<ItemStack> getItems() {
+            return CraftingMenu.this.items;
+        }
+
+        @Override
+        public int getItemTextColor(int index) {
+            return this.canCraft(index) ? 555 : 333;
+        }
+
+        @Override
+        public String getName() {
+            return CraftingMenu.this.getName();
+        }
+    }
+
+    private class HaveMenu extends ItemListMenu {
+        public HaveMenu() {
+            super(
+                CraftingMenu.this.craftingList.x + (CraftingMenu.this.craftingList.width + 2) * 8,
+                CraftingMenu.this.craftingList.y,
+                10, 3
+            );
+        }
+
+        @Override
+        public List<ItemStack> getItems() {
+            Recipe recipe = CraftingMenu.this.craftingList.getSelectedRecipe();
+            return recipe == null ?
+                List.of() :
+                List.of(new ItemStack(recipe.result.instance, 1));
+        }
+
+        @Override
+        public String getItemName(int index) {
+            Recipe recipe = CraftingMenu.this.craftingList.getSelectedRecipe();
+            assert (recipe != null);
+
+            return Integer.toString(CraftingMenu.this.player.inventory.count(recipe.result.instance.item));
+        }
+
+        @Override
+        public int getItemTextColor(int index) {
+            return 555;
+        }
+
+        @Override
+        public String getName() {
+            return "HAVE";
+        }
+    }
+
+    private class CostMenu extends ItemListMenu {
+        public CostMenu() {
+            super(
+                CraftingMenu.this.craftingList.x + (CraftingMenu.this.craftingList.width + 2) * 8,
+                CraftingMenu.this.craftingList.y + (CraftingMenu.this.haveMenu.height + 1) * 8,
+                10, CraftingMenu.this.craftingList.height - CraftingMenu.this.haveMenu.height - 1
+            );
+        }
+
+        @Override
+        public List<ItemStack> getItems() {
+            Recipe recipe = CraftingMenu.this.craftingList.getSelectedRecipe();
+            return recipe == null ?
+                List.of() :
+                recipe.ingredients.stream()
+                    .map(i -> new ItemStack(new ItemInstance(i.item, 0), 0))
+                    .collect(Collectors.toList());
+        }
+
+        @Override
+        public String getItemName(int index) {
+            Recipe recipe = CraftingMenu.this.craftingList.getSelectedRecipe();
+            assert (recipe != null);
+
+            ItemStack item = this.getItems().get(index);
+            int have = CraftingMenu.this.player.inventory.count(item.instance.item),
+                required = recipe.ingredients.stream()
+                    .filter(i -> i.item.id == item.instance.item.id)
+                    .findFirst().get().count;
+            return required + "/" + have;
+        }
+
+        @Override
+        public int getItemTextColor(int index) {
+            return 555;
+        }
+
+        @Override
+        public String getName() {
+            return "COST";
+        }
+    }
+
+    protected final CraftingList craftingList;
+    protected final HaveMenu haveMenu;
+    protected final CostMenu costMenu;
+    protected final List<Menu> submenus;
+
+    protected final EntityPlayer player;
+    protected final List<Recipe> recipes;
+    protected final List<ItemStack> items;
+
+    public CraftingMenu(EntityPlayer player) {
+        this.player = player;
+        this.recipes = Item.STATION_RECIPES.get(this.getStation());
+        this.items = this.recipes.stream().map(r -> r.result).collect(Collectors.toList());
+        this.craftingList = new CraftingList(ControlHandler.MENU_UP, ControlHandler.MENU_DOWN, ControlHandler.MENU_SELECT);
+        this.haveMenu = new HaveMenu();
+        this.costMenu = new CostMenu();
+        this.submenus = List.of(this.craftingList, this.haveMenu, this.costMenu);
+        this.sort();
+    }
+
+    private void sort() {
+        this.recipes.sort(
+            (var a, var b) -> {
+                boolean ma = a.canMake(this.player.inventory, this.getStation()),
+                    mb = b.canMake(this.player.inventory, this.getStation());
+                return ma == mb ? String.CASE_INSENSITIVE_ORDER.compare(
+                    a.result.instance.item.getName(),
+                    b.result.instance.item.getName()
+                ) : (ma ? -1 : 1);
+            }
+        );
+
+        this.items.clear();
+        for (Recipe r : this.recipes) {
+            this.items.add(r.result);
+        }
+    }
+
+    @Override
+    public void init() {
+        super.init();
+        for (Menu m : submenus) {
+            m.init();
+        }
+    }
+
+    @Override
+    public void destroy() {
+        super.destroy();
+        for (Menu m : submenus) {
+            m.destroy();
+        }
+    }
+
+    @Override
+    public void tick() {
+        super.tick();
+
+        this.sort();
+
+        for (Menu m : submenus) {
+            m.tick();
+        }
+    }
+
+    @Override
+    public void update() {
+        super.update();
+        for (Menu m : submenus) {
+            m.update();
+        }
+    }
+
+    @Override
+    public void render() {
+        super.render();
+        for (Menu m : submenus) {
+            m.render();
+        }
+    }
+
+    protected void onCraft(ItemStack stack) {
+        Sound.CRAFT.play();
+    }
+
+    public abstract int getStation();
+
+    public abstract String getName();
+}

Java/Microcraft/src/com/jdh/microcraft/gui/crafting/FurnaceMenu.java

@@ -0,0 +1,35 @@
+package com.jdh.microcraft.gui.crafting;
+
+import com.jdh.microcraft.entity.EntityPlayer;
+import com.jdh.microcraft.entity.furniture.EntityFurnace;
+import com.jdh.microcraft.entity.particle.EntitySmokeParticle;
+import com.jdh.microcraft.item.Item;
+import com.jdh.microcraft.item.ItemStack;
+import com.jdh.microcraft.item.crafting.Recipe;
+
+public class FurnaceMenu extends FurnitureCraftingMenu {
+    public FurnaceMenu(EntityPlayer player, EntityFurnace furnace) {
+        super(player, furnace);
+    }
+
+    @Override
+    protected void onCraft(ItemStack stack) {
+        super.onCraft(stack);
+        EntitySmokeParticle.spawn(
+            this.furniture.level,
+            this.furniture.getCenterX(), this.furniture.getCenterY(),
+            Item.COAL.getColor(),
+            3, 6
+        );
+    }
+
+    @Override
+    public int getStation() {
+        return Recipe.STATION_FURNACE;
+    }
+
+    @Override
+    public String getName() {
+        return "FURNACE";
+    }
+}

Java/Microcraft/src/com/jdh/microcraft/gui/crafting/FurnitureCraftingMenu.java

@@ -0,0 +1,13 @@
+package com.jdh.microcraft.gui.crafting;
+
+import com.jdh.microcraft.entity.EntityPlayer;
+import com.jdh.microcraft.entity.furniture.EntityFurniture;
+
+public abstract class FurnitureCraftingMenu extends CraftingMenu {
+    protected final EntityFurniture furniture;
+
+    public FurnitureCraftingMenu(EntityPlayer player, EntityFurniture furniture) {
+        super(player);
+        this.furniture = furniture;
+    }
+}

Java/Microcraft/src/com/jdh/microcraft/gui/crafting/InventoryCraftingMenu.java

@@ -0,0 +1,37 @@
+package com.jdh.microcraft.gui.crafting;
+
+import com.jdh.microcraft.Global;
+import com.jdh.microcraft.entity.EntityPlayer;
+import com.jdh.microcraft.gui.PlayerInventoryMenu;
+import com.jdh.microcraft.item.crafting.Recipe;
+import com.jdh.microcraft.util.ControlHandler;
+
+public class InventoryCraftingMenu extends CraftingMenu {
+    public InventoryCraftingMenu(EntityPlayer player) {
+        super(player);
+    }
+
+    @Override
+    public void tick() {
+        super.tick();
+
+        if (ControlHandler.TOGGLE_CRAFTING.pressedTick()) {
+            Global.game.setMenu(null);
+        }
+
+        if (ControlHandler.INTERACT.pressedTick()) {
+            // allow direct crafting -> inventory transitions
+            Global.game.setMenu(new PlayerInventoryMenu(this.player, true));
+        }
+    }
+
+    @Override
+    public int getStation() {
+        return Recipe.STATION_INVENTORY;
+    }
+
+    @Override
+    public String getName() {
+        return "CRAFTING";
+    }
+}

Java/Microcraft/src/com/jdh/microcraft/gui/crafting/OvenMenu.java

@@ -0,0 +1,35 @@
+package com.jdh.microcraft.gui.crafting;
+
+import com.jdh.microcraft.entity.EntityPlayer;
+import com.jdh.microcraft.entity.furniture.EntityOven;
+import com.jdh.microcraft.entity.particle.EntitySmokeParticle;
+import com.jdh.microcraft.item.Item;
+import com.jdh.microcraft.item.ItemStack;
+import com.jdh.microcraft.item.crafting.Recipe;
+
+public class OvenMenu extends FurnitureCraftingMenu {
+    public OvenMenu(EntityPlayer player, EntityOven oven) {
+        super(player, oven);
+    }
+
+    @Override
+    protected void onCraft(ItemStack stack) {
+        super.onCraft(stack);
+        EntitySmokeParticle.spawn(
+            this.furniture.level,
+            this.furniture.getCenterX(), this.furniture.getCenterY(),
+            Item.COAL.getColor(),
+            2, 5
+        );
+    }
+
+    @Override
+    public int getStation() {
+        return Recipe.STATION_OVEN;
+    }
+
+    @Override
+    public String getName() {
+        return "OVEN";
+    }
+}

Java/Microcraft/src/com/jdh/microcraft/gui/mainmenu/AboutMenu.java

@@ -0,0 +1,33 @@
+package com.jdh.microcraft.gui.mainmenu;
+
+import com.jdh.microcraft.Global;
+import com.jdh.microcraft.gfx.Font;
+import com.jdh.microcraft.gfx.Renderer;
+import com.jdh.microcraft.gui.DialogMenu;
+
+public class AboutMenu extends DialogMenu {
+    public AboutMenu() {
+        super(
+            "ABOUT",
+            new String [] {
+                "",
+                Font.Colors.YELLOW + "MINICRAFT " + Font.Colors.WHITE + "MADE BY " + Font.Colors.YELLOW + "NOTCH",
+                "FOR " + Font.Colors.BLUE + "LUDUM DARE 22" + Font.Colors.WHITE + " IN 2011.",
+                "",
+                "",
+                Font.Colors.GREEN + "MICROCRAFT" + Font.Colors.WHITE + " REMAKE BY " + Font.Colors.GREEN + "JDH",
+                "FOR " + Font.Colors.ORANGE + "FUN" + Font.Colors.WHITE + " IN 2020.",
+                "",
+                Font.Colors.GREY + "GITHUB.COM/JDAH",
+                Font.Colors.GREY + "YOUTUBE.COM/C/JDHVIDEO"
+            },
+            Renderer.WIDTH / 8, Renderer.HEIGHT / 8,
+            () -> Global.mainMenu.menu = Global.mainMenu.mainMenu
+        );
+    }
+
+    @Override
+    protected boolean shouldCenterText() {
+        return true;
+    }
+}

Java/Microcraft/src/com/jdh/microcraft/gui/mainmenu/HowToPlayMenu.java

@@ -0,0 +1,35 @@
+package com.jdh.microcraft.gui.mainmenu;
+
+import com.jdh.microcraft.Global;
+import com.jdh.microcraft.gfx.Font;
+import com.jdh.microcraft.gfx.Renderer;
+import com.jdh.microcraft.gui.DialogMenu;
+
+public class HowToPlayMenu extends DialogMenu {
+    public HowToPlayMenu() {
+        super(
+            "HOW TO PLAY",
+            new String [] {
+                " ",
+                Font.Colors.GREY + "USE THE " + Font.Colors.GREEN + "POW GLOVE " + Font.Colors.GREY + "TO HIT.",
+                Font.Colors.GREY + "GEAR UP TO FIGHT THE " + Font.Colors.RED + "WIZARD" + Font.Colors.GREY + ".",
+                "",
+                Font.Colors.YELLOW + " WASD" + Font.Colors.WHITE + " TO MOVE",
+                Font.Colors.YELLOW + "SPACE" + Font.Colors.WHITE + " TO HIT",
+                Font.Colors.YELLOW + "    E" + Font.Colors.WHITE + " FOR INVENTORY",
+                Font.Colors.YELLOW + "    E" + Font.Colors.WHITE + " TO USE",
+                Font.Colors.YELLOW + "ENTER" + Font.Colors.WHITE + " TO SELECT",
+                Font.Colors.YELLOW + "    C" + Font.Colors.WHITE + " TO CRAFT",
+                Font.Colors.YELLOW + "    Z" + Font.Colors.WHITE + " TO EQUIP",
+                Font.Colors.YELLOW + "    Q" + Font.Colors.WHITE + " TO DROP"
+            },
+            Renderer.WIDTH / 8, Renderer.HEIGHT / 8,
+            () -> Global.mainMenu.menu = Global.mainMenu.mainMenu
+        );
+    }
+
+    @Override
+    protected boolean shouldAlignToMaxWidth() {
+        return true;
+    }
+}

Java/Microcraft/src/com/jdh/microcraft/gui/mainmenu/LoadingMenu.java

@@ -0,0 +1,56 @@
+package com.jdh.microcraft.gui.mainmenu;
+
+import com.jdh.microcraft.gfx.Font;
+import com.jdh.microcraft.gfx.Renderer;
+import com.jdh.microcraft.gui.Menu;
+import com.jdh.microcraft.util.Window;
+
+public class LoadingMenu extends Menu {
+    private static final int PROGRESS_WIDTH = 128, PROGRESS_HEIGHT = 4;
+
+    public String text;
+    public double progress;
+
+    public LoadingMenu() {
+        this.text = "LOADING";
+        this.progress = 50.0;
+    }
+
+    public void setProgress(double progress) {
+        this.setProgress(this.text, progress);
+    }
+
+    public void setProgress(String text, double progress) {
+        assert(progress >= 0.0 && progress <= 1.0);
+
+        this.text = text;
+        this.progress = progress;
+
+        Renderer.clear();
+        this.render();
+        Window.renderFrame();
+    }
+
+    @Override
+    public void render() {
+        super.render();
+
+        int y = (Renderer.HEIGHT / 2) - 8;
+        Font.render(
+            this.text,
+            (Renderer.WIDTH - Font.width(this.text)) / 2, y,
+            555
+        );
+
+        Renderer.fill(
+            (Renderer.WIDTH - PROGRESS_WIDTH) / 2, y + 12,
+            PROGRESS_WIDTH, PROGRESS_HEIGHT,
+            333
+        );
+        Renderer.fill(
+            (Renderer.WIDTH - PROGRESS_WIDTH) / 2, y + 12,
+            (int) (PROGRESS_WIDTH * this.progress), PROGRESS_HEIGHT,
+            151
+        );
+    }
+}

Java/Microcraft/src/com/jdh/microcraft/gui/mainmenu/MainMenu.java

@@ -0,0 +1,96 @@
+package com.jdh.microcraft.gui.mainmenu;
+
+import com.jdh.microcraft.Global;
+import com.jdh.microcraft.gfx.Color;
+import com.jdh.microcraft.gfx.Font;
+import com.jdh.microcraft.gfx.Renderer;
+import com.jdh.microcraft.gfx.Sprite;
+import com.jdh.microcraft.gui.Menu;
+import com.jdh.microcraft.sound.Sound;
+import com.jdh.microcraft.util.ControlHandler;
+
+public class MainMenu extends Menu {
+    private static final Sprite LOGO = new Sprite("/logo.png");
+    private static final int LOGO_Y = 32;
+
+    private static final String[] OPTIONS = {
+        "START",
+        "HOW TO PLAY",
+        "ABOUT",
+        "QUIT"
+    };
+
+    private static final Runnable[] FUNCTIONS = {
+        () -> {
+            Sound.CRAFT.play();
+            Global.mainMenu.menu = Global.mainMenu.colorSelectMenu;
+        },
+        () -> {
+            Sound.CRAFT.play();
+            Global.mainMenu.menu = Global.mainMenu.howToPlayMenu;
+        },
+        () -> {
+            Sound.CRAFT.play();
+            Global.mainMenu.menu = Global.mainMenu.aboutMenu;
+        },
+        () -> System.exit(0)
+    };
+
+    private int index;
+
+    @Override
+    public void render() {
+        super.render();
+
+        Renderer.render(
+            LOGO,
+            (Renderer.WIDTH - LOGO.width) / 2,
+            LOGO_Y,
+            Color.get(112, 114, 151, 225)
+        );
+
+        int y = LOGO_Y + LOGO.height + 16;
+        for (int i = 0; i < OPTIONS.length; i++) {
+            String s = OPTIONS[i];
+            int color = 333;
+
+            if (i == this.index) {
+                s = "> " + s + " <";
+                color = 555;
+            }
+
+            Font.render(
+                s,
+                (Renderer.WIDTH - Font.width(s)) / 2,
+                y + (i * 8),
+                color
+            );
+        }
+
+        Font.render(
+            Font.Colors.DARK_GREY + "ORIGINALLY BY" + Font.Colors.GREY + " NOTCH",
+            0, Renderer.HEIGHT - 16, 555
+        );
+        Font.render(
+            Font.Colors.DARK_GREY + "REMAKE BY" + Font.Colors.BLUE + " JDH" +
+                Font.Colors.DARK_GREY + " (github.com/jdah)",
+            0, Renderer.HEIGHT - 8, 555);
+    }
+
+    @Override
+    public void tick() {
+        super.tick();
+
+        if (ControlHandler.MENU_UP.pressedTick() && this.index > 0) {
+            this.index--;
+        }
+
+        if (ControlHandler.MENU_DOWN.pressedTick() && this.index < (OPTIONS.length - 1)) {
+            this.index++;
+        }
+
+        if (ControlHandler.MENU_SELECT.pressedTick()) {
+            FUNCTIONS[this.index].run();
+        }
+    }
+}