sync fard

xd

javascript/start.bat

@@ -0,0 +1,2 @@
+@echo off
+ran_windows_amd64.exe --port 80

lwjgl-rundir/resources/pack.txt

@@ -1,2 +1,2 @@
-The default look of Minecraft
-
+Dark theme pack ported by ayunami2000
+Resources by nebulr and rickenzino

src/main/java/me/ayunami2000/ayuncraft/GuiScreenModules.java

@@ -0,0 +1,99 @@
+package me.ayunami2000.ayuncraft;
+
+import net.lax1dude.eaglercraft.EaglerAdapter;
+import net.minecraft.src.*;
+
+public class GuiScreenModules extends GuiScreen {
+
+    public GuiScreenModules(GuiScreen parent) {
+        this.parent = parent;
+    }
+
+    protected String screenTitle = "ayuncraft";
+    private GuiScreen parent;
+    private GuiTextField iteminfo;
+
+    public void initGui() {
+        this.buttonList.add(new GuiButton(200, this.width / 2 - 100, this.height / 6 + 148, "Close"));
+        this.iteminfo = new GuiTextField(this.fontRenderer, this.width / 2 - 98, this.height / 6 + 24, 195, 20);
+        this.iteminfo.setFocused(true);
+        this.iteminfo.setText("383");
+        this.buttonList.add(new GuiButton(1, this.width / 2 - 100, this.height / 6 + 124, "Give"));
+        this.buttonList.add(new GuiButton(2, this.width / 2 - 100, this.height / 6 + 100, "Toggle Notebot"));
+        this.buttonList.add(new GuiButton(3, this.width / 2 - 100, this.height / 6 + 76, "Toggle Legit mode"));
+    }
+
+    public void onGuiClosed() {
+        EaglerAdapter.enableRepeatEvents(false);
+    }
+
+    public void drawScreen(int mx, int my, float par3) {
+        this.drawDefaultBackground();
+        this.drawCenteredString(this.fontRenderer, this.screenTitle, this.width / 2, 15, 16777215);
+        super.drawScreen(mx, my, par3);
+        this.iteminfo.drawTextBox();
+    }
+
+    protected void actionPerformed(GuiButton par1GuiButton) {
+        if(par1GuiButton.id == 200) {
+            this.mc.displayGuiScreen(parent);
+        }else if(par1GuiButton.id == 1) {
+            try{
+                String[] pieces=iteminfo.getText().split(":",2);
+                int itemid=Integer.parseInt(pieces[0]);
+                int dmg=pieces.length==1?0:Integer.parseInt(pieces[1]);
+                ItemStack theitem=new ItemStack(itemid, 64, dmg);
+                mc.thePlayer.inventory.addItemStackToInventory(theitem);
+                //mc.thePlayer.inventoryContainer.detectAndSendChanges();
+                //mc.thePlayer.dropPlayerItem(theitem);
+            }catch(NumberFormatException e){}
+        }else if(par1GuiButton.id == 2) {
+            if(NoteblockPlayer.playing){
+                NoteblockPlayer.playing=false;
+                NoteblockPlayer.thr=null;
+                mc.thePlayer.sendChatToPlayer("Stopped notebot!");
+            }else {
+                NoteblockPlayer.thr = new Thread(new Runnable() {
+                    @Override
+                    public void run() {
+                        EaglerAdapter.openFileChooser("nbs", "application/nbs");
+                        try {
+                            Thread.sleep(1000);
+                            while(!EaglerAdapter.isFocused()){
+                                Thread.sleep(100);
+                            }
+                            Thread.sleep(500);
+                        } catch (InterruptedException e) {}
+                        byte[] b;
+                        if ((b = EaglerAdapter.getFileChooserResult()) != null && b.length > 0) {
+                            String name = EaglerAdapter.getFileChooserResultName();
+                            NoteblockPlayer.songdata = b;
+                            mc.thePlayer.sendChatToPlayer("Playing \""+name+"\" on notebot!");
+                            NoteblockPlayer.play();
+                        }
+                    }
+                });
+                NoteblockPlayer.thr.start();
+            }
+        }else if(par1GuiButton.id == 3){
+            NoteblockPlayer.legit=!NoteblockPlayer.legit;
+        }
+    }
+
+    public void updateScreen() {
+        this.iteminfo.updateCursorCounter();
+    }
+
+    protected void keyTyped(char par1, int par2) {
+        this.iteminfo.textboxKeyTyped(par1, par2);
+    }
+
+    protected void mouseClicked(int par1, int par2, int par3) {
+        super.mouseClicked(par1, par2, par3);
+        this.iteminfo.mouseClicked(par1, par2, par3);
+    }
+
+    public boolean doesGuiPauseGame() {
+        return false;
+    }
+}

src/main/java/me/ayunami2000/ayuncraft/NoteblockPlayer.java

@@ -0,0 +1,453 @@
+package me.ayunami2000.ayuncraft;
+
+import me.ayunami2000.ayuncraft.nbsapi.Layer;
+import me.ayunami2000.ayuncraft.nbsapi.Note;
+import me.ayunami2000.ayuncraft.nbsapi.Song;
+import net.minecraft.client.Minecraft;
+import net.minecraft.src.*;
+
+import java.util.*;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class NoteblockPlayer {
+    public static boolean playing=false;
+    public static byte[] songdata=null;
+    public static Song song=null;
+    public static Thread thr=null;
+    private static final int[] nb2in=new int[]{0,4,1,2,3,7,5,6,8,9,10,11,12,13,14,15};
+    private static int[] in2old=new int[]{0,1,2,3,4,0,0,4,0,0,0,0,4,0,4,0};
+    private static Block[] instruments=new Block[]{Block.dirt,Block.stone,Block.sand,Block.glass,Block.planks};
+    private static Vec3 startingPos = null;
+    private static Minecraft mc=Minecraft.getMinecraft();
+    public static boolean legit=false;
+
+    private static boolean playingSong=false;
+    private static String[] songLiness=null;
+    private static HashMap<Integer,HashMap<Integer,Vec3>> instrNoteToBlocks=null;
+    private static int tickPassed=0;
+    public static void tick(){
+        if(playing&&playingSong){
+            int linesPlayed=0;
+            for (String songLine : songLiness) {
+                String[] songInfo = songLine.split(":");
+                int tick = Integer.parseInt(songInfo[0])-tickPassed;
+                int note = Integer.parseInt(songInfo[1]);
+                int instr = Integer.parseInt(songInfo[2]);
+                if(tick<=0) {
+                    Vec3 blockPos=instrNoteToBlocks.get(instr).get(note);
+                    try {
+                        mc.playerController.clickBlock((int) blockPos.xCoord, (int) (blockPos.yCoord - 1), (int) blockPos.zCoord, 1);
+                        if(legit)rotateToBlock(blockPos.addVector(0,-1,0));
+                    }catch(NullPointerException e){}
+                    //mc.getNetHandler().addToSendQueue(new Packet14BlockDig(0, (int) blockPos.xCoord, (int) blockPos.yCoord, (int) blockPos.zCoord,1));
+                    //mc.thePlayer.swingItem();
+                    linesPlayed++;
+                }else{
+                    break;
+                }
+            }
+            tickPassed++;
+            if(linesPlayed!=0)songLiness=Arrays.copyOfRange(songLiness,linesPlayed,songLiness.length);
+        }
+    }
+
+    /*
+    private static void playSong(String[] songLines,HashMap<Integer,HashMap<Integer,Vec3>> instrNoteToBlock) throws InterruptedException {
+        int ticks=0;
+        for (String songLine : songLines) {
+            if(playing) {
+                String[] songInfo = songLine.split(":");
+                int tick = Integer.parseInt(songInfo[0]);
+                int note = Integer.parseInt(songInfo[1]);
+                int instr = Integer.parseInt(songInfo[2]);
+                if(instr!=-1) {
+                    Vec3 blockPos=instrNoteToBlock.get(instr).get(note);
+                    try {
+                        mc.playerController.clickBlock((int) blockPos.xCoord, (int) (blockPos.yCoord - 1), (int) blockPos.zCoord, 1);
+                        rotateToBlock(blockPos.addVector(0,-1,0));
+                    }catch(NullPointerException e){}
+                    Thread.sleep((tick - ticks) * 50L);
+                    ticks=tick;
+                    //mc.getNetHandler().addToSendQueue(new Packet14BlockDig(0, (int) blockPos.xCoord, (int) blockPos.yCoord, (int) blockPos.zCoord,1));
+                    //mc.thePlayer.swingItem();
+                }
+            }
+        }
+    }
+    */
+
+    public static void rotateToBlock(Vec3 block){
+        block=block.addVector(0.5,0.5,0.5);
+
+        Vec3 eyesPos = mc.thePlayer.getPosition(1).addVector(0,mc.thePlayer.getEyeHeight(),0);
+
+        double diffX = block.xCoord - eyesPos.xCoord;
+        double diffY = block.yCoord - eyesPos.yCoord;
+        double diffZ = block.zCoord - eyesPos.zCoord;
+
+        double diffXZ = Math.sqrt(diffX * diffX + diffZ * diffZ);
+
+        float yaw = (float)Math.toDegrees(Math.atan2(diffZ, diffX)) - 90F;
+        float pitch = (float)-Math.toDegrees(Math.atan2(diffY, diffXZ));
+
+        mc.thePlayer.prevRotationYaw = mc.thePlayer.rotationYaw;
+        mc.thePlayer.prevRotationPitch = mc.thePlayer.rotationPitch;
+        mc.thePlayer.rotationYaw=yaw%360.0F;
+        mc.thePlayer.rotationPitch=pitch%360.0F;
+    }
+
+    public static void play(){
+        playingSong=false;
+        playing=true;
+        String[] songLines=loadSong().split("\n");
+        HashMap<Integer, HashMap<Integer, Vec3>> songBlocks=songLinesToBlocks(songLines);
+        if(playing)placeAndTuneNoteblocks(songBlocks);
+        if(playing) {
+            songLiness=songLines;
+            instrNoteToBlocks=songBlocks;
+            tickPassed=0;
+            playingSong=true;
+            /*
+            try {
+                playSong(songLines,songBlocks);
+            } catch (InterruptedException e) {}
+            */
+        }
+    }
+
+    public static Vec3 notePos=null;
+    public static int targetNote=-1;
+    public static boolean correctNote=false;
+    public static int currentNote=-1;
+    public static int theoreticalNote=-1;
+    public static void notePlayed(int x,int y,int z,int note){
+        if(!playing){
+            correctNote=false;
+            notePos=null;
+            targetNote=-1;
+            currentNote=-1;
+            theoreticalNote=-1;
+        }
+        if(notePos!=null&&targetNote!=-1){
+            if((int)notePos.xCoord==x&&(int)notePos.yCoord==y+1&&(int)notePos.zCoord==z){
+                currentNote=note;
+                if(theoreticalNote<0)theoreticalNote=currentNote;
+                mc.thePlayer.sendChatToPlayer("Tuning: "+note+"/"+targetNote);
+                if(targetNote==note) {
+                    notePos = null;
+                    targetNote = -1;
+                    currentNote = -1;
+                    theoreticalNote = -1;
+                    correctNote = true;
+                }
+            }
+        }
+    }
+
+    public static boolean building=false;
+    public static void placeAndTuneNoteblocks(HashMap<Integer, HashMap<Integer, Vec3>> instrNoteToBlock){
+        if(!playing)return;
+        building=true;
+        //mc.thePlayer.sendChatMessage("/gamemode 1");
+        try {
+            Thread.sleep(100);
+        } catch (InterruptedException e) {}
+        for(Map.Entry<Integer, HashMap<Integer, Vec3>> entry : instrNoteToBlock.entrySet()) {
+            Integer instr = entry.getKey();
+            HashMap<Integer, Vec3> noteBlockPos = entry.getValue();
+            for(Map.Entry<Integer, Vec3> entryy : noteBlockPos.entrySet()) {
+                Integer note = entryy.getKey();
+                Vec3 blockPos = entryy.getValue();
+                if(playing) {
+                    Vec3 currPos=mc.thePlayer.getPosition(1);
+                    //double rangeBlockDist=currPos.addVector(0,mc.thePlayer.getEyeHeight(),0).distanceTo(blockPosVec3d);
+                    double blockDist=currPos.distanceTo(blockPos);
+                    double oldBlockDist=32767;
+                    boolean hasBeenPlaced=false;
+                    correctNote=false;
+                    while (playing&&((!hasBeenPlaced)||(!correctNote))/*!(rangeBlockDist <= mc.playerController.getBlockReachDistance()+1.0F && (blockDist >= 1.25F))*/) {
+                        if(Math.abs(oldBlockDist-blockDist)>0.1){
+                            mc.thePlayer.sendChatToPlayer("Need noteblock with instrument "+instruments[instr].getLocalizedName()+" and tuning "+note+". Distance: "+blockDist+". XYZ: "+blockPos);
+                        }
+                        oldBlockDist=blockDist;
+                        int id1=mc.theWorld.getBlockId((int)blockPos.xCoord,(int)(blockPos.yCoord-1),(int)blockPos.zCoord);
+                        int id2=mc.theWorld.getBlockId((int)blockPos.xCoord,(int)(blockPos.yCoord-2),(int)blockPos.zCoord);
+                        boolean check1=id1==Block.music.blockID;
+                        boolean check2=id2==instruments[instr].blockID;
+                        int slot1id=mc.thePlayer.inventory.mainInventory[0]==null?-1:mc.thePlayer.inventory.mainInventory[0].itemID;
+                        if(mc.playerController.isInCreativeMode()) {
+                            if (check2 && (!check1)) {
+                                if(slot1id != Block.music.blockID) {
+                                    //give block
+                                    ItemStack item = new ItemStack(Block.music);
+                                    mc.thePlayer.inventory.mainInventory[0] = item;
+                                    mc.playerController.sendSlotPacket(item, mc.thePlayer.inventoryContainer.inventorySlots.size() - 9);
+                                    mc.getNetHandler().addToSendQueue(new Packet16BlockItemSwitch(0));
+                                    try{
+                                        Thread.sleep(50);
+                                    } catch (InterruptedException e) {}
+                                }
+                                rotateToBlock(blockPos.addVector(0,-1,0));
+                                if(id1!=0) {
+                                    //attempt to break
+                                    mc.getNetHandler().addToSendQueue(new Packet14BlockDig(0, (int) blockPos.xCoord, (int) (blockPos.yCoord - 1), (int) blockPos.zCoord, 1));
+                                    mc.getNetHandler().addToSendQueue(new Packet14BlockDig(1, (int) blockPos.xCoord, (int) (blockPos.yCoord - 1), (int) blockPos.zCoord, 1));
+                                    mc.getNetHandler().addToSendQueue(new Packet14BlockDig(2, (int) blockPos.xCoord, (int) (blockPos.yCoord - 1), (int) blockPos.zCoord, 1));
+                                    PlayerControllerMP.clickBlockCreative(mc, mc.playerController, (int) blockPos.xCoord, (int) (blockPos.yCoord - 1), (int) blockPos.zCoord, 1);
+                                    try{
+                                        Thread.sleep(50);
+                                    } catch (InterruptedException e) {}
+                                }
+                                /*
+                                //attempt to place
+                                if(legit)rotateToBlock(blockPos.addVector(0,-1,0));
+                                mc.thePlayer.inventory.currentItem=0;
+                                mc.getNetHandler().addToSendQueue(new Packet15Place((int) blockPos.xCoord, (int) (blockPos.yCoord-1), (int) blockPos.zCoord,1,mc.thePlayer.inventory.getCurrentItem(),0,1,0));
+                                */
+                            }else if ((!check2) && (!check1)) {
+                                if(slot1id != instruments[instr].blockID) {
+                                    //give block
+                                    ItemStack item = new ItemStack(instruments[instr]);
+                                    mc.thePlayer.inventory.mainInventory[0] = item;
+                                    mc.playerController.sendSlotPacket(item, mc.thePlayer.inventoryContainer.inventorySlots.size() - 9);
+                                    mc.getNetHandler().addToSendQueue(new Packet16BlockItemSwitch(0));
+                                    try{
+                                        Thread.sleep(50);
+                                    } catch (InterruptedException e) {}
+                                }
+                                rotateToBlock(blockPos.addVector(0,-2,0));
+                                if(id1!=0) {
+                                    //attempt to break block above
+                                    mc.getNetHandler().addToSendQueue(new Packet14BlockDig(0, (int) blockPos.xCoord, (int) (blockPos.yCoord - 1), (int) blockPos.zCoord, 1));
+                                    mc.getNetHandler().addToSendQueue(new Packet14BlockDig(1, (int) blockPos.xCoord, (int) (blockPos.yCoord - 1), (int) blockPos.zCoord, 1));
+                                    mc.getNetHandler().addToSendQueue(new Packet14BlockDig(2, (int) blockPos.xCoord, (int) (blockPos.yCoord - 1), (int) blockPos.zCoord, 1));
+                                    PlayerControllerMP.clickBlockCreative(mc, mc.playerController, (int) blockPos.xCoord, (int) (blockPos.yCoord - 1), (int) blockPos.zCoord, 1);
+                                    try{
+                                        Thread.sleep(50);
+                                    } catch (InterruptedException e) {}
+                                }
+                                if(id2!=0) {
+                                    //attempt to break
+                                    mc.getNetHandler().addToSendQueue(new Packet14BlockDig(0, (int) blockPos.xCoord, (int) (blockPos.yCoord - 2), (int) blockPos.zCoord, 1));
+                                    mc.getNetHandler().addToSendQueue(new Packet14BlockDig(1, (int) blockPos.xCoord, (int) (blockPos.yCoord - 2), (int) blockPos.zCoord, 1));
+                                    mc.getNetHandler().addToSendQueue(new Packet14BlockDig(2, (int) blockPos.xCoord, (int) (blockPos.yCoord - 2), (int) blockPos.zCoord, 1));
+                                    PlayerControllerMP.clickBlockCreative(mc, mc.playerController, (int) blockPos.xCoord, (int) (blockPos.yCoord - 2), (int) blockPos.zCoord, 1);
+                                    try{
+                                        Thread.sleep(50);
+                                    } catch (InterruptedException e) {}
+                                }
+                                /*
+                                //attempt to place
+                                if(legit)rotateToBlock(blockPos.addVector(0,-2,0));
+                                mc.thePlayer.inventory.currentItem=0;
+                                mc.getNetHandler().addToSendQueue(new Packet15Place((int) blockPos.xCoord, (int) (blockPos.yCoord-2), (int) blockPos.zCoord,1,mc.thePlayer.inventory.getCurrentItem(),0,1,0));
+                                */
+                            }
+                        }
+                        if(check1&&check2){
+                            hasBeenPlaced=true;
+                            notePos=blockPos;
+                            targetNote=note;
+                            if(theoreticalNote==-1){
+                                theoreticalNote=-2;
+                                //find out the note
+                                if(mc.playerController.isInCreativeMode()) {
+                                    mc.getNetHandler().addToSendQueue(new Packet15Place((int) blockPos.xCoord, (int) (blockPos.yCoord - 1), (int) blockPos.zCoord, 1, mc.thePlayer.inventory.getCurrentItem(), 0, 1, 0));
+                                }else{
+                                    mc.playerController.clickBlock((int) blockPos.xCoord, (int) blockPos.yCoord-1, (int) blockPos.zCoord,1);
+                                }
+                            }else if(theoreticalNote>=0&&theoreticalNote!=targetNote) {
+                                theoreticalNote=(theoreticalNote+1)%25;
+                                mc.getNetHandler().addToSendQueue(new Packet15Place((int) blockPos.xCoord, (int) (blockPos.yCoord - 1), (int) blockPos.zCoord, 1, mc.thePlayer.inventory.getCurrentItem(), 0, 1, 0));
+                            }
+                        }else{
+                            notePos=null;
+                            targetNote=-1;
+                            currentNote=-1;
+                            hasBeenPlaced=false;
+                        }
+                        try {
+                            Thread.sleep(50);
+                        } catch (InterruptedException e) {}
+                        currPos=mc.thePlayer.getPosition(1);
+                        //rangeBlockDist=currPos.addVector(0,mc.thePlayer.getEyeHeight(),0).distanceTo(blockPosVec3d);
+                        blockDist=currPos.distanceTo(blockPos);
+                    }
+                    correctNote=false;
+                    /*
+                    if(playing) {
+                        ItemStack noteblocks = new ItemStack(instruments[instr]);
+                        mc.thePlayer.inventory.clearInventory(-1,-1);
+                        mc.thePlayer.inventory.currentItem=0;
+                        mc.thePlayer.inventory.mainInventory[mc.thePlayer.inventory.currentItem]=noteblocks;
+                        mc.playerController.sendSlotPacket(noteblocks,0);
+                        try {
+                            Thread.sleep(100);
+                            //mc.thePlayer.inventoryContainer.detectAndSendChanges();
+                        }catch(InterruptedException e){}
+                        PlayerControllerMP.clickBlockCreative(mc,mc.playerController, (int) blockPos.xCoord, (int) (blockPos.yCoord-2), (int) blockPos.zCoord,1);
+                        mc.thePlayer.swingItem();
+                        try {
+                            Thread.sleep(50);
+                            mc.getNetHandler().addToSendQueue(new Packet15Place((int) blockPos.xCoord, (int) (blockPos.yCoord-1), (int) blockPos.zCoord,1,mc.thePlayer.inventory.getCurrentItem(),0,1,0));
+                            Thread.sleep(50);
+                        } catch (InterruptedException e) {
+                        }
+                        noteblocks = new ItemStack(Block.music);
+                        mc.thePlayer.inventory.clearInventory(-1,-1);
+                        mc.thePlayer.inventory.currentItem=0;
+                        mc.thePlayer.inventory.mainInventory[mc.thePlayer.inventory.currentItem]=noteblocks;
+                        mc.getNetHandler().addToSendQueue(new Packet16BlockItemSwitch(0));
+                        mc.playerController.sendSlotPacket(noteblocks,0);
+                        try {
+                            Thread.sleep(100);
+                            //mc.thePlayer.inventoryContainer.detectAndSendChanges();
+                        }catch(InterruptedException e){}
+                        PlayerControllerMP.clickBlockCreative(mc,mc.playerController, (int) blockPos.xCoord, (int) (blockPos.yCoord-1), (int) blockPos.zCoord,1);
+                        mc.thePlayer.swingItem();
+                        try {
+                            Thread.sleep(50);
+                            mc.getNetHandler().addToSendQueue(new Packet15Place((int) blockPos.xCoord, (int) blockPos.yCoord, (int) blockPos.zCoord,1,mc.thePlayer.inventory.getCurrentItem(),0,1,0));
+                            Thread.sleep(50);
+                            for(int i=0;i<note;i++){
+                                Thread.sleep(50);
+                                mc.getNetHandler().addToSendQueue(new Packet15Place((int) blockPos.xCoord, (int) blockPos.yCoord, (int) blockPos.zCoord,1,mc.thePlayer.inventory.getCurrentItem(),0,1,0));
+                            }
+                        } catch (InterruptedException e) {
+                        }
+                    }
+                    */
+                }
+            }
+        }
+        if(playing) {
+            mc.thePlayer.sendChatMessage("/gamemode 0");
+            try {
+                Thread.sleep(500);
+            } catch (InterruptedException e) {}
+        }
+        building = false;
+    }
+
+    public static List<int[]> spiral(int size){
+        List<int[]> result=new ArrayList<int[]>();
+        int x = 0; // current position; x
+        int y = 0; // current position; y
+        int d = 0; // current direction; 0=RIGHT, 1=DOWN, 2=LEFT, 3=UP
+        int c = 0; // counter
+        int s = 1; // chain size
+
+        // starting point
+        x = ((int)Math.floor(size/2.0))-1;
+        y = ((int)Math.floor(size/2.0))-1;
+
+        for (int k=1; k<=(size-1); k++)
+        {
+            for (int j=0; j<(k<(size-1)?2:3); j++)
+            {
+                for (int i=0; i<s; i++)
+                {
+                    result.add(new int[]{x,y});
+                    c++;
+
+                    switch (d)
+                    {
+                        case 0: y = y + 1; break;
+                        case 1: x = x + 1; break;
+                        case 2: y = y - 1; break;
+                        case 3: x = x - 1; break;
+                    }
+                }
+                d = (d+1)%4;
+            }
+            s = s + 1;
+        }
+        return result;
+    }
+
+    public static HashMap<Integer, HashMap<Integer, Vec3>> songLinesToBlocks(String[] songLines){
+        HashMap<Integer,HashMap<Integer,Vec3>> instrNoteToBlock=new HashMap<>();
+        int uniqueNotes=0;
+        startingPos=Vec3.createVectorHelper(Math.floor(mc.thePlayer.posX),Math.floor(mc.thePlayer.posY),Math.floor(mc.thePlayer.posZ));
+        Vec3 centerPos=startingPos.addVector(0,-1,0);
+        for (String songLine : songLines) {
+            String[] songInfo = songLine.split(":");
+            int tick = Integer.parseInt(songInfo[0]);
+            int note = Integer.parseInt(songInfo[1]);
+            int instr = Integer.parseInt(songInfo[2]);
+            if(!(instrNoteToBlock.containsKey(instr)&&instrNoteToBlock.get(instr).containsKey(note))){
+                HashMap<Integer,Vec3> theVal=instrNoteToBlock.containsKey(instr)?instrNoteToBlock.get(instr):new HashMap<Integer,Vec3>();
+                theVal.put(note,centerPos);
+                instrNoteToBlock.put(instr,theVal);
+                uniqueNotes++;
+            }
+        }
+        AtomicInteger counter= new AtomicInteger();
+        //fuck you, add 1 to spiral size. excess is already disposed of, so does it really matter if it only runs once?
+        List<int[]> spiralCoords=spiral(1+Math.min(9,(int)Math.ceil(Math.sqrt(uniqueNotes))));
+        List<int[]> spiralCoordsTwo=uniqueNotes>81?spiral(1+(int)Math.ceil(Math.sqrt(uniqueNotes-81))):new ArrayList<int[]>();
+
+        for(Map.Entry<Integer, HashMap<Integer, Vec3>> entry : instrNoteToBlock.entrySet()) {
+            Integer instr = entry.getKey();
+            HashMap<Integer, Vec3> noteBlockPos = entry.getValue();
+            HashMap<Integer, Vec3> noteBlockPosOrig = (HashMap<Integer, Vec3>) noteBlockPos.clone();
+            for(Map.Entry<Integer, Vec3> entryy : noteBlockPos.entrySet()) {
+                Integer note = entryy.getKey();
+                Vec3 blockPos = entryy.getValue();
+                int currNum=counter.getAndIncrement();
+                Vec3 theBlock=Vec3.createVectorHelper(blockPos.xCoord,blockPos.yCoord,blockPos.zCoord);
+                if(currNum>=81){
+                    theBlock=theBlock.addVector(spiralCoordsTwo.get(currNum-81)[0]-spiralCoordsTwo.get(0)[0],4,spiralCoordsTwo.get(currNum-81)[1]-spiralCoordsTwo.get(0)[1]);
+                }else{
+                    //todo: fix corners
+                    theBlock=theBlock.addVector(spiralCoords.get(currNum)[0]-spiralCoords.get(0)[0],0,spiralCoords.get(currNum)[1]-spiralCoords.get(0)[1]);
+                    Vec3 offset=theBlock.subtract(blockPos);
+                    if(Math.abs(offset.xCoord)==4&&Math.abs(offset.zCoord)==4){
+                        theBlock=theBlock.addVector(0,1,0);
+                    }
+                }
+                noteBlockPos.replace(note,blockPos,theBlock);
+            }
+            instrNoteToBlock.replace(instr,noteBlockPosOrig,noteBlockPos);
+        }
+        return instrNoteToBlock;
+    }
+
+    public static String loadSong(){
+        try{
+            String resSongFile="";
+            Map<Integer, ArrayList<String>> songLines=new HashMap<>();
+            Song nbsSong = new Song(songdata);
+            List<Layer> nbsSongBoard = nbsSong.getSongBoard();
+            for (int i = 0; i < nbsSongBoard.size(); i++) {
+                Layer layer=nbsSongBoard.get(i);
+                HashMap<Integer, Note> noteList = layer.getNoteList();
+                for (Map.Entry note : noteList.entrySet()) {
+                    Note noteInfo = (Note) note.getValue();
+                    Integer noteKey=(int)((double)(int)note.getKey()/(5.0*((double)nbsSong.getTempo()/10000.0)));
+                    if(!songLines.containsKey(noteKey))songLines.put(noteKey,new ArrayList<String>());
+                    ArrayList<String> tickLines=songLines.get(noteKey);
+                    //keep notes within 2-octave range
+                    Integer notePitch=Math.max(33,Math.min(57,noteInfo.getPitch()))-33;
+                    int instrId=noteInfo.getInstrument().getID();
+                    if(instrId!=-1)instrId=in2old[nb2in[instrId]];
+                    tickLines.add(noteKey + ":" + notePitch + ":" + instrId + "\n");
+                    songLines.put(noteKey,tickLines);
+                }
+            }
+            SortedSet<Integer> ticks = new TreeSet<>(songLines.keySet());
+            for (Integer tick : ticks) {
+                ArrayList<String> tickLines = songLines.get(tick);
+                for(int i=0;i<tickLines.size();i++){
+                    resSongFile+=tickLines.get(i);
+                }
+            }
+            if(resSongFile.endsWith("\n"))resSongFile=resSongFile.substring(0,resSongFile.length()-1);
+            return resSongFile;
+        }catch(Exception e){
+            //e.printStackTrace();
+            playing=false;
+            return null;
+        }
+    }
+}

src/main/java/me/ayunami2000/ayuncraft/nbsapi/Instrument.java

@@ -0,0 +1,54 @@
+package me.ayunami2000.ayuncraft.nbsapi;
+
+/**
+ * Note block's instrument.
+ * @author Le Duy Quang
+ *
+ */
+public enum Instrument {
+	HARP (0),
+	BASS (1),
+	DRUM (2),
+	SNARE (3),
+	CLICK (4),
+	GUITAR (5),
+	FLUTE (6),
+	BELL (7),
+	CHIME (8),
+	XYLOPHONE (9);
+	
+	private final int ID;
+	private Instrument(int ID) {
+		this.ID = ID;
+	}
+	
+	/**
+	 * Returns an ID of the instrument to be written in NBS files.
+	 * @return The ID.
+	 */
+	public int getID() {
+		return ID;
+	}
+	
+	/**
+	 * Determines the instrument from its NBS file ID.
+	 * @param ID The instrument ID (0-9).
+	 * @return The corresponding instrument.
+	 * @throws IllegalArgumentException
+	 */
+	public static Instrument fromID(int ID) throws IllegalArgumentException {
+		switch (ID) {
+		case 0: return HARP;
+		case 1: return BASS;
+		case 2: return DRUM;
+		case 3: return SNARE;
+		case 4: return CLICK;
+		case 5: return GUITAR;
+		case 6: return FLUTE;
+		case 7: return BELL;
+		case 8: return CHIME;
+		case 9: return XYLOPHONE;
+		default: throw new IllegalArgumentException("ID must be from 1 to 9.");
+		}
+	}
+}

src/main/java/me/ayunami2000/ayuncraft/nbsapi/Layer.java

@@ -0,0 +1,61 @@
+package me.ayunami2000.ayuncraft.nbsapi;
+
+import java.util.HashMap;
+
+/**
+ * A layer of a song.
+ * @author Le Duy Quang
+ *
+ */
+public class Layer {
+	private HashMap<Integer, Note> notes = new HashMap<Integer, Note>();
+	private String name;
+	private byte volume;
+	
+	/**
+	 * Creates an empty layer with name and volume.
+	 * @param name The layer's name.
+	 * @param volume The layer's volume (0-100).
+	 * @throws IllegalArgumentException
+	 */
+	public Layer(String name, byte volume) throws IllegalArgumentException {
+		setName(name);
+		setVolume(volume);
+	}
+	
+	/**
+	 * Returns the note list of the layer.
+	 * @return The list.
+	 */
+	public HashMap<Integer, Note> getNoteList() {
+		return notes;
+	}
+	
+	/**
+	 * Sets the note at a tick on the layer.
+	 * @param pos The tick where the note is on.
+	 * @param note The note's properties.
+	 * @throws IllegalArgumentException
+	 */
+	public void setNote(int pos, Note note) throws IllegalArgumentException {
+		if (pos < 0) throw new IllegalArgumentException("Note position must not be negative.");
+		notes.put(pos, note);
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	public void setName(String name) {
+		this.name = name;
+	}
+
+	public byte getVolume() {
+		return volume;
+	}
+
+	public void setVolume(byte volume) throws IllegalArgumentException {
+		if (volume < 0 || volume > 100) throw new IllegalArgumentException("Volume must be from 0 to 100.");
+		this.volume = volume;
+	}
+}

src/main/java/me/ayunami2000/ayuncraft/nbsapi/Note.java

@@ -0,0 +1,40 @@
+package me.ayunami2000.ayuncraft.nbsapi;
+
+/**
+ * A note in a song.
+ * @author Le Duy Quang
+ *
+ */
+public class Note {
+	private Instrument instrument;
+	private byte pitch;
+	
+	/**
+	 * A note in a song.
+	 * @param instrument The instrument of the note.
+	 * @param pitch The pitch of the note (0-87).
+	 * @throws IllegalArgumentException
+	 */
+	public Note(Instrument instrument, byte pitch) throws IllegalArgumentException {
+		if (pitch < 0 || pitch > 87) throw new IllegalArgumentException("Pitch must be from 0 to 87.");
+		setInstrument(instrument);
+		setPitch(pitch);
+	}
+
+	public Instrument getInstrument() {
+		return instrument;
+	}
+
+	public void setInstrument(Instrument instrument) {
+		this.instrument = instrument;
+	}
+
+	public byte getPitch() {
+		return pitch;
+	}
+
+	public void setPitch(byte pitch) throws IllegalArgumentException {
+		if (pitch < 0 || pitch > 87) throw new IllegalArgumentException("Pitch must be from 0 to 87.");
+		this.pitch = pitch;
+	}
+}

src/main/java/me/ayunami2000/ayuncraft/nbsapi/Song.java

@@ -0,0 +1,367 @@
+package me.ayunami2000.ayuncraft.nbsapi;
+
+import java.util.*;
+import java.io.*;
+
+/**
+ * A note block song.
+ * @author Le Duy Quang
+ *
+ */
+public class Song {
+	private short length;
+	private short height;
+	private String name;
+	private String author;
+	private String originalAuthor;
+	private String description;
+	private short tempo;
+	private boolean autoSave;
+	private byte autoSaveDuration;
+	private byte timeSignature;
+	private int minutesSpent;
+	private int leftClicks;
+	private int rightClicks;
+	private int blocksAdded;
+	private int blocksRemoved;
+	private String MidiSchematicFile;
+	private List<Layer> songBoard;
+	
+	private ByteArrayInputStream instream;
+	private DataInputStream in;
+	private FileOutputStream outstream;
+	private DataOutputStream out;
+	
+	/**
+	 * Builds a new song with the given information.
+	 * @param length
+	 * @param name
+	 * @param author
+	 * @param originalAuthor
+	 * @param description
+	 * @param tempo
+	 * @param autoSave
+	 * @param autoSaveDuration
+	 * @param timeSignature
+	 * @param minutesSpent
+	 * @param leftClicks
+	 * @param rightClicks
+	 * @param blocksAdded
+	 * @param blocksRemoved
+	 * @param MidiSchematicFile
+	 * @param songBoard
+	 * @throws IllegalArgumentException
+	 */
+	public Song(
+			short length,
+			String name,
+			String author,
+			String originalAuthor,
+			String description,
+			short tempo,
+			boolean autoSave,
+			byte autoSaveDuration,
+			byte timeSignature,
+			int minutesSpent,
+			int leftClicks,
+			int rightClicks,
+			int blocksAdded,
+			int blocksRemoved,
+			String MidiSchematicFile,
+			List<Layer> songBoard) throws IllegalArgumentException {
+		setLength(length);
+		setName(name);
+		setAuthor(author);
+		setOriginalAuthor(originalAuthor);
+		setDescription(description);
+		setTempo(tempo);
+		setAutoSave(autoSave);
+		setAutoSaveDuration(autoSaveDuration);
+		setTimeSignature(timeSignature);
+		setLeftClicks(leftClicks);
+		setRightClicks(rightClicks);
+		setBlocksAdded(blocksAdded);
+		setBlocksRemoved(blocksRemoved);
+		setMidiSchematicFile(MidiSchematicFile);
+		changeSongBoardTo(songBoard);
+	}
+	
+	/**
+	 * Reads a song from a byte array.
+	 * @param fromBytes The byte array that should be read.
+	 * @throws IOException
+	 */
+	public Song(byte[] fromBytes) throws IOException {
+		instream = new ByteArrayInputStream(fromBytes);
+		in = new DataInputStream(instream);
+		setLength(readShort());
+		setHeight(readShort());
+		setName(readString());
+		setAuthor(readString());
+		setOriginalAuthor(readString());
+		setDescription(readString());
+		setTempo(readShort());
+		setAutoSave(in.readBoolean());
+		setAutoSaveDuration(in.readByte());
+		setTimeSignature(in.readByte());
+		setMinutesSpent(readInt());
+		setLeftClicks(readInt());
+		setRightClicks(readInt());
+		setBlocksAdded(readInt());
+		setBlocksRemoved(readInt());
+		setMidiSchematicFile(readString());
+		
+		songBoard = new ArrayList<Layer>();
+		for (int i = 0; i < height; i++) songBoard.add(new Layer("",(byte) 100));
+		int tick = -1;
+		while (true) {
+			short jumpDistance = readShort();
+			if (jumpDistance == 0) break;
+			tick += jumpDistance;
+			short layer = -1;
+			while (true) {
+				short jumpLayers = readShort();
+				if (jumpLayers == 0) break;
+				layer += jumpLayers;
+				while (songBoard.size() < layer+1) {
+					songBoard.add(new Layer("",(byte) 100));
+				}
+				songBoard.get(layer).setNote(tick, new Note(Instrument.fromID(in.readByte()), in.readByte()));
+			}
+		}
+		for (int i = 0; i < getHeight(); i++) {
+			songBoard.get(i).setName(readString());
+			songBoard.get(i).setVolume(in.readByte());
+		}
+		in.close();
+		instream.close();
+	}
+	
+	/**
+	 * Writes the song to the specific file.
+	 * @param toFile The file to write to.
+	 * @throws IOException
+	 */
+	public void writeSong(File toFile) throws IOException {
+		short maxLength = -1;
+		for (Layer l : songBoard) {
+			short maxPos = -1;
+			for (int i : l.getNoteList().keySet()) {
+				if (i > maxPos) maxPos = (short) i;
+			}
+			if (maxPos > maxLength) maxLength = maxPos;
+		}
+		setLength((short) Math.max(1, maxLength));
+		setHeight((short) songBoard.size());
+		
+		outstream = new FileOutputStream(toFile);
+		out = new DataOutputStream(outstream);
+		writeShort(length);
+		writeShort(height);
+		writeString(name);
+		writeString(author);
+		writeString(originalAuthor);
+		writeString(description);
+		writeShort(tempo);
+		out.writeByte(autoSave ? 1 : 0);
+		out.writeByte(autoSaveDuration);
+		out.writeByte(timeSignature);
+		writeInt(minutesSpent);
+		writeInt(leftClicks);
+		writeInt(rightClicks);
+		writeInt(blocksAdded);
+		writeInt(blocksRemoved);
+		writeString(MidiSchematicFile);
+		
+		List<WritableNote> noteList = Utils.convertToWritable(songBoard);
+		int oldTick = -1;
+		int oldLayer = -1;
+		for (WritableNote i : noteList) {
+			if (i.getLocation() > oldTick) {
+				if (oldTick != -1) writeShort((short)0);
+				writeShort((short) (i.getLocation() - oldTick));
+				oldTick = i.getLocation();
+				oldLayer = -1;
+			}
+			writeShort((short)(i.getLayer() - oldLayer));
+			oldLayer = i.getLayer();
+			out.writeByte(i.getInstrument().getID());
+			out.writeByte(i.getPitch());
+		}
+		writeShort((short)0);
+		writeShort((short)0);
+		
+		for (Layer l : songBoard) {
+			writeString(l.getName());
+			out.writeByte(l.getVolume());
+		}
+		
+		out.writeByte(0);
+		out.close();
+		outstream.close();
+	}
+	
+	public short getLength() {
+		return length;
+	}
+	protected void setLength(short length) throws IllegalArgumentException {
+		if (length < 0) throw new IllegalArgumentException("Song length must not be negative.");
+		this.length = length;
+	}
+	public short getHeight() {
+		return height;
+	}
+	protected void setHeight(short height) throws IllegalArgumentException {
+		if (height < 0) throw new IllegalArgumentException("Song height must not be negative.");
+		this.height = height;
+	}
+	public String getName() {
+		return name;
+	}
+	public void setName(String name) {
+		this.name = name;
+	}
+	public String getAuthor() {
+		return author;
+	}
+	public void setAuthor(String author) {
+		this.author = author;
+	}
+	public String getOriginalAuthor() {
+		return originalAuthor;
+	}
+	public void setOriginalAuthor(String originalAuthor) {
+		this.originalAuthor = originalAuthor;
+	}
+	public String getDescription() {
+		return description;
+	}
+	public void setDescription(String description) {
+		this.description = description;
+	}
+	public short getTempo() {
+		return tempo;
+	}
+	public void setTempo(short tempo) throws IllegalArgumentException {
+		if (tempo < 25) throw new IllegalArgumentException("Tempo is too small!");
+		if (tempo%25 != 0) throw new IllegalArgumentException("Tempo must be a multiplication of 25.");
+		this.tempo = tempo;
+	}
+	public boolean isAutoSaveEnabled() {
+		return autoSave;
+	}
+	public void setAutoSave(boolean autoSave) {
+		this.autoSave = autoSave;
+	}
+	public byte getAutoSaveDuration() {
+		return autoSaveDuration;
+	}
+	public void setAutoSaveDuration(byte autoSaveDuration) throws IllegalArgumentException {
+		if (autoSaveDuration < 1 || autoSaveDuration > 60) throw new IllegalArgumentException("Auto-save duration must be from 1 to 60.");
+		this.autoSaveDuration = autoSaveDuration;
+	}
+	public byte getTimeSignature() {
+		return timeSignature;
+	}
+	public void setTimeSignature(byte timeSignature) throws IllegalArgumentException {
+		if (timeSignature < 2 || timeSignature > 8) throw new IllegalArgumentException("Time signature must be from 2 to 8.");
+		this.timeSignature = timeSignature;
+	}
+	public int getMinutesSpent() {
+		return minutesSpent;
+	}
+	public void setMinutesSpent(int minutesSpent) throws IllegalArgumentException {
+		if (minutesSpent < 0) throw new IllegalArgumentException("RMinutes spent must not be negative.");
+		this.minutesSpent = minutesSpent;
+	}
+	public int getRightClicks() {
+		return rightClicks;
+	}
+	public void setRightClicks(int rightClicks) throws IllegalArgumentException {
+		if (rightClicks < 0) throw new IllegalArgumentException("Right-click count must not be negative.");
+		this.rightClicks = rightClicks;
+	}
+	public int getLeftClicks() {
+		return leftClicks;
+	}
+	public void setLeftClicks(int leftClicks) throws IllegalArgumentException {
+		if (leftClicks < 0) throw new IllegalArgumentException("Left-click count must not be negative.");
+		this.leftClicks = leftClicks;
+	}
+	public int getBlocksAdded() {
+		return blocksAdded;
+	}
+	public void setBlocksAdded(int blocksAdded) throws IllegalArgumentException {
+		if (blocksAdded < 0) throw new IllegalArgumentException("Blocks added must not be negative.");
+		this.blocksAdded = blocksAdded;
+	}
+	public int getBlocksRemoved() {
+		return blocksRemoved;
+	}
+	public void setBlocksRemoved(int blocksRemoved) throws IllegalArgumentException {
+		if (blocksRemoved < 0) throw new IllegalArgumentException("Blocks removed must not be negative.");
+		this.blocksRemoved = blocksRemoved;
+	}
+	public String getMidiSchematicFile() {
+		return MidiSchematicFile;
+	}
+	public void setMidiSchematicFile(String midiSchematicFile) {
+		MidiSchematicFile = midiSchematicFile;
+	}
+
+	public List<Layer> getSongBoard() {
+		return songBoard;
+	}
+
+	public void changeSongBoardTo(List<Layer> songBoard) {
+		this.songBoard = songBoard;
+	}
+	
+	// The code below is imported from xxmicloxx's NoteBlockAPI (LGPL 3.0).
+	
+	private short readShort() throws IOException {
+		int byte1 = in.readUnsignedByte();
+        int byte2 = in.readUnsignedByte();
+        return (short) (byte1 + (byte2 << 8));
+	}
+	
+	private int readInt() throws IOException {
+        int byte1 = in.readUnsignedByte();
+        int byte2 = in.readUnsignedByte();
+        int byte3 = in.readUnsignedByte();
+        int byte4 = in.readUnsignedByte();
+        return (byte1 + (byte2 << 8) + (byte3 << 16) + (byte4 << 24));
+    }
+	
+	private String readString() throws IOException {
+        int length = readInt();
+        StringBuilder sb = new StringBuilder(length);
+        for (; length > 0; --length) {
+            char c = (char) in.readByte();
+            if (c == (char) 0x0D) {
+                c = ' ';
+            }
+            sb.append(c);
+        }
+        return sb.toString();
+    }
+	
+	// End of inported code.
+	
+	private void writeShort(short num) throws IOException {
+		out.writeByte(num%256);
+		out.writeByte(num/256);
+	}
+	
+	private void writeInt(int num) throws IOException {
+		out.writeByte(num%256);
+		out.writeByte(num%65536/256);
+		out.writeByte(num%16777216/65536);
+		out.writeByte(num/16777216);
+	}
+	
+	private void writeString(String str) throws IOException {
+		writeInt(str.length());
+		out.writeBytes(str);
+	}
+}

src/main/java/me/ayunami2000/ayuncraft/nbsapi/Utils.java

@@ -0,0 +1,50 @@
+package me.ayunami2000.ayuncraft.nbsapi;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+/**
+ * The utilities used in this API. Not something for you... :/
+ * @author Le Duy Quang
+ *
+ */
+public class Utils {
+	/**
+	 * Converts a song board into a list of notes so that it can be written into a .nbs file.
+	 * @param board The song board.
+	 * @return The note list.
+	 */
+	protected static List<WritableNote> convertToWritable(List<Layer> board) {
+		List<Integer> ticks = new ArrayList<Integer>();
+		for (Layer l : board) {
+			for (int n : l.getNoteList().keySet()) {
+				if (!ticks.contains(n)) ticks.add(n);
+			}
+		}
+		Collections.sort(ticks);
+		
+		List<WritableNote> result = new ArrayList<WritableNote>();
+		List<WritableNote> thisTick = new ArrayList<WritableNote>();
+		for (int i : ticks) {
+			thisTick.clear();
+			int currentLayer = -1;
+			for (Layer l : board) {
+				currentLayer ++;
+				if (l.getNoteList().containsKey(i)) {
+					Note n = l.getNoteList().get(i);
+					thisTick.add(new WritableNote(n.getInstrument(), n.getPitch(), currentLayer, i));
+				}
+			}
+			Collections.sort(thisTick, new Comparator<WritableNote>() {
+				@Override
+				public int compare(WritableNote note1, WritableNote note2) {
+					return Integer.compare(note1.getLayer(), note2.getLayer());
+				}
+			});
+			result.addAll(thisTick);
+		}
+		return result;
+	}
+}

src/main/java/me/ayunami2000/ayuncraft/nbsapi/WritableNote.java

@@ -0,0 +1,62 @@
+package me.ayunami2000.ayuncraft.nbsapi;
+
+/**
+ * A note that can be written into NBS files.
+ * @author Le Duy Quang
+ *
+ */
+public class WritableNote {
+	private Instrument instrument;
+	private byte pitch;
+	private int layer;
+	private int location;
+	
+	/**
+	 * The type of note which contains enough information to be written into .nbs files. You shouldn't use this.
+	 * @param instrument The note's instrument.
+	 * @param pitch The note's pitch.
+	 * @param layer The layer number of the note.
+	 * @param location The song tick where the note is on.
+	 * @throws IllegalArgumentException
+	 */
+	public WritableNote(Instrument instrument, byte pitch, int layer, int location) throws IllegalArgumentException {
+		if (pitch < 0 || pitch > 87) throw new IllegalArgumentException("Pitch must be frrom 0 to 87.");
+		setInstrument(instrument);
+		setPitch(pitch);
+		setLayer(layer);
+		setLocation(location);
+	}
+
+	public Instrument getInstrument() {
+		return instrument;
+	}
+
+	public void setInstrument(Instrument instrument) {
+		this.instrument = instrument;
+	}
+
+	public byte getPitch() {
+		return pitch;
+	}
+
+	public void setPitch(byte pitch) throws IllegalArgumentException {
+		if (pitch < 0 || pitch > 87) throw new IllegalArgumentException("Pitch must be from 0 to 87.");
+		this.pitch = pitch;
+	}
+
+	public int getLocation() {
+		return location;
+	}
+
+	public void setLocation(int location) {
+		this.location = location;
+	}
+
+	public int getLayer() {
+		return layer;
+	}
+
+	public void setLayer(int layer) {
+		this.layer = layer;
+	}
+}

src/main/java/net/lax1dude/eaglercraft/glemu/EaglerAdapterGL30.java

@@ -677,7 +677,7 @@ public class EaglerAdapterGL30 extends EaglerAdapterImpl2 {
 		case GL_NEAREST_MIPMAP_NEAREST: pp3 = _wGL_NEAREST_MIPMAP_NEAREST; break;
 		case GL_NEAREST: pp3 = _wGL_NEAREST; break;
 		case GL_REPEAT: pp3 = _wGL_REPEAT; break;
-		case GL_CLAMP: pp3 = _wGL_REPEAT; break;
+		case GL_CLAMP: pp3 = _wGL_CLAMP; break;
 		}
 
 		if(selectedTex == 0 && boundTexture0 != null && pp2 == _wGL_TEXTURE_MAG_FILTER) {

src/main/java/net/minecraft/client/Minecraft.java

@@ -4,6 +4,7 @@ import java.text.DecimalFormat;
 import java.util.HashSet;
 import java.util.List;
 
+import me.ayunami2000.ayuncraft.NoteblockPlayer;
 import net.minecraft.src.*;
 import net.lax1dude.eaglercraft.DefaultSkinRenderer;
 import net.lax1dude.eaglercraft.EaglerAdapter;
@@ -1132,6 +1133,7 @@ public class Minecraft implements Runnable {
 		}
 
 		GuiScreenVoiceChannel.tickVoiceConnection();
+		NoteblockPlayer.tick();
 
 		if (this.currentScreen == null || this.currentScreen.allowUserInput) {
 			this.mcProfiler.endStartSection("mouse");

src/main/java/net/minecraft/src/BlockNote.java

@@ -1,6 +1,7 @@
 package net.minecraft.src;
 
 
+import me.ayunami2000.ayuncraft.NoteblockPlayer;
 
 public class BlockNote extends BlockContainer {
 	public BlockNote(int par1) {
@@ -71,6 +72,7 @@ public class BlockNote extends BlockContainer {
 	 * z, blockID, EventID, event parameter
 	 */
 	public boolean onBlockEventReceived(World par1World, int par2, int par3, int par4, int par5, int par6) {
+		NoteblockPlayer.notePlayed(par2,par3,par4,par6);
 		float var7 = (float) Math.pow(2.0D, (double) (par6 - 12) / 12.0D);
 		String var8 = "harp";
 

src/main/java/net/minecraft/src/GuiIngameMenu.java

@@ -1,5 +1,6 @@
 package net.minecraft.src;
 
+import me.ayunami2000.ayuncraft.GuiScreenModules;
 import net.lax1dude.eaglercraft.GuiScreenVoiceChannel;
 
 public class GuiIngameMenu extends GuiScreen {
@@ -24,6 +25,7 @@ public class GuiIngameMenu extends GuiScreen {
 
 		this.buttonList.add(new GuiButton(4, this.width / 2 - 100, this.height / 4 + 24 + var1, StatCollector.translateToLocal("menu.returnToGame")));
 		//this.buttonList.add(new GuiButton(5, this.width / 2 - 100, this.height / 4 + 48 + var1, StatCollector.translateToLocal("menu.voicechannel")));
+		this.buttonList.add(new GuiButton(6, this.width / 2 - 100, this.height / 4 + 48 + var1, "ayuncraft"));
 		this.buttonList.add(new GuiButton(0, this.width / 2 - 100, this.height / 4 + 96 + var1, 98, 20, StatCollector.translateToLocal("menu.options")));
 		GuiButton var3;
 		this.buttonList.add(var3 = new GuiButton(7, this.width / 2 + 2, this.height / 4 + 96 + var1, 98, 20, StatCollector.translateToLocal("menu.shareToLan")));
@@ -60,6 +62,10 @@ public class GuiIngameMenu extends GuiScreen {
 		case 5:
 			this.mc.displayGuiScreen(new GuiScreenVoiceChannel(this));
 			break;
+
+		case 6:
+			this.mc.displayGuiScreen(new GuiScreenModules(this));
+			break;
 		}
 	}