API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Aug 24th, 2014
53
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 14.38 KB | None | 0 0
raw download clone embed print report
  1. //world gen minable
  2. package TFC.WorldGen.Generators;
  3. import java.util.ArrayList;
  4. import java.util.Arrays;
  5. import java.util.Random;
  6.  
  7. import net.minecraft.util.MathHelper;
  8. import net.minecraft.world.World;
  9. import net.minecraft.world.biome.WorldChunkManager;
  10. import net.minecraft.world.biome.WorldChunkManagerHell;
  11. import net.minecraft.world.gen.feature.WorldGenerator;
  12. import TFC.Chunkdata.ChunkData;
  13. import TFC.Chunkdata.ChunkDataManager;
  14. import TFC.TileEntities.TEOre;
  15. // remove for multiplayer server
  16.  
  17. // Referenced classes of package net.minecraft.src:
  18. //                      WorldGenerator, MathHelper, World, Block
  19.  
  20. public class WorldGenMinable extends WorldGenerator
  21. {
  22.     //==========================================mp mod
  23.     //private static int[] aOreCheck = new int[256];// setup array to store oreIDs for this chunk // has to be static to survive instance calls                
  24.     //private static int[] metaOreCheck = new int[16];// this is used to check the metaIDs of a given ore ID
  25.     private static ArrayList oreList = new ArrayList();
  26.     public static int MPChunk_X;
  27.     public static int MPChunk_Z;
  28.     private int x_Chunk;
  29.     private int z_Chunk;
  30.     public int MPBlockID;
  31.     private int minableBlockMeta;
  32.     public static int MPPrevX;
  33.     public static int MPPrevZ;
  34.     public static int MPPrevID;
  35.     public static int MPPrevMeta;
  36.     //public static int MPPrevID3;
  37.     //public static int MPPrevID4;
  38.     private static boolean genBeforeCheck;
  39.     public static int mineCount;
  40.     public static int mineCountM;
  41.  
  42.     private static Random randomOut;
  43.     private static Random rand;
  44.     private static World worldObj;
  45.  
  46.     private static WorldChunkManager worldChunkManager;
  47.     private static WorldChunkManagerHell worldChunkManagerHell;
  48.  
  49.     private int mineGen = 1;
  50.     private int subMineGen = 1;
  51.     private int rarity = 2;
  52.     private int veinSi = 2;
  53.     private int veinAm = 2;
  54.     private int height = 2;
  55.     private int mineHeight = 2;
  56.     private int diameter = 2;
  57.     private int vDens = 2;
  58.     private int hDens = 2;
  59.     private int genInBlock = 1;
  60.     private int genInBlockMeta = 1;
  61.     private boolean useMarcoVeins = false;
  62.     private int grade = 0;
  63.  
  64.  
  65.     //==========================================mp mod
  66.     private int minableBlockId;
  67.     private int numberOfBlocks;
  68.  
  69.     public WorldGenMinable(int i, int j, int layerId, int layerMeta, int rarity, int veinSize,
  70.             int veinAmount, int height, int diameter, int vDensity, int hDensity, boolean vein, int oreGrade)
  71.     {
  72.         int emptyHolder = 0;
  73.         minableBlockId = i;
  74.         minableBlockMeta = j;
  75.         emptyHolder = j;
  76.  
  77.         genInBlock= layerId;
  78.         genInBlockMeta = layerMeta;
  79.  
  80.         this.rarity = rarity;
  81.         this.veinSi = veinSize;
  82.         this.veinAm = veinAmount;
  83.         this.height = height;
  84.         this.diameter = diameter;
  85.         this.vDens = vDensity;
  86.         this.hDens = hDensity;
  87.         this.useMarcoVeins = vein;
  88.         grade = oreGrade;
  89.     }
  90.  
  91.     public boolean generateBeforeCheck() // takes a set of current global variables and checks to see if this ore has spawned before in this chunk
  92.     {
  93.         genBeforeCheck = false;
  94.         genBeforeCheck = oreList.contains(Arrays.asList(MPBlockID, minableBlockMeta));
  95.  
  96.         if(oreList.contains(Arrays.asList(MPBlockID, minableBlockMeta)) == false)
  97.             oreList.add(Arrays.asList(MPBlockID, minableBlockMeta));
  98.         return genBeforeCheck;
  99.     }
  100.  
  101.     void createMine( World worldObj, Random rand, int x, int z)
  102.     {
  103.         for(int loopCount = 0; loopCount < veinAm; loopCount++)
  104.         {
  105.             int temp1 = mPCalculateDensity(diameter, hDens);
  106.             int temp2 = mineHeight + mPCalculateDensity(height, vDens);
  107.             int temp3 = mPCalculateDensity(diameter, hDens);
  108.             int posX = x + temp1;
  109.             int posY = temp2;
  110.             int posZ = z + temp3;
  111.             if(useMarcoVeins == false)
  112.                 BODgenerate(worldObj, rand, posX, posY, posZ, veinSi); // generate based on values
  113.             else
  114.                 BODgenerateVein(worldObj, rand, posX, posY, posZ, veinSi);
  115.         }
  116.     }
  117.     void createMineWithChance(World worldObj, Random rand, int x, int z)
  118.     {
  119.         if (rarity == 1 || (rarity > 0 && rand.nextInt(rarity) == 0))
  120.             createMine(worldObj, rand, x, z);
  121.     }
  122.  
  123.     public boolean generate(World world, Random random, int x, int z, int min, int max, String n)//obsorb default system
  124.     {
  125.         MPChunk_X = x;// set output chunk x // snap to grid
  126.         MPChunk_Z = z;// set output chunk z    
  127.  
  128.         rand = random;
  129.  
  130.         worldObj = world; // set world
  131.         mineCount = 0; // this is a new chunk, so list gets set to the beginning
  132.  
  133.         oreList.clear(); // clear the list of ores, this is a new chunk  
  134.  
  135.         MPBlockID = minableBlockId;// set output block ID
  136.         if(MPChunk_X != MPPrevX || MPChunk_Z != MPPrevZ || MPPrevID != MPBlockID || minableBlockMeta != MPPrevMeta)
  137.             if (generateBeforeCheck() == false)
  138.             {
  139.                 MPPrevX = MPChunk_X;
  140.                 MPPrevZ = MPChunk_Z;
  141.                 x_Chunk = MPChunk_X;
  142.                 z_Chunk = MPChunk_Z;
  143.                 MPPrevID = MPBlockID;
  144.                 MPPrevMeta = minableBlockMeta;
  145.                 mineHeight = min + rand.nextInt(max-min);
  146.  
  147.  
  148.                 if (rarity == 1 || (rarity > 0 && rand.nextInt(rarity) == 0))
  149.                     createMine(worldObj, rand, x_Chunk, z_Chunk);
  150.             }
  151.         return true;
  152.     }
  153.  
  154.     public int mPCalculateDensity(int oreDistance, float oreDensity) // returns the density value
  155.     {
  156.  
  157.         int loopCount = 0;
  158.         int densityValuePassInner = 0;
  159.         int densityValuePass = 0;
  160.         oreDensity = oreDensity * .01F;
  161.         oreDensity = (oreDensity * (oreDistance >> 1)) + 1F;// establishes number of times to loop
  162.         loopCount = (int)(oreDensity); //stores number of times to loop
  163.         densityValuePassInner = ((oreDistance/loopCount)); // distance devided by number of times it will loop, establishes the number for randomization
  164.         densityValuePassInner += (((oreDistance - (densityValuePassInner*loopCount))/loopCount));
  165.         densityValuePass = 0;
  166.         while (loopCount > 0) // loops to acumulate random values
  167.         {
  168.             densityValuePass = densityValuePass + rand.nextInt(densityValuePassInner); // acumulate randoms
  169.             loopCount = loopCount - 1; // decriment loop
  170.         }
  171.         return densityValuePass; // return proccesed random value
  172.     }
  173.  
  174.     public boolean BODgenerateVein(World world, Random rand, int parX, int parY, int parZ, int xyz)
  175.     {
  176.         //==========================================mp mod
  177.         int posX = parX;
  178.         int posY = parY;
  179.         int posZ = parZ;
  180.         int tempPosX =0;
  181.         int tempPosY =0;
  182.         int tempPosZ =0;
  183.         int posX2 = 0;
  184.         int posY2 = 0;
  185.         int posZ2 = 0;
  186.         int directionX =0;
  187.         int directionY =0;
  188.         int directionZ =0;
  189.         int directionX2 = 0;
  190.         int directionY2 = 0;
  191.         int directionZ2 = 0;
  192.         int directionX3 =0;
  193.         int directionY3 =0;
  194.         int directionZ3 =0;
  195.         int directionChange =0;
  196.         int directionChange2 =0;
  197.         int blocksToUse = xyz;//input number of blocks per vein
  198.         int blocksToUse2 =0;
  199.         for(int blocksMade=0; blocksMade <= blocksToUse;) // make veins
  200.         {
  201.             blocksToUse2 = 1 + (blocksToUse/30);
  202.             directionChange = rand.nextInt(6);
  203.             directionX = rand.nextInt(2);
  204.             directionY = rand.nextInt(2);
  205.             directionZ = rand.nextInt(2);
  206.  
  207.             for(int blocksMade1 = 0; blocksMade1 <= blocksToUse2; ) // make branch
  208.             {
  209.                 if(directionX == 0 && directionChange != 1)
  210.                     posX = posX + rand.nextInt(2);
  211.                 if(directionX == 1 && directionChange != 1)
  212.                     posX = posX - rand.nextInt(2);
  213.                 if(directionY == 0 && directionChange != 2)
  214.                     posY = posY + rand.nextInt(2);
  215.                 if(directionY == 1 && directionChange != 2)
  216.                     posY = posY - rand.nextInt(2);
  217.                 if(directionZ == 0 && directionChange != 3)
  218.                     posZ = posZ + rand.nextInt(2);
  219.                 if(directionZ == 1 && directionChange != 3)
  220.                     posZ = posZ - rand.nextInt(2);
  221.                 if(rand.nextInt(4) == 0){
  222.                     posX2 = posX2 + rand.nextInt(2);
  223.                     posY2 = posY2 + rand.nextInt(2);
  224.                     posZ2 = posZ2 + rand.nextInt(2);
  225.                     posX2 = posX2 - rand.nextInt(2);
  226.                     posY2 = posY2 - rand.nextInt(2);
  227.                     posZ2 = posZ2 - rand.nextInt(2);
  228.                 }
  229.                 if(rand.nextInt(3) == 0) // make sub-branch
  230.                 {
  231.                     posX2 = posX;
  232.                     posY2 = posY;
  233.                     posZ2 = posZ;
  234.  
  235.                     directionX2 = rand.nextInt(2);
  236.                     directionY2 = rand.nextInt(2);
  237.                     directionZ2 = rand.nextInt(2);
  238.                     directionChange2 = rand.nextInt(6);
  239.                     if(directionX2 == 0 && directionChange2 != 0)
  240.                         posX2 = posX2 + rand.nextInt(2);
  241.                     if(directionY2 == 0 && directionChange2 != 1)
  242.                         posY2 = posY2 + rand.nextInt(2);
  243.                     if(directionZ2 == 0 && directionChange2 != 2)
  244.                         posZ2 = posZ2 + rand.nextInt(2);
  245.                     if(directionX2 == 1 && directionChange2 != 0)
  246.                         posX2 = posX2 - rand.nextInt(2);
  247.                     if(directionY2 == 1 && directionChange2 != 1)
  248.                         posY2 = posY2 - rand.nextInt(2);
  249.                     if(directionZ2 == 1 && directionChange2 != 2)
  250.                         posZ2 = posZ2 - rand.nextInt(2);
  251.  
  252.                     for(int blocksMade2 = 0; blocksMade2 <= (1 +(blocksToUse2/5)); )
  253.                     {
  254.  
  255.                         if(directionX2 == 0 && directionChange2 != 0)
  256.                             posX2 = posX2 + rand.nextInt(2);
  257.                         if(directionY2 == 0 && directionChange2 != 1)
  258.                             posY2 = posY2 + rand.nextInt(2);
  259.                         if(directionZ2 == 0 && directionChange2 != 2)
  260.                             posZ2 = posZ2 + rand.nextInt(2);
  261.                         if(directionX2 == 1 && directionChange2 != 0)
  262.                             posX2 = posX2 - rand.nextInt(2);
  263.                         if(directionY2 == 1 && directionChange2 != 1)
  264.                             posY2 = posY2 - rand.nextInt(2);
  265.                         if(directionZ2 == 1 && directionChange2 != 2)
  266.                             posZ2 = posZ2 - rand.nextInt(2);
  267.  
  268.  
  269.                         boolean isCorrectRockType = false;
  270.                         boolean isCorrectMeta = false;
  271.                         int localX = posX & 15;
  272.                         int localZ = posZ & 15;
  273.  
  274.                         ChunkData data = ChunkDataManager.getData(posX >> 4, posZ >> 4);
  275.                         int hm = data != null ? data.heightmap[localX + localZ * 16] : 0;
  276.                         posY = Math.min(255, posY + hm);
  277.  
  278.                         int m = world.getBlockMetadata(posX, posY, posZ);
  279.                         int id = world.getBlockId(posX, posY, posZ);
  280.                         isCorrectRockType = id == this.genInBlock;
  281.                         isCorrectMeta = (m == this.genInBlockMeta || this.genInBlockMeta == -1);
  282.  
  283.                         if(isCorrectRockType && isCorrectMeta)
  284.                         {
  285.  
  286.                             world.setBlock(posX, posY, posZ, MPBlockID, minableBlockMeta, 2);
  287.                             TEOre te = (TEOre)world.getBlockTileEntity(posX, posY, posZ);
  288.                             if(te!= null)
  289.                             {
  290.                                 te.baseBlockID = id;
  291.                                 te.baseBlockMeta = m;
  292.                                 te.extraData = (byte)grade;
  293.                             }
  294.                         }
  295.                         blocksMade++;
  296.                         blocksMade1++;
  297.                         blocksMade2++;
  298.                     }
  299.                 }
  300.  
  301.                 int localX = posX & 15;
  302.                 int localZ = posZ & 15;
  303.                 ChunkData data = ChunkDataManager.getData(posX >> 4, posZ >> 4);
  304.                 int hm = data != null ? data.heightmap[localX + localZ * 16] : 0;
  305.                 posY = Math.min(255, posY + hm);
  306.  
  307.                 int m = world.getBlockMetadata(posX, posY, posZ);
  308.                 int id = world.getBlockId(posX, posY, posZ);
  309.                 boolean isCorrectRockType = id == this.genInBlock;
  310.                 boolean isCorrectMeta = (m == this.genInBlockMeta || this.genInBlockMeta == -1);
  311.  
  312.                 if(isCorrectRockType && isCorrectMeta)
  313.                 {                  
  314.                     world.setBlock(posX, posY, posZ, MPBlockID, minableBlockMeta, 2);
  315.                     TEOre te = (TEOre)world.getBlockTileEntity(posX, posY, posZ);
  316.                     if(te!= null)
  317.                     {
  318.                         te.baseBlockID = id;
  319.                         te.baseBlockMeta = m;
  320.                         te.extraData = (byte)grade;
  321.                     }
  322.                 }
  323.  
  324.                 blocksMade++;
  325.                 blocksMade1++;
  326.  
  327.             }
  328.  
  329.             parX = parX + (rand.nextInt(3) - 1);
  330.             parY = parY + (rand.nextInt(3) - 1);
  331.             parZ = parZ + (rand.nextInt(3) - 1);
  332.             posX = parX;
  333.             posY = parY;
  334.             posZ = parZ;
  335.  
  336.         }
  337.  
  338.  
  339.         return true;
  340.     }  
  341.  
  342.     public boolean BODgenerate(World world, Random rand, int par3, int par4, int par5, int xyz)
  343.     {
  344.  
  345.         //==========================================mp mod
  346.         numberOfBlocks = xyz; //input number of blocks per vein
  347.  
  348.         //==========================================mp mod
  349.         float var6 = rand.nextFloat() * (float)Math.PI;
  350.         double var7 = par3 + 8 + MathHelper.sin(var6) * numberOfBlocks / 8.0F;
  351.         double var9 = par3 + 8 - MathHelper.sin(var6) * numberOfBlocks / 8.0F;
  352.         double var11 = par5 + 8 + MathHelper.cos(var6) * numberOfBlocks / 8.0F;
  353.         double var13 = par5 + 8 - MathHelper.cos(var6) * numberOfBlocks / 8.0F;
  354.         double var15 = par4 + rand.nextInt(3) - 2;
  355.         double var17 = par4 + rand.nextInt(3) - 2;
  356.  
  357.         for (int var19 = 0; var19 <= numberOfBlocks; ++var19)
  358.         {
  359.             double var20 = var7 + (var9 - var7) * var19 / numberOfBlocks;
  360.             double var22 = var15 + (var17 - var15) * var19 / numberOfBlocks;
  361.             double var24 = var11 + (var13 - var11) * var19 / numberOfBlocks;
  362.             double var26 = rand.nextDouble() * this.numberOfBlocks / 16.0D;
  363.             double var28 = (MathHelper.sin(var19 * (float)Math.PI / numberOfBlocks) + 1.0F) * var26 + 1.0D;
  364.             double var30 = (MathHelper.sin(var19 * (float)Math.PI / numberOfBlocks) + 1.0F) * var26 + 1.0D;
  365.             int var32 = MathHelper.floor_double(var20 - var28 / 2.0D);
  366.             int var33 = MathHelper.floor_double(var22 - var30 / 2.0D);
  367.             int var34 = MathHelper.floor_double(var24 - var28 / 2.0D);
  368.             int var35 = MathHelper.floor_double(var20 + var28 / 2.0D);
  369.             int var36 = MathHelper.floor_double(var22 + var30 / 2.0D);
  370.             int var37 = MathHelper.floor_double(var24 + var28 / 2.0D);
  371.  
  372.             for (int posX = var32; posX <= var35; ++posX)
  373.             {
  374.                 double var39 = (posX + 0.5D - var20) / (var28 / 2.0D);
  375.  
  376.                 if (var39 * var39 < 1.0D)
  377.                     for (int posY = var33; posY <= var36; ++posY)
  378.                     {
  379.                         double var42 = (posY + 0.5D - var22) / (var30 / 2.0D);
  380.  
  381.                         if (var39 * var39 + var42 * var42 < 1.0D)
  382.                             for (int posZ = var34; posZ <= var37; ++posZ)
  383.                             {
  384.                                 double var45 = (posZ + 0.5D - var24) / (var28 / 2.0D);
  385.  
  386.                                 int localX = posX & 15;
  387.                                 int localZ = posZ & 15;
  388.                                 ChunkData data = ChunkDataManager.getData(posX >> 4, posZ >> 4);
  389.                                 int hm = data != null ? data.heightmap[localX + localZ * 16] : 0;
  390.                                 posY = Math.min(255, posY + hm);
  391.  
  392.                                 int m = world.getBlockMetadata(posX, posY, posZ);
  393.                                 int id = world.getBlockId(posX, posY, posZ);
  394.                                 boolean isCorrectRockType = world.getBlockId(posX, posY, posZ) == this.genInBlock;
  395.                                 boolean isCorrectMeta = (m == this.genInBlockMeta || this.genInBlockMeta == -1);
  396.  
  397.                                 if(isCorrectRockType && isCorrectMeta)
  398.                                     if (var39 * var39 + var42 * var42 + var45 * var45 < 1.0D)
  399.                                     {
  400.                                         world.setBlock(posX, posY, posZ, MPBlockID, minableBlockMeta, 2);
  401.                                         TEOre te = (TEOre)world.getBlockTileEntity(posX, posY, posZ);
  402.                                         if(te!= null)
  403.                                         {
  404.                                             te.baseBlockID = id;
  405.                                             te.baseBlockMeta = m;
  406.                                             te.extraData = (byte)grade;
  407.                                         }
  408.                                     }
  409.  
  410.                             }
  411.                     }
  412.             }
  413.         }
  414.         //System.out.println("a vein was placed " + minableBlockId + "." + minableBlockMeta+ " at " + par3 +" "+par4+" "+par5); /// for debugging
  415.         return true;
  416.     }
  417.  
  418.     @Override
  419.     public boolean generate(World world, Random random, int i, int j, int k)
  420.     {
  421.         return false;
  422.     }
  423. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!