Mondkalb's Terrain Tutorial

This guide will not explain every single mouseclick that you need to do, it will however guide you completely through the entire process of making a terrain by providing instruction on each step, with a dedicated segment on correctly exporting .emf files and creating satellite imagery used in a terrain. When Possible, this tutorial will provide links to more detailed tutorials about certain aspects. For example there will be links to a dedicated tutorial for creating heightmaps and setting up P:\ drive. You can return to this guide once you finished working through a detailed tutorial and follow the "red line" in creating a Terrin to the next tutorial with more details about how to make intro scene missions.

Think of this tutorial as the chewing gum that is used to make everything hold together.

Having an idea

This is one of the most important parts during the process of making a map: Having an idea all planned out.

Before you start creating a terrain, you should think about the purpose of your soon-to-be terrain, what it should look like and whether you would enjoy making it. Then decide on a size.

For beginners, that is in my opinion people that have never made a terrain ever before, I recommend starting quite small: A terrain of roughly 2km x 2km size. This is a manageable size. Forget about 10km x 10km, 20km x 20km or 100km x 100km for now. You will never finish those and then give up map making in despair. A small 2km² terrain however will let you learn everything you need to know to complete bigger projects. The key to those is to have successfully managed at least one terrain before you start work on a Terrain that you intend to announce and release.

Setting up the tools

Download and install BI Tools 2.5.1 (Or whatever is the most recent version)
Additionally you will need IrfanView: http://www.irfanview.com/
Also you will need L3DT to create and export a heightmap.

When the BI-Tools have finished installing, you should find yourself with a new drive P:\ on your computer. This is a fake partition that is needed for the BI tools to work fine. No worries, nothing is being destroyed or deleted by this. But also you don't have magically gained new HDD space. It is just a folder that pretends to be a partition.

Go to P:\ and create a new folder. Name this folder TUT_IslandName. TUT being your addon maker's nametag Nametag, what is this? IslandName being obviously your island's name. So, if your addontag would be ABC, and you decided to name your terrain "Roundland", this folder you're about to create should be namend "ABC_Roundland".

Then read through Bushlurker's Micro Terrain Tutorial to correctly fill up P:\ with all needed CA content.

Creating a Heightmap

There are many ways of acquiring a heightmap. using real life digital elevation data, imagined terrain or simply something random generated using L3DT. We will focus on the latter in this tutorial, since it is the easiest. If you feel confident enough using other tools, you might skip this step if you already have a heightmap that is 8bit greyscale, though keeping on reading wouldn't hurt.

Terrain size

Now we actually decide for a terrain size. If you want to make a terrain that is 2048m x 2048m large, you can use different heightmaps that allow you to have different terrain cell sizes. A terrain cell is basically a piece of a net. If your terrain cell size is 10m, every 10m on the X and Y axis a point will be modifiable. If you have a 4m cell size, you will be able to modify a terrain node every 4 meters, allowing you to have ditches in terrains, though the overall performance of this terrain might drop drastically if you go insane on the terrain cell size.

Your best choices now are:

256 x 256 px @ 8m terrain cell size
512 x 512 px @ 4m terrain cell size

which will result in a 2048m x 2048m terrain. (I highly recommend this, as all figures are based on a power of 2, which is always good)

Alternatively, your choices now also are:

256 x 256px heightmap @ 10m terrain cell size
512 x 512px heightmap @ 5m terrain cell size

which will both result in a 2560m x 2560m terrain.

For now all we care about is the amount of pixels our heightmap will have.

Using L3DT

So now on to create the heightmap:

Start L3DT. Click on the "Create a new Project"-button and follow the Wizard.

You will want to have the following selected during the wizard:

Designable map
Width & Height = 256 and Horiz. scale = 10
HF/DM Ratio = 64 (4x4px)
Play around whith these values to influence the heightmap (self-explanatory)
Tick "Design Map" and "Heightfield"

Depending on the parameters you provided, you will now be the proud owner of a randomly generated Heightmap. Hooray!

Now, save this project as TUT_IslandName_Heightmap.proj.

Saving

Now go to "File -> Export -> Export active map layer" Select "XYZ" as File format, and save this to P:\TUT_IslandName\source as "heightmap_001.xyz".

Done!

Setting up a terrain in Visitor 3

Start Visitor 3.

Go to "Project -> New" Set the terrain grid size to "256 x 256" and the Terrain cell size to 10.

Then hit the "Calculator..." button. This is really important! This will set up everything for our terrain satmap.

Ideally you will have a 1:1 ratio for terrain (m) to satmap (px). So we'll go with a 2560x2560px satmap for a 2560x2560m terrain.

Click "Apply proposed". Then "OK".

Visior 3 configuration

Now your screen should show a blue background. But before we continue we need to setup more stuff, so back to the settings.

Go to "Tools -> System Preferences" and paste this into the second field:

"p:\buldozer.exe" -window -buldozer -exThreads=0 -cpuCount=2 -noPause

This will make your buldozer work as smooth as possible.

Now go to "Tools -> Project Parameters...". You wills see that the terrain grid size is locked, but the Texture layers is now unlocked. At this point, you can no longer alter a map's size.

Click "Add..." and create a new texture layer. Name it whatever you want, and select 20.0x20.0m. The Texture size should always be the double of your terrain-cell-size (In this tutorial 10.0m).

Go to your P:\ drive and create a new folder named "TUT_IslandName_data".

Visior 3 Project configuration

Back in Visitor navigate to "Tools -> Project Preferences...", then enter the name of the newly created folder into the "Folder - Textures" field. Leave "Folder - Objects" blank.

Now we're good to go.

Save this project as "IslandName_001.pew" to "P:\TUT_IslandName\source"

Every time you save the island, save it with a new number. (i.e. _002, _003). This way, in case V3 messes up a .pew file, not everything is lost, and you've got a backup to start from.

Importing the heightmap into Visitor

Go to "Project -> Import Terrain from XYZ". Select Islandname_heightmap.xyz and see the result instantly. As opposed to importing a greyscale terrain with a .pbl file, the xyz file contains all necessary data and imports almost instantly, no matter how many objects the .pew already contains.

Save as IslandName_002.pew

Navigating in Visitor3

will pan the map.
Ctrl + will zoom in and out
will select objects.
Ctrl + + drag will rotate objects

Placing objects on the island

This is fairly simple. Go to "Tools -> Artificial objects...", click the Add/Browse... button and go scavenging in P:\CA\ for all the content A2 and OA offer. When adding new objects, be aware that you can only import 6 objects at a time. It is a good idea to have only buildings having the standard color scheme. Walls, signs and other small stuff should have both the fill and the stroke color set to pure blue [0,0,255]. Later on, when we export the map as picture, this will help us hide certain elements.

Click "OK" to leave this screen. Now let's place some objects. Select "Artifical objects" from the "Panel of objects". If there is no such window, go to "View -> Panel of object" to bring it up again. Then select the items in that list and left-click into the terrain.

Placing trees on the island

Go back again to "Tools -> Nature objects..." and add trees and rocks. While trees and bushes are good to have on the exported picture, give the all-blue paint to the rocks to hide them later on from the satmap.

Create forests by grouping large amounts of trees and bushes.

Make sure to tick the randomizer options like "Randomize size" and "Randomize orientation" for plants. "Randomize angle" makes the trees and bushes be leant over to a side, which looks bad unless it is a dead tree.

First preview

Time to start the 3D viewer to adjust your objects. Do so by pressing the exclamation mark button. This will start Buldozer, but then it may immediately crash! No worries, is this because the island does not have a satmap, yet.

Create preview satmap and satmask

Time to create a temporary satmap. Start your favourite image editing software. I am stuck with using Photoshop over the years, so please bear with me.

Create a new image with the dimensions of "2560px x 2560px".

Then fill this image with dark green as a placeholder for now. RGB: 77-88-60 should be OK. Save it as "TUT_NewMap_SatMap_LCO" to P:\TUT_NewIsland\source. Now fill the image with black color and save it as "TUT_NewMap_LayerMask_LCO" to P:\TUT_NewIsland\source.

Both files should be saved in their native format (i.e. .psd if you use Photoshop and as .png for Visitor 3 to work with it).

Layers.cfg

Now navigate to P:\TUT_NewIsland\source and create a new file. Rename it to "Layers.cfg". This file will be the link between the two pictures and Visitor3. Open this new .cfg file and fill it with this:

class layers
{
	// make sure all the paths and files are lowercased, this is important for the clutter to work correctly later on without any major problems.
	class grass
	{
		texture  = "tut_islandname_data\tut_islandname_grass_co.paa";
		material = "tut_islandname_data\tut_islandname_grass.rvmat";
	};
};

class legend
{
	picture="TUT_IslandName\source\SurfaceMapLegend.png";
	class colors
	{
		grass[]		= {{ 0 ,	255,	 0 }};
	}
};

Detail Textures

You can get grass_co grass_nopx (needed for the parallax ground texture effect) files by unpacking utes.pbo or takistan_data.pbo. Or create them yourself. There are plenty tutorials for that out there. [links?] Search for "trava" or "travajih", it is Czech for grass. I recommend using these for this tutorial:

ut_trava_detail_co.paa
ut_trava_detail_nohq.paa

Save this file as your SurfaceMapLegend.png:

But we will be needing an .rvmat to go with this. Use this template here and save it as tut_islandname_data\tut_islandname_grass.rvmat.

ambient[] = { 0.89999998, 0.89999998, 0.89999998, 1 };
diffuse[] = { 0.89999998, 0.89999998, 0.89999998, 1 };
forcedDiffuse[] = { 0.02, 0.02, 0.02, 1 };
emmisive[] = { 0, 0, 0, 0 };
specular[] = { 0, 0, 0, 0 };
specularPower = 1;
PixelShaderID = "NormalMapDiffuse";
VertexShaderID = "NormalMapDiffuseAlpha";
class Stage1
{
	texture = "tut_islandname_data\tut_islandname_grass_nopx.paa";
	uvSource = "tex";
	class uvTransform
	{
		aside[] = { 10, 0, 0 };
		up[] = { 0, 10, 0 };
		dir[] = { 0, 0, 10 };
		pos[] = { 0, 0, 0 };
	};
};
class Stage2
{
	texture = "tut_islandname_data\tut_islandname_grass_co.paa";
	uvSource = "tex";
	class uvTransform
	{
		aside[] = { 10, 0, 0 };
		up[] = { 0, 10, 0 };
		dir[] = { 0, 0, 10 };
		pos[] = { 0, 0, 0 };
	};
};

Go to P:\TUT_IslandName_data and paste the grass detail texture you just stole, made, bought or found. Rename them to match the format in the layers.cfg. Lowercase will prevent case-sensitivity errors that might happen when trying to add clutter. Same goes for the .rvmat.

Ideally, your contents of P:\TUT_IslandName_data should look like this:

Importing the preview satmap

Now all is ready to import the first but temporary satmap:

go to "Tools -> Import Satellite + Mask..." in Visitor3
select the layers.cfg from your source folder. Select "Text" when asked
select the TUT_NewMap_SatMap_LCO.png
select the TUT_NewMap_LayerMask_LCO.png
wait for the loading bar to finish.

Then save the project again. Remember to increment the number.

Now press the Buldozer button again.

A small DOS window will appear which is converting all the small .png files that the previous loading bar created to .paa, which the game will need. This is one of the slowest parts. You might as well grab a sandwich when doing this with 25600px x 25600px Satmap.

When it is done, enjoy! You've made it through the most crucial part there is.

Within Buldozer you are able to move, rotate and shift the objects. You can customize the controls in Arma 2:OA -> Controls -> Buldozer, or by pressing F1 in Buldozer, but you might get some errors if your content is not unpacked correctly.

Placing roads on the island

"Tools -> Roads..." Click "Add...", then give this new road-preset a name: "Fine road". Avoid the color blue. I like to give roads an organe color.

Then go through all the categories like "Straight parts", "Curves", etc and add new roads. Once a category is selected, click on "Browse..", navigate to "P:\ca\roads2" and select asf1_6.

Here a list of what road extensions mean what:

Straight parts:

_6
_12
_25

Curves:

_10 25
_10 50
_10 75
_10 100

Ends:

_konec

Once you've filled an entire roadset with appropriate segments it is time to save again.

Select "Road Networks" from the panel of objects, double-click somewhere. Then select "Straight-Part", select a road object to begin with and confirm. Now press Enter ↵ and start building your road. The interface is pretty intuitive.

Buldozer has the habit of crashing if new content is added to the Panel of Objects, so make sure to set up all the object you want to use before starting buldozer on big island projects where loading the terrain in Buldozer takes 5-10 minutes.

Now add some stuff like roads, buildings, bushes to the terrain. Use Buldozer to fine-tune.

Exporting reference layer

Now this panel will be of interest:

We can export everything that is currently displayed in visitor as .emf file. We will use this to create reference layers that we then use as help while creating the satmap. First hide everything except for the roads. Then click one of the four buttons that are leftmost of the panel shown above to turn the background entirely blue. Then go to "Project -> Export map as image...". This window will appear:

Blue Edge ™

Search keyword: BLUE EDGE! ™

If you got here for searching for "Blue edge, you're in the right spot. If you were following the tutorial from the beginning, read carefully onwards.

Visitor automatically adds something that is known as the "Blue Edge" (tm). It is a line of additional pixels shown on the left and the bottom edge in visitor. And this edge is always exactly 1 times the size of your terrain cell size.

So, in our case of having a 2560m x 2560m terrain, based on a 256px x 256px heightmap imported with a 10m cell size, our project's blue edge will be 10px. When exporting our reference layer, we will need to account for that, thus we will export 2570x2570px instead of 2560x2560px. Later on we will cut the additional 10px away. But now they are needed to keep the aspect ratio of our layers and to ensure they're 100% spot-on.

The amount of extra pixels to accommodate for the Blue Edge (tm) is NOT simply the terrain cell size!

Export Plants, Buildings, Roads and the terrain separate layers. Hide and unhide as needed. Save those as:

roads_layer
plants_layer
building_layer
Terrain_layer (only needed if coastline is present)

Once you have four .emf files, we will convert them to .png, a format that we can work with. Go to your Visitor3 installation folder and grab the "EmfToPng.exe", and dump it into your source folder. Now drag on all four/three .emf files onto that .exe. New .png files should appear.

Creating the satmap

Welcome to the main-feature of this tutorial. :) Back in photoshop - open TUT_NewMap_SatMap_LCO.psd if you have closed it - and also open all four/three layer pngs we just converted. Then select all of the layer, Cut it, go to the satmap, paste it have it fit into the top-left corner. Do not resize this to fit. If everything went right, exactly 10px on the left and 10px on the bottom will be cropped away.

Once you have all layers in the satmap project, the layers window should look something like this:

Now we need to get the blue stuff away from each layer. Unhide all layers but the background and the buildings layer. Then Double-click the Buildings-layer and arrange the "Blend if" section to look like in the picture below:

Only the red stuff will remain.

To make the building-layer actually usable, create a new, empty layer, move it underneath the Buildings-layer, and then select the Buildings layer again, then press Ctrl + E. This will merge this into a new layer that only contains non-blue stuff. Your layer window should look like this now:

Do this for all layers. You might need the magic wand for the terrain layer to get hold of the coastline. If you did everything right, it should look similar to this:

Now it is only up to your photoshop skills to make this an awesome satmap. But the mechanics of importing .emf files and using them as references are always the same.

When you're done. It could look something like this, but that really depends on how awesome your skills with your image editing software is. I recommend cgtextures.com as a 1st stop for texture hunting.

Creating the layermask

The layermask tells the game where to put what detail texture. In our temporary satmap we used an entirely black image to put grass everywhere, but now, whith a road a house and some sand and coastline on the map, we don't want that anymore.

So back to PS, save the current satmask as layermask and start reducing them to colors. Unique colors. Avoid blurs at all costs! So, if you use four detail maps on your terrain, the layermaks MUST contain only four different colors.

In this case I chose green for grass, yellow for sand, black for gravel underneath roads and red for gravel underneath buildings. It could look like this:

Let's adjust the layer.cfg to match this:

class layers
{
	// make sure all the paths and files are lowercased, this is important for the clutter to work correctly later on without any major problems.
	class grass
	{
		texture  = "tut_islandname_data\tut_islandname_grass_co.paa";
		material = "tut_islandname_data\tut_islandname_grass.rvmat";
	};
	class sand
	{
		texture  = "tut_islandname_data\tut_islandname_sand_co.paa";
		material = "tut_islandname_data\tut_islandname_sand.rvmat";
	};
	class gravela
	{
		texture  = "tut_islandname_data\tut_islandname_gravela_co.paa";
		material = "tut_islandname_data\tut_islandname_gravela.rvmat";
	};
	class gravelb
	{
		texture  = "tut_islandname_data\tut_islandname_gravelb_co.paa";
		material = "tut_islandname_data\tut_islandname_gravelb.rvmat";
	};
};

class legend
{
	picture = "TUT_IslandName\source\maplegend.png";
	class colors
	{
		grass[]		= {{ 0 ,	255,	 0 }};
		sand[]		= {{255,	255,	 0 }};
		gravela[]	= {{ 0 ,	 0 ,	 0 }};
		gravelb[]	= {{255,	 0 ,	 0 }};
	};
};

Create corresponding textures and rvmats, then import the satmap again. Make sure Buldozer is closed to speed things up.

And if all went well, it looks like this ingame:

Save again.

Bringing the island into the game

Last step! Go to "Project -> Export World..." and save the island as IslandName.wrp. Save it to P:\TUT_islandName This will only work when Buldozer is running.

Take a snapshot, convert it to 512x128 px, save it as TUT_IslandName_pic_ca.paa into P:\TUT_islandName. Use texview to convert TGA->Paa, it is installed with BI Tools.

TUT_newIsland\Config.cpp

Then create a config.cpp and copy this into it:

class CfgPatches {

	class TUT_IslandName {
		units[] = {};
		weapons[] = {};
		requiredVersion = 1.500000;
		requiredAddons[] = { "Chernarus", "Takistan", "CAStructures", "CAData", "CABuildings", "CAMisc", "CABuildings2", "TUT_IslandName_data" };
		author = "You";
		mail = "";
	};
};

class CfgWorlds
{

	class DefaultWorld
	{
		/*extern*/ class Weather;
	};

	class CAWorld : DefaultWorld
	{
		class Grid
		{
		};
		/*extern*/ class DayLightingBrightAlmost;
		/*extern*/ class DayLightingRainy;
		/*extern*/ class DefaultClutter;

		class Weather : Weather
		{
			/*extern*/ class Lighting;
		};
	};
	/*extern*/ class DefaultLighting;

	class IslandName : CAWorld
	{
		cutscenes[] = {"TUT_IslandName_Cutscene1"};
		description = "IslandName";
		worldName = "\TUT_IslandName\IslandName.wrp";
		pictureShot = "\TUT_IslandName\TUT_IslandName_pic_ca.paa";
		icon = "";
		pictureMap = "";
		plateFormat = "MBG## $$#";
		plateLetters = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
		longitude = 1;
		latitude = 51;
		startTime = "13:30";
		startDate = "09/02/2011";
		startWeather = 0.400000;
		startFog = 0;
		forecastWeather = 0.10000;
		forecastFog = 0;
		centerPosition[] = { 829, 1473 };
		seagullPos[] = { 829, 150, 1473 };
		clutterGrid = 1.000000;
		clutterDist = 65;
		noDetailDist = 40;
		fullDetailDist = 15;
		midDetailTexture = "ca\chernarus\data\cr_trava1_mco.paa";
		minTreesInForestSquare = 1;
		minRocksInRockSquare = 1;
		ilsPosition[] = { 4887.5, 9660 };
		ilsDirection[] = { 0, 0, 0 };
		ilsTaxiin[] = { 4887.5, 9660 };
		ilsTaxiOff[] = { 4887.5,9660 };

		drawTaxiway = 0;

		class SecondaryAirports {};

		class Grid : Grid
		{
			offsetX = 0;
			offsetY = -25000;
			class Zoom1
			{
				zoomMax = 0.0001;
				format = "XY";
				formatX = "0000";
				formatY = "0000";
				stepX = 10;
				stepY = -10;
			};

			class Zoom2
			{
				zoomMax = 0.5;
				format = "XY";
				formatX = "000";
				formatY = "000";
				stepX = 100;
				stepY = -100;
			};

			class Zoom3
			{
				zoomMax = 1e+030.0;
				format = "XY";
				formatX = "00";
				formatY = "00";
				stepX = 1000;
				stepY = -1000;
			};
		};

		class OutsideTerrain
		{
		};

		class Lighting : DefaultLighting
		{
			groundReflection[] = { 0.060000, 0.060000, 0.030000 };
		};

		class DayLightingBrightAlmost : DayLightingBrightAlmost
		{
			deepNight[] = {-15, {0.050000, 0.050000, 0.060000}, {0.001000, 0.001000, 0.002000}, {0.020000, 0.020000, 0.050000}, {0.003000, 0.003000, 0.003000}, {0.000100, 0.000100, 0.000200}, {0.000100, 0.000100, 0.000200}, 0};
			fullNight[] = {-5, {0.050000, 0.050000, 0.050000}, {0.020000, 0.020000, 0.020000}, {0.040000, 0.040000, 0.040000}, {0.040000, 0.040000, 0.040000}, {0.010000, 0.010000, 0.020000}, {0.080000, 0.060000, 0.060000}, 0};
			sunMoon[] = {-3.750000, {0.045000, 0.040000, 0.040000}, {0.040000, 0.040000, 0.040000}, {0.045000, 0.040000, 0.040000}, {0.040000, 0.040000, 0.040000}, {0.040000, 0.035000, 0.040000}, {0.100000, 0.080000, 0.090000}, 0.500000};
			earlySun[] = {-2.500000, {0.120000, 0.100000, 0.100000}, {0.080000, 0.060000, 0.070000}, {0.120000, 0.100000, 0.100000}, {0.080000, 0.060000, 0.070000}, {0.080000, 0.070000, 0.080000}, {0.100000, 0.100000, 0.120000}, 1};
			sunrise[] = {0, {{0.700000, 0.450000, 0.450000}, "5.16+(-4)"}, {{0.070000, 0.090000, 0.120000}, "4.0+(-4)"}, {{0.600000, 0.470000, 0.250000}, "4.66+(-4)"}, {{0.100000, 0.090000, 0.100000}, "4.3+(-4)"}, {{0.500000, 0.400000, 0.400000}, "6.49+(-4)"}, {{0.880000, 0.510000, 0.240000}, "8.39+(-4)"}, 1};
			earlyMorning[] = {3, {{0.650000, 0.550000, 0.550000}, "6.04+(-4)"}, {{0.080000, 0.090000, 0.110000}, "4.5+(-4)"}, {{0.550000, 0.470000, 0.250000}, "5.54+(-4)"}, {{0.100000, 0.090000, 0.100000}, "5.02+(-4)"}, {{0.500000, 0.400000, 0.400000}, "7.05+(-4)"}, {{0.880000, 0.510000, 0.240000}, "8.88+(-4)"}, 1};
			midMorning[] = {8, {{0.980000, 0.850000, 0.800000}, "8.37+(-4)"}, {{0.080000, 0.090000, 0.110000}, "6.42+(-4)"}, {{0.870000, 0.470000, 0.250000}, "7.87+(-4)"}, {{0.090000, 0.090000, 0.100000}, "6.89+(-4)"}, {{0.500000, 0.400000, 0.400000}, "8.9+(-4)"}, {{0.880000, 0.510000, 0.240000}, "10.88+(-4)"}, 1};
			morning[] = {16, {{1, 1, 0.900000}, "13.17+(-4)"}, {{0.170000, 0.180000, 0.190000}, "10.26+(-4)"}, {{1, 1, 0.900000}, "12.67+(-4)"}, {{0.170000, 0.180000, 0.190000}, "11.71+(-4)"}, {{0.150000, 0.150000, 0.150000}, "12.42+(-4)"}, {{0.170000, 0.170000, 0.150000}, "14.42+(-4)"}, 1};
			noon[] = {45, {{1, 1, 1}, "17+(-4)"}, {{1, 1.300000, 1.550000}, "13.5+(-4)"}, {{1, 1, 1}, "15+(-4)"}, {{0.360000, 0.370000, 0.380000}, "13.5+(-4)"}, {{1, 1, 1}, "16+(-4)"}, {{1, 1, 1}, "17+(-4)"}, 1};
		};

		class DayLightingRainy: DayLightingRainy {
			deepNight[] = {-15, {0.003400, 0.003400, 0.004000}, {0.003000, 0.003000, 0.003000}, {0.003400, 0.003400, 0.004000}, {0.003000, 0.003000, 0.003000}, {0.001000, 0.001000, 0.002000}, {0.001000, 0.001000, 0.002000}, 0};
			fullNight[] = {-5, {0.023000, 0.023000, 0.023000}, {0.020000, 0.020000, 0.020000}, {0.023000, 0.023000, 0.023000}, {0.020000, 0.020000, 0.020000}, {0.010000, 0.010000, 0.020000}, {0.080000, 0.060000, 0.060000}, 0};
			sunMoon[] = {-3.750000, {0.040000, 0.040000, 0.050000}, {0.040000, 0.040000, 0.050000}, {0.040000, 0.040000, 0.050000}, {0.040000, 0.040000, 0.050000}, {0.040000, 0.035000, 0.040000}, {0.110000, 0.080000, 0.090000}, 0.500000};
			earlySun[] = {-2.500000, {0.068900, 0.068900, 0.080400}, {0.060000, 0.060000, 0.070000}, {0.068900, 0.068900, 0.080400}, {0.060000, 0.060000, 0.070000}, {0.080000, 0.070000, 0.080000}, {0.140000, 0.100000, 0.120000}, 0.500000};
			earlyMorning[] = {0, {{1, 1, 1}, "(-4)+3.95"}, {{1, 1, 1}, "(-4)+3.0"}, {{1, 1, 1}, "(-4)+3.95"}, {{1, 1, 1}, "(-4)+3.0"}, {{1, 1, 1}, "(-4)+4"}, {{1, 1, 1}, "(-4)+5.5"}, 1};
			morning[] = {5, {{1, 1, 1}, "(-4)+5.7"}, {{1, 1, 1}, "(-4)+4.5"}, {{1, 1, 1}, "(-4)+5.7"}, {{1, 1, 1}, "(-4)+4.5"}, {{1, 1, 1}, "(-4)+7"}, {{1, 1, 1}, "(-4)+8"}, 1};
			lateMorning[] = {25, {{1, 1, 1}, "(-4)+10.45"}, {{1, 1, 1}, "(-4)+9.75"}, {{1, 1, 1}, "(-4)+10.45"}, {{1, 1, 1}, "(-4)+9.75"}, {{1, 1, 1}, "(-4)+12"}, {{1, 1, 1}, "(-4)+12.75"}, 1};
			noon[] = {70, {{1, 1, 1}, "(-4)+12.5"}, {{1, 1, 1}, "(-4)+11"}, {{1, 1, 1}, "(-4)+12"}, {{1, 1, 1}, "(-4)+11"}, {{1, 1, 1}, "(-4)+13.5"}, {{1, 1, 1}, "(-4)+14"}, 1};
		};

		class Weather : Weather
		{
			class Lighting : Lighting
			{
				class BrightAlmost : DayLightingBrightAlmost
				{
					overcast = 0;
				};

				class Rainy : DayLightingRainy
				{
					overcast = 1;
				};
			};
		};

		class Clutter
		{
			#include "cfgClutter.hpp"
		};

		class Names
		{
			#include "Tut_IslandName.hpp" // Automatically created upon exporting as .wrp
		};

		class Ambient
		{
			class Mammals
			{
				radius = 200;
				cost = "(1 + forest + trees) * (0.5 + (0.5 * night)) * (1 - sea) * (1 - houses)";

				class Species
				{
					class Rabbit
					{
						probability = 0.200000;
						cost = 1;
					};
				};
			};

			class BigBirds
			{
				radius = 300;
				cost = "((8 + forest + trees) - ((1 * rain)) - houses) * (1 - night) * (1 - sea)";

				class Species
				{
					class Hawk
					{
						probability = 1;
						cost = 1;
					};

				};
			};

			class BigInsects
			{
				radius = 20;
				cost = "(5 - (2 * houses)) * (1 - night) * (1 - rain) * (1 - sea) * (1 - windy)";

				class Species
				{
					class DragonFly
					{
						probability = "0.6 - (meadow * 0.5) + (forest * 0.4)";
						cost = 1;
					};

					class ButterFly
					{
						probability = "0.6 + (meadow * 0.4) - (forest * 0.4)";
						cost = 1;
					};
				};
			};

			class BigInsectsAquatic
			{
				radius = 20;
				cost = "(3 * sea) * (1 - night) * (1 - rain) * (1 - windy)";

				class Species
				{
					class DragonFly
					{
						probability = 1;
						cost = 1;
					};
				};
			};

			class SmallInsects
			{
				radius = 3;
				cost = "(12 - 8 * hills) * (1 - night) * (1 - rain) * (1 - sea) * (1 - windy)";

				class Species
				{
					class HouseFly
					{
						probability = "deadBody + (1 - deadBody) * (0.5 - forest * 0.1 - meadow * 0.2)";
						cost = 1;
					};

					class HoneyBee
					{
						probability = "(1 - deadBody) * (0.8 - forest * 0.1 + meadow * 0.2)";
						cost = 1;
					};

					class Mosquito
					{
						probability = "(1 - deadBody) * (forest)";
						cost = 1;
					};
				};
			};

			class NightInsects
			{
				radius = 3;
				cost = "(9 - 8 * hills) * night * (1 - rain) * (1 - sea) * (1 - windy)";

				class Species
				{
					class Mosquito
					{
						probability = 1;
						cost = 1;
					};
				};
			};

			class WindClutter
			{
				radius = 10;
				cost = "((20 - 5 * rain) * (3 * (windy factor [0.2, 0.5]))) * (1 - sea)";

				class Species
				{
					class FxWindGrass1
					{
						probability = "0.6 + 0.2 * hills - 0.2 * trees";
						cost = 1;
					};

					class FxWindGrass2
					{
						probability = "0.6 + 0.2 * hills - 0.2 * trees";
						cost = 1;
					};

					class FxWindRock1
					{
						probability = "0.4 * hills";
						cost = 1;
					};
				};
			};

			class NoWindClutter
			{
				radius = 15;
				cost = 8;

				class Species
				{
					class FxWindPollen1
					{
						probability = 1;
						cost = 1;
					};
				};
			};
		};

		class Armory
		{
			positionAdmin[] = { 3500, 3500 };
			positionStartWater[] = { 7584.109863, 1206.680054 };
			positionsViewer[] = { { 3500, 3500 } };
		};

		class Subdivision
		{
			class Fractal
			{
				rougness = 5;
				maxRoad = 0.02;
				maxTrack = 0.5;
				maxSlopeFactor = 0.05;
			};
			class WhiteNoise
			{
				rougness = 2;
				maxRoad = 0.01;
				maxTrack = 0.05;
				maxSlopeFactor = 0.0025;
			};
			minY = -0.0;
			minSlope = 0.02;
		};

		class ReplaceObjects
		{
		};

		class Sounds
		{
			sounds[] = {};
		};

		class Animation
		{
			vehicles[] = {};
		};
	};
};

class CfgMissions
{
	class Cutscenes
	{
		class TUT_IslandName_Cutscene1
		{
			directory = "TUT_IslandName\scenes\intro.islandName";
		};
	};
};

class CfgWorldList
{
	class islandName
	{
	};
};

#include "cfgSurfaces.hpp"

↑ Back to spoiler's top

TUT_newIsland\cfgClutter.hpp

Then create cfgClutter.hpp and paste this into it:

class TUT_IslandName_TK_GrassGreenLong : DefaultClutter
{
	model = "ca\plants_E\Clutter\c_GrassGreen_EP1.p3d";
	affectedByWind = 0.7;
	swLighting = 1;
	scaleMin = 0.85;
	scaleMax = 1.1;
};

TUT_newIsland\cfgSurfaces.hpp

And then create cfgSurfaces.hpp and paste this into it:

class CfgSurfaces
{
	class Default {};
	class TUT_IslandName_GreenGrass : Default
	{
		files = "tut_newisland_grass_*"; // THIS IS CASE SENSITIVE!!!!111eleven
		rough = 0.2;
		dust = 0.01;
		soundHit = "soft_ground";
		soundEnviron = "grass";
		character = "TUT_IslandName_GreenGrass_Character";
	};

	class TUT_IslandName_Sand : Default
	{
		files = "tut_newisland_sand_*"; // THIS IS CASE SENSITIVE!!!!111eleven
		rough = 0.13;
		dust = 0.3;
		soundEnviron = "dirt";
		character = "Empty";
		soundHit = "soft_ground";
	};

	class TUT_IslandName_gravelA : Default
	{
		files = "tut_newisland_gravela_*"; // THIS IS CASE SENSITIVE!!!!111eleven
		rough = 0.1;
		dust = 0.25;
		soundEnviron = "gravel";
		character = "Empty";
		soundHit = "hard_ground";
	};

	class TUT_IslandName_gravelB : TUT_IslandName_gravela
	{
		files = "tut_newisland_gravelb_*"; //THIS IS CASE SENSITIVE!!!!111eleven
	};
};

class CfgSurfaceCharacters
{
	class TUT_IslandName_GreenGrass_Character
	{
		probability[] = { 0.6 };
		names[] = { "TUT_IslandName_TK_GrassGreenLong" };
	};
};

TUT_newIsland_data\config.cpp

Now go to P:\TUT_newIsland_data and create another config.cpp, fill it with this:

class CfgPatches
{
	class TUT_IslandName_data
	{
		units[] = {};
		weapons[] = {};
		requiredVersion = 1.500000;
		requiredAddons[] = {};
		author = "You";
		mail = "";
	};
};

Packing

Now fire up BinPbo and pack P:\TUT_newIsland_data and then P:\TUT_newIsland. Check the "Copy files directly" line in BinPBO (under Options/Settings) and add *.rvmat if it is missing.

If you want a background "movie" when the island was selected and you go back to the main menu, simply create a small mission (that is set to Intro) containing a few camera movements and save it as TUT_IslandName\scenes\intro.islandName.

If everything works, you're one lucky son of a gun and it is time for you to start your own project, now that you've managed to bring a terrain ingame.

Being Done

This is it.