//Quantity is adjusted directly as a side effect of this function MonsterGroupResult MonsterGroupManager::GetResultFromGroup( const mongroup_id &group_name, int *quantity ) { auto &group = GetUpgradedMonsterGroup( group_name ); int spawn_chance = rng( 1, group.freq_total ); //Default 1000 unless specified //Our spawn details specify, by default, a single instance of the default monster MonsterGroupResult spawn_details = MonsterGroupResult( group.defaultMonster, 1 ); bool monster_found = false; // Loop invariant values const time_point sunset = calendar::turn.sunset(); const time_point sunrise = calendar::turn.sunrise(); const season_type season = season_of_year( calendar::turn ); // Step through spawn definitions from the monster group until one is found or for( auto it = group.monsters.begin(); it != group.monsters.end() && !monster_found; ++it ) { // There's a lot of conditions to work through to see if this spawn definition is valid bool valid_entry = true; //Insure that the time is not before the spawn first appears or after it stops appearing valid_entry = valid_entry && ( calendar::time_of_cataclysm + it->starts < calendar::turn ); valid_entry = valid_entry && ( it->lasts_forever() || calendar::time_of_cataclysm + it->ends > calendar::turn ); std::vector<std::pair<time_point, time_point> > valid_times_of_day; bool season_limited = false; bool season_matched = false; //Collect the various spawn conditions, and then insure they are met appropriately for( auto &elem : it->conditions ) { //Collect valid time of day ranges if( elem == "DAY" || elem == "NIGHT" || elem == "DUSK" || elem == "DAWN" ) { if( elem == "DAY" ) { valid_times_of_day.push_back( std::make_pair( sunrise, sunset ) ); } else if( elem == "NIGHT" ) { valid_times_of_day.push_back( std::make_pair( sunset, sunrise ) ); } else if( elem == "DUSK" ) { valid_times_of_day.push_back( std::make_pair( sunset - 1_hours, sunset + 1_hours ) ); } else if( elem == "DAWN" ) { valid_times_of_day.push_back( std::make_pair( sunrise - 1_hours, sunrise + 1_hours ) ); } } //If we have any seasons listed, we know to limit by season, and if any season matches this season, we are good to spawn if( elem == "SUMMER" || elem == "WINTER" || elem == "SPRING" || elem == "AUTUMN" ) { season_limited = true; if( ( season == SUMMER && elem == "SUMMER" ) || ( season == WINTER && elem == "WINTER" ) || ( season == SPRING && elem == "SPRING" ) || ( season == AUTUMN && elem == "AUTUMN" ) ) { season_matched = true; } } } //Make sure the current time of day is within one of the valid time ranges for this spawn bool is_valid_time_of_day = false; if( valid_times_of_day.empty() ) { //Then it can spawn whenever, since no times were defined is_valid_time_of_day = true; } else { //Otherwise, it's valid if it matches any of the times of day for( auto &elem : valid_times_of_day ) { if( calendar::turn > elem.first && calendar::turn < elem.second ) { is_valid_time_of_day = true; } } } if( !is_valid_time_of_day ) { valid_entry = false; } //If we are limited by season, make sure we matched a season if( season_limited && !season_matched ) { valid_entry = false; } //If the entry was valid, check to see if we actually spawn it if( valid_entry ) { //If the monsters frequency is greater than the spawn_chance, select this spawn rule if( it->frequency >= spawn_chance ) { if( it->pack_maximum > 1 ) { spawn_details = MonsterGroupResult( it->name, rng( it->pack_minimum, it->pack_maximum ) ); } else { spawn_details = MonsterGroupResult( it->name, 1 ); } //And if a quantity pointer with remaining value was passed, will modify the external value as a side effect //We will reduce it by the spawn rule's cost multiplier if( quantity ) { *quantity -= std::max( 1, it->cost_multiplier * spawn_details.pack_size ); } monster_found = true; //Otherwise, subtract the frequency from spawn result for the next loop around } else { spawn_chance -= it->frequency; } } } // Force quantity to decrement regardless of whether we found a monster. if( quantity && !monster_found ) { ( *quantity )--; } return spawn_details; }
//Quantity is adjusted directly as a side effect of this function MonsterGroupResult MonsterGroupManager::GetResultFromGroup( std::string group_name, int *quantity, int turn ) { int spawn_chance = rng(1, 1000); MonsterGroup group = monsterGroupMap[group_name]; //Our spawn details specify, by default, a single instance of the default monster MonsterGroupResult spawn_details = MonsterGroupResult(group.defaultMonster,1); //If the default monster is too difficult, replace this with "mon_null" if(turn!=-1 && (turn + 900 < MINUTES(STARTING_MINUTES) + HOURS(GetMType(group.defaultMonster)->difficulty))){ spawn_details = MonsterGroupResult("mon_null",0); } bool monster_found = false; // Step through spawn definitions from the monster group until one is found or for (FreqDef_iter it = group.monsters.begin(); it != group.monsters.end() && !monster_found; ++it){ // There's a lot of conditions to work through to see if this spawn definition is valid bool valid_entry = true; // I don't know what turn == -1 is checking for, but it makes monsters always valid for difficulty purposes valid_entry = valid_entry && (turn == -1 || (turn+900) >= (MINUTES(STARTING_MINUTES) + HOURS(GetMType(it->name)->difficulty))); // If we are in classic mode, require the monster type to be either CLASSIC or WILDLIFE if(ACTIVE_WORLD_OPTIONS["CLASSIC_ZOMBIES"]){ valid_entry = valid_entry && (GetMType(it->name)->in_category("CLASSIC") || GetMType(it->name)->in_category("WILDLIFE")); } //Insure that the time is not before the spawn first appears or after it stops appearing valid_entry = valid_entry && (HOURS(it->starts) < g->turn.get_turn()); valid_entry = valid_entry && (it->lasts_forever() || HOURS(it->ends) > g->turn.get_turn()); std::vector<std::pair<int,int> > valid_times_of_day; bool season_limited = false; bool season_matched = false; //Collect the various spawn conditions, and then insure they are met appropriately for(std::vector<std::string>::iterator condition = it->conditions.begin(); condition != it->conditions.end(); ++condition){ //Collect valid time of day ranges if( (*condition) == "DAY" || (*condition) == "NIGHT" || (*condition) == "DUSK" || (*condition) == "DAWN" ){ int sunset = g->turn.sunset().get_turn(); int sunrise = g->turn.sunrise().get_turn(); if((*condition) == "DAY"){ valid_times_of_day.push_back( std::make_pair(sunrise,sunset) ); } else if((*condition) == "NIGHT"){ valid_times_of_day.push_back( std::make_pair(sunset,sunrise) ); } else if((*condition) == "DUSK"){ valid_times_of_day.push_back( std::make_pair(sunset-HOURS(1),sunset+HOURS(1)) ); } else if((*condition) == "DAWN"){ valid_times_of_day.push_back( std::make_pair(sunrise-HOURS(1),sunrise+HOURS(1)) ); } } //If we have any seasons listed, we know to limit by season, and if any season matches this season, we are good to spawn if( (*condition) == "SUMMER" || (*condition) == "WINTER" || (*condition) == "SPRING" || (*condition) == "AUTUMN" ){ season_limited = true; if( (g->turn.get_season() == SUMMER && (*condition) == "SUMMER") || (g->turn.get_season() == WINTER && (*condition) == "WINTER") || (g->turn.get_season() == SPRING && (*condition) == "SPRING") || (g->turn.get_season() == AUTUMN && (*condition) == "AUTUMN") ){ season_matched = true; } } } //Make sure the current time of day is within one of the valid time ranges for this spawn bool is_valid_time_of_day = false; if(valid_times_of_day.size() < 1){ //Then it can spawn whenever, since no times were defined is_valid_time_of_day = true; } else { //Otherwise, it's valid if it matches any of the times of day for(std::vector<std::pair<int,int> >::iterator time_pair = valid_times_of_day.begin(); time_pair != valid_times_of_day.end(); ++time_pair){ int time_now = g->turn.get_turn(); if(time_now > time_pair->first && time_now < time_pair->second){ is_valid_time_of_day = true; } } } if(!is_valid_time_of_day){ valid_entry = false; } //If we are limited by season, make sure we matched a season if(season_limited && !season_matched){ valid_entry = false; } //If the entry was valid, check to see if we actually spawn it if(valid_entry){ //If the monsters frequency is greater than the spawn_chance, select this spawn rule if(it->frequency >= spawn_chance){ if(it->pack_maximum > 1){ spawn_details = MonsterGroupResult(it->name, rng(it->pack_minimum,it->pack_maximum)); } else { spawn_details = MonsterGroupResult(it->name, 1); } //And if a quantity pointer with remaining value was passed, will will modify the external value as a side effect //We will reduce it by the spawn rule's cost multiplier if(quantity){ *quantity -= it->cost_multiplier * spawn_details.pack_size; } monster_found = true; //Otherwise, subtract the frequency from spawn result for the next loop around }else{ spawn_chance -= it->frequency; } } } return spawn_details; }