1self.importScripts('landmap.js');
  2self.addEventListener('message', function(e) {
  3  var data = e.data;
  4  var terrain;
  5  switch (data) {
  6    case 'smooth-simple-erosion':
  7      terrain = new LandMap({
  8        containerId: "container-smooth-simple-erosion"
  9      });
 10      terrain.generate({
 11        deviation: 0.75,
 12        feature: "m1"
 13      });
 14      terrain.simpleErosion({
 15        carryingCapacity: 1.5,
 16        depositionSpeed: 0.03,
 17        iterations: 10,
 18        drops: 1000000,
 19        from: "m1",
 20        to: "m2"
 21      });
 22      terrain.smooth({
 23        amount: 3,
 24        from: "m2",
 25        to: "m3"
 26      });
 27      break;
 28    case 'smooth-complex-erosion':
 29      terrain = new LandMap({
 30        containerId: "container-smooth-complex-erosion"
 31      });
 32      terrain.generate({
 33        deviation: 0.75,
 34        feature: "m1"
 35      });
 36      terrain.complexErosion({
 37        carryingCapacity: 1.5,
 38        depositionSpeed: 0.03,
 39        iterations: 3,
 40        drops: 8000000,
 41        from: "m1",
 42        to: "m2"
 43      });
 44      terrain.smooth({
 45        amount: 2,
 46        from: "m2",
 47        to: "m3"
 48      });
 49      break;
 50    case 'many':
 51      terrain = new LandMap({
 52        containerId: "container-many"
 53      });
 54      terrain.generate({
 55        deviation: 0.75,
 56        feature: "m1"
 57      });
 58      terrain.smooth({
 59        amount: 10,
 60        from: "m1",
 61        to: "m2"
 62      });
 63      terrain.generate({
 64        deviation: 0.75,
 65        feature: "p1"
 66      });
 67      terrain.smooth({
 68        amount: 10,
 69        from: "p1",
 70        to: "p2"
 71      });
 72      terrain.complexErosion({
 73        carryingCapacity: 1.5,
 74        depositionSpeed: 0.03,
 75        iterations: 3,
 76        drops: 8000000,
 77        from: "p2",
 78        to: "p3"
 79      });
 80      //combining
 81      terrain.combine({
 82        one: "p2",
 83        two: "p3",
 84        three: "m2",
 85        result: "c1 from (p2,p3,m2)"
 86      });
 87      terrain.combine({
 88        one: "p3",
 89        two: "p2",
 90        three: "m2",
 91        result: "c2 from (p3,p2,m2)"
 92      });
 93      break;
 94    case 'sample':
 95      terrain = new LandMap({
 96        containerId: "container-sample"
 97      });
 98      terrain.generate({
 99        deviation: 0.75,
100        feature: "standard"
101      });
102      terrain.smooth({
103        amount: 10,
104        from: "standard",
105        to: "smoothed-10"
106      });
107      terrain.grd({
108        amount: 20,
109        percent: 0.03,
110        from: "standard",
111        to: "grd-20-0.03"
112      });
113      terrain.complexErosion({
114        carryingCapacity: 1.5,
115        depositionSpeed: 0.03,
116        iterations: 3,
117        drops: 8000000,
118        from: "standard",
119        to: "complexErosion-8000000-3ipd"
120      });
121      break;
122    case 'complexErosion':
123      terrain = new LandMap({
124        containerId: "container-complexErosion"
125      });
126      terrain.generate({
127        deviation: 0.75,
128        feature: "standard"
129      });
130      terrain.complexErosion({
131        carryingCapacity: 1.5,
132        depositionSpeed: 0.03,
133        iterations: 10,
134        drops: 1000000,
135        from: "standard",
136        to: "complexErosion-1000000-10ipd"
137      });
138      terrain.complexErosion({
139        carryingCapacity: 1.5,
140        depositionSpeed: 0.03,
141        iterations: 20,
142        drops: 1000000,
143        from: "standard",
144        to: "complexErosion-1000000-20ipd"
145      });
146      terrain.complexErosion({
147        carryingCapacity: 1.5,
148        depositionSpeed: 0.03,
149        iterations: 3,
150        drops: 4000000,
151        from: "standard",
152        to: "complexErosion-4000000-3ipd"
153      });
154      terrain.complexErosion({
155        carryingCapacity: 1.5,
156        depositionSpeed: 0.03,
157        iterations: 3,
158        drops: 8000000,
159        from: "standard",
160        to: "complexErosion-8000000-3ipd"
161      });
162      break;
163    case 'simpleErosion':
164      terrain = new LandMap({
165        containerId: "container-simpleErosion"
166      });
167      terrain.generate({
168        deviation: 0.75,
169        feature: "standard"
170      });
171      terrain.simpleErosion({
172        carryingCapacity: 1.5,
173        depositionSpeed: 0.03,
174        iterations: 10,
175        drops: 1000000,
176        from: "standard",
177        to: "simpleErosion"
178      });
179      break;
180    case 'grd':
181      terrain = new LandMap({
182        containerId: "container-grd"
183      });
184      terrain.generate({
185        deviation: 0.75,
186        feature: "standard"
187      });
188      terrain.grd({
189        amount: 22,
190        percent: 0.01,
191        from: "standard",
192        to: "grd-22-0.01"
193      });
194      terrain.grd({
195        amount: 20,
196        percent: 0.03,
197        from: "standard",
198        to: "grd-20-0.03"
199      });
200      terrain.grd({
201        amount: 40,
202        percent: 0.01,
203        from: "standard",
204        to: "grd-40-0.01"
205      });
206      break;
207    case 'combined':
208      terrain = new LandMap({
209        containerId: "container-combined"
210      });
211      terrain.generate({
212        deviation: 0.75,
213        feature: "standard"
214      });
215      terrain.generate({
216        deviation: 0.75,
217        feature: "standard-two"
218      });
219      terrain.smooth({
220        amount: 10,
221        from: "standard",
222        to: "standard-10"
223      });
224      terrain.smooth({
225        amount: 20,
226        from: "standard-two",
227        to: "standard-two-20"
228      });
229      terrain.combine({
230        one: "standard",
231        two: "standard-10",
232        three: "standard-two-20",
233        result: "combined"
234      });
235      terrain.combine({
236        one: "standard-10",
237        two: "standard",
238        three: "standard-two-20",
239        result: "reversed"
240      });
241      break;
242    case 'smoothed':
243      terrain = new LandMap({
244        containerId: "container-smoothed"
245      });
246      terrain.generate({
247        deviation: 0.75,
248        feature: "p1"
249      });
250      terrain.smooth({
251        amount: 10,
252        from: "p1",
253        to: "p2"
254      });
255      terrain.smooth({
256        amount: 20,
257        from: "p1",
258        to: "p3"
259      });
260      break;
261    case 'standard':
262      terrain = new LandMap({
263        containerId: "container-standard"
264      });
265      terrain.generate({
266        deviation: 0.35,
267        feature: "m1"
268      });
269      terrain.generate({
270        deviation: 0.75,
271        feature: "p1"
272      });
273      terrain.generate({
274        deviation: 0.95,
275        feature: "r1"
276      });
277      break;
278  };
279  self.postMessage(terrain);
280}, false);