Häuserblöcke / Blockbebauung / Trabantenstädte / Satellitenstadt / Cluster

[makie]

Das hier ist die relevante Routine aus simworld.cc Zeile 877

                const sint32 citizens = (2500l * new_mean_citizen_count) /(simrand(20000)+100);

                sint32 diff = (original_start_year-game_start)/2;
                sint32 growth = 32;
                sint32 current_bev = 1;

                /* grow gradually while aging
                 * the difference to the current end year will be halved,
                 * while the growth step is doubled
                 */
                current_month = game_start;
                bool not_updated = false;
                bool new_town = true;
                while(  current_bev < citizens  ) {
                    growth = min( citizens-current_bev, growth*2 );
                    current_bev += growth;
                    stadt[i]->change_size( growth, new_town );
                    // Only "new" for the first change_size call
                    new_town = false;
                    if(  current_bev > citizens/2  &&  not_updated  ) {
                        ls.set_progress( ++old_progress );
                        not_updated = true;
                    }
                    current_month += diff;
                    diff >>= 1;
                }

Variable diff = Zeitraum = gewünschtes Spielbeginn Jahr - Pak Startjahr
der Wert versteht sich als Jahr * 12 + Monat
der Zeitraum wird halbiert
zum current_month addiert und wieder halbiert

Die Einwohnerzahl startet mit 1 growth mit = 32
es wird growth mit 2 multipliziert und zur Einwohnerzahl addiert
-------------------------------------------------------------------------------------------------------
das hier war mein Versuch mit gleichmäßiger Verteilung der Steigerung über die Jahre

                sint32 diff = (original_start_year-game_start)/(log2(citizens)-6);
                sint32 growth = 32;
                sint32 current_bev = 1;

                /* grow gradually while aging
                 * the difference to the current end year will be halved,
                 * while the growth step is doubled
                 */
                current_month = game_start;
                bool not_updated = false;
                bool new_town = true;
                while(  current_bev < citizens  ) {
                    growth = min( citizens-current_bev, growth*2 );
                    current_bev += growth;
                    stadt[i]->change_size( growth, new_town );
                    // Only "new" for the first change_size call
                    new_town = false;
                    if(  current_bev > citizens/2  &&  not_updated  ) {
                        ls.set_progress( ++old_progress );
                        not_updated = true;
                    }
                    current_month += diff;
//                    diff >>= 1;
                }

es werden die Anzahl Verdoppelungsschritte die notwendig sind  berechnet
und Gleichmäßig auf die Jahre verteilt.

Funktioniert nicht: weil letzter Verdoppelungsschritt das groß der Leute bringt und  nicht fein genug auf die letzten Jahre verteilt wird.

--------------------------------------------------------------------------
Versuch quadratisches Wachstum
Ziel war mehr Steigerungsschritte erreichen für eine feinere Verteilung auf die Jahre

    //            citizens = citizens/10+simrand(2*citizens+1);
                const sint32 citizens = (2500l * new_mean_citizen_count) /(simrand(20000)+100);

                sint32 step =1;
                sint32 diff = (original_start_year-game_start)/(sqrt(citizens/64));
                sint32 growth = 32;
                sint32 current_bev = 1;

                /* grow gradually while aging
                 * the difference to the current end year will be halved,
                 * while the growth step is doubled
                 */
                current_month = game_start;
                bool not_updated = false;
                bool new_town = true;
                while(  current_bev < citizens  ) {
                    growth = min( citizens-current_bev, (64*step*step)-current_bev);
                    current_bev += growth;
                    step++;
                    stadt[i]->change_size( growth, new_town );
                    // Only "new" for the first change_size call
                    new_town = false;
                    if(  current_bev > citizens/2  &&  not_updated  ) {
                        ls.set_progress( ++old_progress );
                        not_updated = true;
                    }
                    current_month += diff;
                }

Funktioniert nicht weil die letzten Jahre zwar mehr Schritte haben, aber zu wenig Leute
-------------------------------------------------------------------------------------------------------------
Derzeit tendiere ich dazu das doch einfach so zu lassen wie bisher
Wobei die Anzahl notwendiger Verdoppelungsschritte nur zufällig ähnlich sind wie die Anzahl Halbierungsschritte bei den Jahren
--------------------------------------------------------------------------------------------

was man testen könnte wäre ob er das selbe bei nur 100 jahren macht, also erste verdoppelung dann nach 50 jahren und dann grob jeweils halbiertem zeitabstand zu der jeweils nächsten verdoppelung

Die 190 Jahre werden berechnet und von da an halbiert
Die notwendigen Verdoppelungen der Einwohner werden immer erreicht weil auch innerhalb des letzten Jahres die Monate halbiert werden können.
und durch diff >>= 1 der Steigerungswert im Notfall auch auf glatt 0 laufen darf.