Balthizarlucien

So I have been gathering information about each tree so I could build a few fully grown specimens of each as well as juvenile and baby versions as well. I wanted to ask before investing the time in these builds if the actual sizes were good or if I needed to scale them down some first. Secondly I noticed that the acacia tree is actually covered in sharp thorns so wanted to ask if you were planning to make the leaf blocks cause damage or not? Acacia 21m tall, 21m wide crown Ash 37m tall, 16m wide crown Aspen 15m tall, 9m wide crown Birch 19m tall, 22m wide crown Chestnut 30m tall, 21m wide crown Douglas fir 75m tall, 18m wide crown Hickory 36m tall, 21m wide crown Maple 23m tall, 15m wide crown Oak 24m tall, 24m wide crown Pine 70m tall, 18m wide crown Sequoia 87m tall, 34m wide crown Spruce 60m tall, 20m wide crown Sycamore 31m tall, 31m wide crown White cedar 20m tall, 8m wide crown Willow 12m tall, 11m wide crown Kapok 61m tall, 61m wide crown Rosewood 12m tall, 12m wide crown African Blackwood 9m tall, 9m wide crown

Awesome, will do that when I am back at my computer! Thank you bioxx

ok so it is most likely because I am a) running on far too little sleep and b0 I have not used github before except for browsing other people's code but I will ask the question anyway as I know that there are a lot less savvy people who would love to see the world gen just as much as I would. How do I compile your TFC2 github project? I have eclipse and Xcode both on my system so I can use either.. sorry for the ultra noob question Bioxx.

for the big boys it wouldn't make sense for them spawning in the mountains anyway. couldn't you run a check for headroom so that you do not run into issues like this anyway? if not, what is the max headroom you would have from the top of the tallest peak to build limit? I would like to help the best I am able. as far as clutter is concerned, I do not know if this would work, but is is possible to add it in like you did for boulders or is that a no go?

Poplar which is tinted blue comes from beetle infested trees. The beetle digs into the tree and in the process open a wound for a parasitic fungus. The fungus eventually kills the tree but not before staining the wood blue. It also occurs in several varieties of pine.

I will have to do that! Although the acacia I built looks awesome in real size, it seemed huge in comparison to the average minecraft tree as well as the terrain it may have been seated on. I think though you should have some of the giants truly be epic in scale if that is at all possible as the cathedral buttress like roots of the kapok or the hulking mass of the sequoia can't truly be done the justice they deserve at a smaller scale. Second question for you bioxx would you like to have fallen/ decaying versions of each tree? Storm toppled roots and broken canopies would look like the forest has a true life cycle as would half buried logs etc.. Perhaps stumps of long dead giant trees could add some character too. What do you think?

My server uses a 336 day year so I have seen them all

There is one for the rest of the dev team too

I would love to see a build contest or submissions forum for this but more pertinently for the trees that bioxx needs for the terrain gen testing. He had mentioned he wanted help in a tweet but I was unsure of a few things such as wether to use vanilla blocks or Tfc blocks and where to submit said schematics... Perhaps you could enlighten us Bioxx?

Just wanted to say that the gui is awesome! Love the clean look of it. The only thing I am thinking needs a minor tweak is the creeper texture. It is too dark to see the detail you put into it. I might suggest lighting it just a touch so those details show. Keep up the good work!

I actually love using your pack and I have been using it on the Ursine Nation server... I will need to post some pics of the Motte And Bailey I have been building

I am totally with you on the peat block! Peat blocks, deserts, barren tundra are all just fantastic hearsay until a seed is posted! I am going to start a thread where we in the community can post those ultra rare seeds let's see how long it takes to find peat!

I thought deserts were perhaps a myth as I had personally never seen one... Cool to know they are at least possible

Improving TFC Terrain Generation I personally, as most TFC players I am sure, love the way the terrain looks and feels as you wander through any world spawn but I get frustrated with chunk loading delays. After reviewing the source code and more specifically the terrain generation I noticed that the algorithms could use some work to improve the efficiency as well as the finer details of the terrain which don't quite match against nature. I happen to have been working on a procedural terrain generator that deals with all of these issues but it is being written in a different language for my own personal project so it is not directly applicable here. However, I figure I might describe the process I am using and Provide some Pseudocode so that Bioxx or whomever handles this aspect of TFC may be able to take some inspiration from it for either this incarnation of TFC or the currently under development TFC2. The best way to solve the terrain generation delay is to simply not have it happen in the first place. Sure, this is easier said than done I know but hear me out. The only way to avoid individual chunk generation delay is through a process of pre-generation. Instead of trying to generate the entire world, which would be nuts, simply generate the world 200x200 chunks at a time. I term this idea as a Super Chunk. This would increase generation time; but, it would be a significantly smaller amount of time than is spent trying to play whilst the game is already burdened with the task of terrain generation for each new chunk you load. Also, using a super-chunk would mean that while you are huddled in your hovel for the night or while you are staying within your already generated 10,240,000 block2 space and not generating new land the game can be generating the surrounding super-chunks with a passive, unobtrusive background function taking advantage of the downtimes in processing power. Using a pre-generation method will allow for a load delay free exploration process but it is not the only way to increase efficiency as well as improve on the realistic appearance of the terrain. There are several other improvements which can be made to the way that the terrain generates by changing the specific algorithms used in the generation process itself. Ken Perlin created Perlin noise in 1983 because he was more than a little frustrated with the machinelike qualities found within computer graphics of the time and it was exceptionally effective for use within the film he had been working on at the time, Tron. This was a small and mostly obscure title I am sure no one has heard of, right? I can completely understand his feelings as I had similar feelings with them myself in the mid to late 90’s. Perlin noise has since become the benchmark for any form of procedural terrain or texture generation used within the industry since. Computational Theory Ahead! Warning! This means Perlin noise scales with complexity to for dimensions. This seems fine for most applications because this function is still widely used within the industry even today. The pseudocode for this function is as follows: // Function to linearly interpolate between a0 and a1 // Weight w should be in the range [0.0, 1.0] function lerp(float a0, float a1, float w) { return (1.0 - w)*a0 + w*a1; } // Computes the dot product of the distance and gradient vectors. function dotGridGradient(int ix, int iy, float x, float y) { // Precomputed (or otherwise) gradient vectors at each grid point X,Y extern float Gradient[Y][X][2]; // Compute the distance vector float dx = x - (double)ix; float dy = y - (double)iy; // Compute the dot-product return (dx*Gradient[iy][ix][0] + dy*Gradient[iy][ix][1]); } // Compute Perlin noise at coordinates x, y function perlin(float x, float y) { // Determine grid cell coordinates int x0 = (x > 0.0 ? (int)x : (int)x - 1); int x1 = x0 + 1; int y0 = (y > 0.0 ? (int)y : (int)y - 1); int y1 = y0 + 1; // Determine interpolation weights // Could also use higher order polynomial/s-curve here float sx = x - (double)x0; float sy = y - (double)y0; // Interpolate between grid point gradients float n0, n1, ix0, ix1, value; n0 = dotGridGradient(x0, y0, x, y); n1 = dotGridGradient(x1, y0, x, y); ix0 = lerp(n0, n1, sx); n0 = dotGridGradient(x0, y1, x, y); n1 = dotGridGradient(x1, y1, x, y); ix1 = lerp(n0, n1, sx); value = lerp(ix0, ix1, sy); return value; } In 2001 Ken Perlin published a massive revision to this most classic system for noise generation that so pervades the industry. He called his new noise algorithm Simplex Noise because it made noise generation exceptionally more simple and significantly smaller computational overhead. For those who are not aware, Computational overhead is what causes computational delays in the first place. Now why isn’t tis used as the base for TFC’s Terrain generation? Computational Theory Ahead! Warning! The computational cost of a simplex algorithm is significantly more efficient at for dimensions instead of the of classic noise. This means less pressure on the CPU or GPU for generating terrain and a much better looking product to boot due to the lack of Directional artifacts which are typically found in Perlin noise. (This would be those weird lines that I am sure we have all seen appear on the terrain and extend for a few chunks or more.) The best article I have found comparing both Perlin's Classic and Simplex noise can be found here: http://webstaff.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf Now that this explanation is out of the way let me explain the way in which my process works as I find the results to be quite breathtaking. When Minecraft (or TFC) generates terrain it calls on perlin noise in octaves to generate the terrain details in waves from the largest to the smallest pattern first. This is fine but as we know it is highly inefficient and in vanilla Minecraft it also yields poorly constructed or strange results. Also, because the terrain is using a 3d perlin noise function, you will always end up with those obnoxious flying islands because these are what is known as signature artifacts of the 3d noise process. To solve these issues we can simply change the algorithm it is using altogether and tailor it to a much more realistic system. Since we know that no landforms are ever going to appear flying we can deduce that we do not need to use a 3 dimensional noise function. We can easily get away with a 2d noise function that creates our height data and yields none of those artifacts mentioned before. Because of the information we are now armed with we can also choose the correct noise function to improve efficiency and reduce the amount of processing required to obtain the same results. For this we simply choose the superior noise algorithm, Simplex Noise. Even simplex noise, implemented correctly, can get a bit repetitive and lack variety when it is repeated on ever increasingly smaller scales. on top of this, pure simplex noise is also unappealingly smooth, as is Perlin's classic noise at its base. We need a way to rough up our noise field. No one likes overly smooth terrain. It looks far to fake and will yield terrible results in the end if we leave it be. For my own project I turned to a function which is perfectly suited for this specific task. It is called Fractional Brownian Motion. In science, Fractional Brownian Motion is a mathematical physics system which explains how small particles behave in relation to one another. An easy way to explain this is to imagine a dark room with a single ray of light. When you look into the ray of light you are able to see dust particles which, if left undisturbed by wind, seem to have a random pattern of motion. This random pattern is intact the result of the dust particles which we can see interacting with the molecules in the air which we are unable to see. This can be simulated using a very simple algorithm: //for each pixel, get the value total = 0.0f; frequency = 1.0f/(float)hgrid; amplitude = gain; for (i = 0; i < octaves; ++i) { total += noise((float)x * frequency, (float)y * frequency) * amplitude; frequency *= lacunarity; amplitude *= gain; } //now that we have the value, put it in map[x][y]=total; This will turn the height map from this: To this: As you can see, there is a marked improvement in the height map as a result of the added motion function but it is still very raw and will not work well as a terrain map like this. As with the previous terrain generation used by the default Minecraft system we need to make some enhancements to the original height map before we add the motion so that we can create a much better overall terrain in general. The second major issue that makes the default Minecraft terrain slightly... Off. Instead of varying the algorithm used for the terrain generation the system simply calls the same function over again with a slightly reduced set of variables and passes over the terrain a second, third, fourth etc time until it's finished generating the terrain. This is fine as it does create the finer details required to make the terrain look less smooth and strange but the repeats are noticeable and to me this is unacceptable. Using a simple two stage for loop you can call the simplex noise and after it runs but before the loop finishes it calls a second noise function. But what function should be called and how much noise is enough? I think that this question needs some exploration but we can use some good old deduction to really dig into this and find a decent answer. So what truly determines the shape of the land, dirt or stone? Well, duh.. The stone obviously. The dirt is just the superficial skin covering the stone below. So is there a noise function that is designed to look like stone? Actually yes! The noise algorithm used for this is called Worley Noise. Worley Noise was created in 1996 by Steven Worley to eliminate the need for artists from having to try and draw stone textures but since we are trying to generate a height map that is essentially the skeleton we will lay the skin on top of this fits the bill nicely. So to vary the noise and create a better base we simply need to cycle between Simplex and Worley noise using the same octave shifting as we would use on just the simplex noise. This will allow for the layering effect we need without worrying about the issues of visible repetition that currently haunts the terrain. Minecraft runs what appears to be at least 8 cycles or "octaves" minimum but it's possible that it may cycle more. With our system we do not need quite so much to work with so we can do this with a nice even 4 octaves as that will be the same as 8 octaves of Minecraft's original noise generation except much better looking. Now that the noise image has been generated and we have applied the Fractional Brownian Motion we have a data set that will work but it isn't complete yet by a long shot. Nature leaves her fingerprint on the earth and we should drive to achieve the same thing otherwise our terrain will just fall into the realm of sub par generation and our terrain will feel half done. Since we are shooting for realism in this terrain model we have been building we might as well speak bit on how rocks end up where they are. There is really only one question we need to answer whilst we determine what types of rock goes where in our world. where are we? the reason for this is simple. There are currently two major categories of crust we need to contend with as per geologists in the field. The first is Oceanic Crust. any of these expansive oceans we often find within TFC would be where we would need to generate what we will call Crust 1 Stone. the second major type of crust we need to know about is known as Continental Crust. This will appear in land masses which are larger than a set value (greater than 1000 blocks in diameter for example) and have what we will call Crust 2 Stone. Crust 1 The Oceanic Crust is about 7-10Km thick and composed of mafic (magnesium and Iron rich) igneous rocks most commonly Basalt (pillow Lavas) and Gabbro. This is also laid out in layers instead of having been pushed around into a sort of noise. this makes the oceanic crust easy to simulate. No extra noise functions are required here. the layers are: Basalt Dacite / Andesite / Rhyolite vertical sheets (4-8 blocks wide alternating randomly) Gabbro Crust 2 As you can see from the image below, this is where we need to use some noise functions to make this work a bit better. For the noise model we can simply use the same simplex noise algorithm we used before but in 3 dimensions rather than 2. This will allow for a realistic blend of stone to appear underground as opposed to a layered appearance. One thing which needs some adjustment is simply an octave modified based on surface height. This will make the stone apear to bunch up as it approaches mountains just like you would expect in plate tectonics without all of the heavy overhead involved with modeling them. The stone which needs to be blended must be added into an existing base stone. knowing this and knowing granite is the most common stone found on earth we will use granite as our base medium but feed the other stone types in with each iteration of the noise function. below is the list of stone types with their percentages as per the earth’s own crust: Granite 38% Diorite 20% Gabbro 15% Slate 10% Gneiss 6% Schist 4% Marble 3% Phyllite 2% Quartzite 2% These figures are of course rough but will provide a fairly decent blend of rock in the ground in a pattern that is believable. now that the stone types are out of the way the dirt can be calculated for and laid out in the appropriate depths. Real terrain is weathered. It's beaten and its worn down. Luckily these are very easy to mimic as well. There are two primary algorithms used to simulate erosion on height maps and they are implemented at varying strengths and implementations depending on the degree of erosion needed. We need to implement both types not only for the realism but also because we need to try and prevent any sort of processor delay we may experience whilst wandering our new landscape. I know it isn't much of a weight on the processor as we have already gotten the majority of the processing already done; but the gravity added by TFC is still something we can eliminate from new chunk loading so why not take care of it ahead of time as well? The first erosion algorithm we need to implement will be thermal erosion. One would assume that this has something to do with heat but in fact it does not. It is a simulation of gravity which looks for cliff faces which are unrealistically smooth and wears them down. The way in which it does this is by looking for cliff faces which are greater than a predetermined angle (T) by comparing each block against its neighbor. to do this efficiently a rotated Von Neumann neighborhood should be used as it reduces a large portion of the processor load against the Moore Neighborhood but produces almost identical results in the end. If it finds such a cliff then it moves the soil in said cliff face one layer at a time down the cliff until the slope is less than T. In our 2 dimensional height map we have been building for our terrain we will predetermine that this angle should be 88° grade or steeper. This will prevent only the most shear of cliff faces from appearing but allow some of the more impressive cliffs to remain intact. This part of the erosion does not care what kind of stone is in the way so up until now we have not needed the data we have generated. the next segment however, does require this information to procede as does it require our surface soil layer and climate data otherwise we would not be able to properly apply the algorithm appropriately. For this we need to create our climate data, rock data etc. the only type of erosion that is left to apply is hydraulic. This type of erosion is very good at not only simulating water but wind as well because air is nothing more than a very thin fluid as it behaves almost exactly the same. Air motion is easily predictable because air will always move from cold locations to hot locations. The temperature system in TFC facilitates this by providing temperature data based on both elevation and latitude within the game. Using these facts we can easily generate a wind model like what is shown here http://earth.nullschool.net/#current/wind/surface/level/orthographic=202.50,11.03,446 that will be able to gently erode the terrain, carry sediments and deposit them in logical places. This type of erosion is typically gentle but it is widespread and highly directional which means that it will work to smooth out the roughness left behind from the original noise generation. This will lead to mountains with a smooth face on one side and a rough face on another. Wind is not the biggest fluid we need to contend with however. Erosion by water has carved some of the most spectacular things on our planet. Using the precipitation of each TFC zone we can accurately model the volume of water passing over the surface on a yearly basis and use this to carve out rivers, gullies, ravines etc as well as setup lakes, rivers, sedimentary beds and more. These beds will stick the right types of sedimentary stones near their associated igneous counterparts. included below is a hydraulic erosion program in a variation of C that I found online that may make a good reference point for you: Hydraulic Erosion Filter //recommended default values: //iterations_ = 50 //threshold_ = 4096/heightmap size var* TERRAIN_hydraulic_erosion_tmp=NULL; /////////////////////////////// void TERRAIN_bmap_hydraulic_erosion_filter(BMAP* bmap_,var iterations_,var threshold_) { //get size double size_x_=bmap_width(bmap_); double size_y_=bmap_height(bmap_); //create data TERRAIN_hydraulic_erosion_tmp=(var*)sys_malloc(sizeof(var) * size_x_*size_y_); //fill data with pixel color int py; for(py=0;py<size_y_;py++) { int px; for(px=0;px<size_x_;px++) { COLOR color_; var format=bmap_lock(bmap_,0);var alpha_; var pixel=pixel_for_bmap(bmap_, px, py); pixel_to_vec(color_,alpha_,format,pixel); bmap_unlock(bmap_); TERRAIN_hydraulic_erosion_tmp[px*size_x_+py]=color_.red; } } int i; for(i=0;i<iterations_;i++) { int py; for(py=0;py<size_y_;py++) { int px; for(px=0;px<size_x_;px++) { var h_=TERRAIN_hydraulic_erosion_tmp[px*size_x_+py]; var d[4]; COLOR color_tmp_; var h[4]; h[0]=TERRAIN_hydraulic_erosion_tmp[clamp(px-1,0,size_x_-1)*size_x_+clamp(py,0,size_y_-1)]; h[1]=TERRAIN_hydraulic_erosion_tmp[clamp(px,0,size_x_-1)*size_x_+clamp(py-1,0,size_y_-1)]; h[2]=TERRAIN_hydraulic_erosion_tmp[clamp(px+1,0,size_x_-1)*size_x_+clamp(py,0,size_y_-1)]; h[3]=TERRAIN_hydraulic_erosion_tmp[clamp(px,0,size_x_-1)*size_x_+clamp(py+1,0,size_y_-1)]; var dtotal=0,dmax=0,l=0; int j; for(j=0;j<4;j++) { d[j]=h_-h[j]; if(d[j]>dmax) { dmax=d[j]; l=j; } } var hd; if(dmax>0 && dmax<=threshold_) { hd=0.5*dmax; h_=h_-hd; h[l]=h[l]+hd; } TERRAIN_hydraulic_erosion_tmp[px*size_x_+py]=h_; TERRAIN_hydraulic_erosion_tmp[clamp(px-1,0,size_x_-1)*size_x_+clamp(py,0,size_y_-1)]=h[0]; TERRAIN_hydraulic_erosion_tmp[clamp(px,0,size_x_-1)*size_x_+clamp(py-1,0,size_y_-1)]=h[1]; TERRAIN_hydraulic_erosion_tmp[clamp(px+1,0,size_x_-1)*size_x_+clamp(py,0,size_y_-1)]=h[2]; TERRAIN_hydraulic_erosion_tmp[clamp(px,0,size_x_-1)*size_x_+clamp(py+1,0,size_y_-1)]=h[3]; } } } //fill pixels with array data int py; for(py=0;py<size_y_;py++) { int px; for(px=0;px<size_x_;px++) { //set colors COLOR bmp_color_; bmp_color_.red=TERRAIN_hydraulic_erosion_tmp[px*size_x_+py]; bmp_color_.green=TERRAIN_hydraulic_erosion_tmp[px*size_x_+py]; bmp_color_.blue=TERRAIN_hydraulic_erosion_tmp[px*size_x_+py]; //add to heightmap var format=bmap_lock(bmap_,0); var pixel=pixel_for_vec(bmp_color_,100,format); pixel_to_bmap(bmap_, px, py, pixel); bmap_unlock(bmap_); } } //free data sys_free(TERRAIN_hydraulic_erosion_tmp); } Now that the erosion of the terrain is complete the world can be opened and used. although this took a very long time to explain, for this I am sorry, the world generation would actually take place significantly faster and may be only slightly longer for this system than your normal world gen. If you made it through the entire post, Thank you! it took a long time and a lot of research to assemble and it took even longer to figure out how to explain it so I appreciate your diligence in reading it.

That looks pretty awesome but I bet I know why it fails... It has to do with the way TFC builds its layers, ores etc.

Blaziken_11 I have approved you for access to the server, look for a message containing the details for access and expectations

I have made a thorough review of everyone qualified to join us on the whitelist who has submitted their applications here. the resulting names were: sgtjole Jagerkampf ijevinator zoltanfizz Killercoffee2013 NordinTheLich Verelina cybernation Cpt_Wiggles I will be sending a private message to each and every person on this list to confirm their interest to join us on the Life On the Frontier server. if those whom I message reply with a yes, they will be accepted and a hole filled on our ever growing community. If you have yet to apply and are interested, stay tuned as I will post the number of remaining spots in 7 days from today. If the whitelist does fill up, that is ok. I have a running waitlist that I check after every single purge and will accordingly follow this same process each and every time. Thank you all again for your interest and your applications, we love hearing about each and every one of you. this also lets everyone else on this server get a chance to find out more about you as well. Have a wonderful day and good luck!

The Next Purge is set for July 20th! Please remember to sign in here and post your character name if it differs from your Enjin Name so that we know who is and is not active! This means I will be able to add more folks to our white list. I will be gathering a list of all candidates and verifying their interest. Please keep an eye on your messages on this site to ensure you do not miss your opportunity!

Yes. Vanilla wood is typically oak.

I love this pack! Was wondering about vanilla oak and Tfc oak textures though, is there a reason you can't just use the same texture? Also, could you please include the villager zombies in the next update? Their strikingly green color clashes severely with the regular zombies.

For those on the waiting list, our next server purge is set for June 22nd! For those who are members of the server already, please visit Ursine-Nation.enjin.com and read the new thread and follow its instructions. If you need the forum password and are already on the whitelist please message me on terrafirmacraft.com or on the server and I will gladly give you the password. I will be contacting everyone on the waiting list regarding the purge in the next few days to confirm interest.

I am very excited that the terrain generation is taking this route! I have been following bioxx's tfc2 github and have been watching carefully the way he has been approaching this problem and each update he adds I smile a bit more. I do hope though (as I have seen no sign of it yet) that he takes part of my huge terrain gen suggestion and applies it. The part I am talking about specifically is in reference to rock layers becoming more noisy as the surface height rises. That should be realitivly simple to achieve and it would mimic tectonic shifting without all that messy background number crunching :)Thanks for the link to that page kitty. It is a fun tool to play around with!

BboyKD Thank you for applying to join us on L.O.T.F! I have whitelisted you on the server as of now. Welcome to the server and welcome to the community! check your Private Messages for the server Information.

You are not too late and yes we have open places within our server at the moment as we have recently cleared our whitelist of non active players. If you wish to apply to join us feel free to do so and lilmamabear will run a check on you and determine if you are welcome.

TFC++ A Terrafirmacraft modpack that amplifies the danger! The goal of this pack is simple: to maintain the intent of terrafirmacraft whilst amplifying the realism as well as increasing the difficulty as much as possible. What follows is a very short list of mods which reach this goal nicely without being too overbearing. A good deal of these mods are included primarily for their aesthetic appeal rather than for a functional purpose but I have added quite a few that make significant changes to the AI of the monsters and animals which you share the world with. This post is not complete but I wanted to share it now as to peak people's interest! This mod pack is currently in a beta stage as I am still trying to iron out some of the config files but for the most part it plays well and it is quite enjoyable. I would love for someone who is better at writing mods than I to take a crack at ironing out some of the finer details so if anyone is up to the challenge, please let me know and I will discuss this further. As Kittychanley as so kindly posted a wonderfully configured JVM script further down in this thread I figure I would provide the script here but I highly recommend reading the post that goes with it as it was exceptionally enlightening as to what it all means. simply scroll down on this first page and have a read through the script is as follows: -Xmn1G -Xms1G -Xmx2G -XX:NewSize=512M -XX:SurvivorRatio=2 -XX:+DisableExplicitGC -XX:ParallelGCThreads=4 -d64 -XX:+UseConcMarkSweepGC -XX:+CMSIncrementalPacing -XX:+AggressiveOpts Terrafirmacraft - The heart and soul of this mod pack! Better Foliage - Better Foliage is a Forge mod that will make your Minecraft worlds more impressive, mainly by improving how vegetation looks. (homepage) TFCellars - This adds a multi block structure as well as some specific blocks to TFC which allows you to build and control a cold room (as they were called in maine where I grew up) or Cellar in which to store your food for the long winter. (homepage) Decorations - This is a TFC only mod which I have added due to the added features like the lanterns and especially the mud bricks! (homepage) Dynamic Lights - dynamically light up the world with moving light sources. (homepage) Fastcraft - FastCraft is a sophisticated mod which improves the client and server performance significantly without any game play changes. FastCraft is useful for anything, even fast PCs and servers benefit. (homepage) Herdcraft - This expands the AI and wild breeding characteristics of pigs, chickens, sheep, cows and horses. This mod also adds some AI to zombies to allow for zombie hordes to spawn and travel together. (homepage) Item Physics - causes items to fly through through the air and land more realistically. It also stops non flammable items from being destroyed in lava. (homepage) MultiMine - This allows you to partially damage a block and the game will remember that damage if you happen to stop for some reason... (Zombies!) (homepage) Voxelmap - VoxelMap is a full-featured Mini-Map mod for Minecraft featuring Waypoints, Entity Radar, Death Marker and much more. (homepage) Better Clouds - Improves rendering of clouds so that clouds are translucent when viewed from below as well as from above. Prevents the top of tall mountains from being obscured by clouds. (homepage) OpenEye - this mod is an excellent tool that simply gathers basic information about the mods used, crashes, etc so that users and modders alike can track the mods they are using or developing. (homepage) Optifine - This is a mod many of us currently use I suspect and thus needs little explanation. needless to say though, if you are unfamiliar with it, its sole purpose is to correct issues within the code and optimize minecraft and its graphics system in general Realistic Pain - this mod adds GUI and audio effects to the game which makes taking damage or being close to explosions etc much more impactful. (homepage) Smart Moving and PlayerAPI- The Smart Moving mod provides various additional moving possibilities. This allows traversing the terrafirmacraft terrain in new ways. (homepage) (homepage) Sound Filters - this adds more realistic sound calculations to the game to allow for reverb in caves, muted sounds when under water or when the sound source is behind a wall. (homepage) Smooth Bedrock- smooth bedrock does precisely what's on the tin. It reduces bedrock to a single uniform layer. (homepage) Stalker Creepers - This mod makes Creepers STALK YOU. (homepage) Streams and its dependancy- This mod adds real flowing streams into the game. The way this mod generates rivers is quite stunning and I think it is a must for this pack! (homepage) Weather - this mod adds localized weather that uses the environment to generate storms including tornadoes and cyclones capable of destroying blocks in their path. (homepage) Zombie Awareness - last but not least this mod amplifies the AI of the humble zombie making it far more dangerous to encounter them, especially since the herd craft mod allows whole hordes to spawn! (homepage) Below I have included the first version of the configs. It is mostly complete but I will continue to fine tune it as I work further on this pack. To-Do: - Finish consolidating the config files to work smoothly together - obtain permissions from each mod maker to use their mods within an official modpackt release - include a few mod specific seeds with Images - create a mod pack banner - optimize all mod coding to remove duplicate Items/functions or conflicting recipes - Ensure each mod properly hooks data from all other mods - attempt to optimize the coding structure of each mod by improving their respective algorithms, layouts etc. - ditch all AI mods to write my own custom AI mod for all mobs/entities. -obtain permissions to attempt to update or assist in updating all mods (including terrafirmacraft) to 1.8.3 or the current latest version [i hold a bachelor's of computer science focusing on programming) and as always... - whatever else comes to mind config.zip