API tools faq
paste
Advertisement
Earthcomputer

OverworldDimension.cpp

Earthcomputer
Nov 25th, 2018
238
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 18.29 KB | None | 0 0
raw download clone embed print report
  1. __int64 __fastcall OverworldDimension::createDefaultLayers(__int64 seed, __int64 layers1, __int64 layers2, int generatorId, char experimentalGameplay)
  2. {
  3.   __int64 v5; // STF0_8
  4.   __int64 v6; // STD8_8
  5.   __int64 v7; // STC8_8
  6.   __int64 v8; // STB0_8
  7.   __int64 v9; // ST80_8
  8.   __int64 v10; // ST70_8
  9.   __int64 v11; // ST60_8
  10.   __int64 v12; // ST50_8
  11.   __int64 v13; // ST40_8
  12.   __int64 v14; // ST30_8
  13.   __int64 v15; // ST20_8
  14.   __int64 v16; // ST10_8
  15.   __int64 v17; // rax
  16.   __int64 v18; // rax
  17.   int v20; // [rsp+1B4h] [rbp-43Ch]
  18.   char v21; // [rsp+1B8h] [rbp-438h]
  19.   char v22; // [rsp+1C8h] [rbp-428h]
  20.   int v23; // [rsp+1DCh] [rbp-414h]
  21.   char v24; // [rsp+1E0h] [rbp-410h]
  22.   int v25; // [rsp+1F4h] [rbp-3FCh]
  23.   char v26; // [rsp+1F8h] [rbp-3F8h]
  24.   int v27; // [rsp+20Ch] [rbp-3E4h]
  25.   char v28; // [rsp+210h] [rbp-3E0h]
  26.   int v29; // [rsp+224h] [rbp-3CCh]
  27.   char v30; // [rsp+228h] [rbp-3C8h]
  28.   int v31; // [rsp+23Ch] [rbp-3B4h]
  29.   char v32; // [rsp+240h] [rbp-3B0h]
  30.   int v33; // [rsp+254h] [rbp-39Ch]
  31.   char v34; // [rsp+258h] [rbp-398h]
  32.   int v35; // [rsp+26Ch] [rbp-384h]
  33.   int v36; // [rsp+270h] [rbp-380h]
  34.   int v37; // [rsp+278h] [rbp-378h]
  35.   __int64 v38; // [rsp+280h] [rbp-370h]
  36.   __int64 *v39; // [rsp+288h] [rbp-368h]
  37.   int v40; // [rsp+294h] [rbp-35Ch]
  38.   char v41; // [rsp+298h] [rbp-358h]
  39.   int v42; // [rsp+2ACh] [rbp-344h]
  40.   char v43; // [rsp+2B0h] [rbp-340h]
  41.   int v44; // [rsp+2C4h] [rbp-32Ch]
  42.   char v45; // [rsp+2C8h] [rbp-328h]
  43.   char v46; // [rsp+2D8h] [rbp-318h]
  44.   char v47; // [rsp+2E8h] [rbp-308h]
  45.   int v48; // [rsp+2FCh] [rbp-2F4h]
  46.   char v49; // [rsp+300h] [rbp-2F0h]
  47.   char v50; // [rsp+310h] [rbp-2E0h]
  48.   char layer5; // [rsp+320h] [rbp-2D0h]
  49.   bool v52; // [rsp+333h] [rbp-2BDh]
  50.   int v53; // [rsp+334h] [rbp-2BCh]
  51.   char v54; // [rsp+338h] [rbp-2B8h]
  52.   char v55; // [rsp+348h] [rbp-2A8h]
  53.   int v56; // [rsp+35Ch] [rbp-294h]
  54.   char v57; // [rsp+360h] [rbp-290h]
  55.   int v58; // [rsp+374h] [rbp-27Ch]
  56.   char v59; // [rsp+378h] [rbp-278h]
  57.   char v60; // [rsp+388h] [rbp-268h]
  58.   char layer3; // [rsp+398h] [rbp-258h]
  59.   unsigned int biomeSize; // [rsp+3ACh] [rbp-244h]
  60.   char v63; // [rsp+3B0h] [rbp-240h]
  61.   int v64; // [rsp+3C4h] [rbp-22Ch]
  62.   char v65; // [rsp+3C8h] [rbp-228h]
  63.   int v66; // [rsp+3DCh] [rbp-214h]
  64.   char v67; // [rsp+3E0h] [rbp-210h]
  65.   int v68; // [rsp+3F4h] [rbp-1FCh]
  66.   char v69; // [rsp+3F8h] [rbp-1F8h]
  67.   int v70; // [rsp+40Ch] [rbp-1E4h]
  68.   char v71; // [rsp+410h] [rbp-1E0h]
  69.   int v72; // [rsp+424h] [rbp-1CCh]
  70.   char v73; // [rsp+428h] [rbp-1C8h]
  71.   int v74; // [rsp+438h] [rbp-1B8h]
  72.   int v75; // [rsp+43Ch] [rbp-1B4h]
  73.   char v76; // [rsp+440h] [rbp-1B0h]
  74.   int v77; // [rsp+450h] [rbp-1A0h]
  75.   int v78; // [rsp+454h] [rbp-19Ch]
  76.   char v79; // [rsp+458h] [rbp-198h]
  77.   int v80; // [rsp+468h] [rbp-188h]
  78.   int v81; // [rsp+46Ch] [rbp-184h]
  79.   char v82; // [rsp+470h] [rbp-180h]
  80.   int v83; // [rsp+484h] [rbp-16Ch]
  81.   char v84; // [rsp+488h] [rbp-168h]
  82.   int v85; // [rsp+49Ch] [rbp-154h]
  83.   char v86; // [rsp+4A0h] [rbp-150h]
  84.   char v87; // [rsp+4B0h] [rbp-140h]
  85.   int v88; // [rsp+4C4h] [rbp-12Ch]
  86.   char v89; // [rsp+4C8h] [rbp-128h]
  87.   int v90; // [rsp+4DCh] [rbp-114h]
  88.   char v91; // [rsp+4E0h] [rbp-110h]
  89.   char layer2; // [rsp+4F0h] [rbp-100h]
  90.   int v93; // [rsp+504h] [rbp-ECh]
  91.   char v94; // [rsp+508h] [rbp-E8h]
  92.   int v95; // [rsp+51Ch] [rbp-D4h]
  93.   char v96; // [rsp+520h] [rbp-D0h]
  94.   int v97; // [rsp+534h] [rbp-BCh]
  95.   char v98; // [rsp+538h] [rbp-B8h]
  96.   int v99; // [rsp+54Ch] [rbp-A4h]
  97.   char v100; // [rsp+550h] [rbp-A0h]
  98.   int v101; // [rsp+564h] [rbp-8Ch]
  99.   char v102; // [rsp+568h] [rbp-88h]
  100.   int v103; // [rsp+57Ch] [rbp-74h]
  101.   char v104; // [rsp+580h] [rbp-70h]
  102.   int v105; // [rsp+594h] [rbp-5Ch]
  103.   char v106; // [rsp+598h] [rbp-58h]
  104.   int v107; // [rsp+5ACh] [rbp-44h]
  105.   char v108; // [rsp+5B0h] [rbp-40h]
  106.   char layer1; // [rsp+5C0h] [rbp-30h]
  107.   char v110; // [rsp+5D3h] [rbp-1Dh]
  108.   int generatorId_1; // [rsp+5D4h] [rbp-1Ch]
  109.   __int64 layer7; // [rsp+5D8h] [rbp-18h]
  110.   __int64 layer4; // [rsp+5E0h] [rbp-10h]
  111.   __int64 seed_1; // [rsp+5E8h] [rbp-8h]
  112.  
  113.   seed_1 = seed;
  114.   layer4 = layers1;
  115.   layer7 = layers2;
  116.   generatorId_1 = generatorId;
  117.   v110 = experimentalGameplay & 1;
  118.   // SECTION 1
  119.   v107 = 1;                                     // GenLayer layer1 = new GenLayerIsland(1L);
  120.   std::make_shared<IslandLayer,int>(&v108, &v107);
  121.   std::shared_ptr<Layer>::shared_ptr<IslandLayer,void>(&layer1, &v108);
  122.   std::shared_ptr<IslandLayer>::~shared_ptr(&v108);
  123.   v105 = 2000;                                  // layer1 = new GenLayerFuzzyZoom(2000L, layer1);
  124.   std::make_shared<FuzzyZoomLayer,int,std::shared_ptr<Layer> &>(&v106, &v105, &layer1);
  125.   std::shared_ptr<Layer>::operator=<FuzzyZoomLayer>(&layer1, &v106);
  126.   std::shared_ptr<FuzzyZoomLayer>::~shared_ptr(&v106);
  127.   v103 = 1;                                     // layer1 = new GenLayerAddIsland(1L, layer1);
  128.   std::make_shared<AddIslandLayer,int,std::shared_ptr<Layer> &>(&v104, &v103, &layer1);
  129.   std::shared_ptr<Layer>::operator=<AddIslandLayer>(&layer1, &v104);
  130.   std::shared_ptr<AddIslandLayer>::~shared_ptr(&v104);
  131.   v101 = 2001;                                  // layer1 = new GenLayerZoom(2001L, layer1);
  132.   std::make_shared<ZoomLayer,int,std::shared_ptr<Layer> &>(&v102, &v101, &layer1);
  133.   std::shared_ptr<Layer>::operator=<ZoomLayer>(&layer1, &v102);
  134.   std::shared_ptr<ZoomLayer>::~shared_ptr(&v102);
  135.   v99 = 2;                                      // layer1 = new GenLayerAddIsland(2L, layer1);
  136.   std::make_shared<AddIslandLayer,int,std::shared_ptr<Layer> &>(&v100, &v99, &layer1);
  137.   std::shared_ptr<Layer>::operator=<AddIslandLayer>(&layer1, &v100);
  138.   std::shared_ptr<AddIslandLayer>::~shared_ptr(&v100);
  139.   v97 = 50;                                     // layer1 = new GenLayerAddIsland(50L, layer1);
  140.   std::make_shared<AddIslandLayer,int,std::shared_ptr<Layer> &>(&v98, &v97, &layer1);
  141.   std::shared_ptr<Layer>::operator=<AddIslandLayer>(&layer1, &v98);
  142.   std::shared_ptr<AddIslandLayer>::~shared_ptr(&v98);
  143.   v95 = 70;                                     // layer1 = new GenLayerAddIsland(70L, layer1);
  144.   std::make_shared<AddIslandLayer,int,std::shared_ptr<Layer> &>(&v96, &v95, &layer1);
  145.   std::shared_ptr<Layer>::operator=<AddIslandLayer>(&layer1, &v96);
  146.   std::shared_ptr<AddIslandLayer>::~shared_ptr(&v96);
  147.   v93 = 2;                                      // layer1 = new GenLayerRemoveTooMuchOcean(2L, layer1);
  148.   std::make_shared<RemoveTooMuchOceanLayer,int,std::shared_ptr<Layer> &>(&v94, &v93, &layer1);
  149.   std::shared_ptr<Layer>::operator=<RemoveTooMuchOceanLayer>(&layer1, &v94);
  150.   std::shared_ptr<RemoveTooMuchOceanLayer>::~shared_ptr(&v94);
  151.   // SECTION 2 (not in the Java code)
  152.   std::shared_ptr<Layer>::shared_ptr(&layer2, &layer1);// GenLayer layer2 = layer1;
  153.   v90 = 2;                                      // layer2 = new AddOceanTemperatureLayer(2L, layer2);
  154.   std::make_shared<AddOceanTemperatureLayer,int,std::shared_ptr<Layer> &>(&v91, &v90, &layer2);
  155.   std::shared_ptr<Layer>::operator=<AddOceanTemperatureLayer>(&layer2, &v91);
  156.   std::shared_ptr<AddOceanTemperatureLayer>::~shared_ptr(&v91);
  157.   v88 = 2;                                      // layer2 = new AddOceanEdgeLayer(2L, layer2);
  158.   std::make_shared<AddOceanEdgeLayer,int,std::shared_ptr<Layer> &>(&v89, &v88, &layer2);
  159.   std::shared_ptr<Layer>::operator=<AddOceanEdgeLayer>(&layer2, &v89);
  160.   std::shared_ptr<AddOceanEdgeLayer>::~shared_ptr(&v89);
  161.   ZoomLayer::zoom(&v87, 2001LL, &layer2, 6LL);  // layer2 = GenLayerZoom.magnify(2001L, layer2, 6);
  162.   std::shared_ptr<Layer>::operator=(&layer2, &v87);
  163.   std::shared_ptr<Layer>::~shared_ptr(&v87);
  164.   // SECTION 3
  165.   v85 = 2;                                      // layer1 = new GenLayerAddSnow(2L, layer1);
  166.   std::make_shared<AddSnowLayer,int,std::shared_ptr<Layer> &>(&v86, &v85, &layer1);
  167.   std::shared_ptr<Layer>::operator=<AddSnowLayer>(&layer1, &v86);
  168.   std::shared_ptr<AddSnowLayer>::~shared_ptr(&v86);
  169.   v83 = 3;                                      // layer1 = new GenLayerAddIsland(3L, layer1);
  170.   std::make_shared<AddIslandLayer,int,std::shared_ptr<Layer> &>(&v84, &v83, &layer1);
  171.   std::shared_ptr<Layer>::operator=<AddIslandLayer>(&layer1, &v84);
  172.   std::shared_ptr<AddIslandLayer>::~shared_ptr(&v84);
  173.   v81 = 2;                                      // layer1 = new GenLayerEdge(2L, layer1, GenLayerEdge.Mode.COOL_WARM);
  174.   v80 = 0;
  175.   std::make_shared<AddEdgeLayer,int,std::shared_ptr<Layer> &,AddEdgeLayer::Mode>(&v82, &v81, &layer1, &v80);
  176.   std::shared_ptr<Layer>::operator=<AddEdgeLayer>(&layer1, &v82);
  177.   std::shared_ptr<AddEdgeLayer>::~shared_ptr(&v82);
  178.   v78 = 2;                                      // layer1 = new GenLayerEdge(2L, layer1, GenLayerEdge.Mode.HEAT_ICE);
  179.   v77 = 1;
  180.   std::make_shared<AddEdgeLayer,int,std::shared_ptr<Layer> &,AddEdgeLayer::Mode>(&v79, &v78, &layer1, &v77);
  181.   std::shared_ptr<Layer>::operator=<AddEdgeLayer>(&layer1, &v79);
  182.   std::shared_ptr<AddEdgeLayer>::~shared_ptr(&v79);
  183.   v75 = 3;                                      // layer1 = new GenLayerEdge(3L, layer1, GenLayerEdge.Mode.SPECIAL);
  184.   v74 = 2;
  185.   std::make_shared<AddEdgeLayer,int,std::shared_ptr<Layer> &,AddEdgeLayer::Mode>(&v76, &v75, &layer1, &v74);
  186.   std::shared_ptr<Layer>::operator=<AddEdgeLayer>(&layer1, &v76);
  187.   std::shared_ptr<AddEdgeLayer>::~shared_ptr(&v76);
  188.   v72 = 2002;                                   // layer1 = new GenLayerZoom(2002L, layer1);
  189.   std::make_shared<ZoomLayer,int,std::shared_ptr<Layer> &>(&v73, &v72, &layer1);
  190.   std::shared_ptr<Layer>::operator=<ZoomLayer>(&layer1, &v73);
  191.   std::shared_ptr<ZoomLayer>::~shared_ptr(&v73);
  192.   v70 = 2003;                                   // layer1 = new GenLayerZoom(2003L, layer1);
  193.   std::make_shared<ZoomLayer,int,std::shared_ptr<Layer> &>(&v71, &v70, &layer1);
  194.   std::shared_ptr<Layer>::operator=<ZoomLayer>(&layer1, &v71);
  195.   std::shared_ptr<ZoomLayer>::~shared_ptr(&v71);
  196.   v68 = 4;                                      // layer1 = new GenLayerAddIsland(4L, layer1);
  197.   std::make_shared<AddIslandLayer,int,std::shared_ptr<Layer> &>(&v69, &v68, &layer1);
  198.   std::shared_ptr<Layer>::operator=<AddIslandLayer>(&layer1, &v69);
  199.   std::shared_ptr<AddIslandLayer>::~shared_ptr(&v69);
  200.   v66 = 5;                                      // layer1 = new GenLayerAddMushroomIsland(5L, layer1);
  201.   std::make_shared<AddMushroomIslandLayer,int,std::shared_ptr<Layer> &>(&v67, &v66, &layer1);
  202.   std::shared_ptr<Layer>::operator=<AddMushroomIslandLayer>(&layer1, &v67);
  203.   std::shared_ptr<AddMushroomIslandLayer>::~shared_ptr(&v67);
  204.   v64 = 4;                                      // layer1 = new GenLayerDeepOcean(4L, layer1);
  205.   std::make_shared<AddDeepOceanLayer,int,std::shared_ptr<Layer> &>(&v65, &v64, &layer1);
  206.   std::shared_ptr<Layer>::operator=<AddDeepOceanLayer>(&layer1, &v65);
  207.   std::shared_ptr<AddDeepOceanLayer>::~shared_ptr(&v65);
  208.   ZoomLayer::zoom(&v63, 1000LL, &layer1, 0LL);  // layer1 = GenLayerZoom.magnify(1000L, layer1, 0);
  209.   std::shared_ptr<Layer>::operator=(&layer1, &v63);
  210.   std::shared_ptr<Layer>::~shared_ptr(&v63);
  211.   biomeSize = 4;
  212.   if ( !generatorId_1 )
  213.     biomeSize = 2;
  214.   // SECTION 4
  215.   std::shared_ptr<Layer>::shared_ptr(&layer3, &layer1);// GenLayer layer3 = layer1;
  216.   ZoomLayer::zoom(&v60, 1000LL, &layer3, 0LL);  // layer3 = GenLayerZoom.magnify(1000L, layer3, 0);
  217.   std::shared_ptr<Layer>::operator=(&layer3, &v60);
  218.   std::shared_ptr<Layer>::~shared_ptr(&v60);
  219.   v58 = 100;                                    // layer3 = new GenLayerRiverInit(100L, layer3);
  220.   std::make_shared<RiverInitLayer,int,std::shared_ptr<Layer> &>(&v59, &v58, &layer3);
  221.   std::shared_ptr<Layer>::operator=<RiverInitLayer>(&layer3, &v59);
  222.   std::shared_ptr<RiverInitLayer>::~shared_ptr(&v59);
  223.   // SECTION 5
  224.   std::shared_ptr<Layer>::operator=(layer4, &layer1);// GenLayer layer4 = layer1;
  225.   v56 = 200;                                    // layer4 = new GenLayerBiome(200L, layer4, generatorId);
  226.   v5 = layer4;
  227.   std::make_shared<BiomeInitLayer,int,std::shared_ptr<Layer> &,GeneratorType &>(&v57, &v56, layer4, &generatorId_1);
  228.   std::shared_ptr<Layer>::operator=<BiomeInitLayer>(v5, &v57);
  229.   std::shared_ptr<BiomeInitLayer>::~shared_ptr(&v57);
  230.   v6 = layer4;                                  // layer4 = GenLayerZoom.magnify(1000L, layer4, 2);
  231.   ZoomLayer::zoom(&v55, 1000LL, layer4, 2LL);
  232.   std::shared_ptr<Layer>::operator=(v6, &v55);
  233.   std::shared_ptr<Layer>::~shared_ptr(&v55);
  234.   v53 = 1000;                                   // layer4 = new GenLayerBiomeEdge(1000L, layer4, generatorId == 1);
  235.   v52 = generatorId_1 == 1;
  236.   v7 = layer4;
  237.   std::make_shared<BiomeEdgeLayer,int,std::shared_ptr<Layer> &,bool>(&v54, &v53, layer4, &v52);
  238.   std::shared_ptr<Layer>::operator=<BiomeEdgeLayer>(v7, &v54);
  239.   std::shared_ptr<BiomeEdgeLayer>::~shared_ptr(&v54);
  240.   std::shared_ptr<Layer>::shared_ptr(&layer5, &layer3);// GenLayer layer5 = layer3;
  241.   ZoomLayer::zoom(&v50, 1000LL, &layer5, 2LL);  // layer5 = GenLayerZoom.magnify(1000L, layer5, 2);
  242.   std::shared_ptr<Layer>::operator=(&layer5, &v50);
  243.   std::shared_ptr<Layer>::~shared_ptr(&v50);
  244.   v48 = 1000;                                   // layer4 = new GenLayerHills(1000L, layer4, layer5);
  245.   v8 = layer4;
  246.   std::make_shared<RegionHillsLayer,int,std::shared_ptr<Layer> &,std::shared_ptr<Layer> &>(&v49, &v48, layer4, &layer5);
  247.   std::shared_ptr<Layer>::operator=<RegionHillsLayer>(v8, &v49);
  248.   std::shared_ptr<RegionHillsLayer>::~shared_ptr(&v49);
  249.   // SECTION 6
  250.   ZoomLayer::zoom(&v47, 1000LL, &layer3, 2LL);  // layer3 = GenLayerZoom.magnify(1000L, layer3, 2);
  251.   std::shared_ptr<Layer>::operator=(&layer3, &v47);
  252.   std::shared_ptr<Layer>::~shared_ptr(&v47);
  253.   ZoomLayer::zoom(&v46, 1000LL, &layer3, biomeSize);// layer3 = GenLayerZoom.magnify(1000L, layer3, biomeSize);
  254.   std::shared_ptr<Layer>::operator=(&layer3, &v46);
  255.   std::shared_ptr<Layer>::~shared_ptr(&v46);
  256.   v44 = 1;                                      // layer3 = new GenLayerRiver(1L, layer3);
  257.   std::make_shared<RiverLayer,int,std::shared_ptr<Layer> &>(&v45, &v44, &layer3);
  258.   std::shared_ptr<Layer>::operator=<RiverLayer>(&layer3, &v45);
  259.   std::shared_ptr<RiverLayer>::~shared_ptr(&v45);
  260.   v42 = 1000;                                   // layer3 = new GenLayerSmooth(1000L, layer3);
  261.   std::make_shared<SmoothLayer,int,std::shared_ptr<Layer> &>(&v43, &v42, &layer3);
  262.   std::shared_ptr<Layer>::operator=<SmoothLayer>(&layer3, &v43);
  263.   std::shared_ptr<SmoothLayer>::~shared_ptr(&v43);
  264.   // SECTION 7
  265.   v40 = 1001;                                   // layer4 = new GenLayerRareBiome(1001L, layer4);
  266.   v9 = layer4;
  267.   std::make_shared<RareBiomeSpotLayer,int,std::shared_ptr<Layer> &>(&v41, &v40, layer4);
  268.   std::shared_ptr<Layer>::operator=<RareBiomeSpotLayer>(v9, &v41);
  269.   std::shared_ptr<RareBiomeSpotLayer>::~shared_ptr(&v41);
  270.   v38 = range<int,1>(biomeSize);                // for (int i = 0; i < biomeSize; i++)
  271.   v39 = &v38;
  272.   v37 = Range<int,1>::begin(&v38);
  273.   v36 = Range<int,1>::end(v39);
  274.   while ( Range<int,1>::iterator::operator!=(&v37, &v36) & 1 )
  275.   {                                             // {
  276.     v35 = Range<int,1>::iterator::operator*(&v37);// layer4 = new GenLayerZoom(1000L + i, layer4);
  277.     v33 = v35 + 1000;
  278.     v10 = layer4;
  279.     std::make_shared<ZoomLayer,int,std::shared_ptr<Layer> &>(&v34, &v33, layer4);
  280.     std::shared_ptr<Layer>::operator=<ZoomLayer>(v10, &v34);
  281.     std::shared_ptr<ZoomLayer>::~shared_ptr(&v34);
  282.     if ( !v35 )                                 // if (i != 0)
  283.     {                                           // {
  284.       v31 = 3;                                  // layer4 = new GenLayerAddIsland(3L, layer4);
  285.       v11 = layer4;
  286.       std::make_shared<AddIslandLayer,int,std::shared_ptr<Layer> &>(&v32, &v31, layer4);
  287.       std::shared_ptr<Layer>::operator=<AddIslandLayer>(v11, &v32);
  288.       std::shared_ptr<AddIslandLayer>::~shared_ptr(&v32);
  289.     }                                           // }
  290.     if ( v35 == 1 )                             // if (i == 1)
  291.     {                                           // {
  292.       v29 = 1000;                               // layer4 = new GenLayerShore(1000L, layer4);
  293.       v12 = layer4;
  294.       std::make_shared<ShoreLayer,int,std::shared_ptr<Layer> &>(&v30, &v29, layer4);
  295.       std::shared_ptr<Layer>::operator=<ShoreLayer>(v12, &v30);
  296.       std::shared_ptr<ShoreLayer>::~shared_ptr(&v30);
  297.     }                                           // }
  298.     Range<int,1>::iterator::operator++(&v37);
  299.   }                                             // }
  300.   v27 = 1000;                                   // layer4 = new GenLayerSmooth(1000L, layer4);
  301.   v13 = layer4;
  302.   std::make_shared<SmoothLayer,int,std::shared_ptr<Layer> &>(&v28, &v27, layer4);
  303.   std::shared_ptr<Layer>::operator=<SmoothLayer>(v13, &v28);
  304.   std::shared_ptr<SmoothLayer>::~shared_ptr(&v28);
  305.   v25 = 100;                                    // layer4 = new GenLayerRiverMix(100L, layer4, layer3);
  306.   v14 = layer4;
  307.   std::make_shared<RiverMixerLayer,int,std::shared_ptr<Layer> &,std::shared_ptr<Layer> &>(&v26, &v25, layer4, &layer3);
  308.   std::shared_ptr<Layer>::operator=<RiverMixerLayer>(v14, &v26);
  309.   std::shared_ptr<RiverMixerLayer>::~shared_ptr(&v26);
  310.   v23 = 100;                                    // layer4 = new GenLayerOceanMix(100L, layer4, layer2); // not in the Java
  311.   v15 = layer4;
  312.   std::make_shared<OceanMixerLayer,int,std::shared_ptr<Layer> &,std::shared_ptr<Layer> &>(&v24, &v23, layer4, &layer2);
  313.   std::shared_ptr<Layer>::operator=<OceanMixerLayer>(v15, &v24);
  314.   std::shared_ptr<OceanMixerLayer>::~shared_ptr(&v24);
  315.   // SECTION 8
  316.   std::shared_ptr<Layer>::shared_ptr(&v22, layer4);
  317.   v20 = 10;                                     // GenLayer layer7 = new GenLayerVoronoiZoom(10L, layer4);
  318.   v16 = layer7;
  319.   std::make_shared<VoronoiZoom,int,std::shared_ptr<Layer> &>(&v21, &v20, layer4);
  320.   std::shared_ptr<Layer>::operator=<VoronoiZoom>(v16, &v21);
  321.   std::shared_ptr<VoronoiZoom>::~shared_ptr(&v21);
  322.   // SECTION 9
  323.   v17 = std::__shared_ptr<Layer,(__gnu_cxx::_Lock_policy)2>::operator->(layer4);// return {layer4, layer7};
  324.   (*(void (__fastcall **)(__int64, __int64))(*(_QWORD *)v17 + 16LL))(v17, seed_1);
  325.   v18 = std::__shared_ptr<Layer,(__gnu_cxx::_Lock_policy)2>::operator->(layer7);
  326.   (*(void (__fastcall **)(__int64, __int64))(*(_QWORD *)v18 + 16LL))(v18, seed_1);
  327.   std::shared_ptr<Layer>::~shared_ptr(&v22);
  328.   std::shared_ptr<Layer>::~shared_ptr(&layer5);
  329.   std::shared_ptr<Layer>::~shared_ptr(&layer3);
  330.   std::shared_ptr<Layer>::~shared_ptr(&layer2);
  331.   return std::shared_ptr<Layer>::~shared_ptr(&layer1);
  332. }
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!