mirror of https://github.com/OpenRCT2/OpenRCT2.git
634 lines
17 KiB
C
634 lines
17 KiB
C
/*****************************************************************************
|
|
* Copyright (c) 2014 Ted John
|
|
* OpenRCT2, an open source clone of Roller Coaster Tycoon 2.
|
|
*
|
|
* This file is part of OpenRCT2.
|
|
*
|
|
* OpenRCT2 is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*****************************************************************************/
|
|
|
|
#include "../addresses.h"
|
|
#include "../interface/window.h"
|
|
#include "../localisation/localisation.h"
|
|
#include "../peep/peep.h"
|
|
#include "../ride/ride.h"
|
|
#include "../scenario.h"
|
|
#include "../world/sprite.h"
|
|
#include "award.h"
|
|
#include "news_item.h"
|
|
|
|
#define NEGATIVE 0
|
|
#define POSITIVE 1
|
|
|
|
static const uint8 AwardPositiveMap[] = {
|
|
NEGATIVE, // PARK_AWARD_MOST_UNTIDY
|
|
POSITIVE, // PARK_AWARD_MOST_TIDY
|
|
POSITIVE, // PARK_AWARD_BEST_ROLLERCOASTERS
|
|
POSITIVE, // PARK_AWARD_BEST_VALUE
|
|
POSITIVE, // PARK_AWARD_MOST_BEAUTIFUL
|
|
NEGATIVE, // PARK_AWARD_WORST_VALUE
|
|
POSITIVE, // PARK_AWARD_SAFEST
|
|
POSITIVE, // PARK_AWARD_BEST_STAFF
|
|
POSITIVE, // PARK_AWARD_BEST_FOOD
|
|
NEGATIVE, // PARK_AWARD_WORST_FOOD
|
|
POSITIVE, // PARK_AWARD_BEST_RESTROOMS
|
|
NEGATIVE, // PARK_AWARD_MOST_DISAPPOINTING
|
|
POSITIVE, // PARK_AWARD_BEST_WATER_RIDES
|
|
POSITIVE, // PARK_AWARD_BEST_CUSTOM_DESIGNED_RIDES
|
|
POSITIVE, // PARK_AWARD_MOST_DAZZLING_RIDE_COLOURS
|
|
NEGATIVE, // PARK_AWARD_MOST_CONFUSING_LAYOUT
|
|
POSITIVE, // PARK_AWARD_BEST_GENTLE_RIDES
|
|
};
|
|
|
|
rct_award *gCurrentAwards = (rct_award*)RCT2_ADDRESS_AWARD_LIST;
|
|
|
|
bool award_is_positive(int type)
|
|
{
|
|
return AwardPositiveMap[type];
|
|
}
|
|
|
|
#pragma region Award checks
|
|
|
|
/** More than 1/16 of the total guests must be thinking untidy thoughts. */
|
|
static int award_is_deserved_most_untidy(int awardType, int activeAwardTypes)
|
|
{
|
|
uint16 spriteIndex;
|
|
rct_peep *peep;
|
|
int negativeCount;
|
|
|
|
if (activeAwardTypes & (1 << PARK_AWARD_MOST_BEAUTIFUL))
|
|
return 0;
|
|
if (activeAwardTypes & (1 << PARK_AWARD_BEST_STAFF))
|
|
return 0;
|
|
if (activeAwardTypes & (1 << PARK_AWARD_MOST_TIDY))
|
|
return 0;
|
|
|
|
negativeCount = 0;
|
|
FOR_ALL_GUESTS(spriteIndex, peep) {
|
|
if (peep->outside_of_park != 0)
|
|
continue;
|
|
|
|
if (peep->thoughts[0].var_2 > 5)
|
|
continue;
|
|
|
|
if (peep->thoughts[0].type == PEEP_THOUGHT_TYPE_BAD_LITTER ||
|
|
peep->thoughts[0].type == PEEP_THOUGHT_TYPE_PATH_DISGUSTING ||
|
|
peep->thoughts[0].type == PEEP_THOUGHT_TYPE_VANDALISM
|
|
) {
|
|
negativeCount++;
|
|
}
|
|
}
|
|
|
|
return (negativeCount > RCT2_GLOBAL(RCT2_ADDRESS_GUESTS_IN_PARK, uint16) / 16);
|
|
}
|
|
|
|
/** More than 1/64 of the total guests must be thinking tidy thoughts and less than 6 guests thinking untidy thoughts. */
|
|
static int award_is_deserved_most_tidy(int awardType, int activeAwardTypes)
|
|
{
|
|
uint16 spriteIndex;
|
|
rct_peep *peep;
|
|
int positiveCount;
|
|
int negativeCount;
|
|
|
|
if (activeAwardTypes & (1 << PARK_AWARD_MOST_UNTIDY))
|
|
return 0;
|
|
if (activeAwardTypes & (1 << PARK_AWARD_MOST_DISAPPOINTING))
|
|
return 0;
|
|
|
|
positiveCount = 0;
|
|
negativeCount = 0;
|
|
FOR_ALL_GUESTS(spriteIndex, peep) {
|
|
if (peep->outside_of_park != 0)
|
|
continue;
|
|
|
|
if (peep->thoughts[0].var_2 > 5)
|
|
continue;
|
|
|
|
if (peep->thoughts[0].type == PEEP_THOUGHT_VERY_CLEAN)
|
|
positiveCount++;
|
|
|
|
if (peep->thoughts[0].type == PEEP_THOUGHT_TYPE_BAD_LITTER ||
|
|
peep->thoughts[0].type == PEEP_THOUGHT_TYPE_PATH_DISGUSTING ||
|
|
peep->thoughts[0].type == PEEP_THOUGHT_TYPE_VANDALISM
|
|
) {
|
|
negativeCount++;
|
|
}
|
|
}
|
|
|
|
return (negativeCount <= 5 && positiveCount > RCT2_GLOBAL(RCT2_ADDRESS_GUESTS_IN_PARK, uint16) / 64);
|
|
}
|
|
|
|
/** At least 6 open roller coasters. */
|
|
static int award_is_deserved_best_rollercoasters(int awardType, int activeAwardTypes)
|
|
{
|
|
int i, rollerCoasters;
|
|
rct_ride *ride;
|
|
rct_ride_type *rideType;
|
|
|
|
rollerCoasters = 0;
|
|
FOR_ALL_RIDES(i, ride) {
|
|
rideType = gRideTypeList[ride->subtype];
|
|
if (rideType->category[0] != RIDE_GROUP_ROLLERCOASTER && rideType->category[1] != RIDE_GROUP_ROLLERCOASTER)
|
|
continue;
|
|
|
|
if (ride->status != RIDE_STATUS_OPEN || (ride->lifecycle_flags & RIDE_LIFECYCLE_CRASHED))
|
|
continue;
|
|
|
|
rollerCoasters++;
|
|
}
|
|
|
|
return (rollerCoasters >= 6);
|
|
}
|
|
|
|
/** Entrance fee is 0.10 less than half of the total ride value. */
|
|
static int award_is_deserved_best_value(int awardType, int activeAwardTypes)
|
|
{
|
|
if (activeAwardTypes & (1 << PARK_AWARD_WORST_VALUE))
|
|
return 0;
|
|
if (activeAwardTypes & (1 << PARK_AWARD_MOST_DISAPPOINTING))
|
|
return 0;
|
|
if (RCT2_GLOBAL(RCT2_ADDRESS_PARK_FLAGS, uint32) & (PARK_FLAGS_NO_MONEY | PARK_FLAGS_PARK_FREE_ENTRY))
|
|
return 0;
|
|
if (RCT2_GLOBAL(RCT2_TOTAL_RIDE_VALUE, money16) < MONEY(10, 00))
|
|
return 0;
|
|
if (RCT2_GLOBAL(RCT2_ADDRESS_PARK_ENTRANCE_FEE, money16) + MONEY(0, 10) >= RCT2_GLOBAL(RCT2_TOTAL_RIDE_VALUE, money16) / 2)
|
|
return 0;
|
|
return 1;
|
|
}
|
|
|
|
/** More than 1/128 of the total guests must be thinking scenic thoughts and less than 16 untidy thoughts. */
|
|
static int award_is_deserved_most_beautiful(int awardType, int activeAwardTypes)
|
|
{
|
|
uint16 spriteIndex;
|
|
rct_peep *peep;
|
|
int positiveCount;
|
|
int negativeCount;
|
|
|
|
if (activeAwardTypes & (1 << PARK_AWARD_MOST_UNTIDY))
|
|
return 0;
|
|
if (activeAwardTypes & (1 << PARK_AWARD_MOST_DISAPPOINTING))
|
|
return 0;
|
|
|
|
positiveCount = 0;
|
|
negativeCount = 0;
|
|
FOR_ALL_GUESTS(spriteIndex, peep) {
|
|
if (peep->outside_of_park != 0)
|
|
continue;
|
|
|
|
if (peep->thoughts[0].var_2 > 5)
|
|
continue;
|
|
|
|
if (peep->thoughts[0].type == PEEP_THOUGHT_TYPE_SCENERY)
|
|
positiveCount++;
|
|
|
|
if (peep->thoughts[0].type == PEEP_THOUGHT_TYPE_BAD_LITTER ||
|
|
peep->thoughts[0].type == PEEP_THOUGHT_TYPE_PATH_DISGUSTING ||
|
|
peep->thoughts[0].type == PEEP_THOUGHT_TYPE_VANDALISM
|
|
) {
|
|
negativeCount++;
|
|
}
|
|
}
|
|
|
|
return (negativeCount <= 15 && positiveCount > RCT2_GLOBAL(RCT2_ADDRESS_GUESTS_IN_PARK, uint16) / 128);
|
|
}
|
|
|
|
/** Entrance fee is more than total ride value. */
|
|
static int award_is_deserved_worse_value(int awardType, int activeAwardTypes)
|
|
{
|
|
if (activeAwardTypes & (1 << PARK_AWARD_BEST_VALUE))
|
|
return 0;
|
|
if (RCT2_GLOBAL(RCT2_ADDRESS_PARK_FLAGS, uint32) & PARK_FLAGS_NO_MONEY)
|
|
return 0;
|
|
if (RCT2_GLOBAL(RCT2_ADDRESS_PARK_ENTRANCE_FEE, money16) == MONEY(0, 00))
|
|
return 0;
|
|
if (RCT2_GLOBAL(RCT2_TOTAL_RIDE_VALUE, money16) >= RCT2_GLOBAL(RCT2_ADDRESS_PARK_ENTRANCE_FEE, money16))
|
|
return 0;
|
|
return 1;
|
|
}
|
|
|
|
/** No more than 2 people who think the vandalism is bad and no crashes. */
|
|
static int award_is_deserved_safest(int awardType, int activeAwardTypes)
|
|
{
|
|
int i, peepsWhoDislikeVandalism;
|
|
uint16 spriteIndex;
|
|
rct_peep *peep;
|
|
rct_ride *ride;
|
|
|
|
peepsWhoDislikeVandalism = 0;
|
|
FOR_ALL_GUESTS(spriteIndex, peep) {
|
|
if (peep->outside_of_park != 0)
|
|
continue;
|
|
if (peep->thoughts[0].var_2 <= 5 && peep->thoughts[0].type == PEEP_THOUGHT_TYPE_VANDALISM)
|
|
peepsWhoDislikeVandalism++;
|
|
}
|
|
|
|
if (peepsWhoDislikeVandalism > 2)
|
|
return 0;
|
|
|
|
// Check for rides that have crashed maybe?
|
|
FOR_ALL_RIDES(i, ride)
|
|
if (ride->last_crash_type != RIDE_CRASH_TYPE_NONE)
|
|
return 0;
|
|
|
|
return 1;
|
|
}
|
|
|
|
/** All staff types, at least 20 staff, one staff per 32 peeps. */
|
|
static int award_is_deserved_best_staff(int awardType, int activeAwardTypes)
|
|
{
|
|
uint16 spriteIndex;
|
|
rct_peep *peep;
|
|
int peepCount, staffCount;
|
|
int staffTypeFlags;
|
|
|
|
if (activeAwardTypes & (1 << PARK_AWARD_MOST_UNTIDY))
|
|
return 0;
|
|
|
|
peepCount = 0;
|
|
staffCount = 0;
|
|
staffTypeFlags = 0;
|
|
FOR_ALL_PEEPS(spriteIndex, peep) {
|
|
if (peep->type == PEEP_TYPE_STAFF) {
|
|
staffCount++;
|
|
staffTypeFlags |= (1 << peep->staff_type);
|
|
} else {
|
|
peepCount++;
|
|
}
|
|
}
|
|
|
|
return ((staffTypeFlags & 0xF) && staffCount >= 20 && staffCount >= peepCount / 32);
|
|
|
|
}
|
|
|
|
/** At least 7 shops, 4 unique, one shop per 128 guests and no more than 12 hungry guests. */
|
|
static int award_is_deserved_best_food(int awardType, int activeAwardTypes)
|
|
{
|
|
int i, hungryPeeps, shops, uniqueShops;
|
|
uint64 shopTypes;
|
|
rct_ride *ride;
|
|
rct_ride_type *rideType;
|
|
uint16 spriteIndex;
|
|
rct_peep *peep;
|
|
|
|
if (activeAwardTypes & (1 << PARK_AWARD_WORST_FOOD))
|
|
return 0;
|
|
|
|
shops = 0;
|
|
uniqueShops = 0;
|
|
shopTypes = 0;
|
|
FOR_ALL_RIDES(i, ride) {
|
|
if (ride->status != RIDE_STATUS_OPEN)
|
|
continue;
|
|
if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_SELLS_FOOD))
|
|
continue;
|
|
|
|
shops++;
|
|
rideType = gRideTypeList[ride->subtype];
|
|
if (!(shopTypes & (1ULL << rideType->shop_item))) {
|
|
shopTypes |= (1ULL << rideType->shop_item);
|
|
uniqueShops++;
|
|
}
|
|
}
|
|
|
|
if (shops < 7 || uniqueShops < 4 || shops < RCT2_GLOBAL(RCT2_ADDRESS_GUESTS_IN_PARK, uint16) / 128)
|
|
return 0;
|
|
|
|
// Count hungry peeps
|
|
hungryPeeps = 0;
|
|
FOR_ALL_GUESTS(spriteIndex, peep) {
|
|
if (peep->outside_of_park != 0)
|
|
continue;
|
|
|
|
if (peep->thoughts[0].var_2 <= 5 && peep->thoughts[0].type == PEEP_THOUGHT_TYPE_HUNGRY)
|
|
hungryPeeps++;
|
|
}
|
|
|
|
return (hungryPeeps <= 12);
|
|
}
|
|
|
|
/** No more than 2 unique shops, less than one shop per 256 guests and more than 15 hungry guests. */
|
|
static int award_is_deserved_worst_food(int awardType, int activeAwardTypes)
|
|
{
|
|
int i, hungryPeeps, shops, uniqueShops;
|
|
uint64 shopTypes;
|
|
rct_ride *ride;
|
|
rct_ride_type *rideType;
|
|
uint16 spriteIndex;
|
|
rct_peep *peep;
|
|
|
|
if (activeAwardTypes & (1 << PARK_AWARD_BEST_FOOD))
|
|
return 0;
|
|
|
|
shops = 0;
|
|
uniqueShops = 0;
|
|
shopTypes = 0;
|
|
FOR_ALL_RIDES(i, ride) {
|
|
if (ride->status != RIDE_STATUS_OPEN)
|
|
continue;
|
|
if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_SELLS_FOOD))
|
|
continue;
|
|
|
|
shops++;
|
|
rideType = gRideTypeList[ride->subtype];
|
|
if (!(shopTypes & (1ULL << rideType->shop_item))) {
|
|
shopTypes |= (1ULL << rideType->shop_item);
|
|
uniqueShops++;
|
|
}
|
|
}
|
|
|
|
if (uniqueShops > 2 || shops > RCT2_GLOBAL(RCT2_ADDRESS_GUESTS_IN_PARK, uint16) / 256)
|
|
return 0;
|
|
|
|
// Count hungry peeps
|
|
hungryPeeps = 0;
|
|
FOR_ALL_GUESTS(spriteIndex, peep) {
|
|
if (peep->outside_of_park != 0)
|
|
continue;
|
|
|
|
if (peep->thoughts[0].var_2 <= 5 && peep->thoughts[0].type == PEEP_THOUGHT_TYPE_HUNGRY)
|
|
hungryPeeps++;
|
|
}
|
|
|
|
return (hungryPeeps > 15);
|
|
}
|
|
|
|
/** At least 4 restrooms, 1 restroom per 128 guests and no more than 16 guests who think they need the restroom. */
|
|
static int award_is_deserved_best_restrooms(int awardType, int activeAwardTypes)
|
|
{
|
|
unsigned int i, numRestrooms, guestsWhoNeedRestroom;
|
|
rct_ride *ride;
|
|
uint16 spriteIndex;
|
|
rct_peep *peep;
|
|
|
|
// Count open restrooms
|
|
numRestrooms = 0;
|
|
FOR_ALL_RIDES(i, ride)
|
|
if (ride->type == RIDE_TYPE_TOILETS && ride->status == RIDE_STATUS_OPEN)
|
|
numRestrooms++;
|
|
|
|
// At least 4 open restrooms
|
|
if (numRestrooms < 4)
|
|
return 0;
|
|
|
|
// At least one open restroom for every 128 guests
|
|
if (numRestrooms < RCT2_GLOBAL(RCT2_ADDRESS_GUESTS_IN_PARK, uint16) / 128U)
|
|
return 0;
|
|
|
|
// Count number of guests who are thinking they need the restroom
|
|
guestsWhoNeedRestroom = 0;
|
|
FOR_ALL_GUESTS(spriteIndex, peep) {
|
|
if (peep->outside_of_park != 0)
|
|
continue;
|
|
|
|
if (peep->thoughts[0].var_2 <= 5 && peep->thoughts[0].type == PEEP_THOUGHT_TYPE_BATHROOM)
|
|
guestsWhoNeedRestroom++;
|
|
}
|
|
|
|
return (guestsWhoNeedRestroom <= 16);
|
|
}
|
|
|
|
/** More than half of the rides have satisfication <= 6 and park rating <= 650. */
|
|
static int award_is_deserved_most_disappointing(int awardType, int activeAwardTypes)
|
|
{
|
|
unsigned int i, countedRides, disappointingRides;
|
|
rct_ride *ride;
|
|
|
|
if (activeAwardTypes & (1 << PARK_AWARD_BEST_VALUE))
|
|
return 0;
|
|
if (RCT2_GLOBAL(RCT2_ADDRESS_CURRENT_PARK_RATING, uint16) > 650)
|
|
return 0;
|
|
|
|
// Count the number of disappointing rides
|
|
countedRides = 0;
|
|
disappointingRides = 0;
|
|
|
|
FOR_ALL_RIDES(i, ride) {
|
|
if (ride->excitement == (ride_rating)0xFFFF || ride->popularity == 0xFF)
|
|
continue;
|
|
|
|
countedRides++;
|
|
|
|
// Unpopular
|
|
if (ride->popularity <= 6)
|
|
disappointingRides++;
|
|
}
|
|
|
|
// Half of the rides are disappointing
|
|
return (disappointingRides >= countedRides / 2);
|
|
}
|
|
|
|
/** At least 6 open water rides. */
|
|
static int award_is_deserved_best_water_rides(int awardType, int activeAwardTypes)
|
|
{
|
|
int i, waterRides;
|
|
rct_ride *ride;
|
|
rct_ride_type *rideType;
|
|
|
|
waterRides = 0;
|
|
FOR_ALL_RIDES(i, ride) {
|
|
rideType = gRideTypeList[ride->subtype];
|
|
if (rideType->category[0] != RIDE_GROUP_WATER && rideType->category[1] != RIDE_GROUP_WATER)
|
|
continue;
|
|
|
|
if (ride->status != RIDE_STATUS_OPEN || (ride->lifecycle_flags & RIDE_LIFECYCLE_CRASHED))
|
|
continue;
|
|
|
|
waterRides++;
|
|
}
|
|
|
|
return (waterRides >= 6);
|
|
}
|
|
|
|
/** At least 6 custom designed rides. */
|
|
static int award_is_deserved_best_custom_designed_rides(int awardType, int activeAwardTypes)
|
|
{
|
|
int i, customDesignedRides;
|
|
rct_ride *ride;
|
|
|
|
if (activeAwardTypes & (1 << PARK_AWARD_MOST_DISAPPOINTING))
|
|
return 0;
|
|
|
|
customDesignedRides = 0;
|
|
FOR_ALL_RIDES(i, ride) {
|
|
if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_HAS_TRACK))
|
|
continue;
|
|
if (ride->lifecycle_flags & RIDE_LIFECYCLE_NOT_CUSTOM_DESIGN)
|
|
continue;
|
|
if (ride->excitement < RIDE_RATING(5, 50))
|
|
continue;
|
|
if (ride->status != RIDE_STATUS_OPEN || (ride->lifecycle_flags & RIDE_LIFECYCLE_CRASHED))
|
|
continue;
|
|
|
|
customDesignedRides++;
|
|
}
|
|
|
|
return (customDesignedRides >= 6);
|
|
}
|
|
|
|
/** At least 5 colourful rides and more than half of the rides are colourful. */
|
|
const uint8 dazzling_ride_colours[] = { 5, 14, 20, 30 };
|
|
static int award_is_deserved_most_dazzling_ride_colours(int awardType, int activeAwardTypes)
|
|
{
|
|
int i, j, countedRides, colourfulRides;
|
|
rct_ride *ride;
|
|
uint8 mainTrackColour;
|
|
|
|
if (activeAwardTypes & (1 << PARK_AWARD_MOST_DISAPPOINTING))
|
|
return 0;
|
|
|
|
countedRides = 0;
|
|
colourfulRides = 0;
|
|
FOR_ALL_RIDES(i, ride) {
|
|
if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_HAS_TRACK))
|
|
continue;
|
|
|
|
countedRides++;
|
|
|
|
mainTrackColour = ride->track_colour_main[0];
|
|
for (j = 0; j < countof(dazzling_ride_colours); j++) {
|
|
if (mainTrackColour == dazzling_ride_colours[j]) {
|
|
colourfulRides++;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (colourfulRides >= 5 && colourfulRides >= countedRides - colourfulRides);
|
|
}
|
|
|
|
/** At least 10 peeps and more than 1/64 of total guests are lost or can't find something. */
|
|
static int award_is_deserved_most_confusing_layout(int awardType, int activeAwardTypes)
|
|
{
|
|
unsigned int peepsCounted, peepsLost;
|
|
uint16 spriteIndex;
|
|
rct_peep *peep;
|
|
|
|
peepsCounted = 0;
|
|
peepsLost = 0;
|
|
FOR_ALL_GUESTS(spriteIndex, peep) {
|
|
if (peep->outside_of_park != 0)
|
|
continue;
|
|
|
|
peepsCounted++;
|
|
if (peep->thoughts[0].var_2 <= 5 && (peep->thoughts[0].type == PEEP_THOUGHT_TYPE_LOST || peep->thoughts[0].type == PEEP_THOUGHT_TYPE_CANT_FIND))
|
|
peepsLost++;
|
|
}
|
|
|
|
return (peepsLost >= 10 && peepsLost >= peepsCounted / 64);
|
|
}
|
|
|
|
/** At least 10 open gentle rides. */
|
|
static int award_is_deserved_best_gentle_rides(int awardType, int activeAwardTypes)
|
|
{
|
|
int i, gentleRides;
|
|
rct_ride *ride;
|
|
rct_ride_type *rideType;
|
|
|
|
gentleRides = 0;
|
|
FOR_ALL_RIDES(i, ride) {
|
|
rideType = gRideTypeList[ride->subtype];
|
|
if (rideType->category[0] != RIDE_GROUP_GENTLE && rideType->category[1] != RIDE_GROUP_GENTLE)
|
|
continue;
|
|
|
|
if (ride->status != RIDE_STATUS_OPEN || (ride->lifecycle_flags & RIDE_LIFECYCLE_CRASHED))
|
|
continue;
|
|
|
|
gentleRides++;
|
|
}
|
|
|
|
return (gentleRides >= 10);
|
|
}
|
|
|
|
typedef int (*award_deserved_check)(int, int);
|
|
|
|
award_deserved_check _awardChecks[] = {
|
|
award_is_deserved_most_untidy,
|
|
award_is_deserved_most_tidy,
|
|
award_is_deserved_best_rollercoasters,
|
|
award_is_deserved_best_value,
|
|
award_is_deserved_most_beautiful,
|
|
award_is_deserved_worse_value,
|
|
award_is_deserved_safest,
|
|
award_is_deserved_best_staff,
|
|
award_is_deserved_best_food,
|
|
award_is_deserved_worst_food,
|
|
award_is_deserved_best_restrooms,
|
|
award_is_deserved_most_disappointing,
|
|
award_is_deserved_best_water_rides,
|
|
award_is_deserved_best_custom_designed_rides,
|
|
award_is_deserved_most_dazzling_ride_colours,
|
|
award_is_deserved_most_confusing_layout,
|
|
award_is_deserved_best_gentle_rides
|
|
};
|
|
|
|
static int award_is_deserved(int awardType, int activeAwardTypes)
|
|
{
|
|
return _awardChecks[awardType](awardType, activeAwardTypes);
|
|
}
|
|
|
|
#pragma endregion
|
|
|
|
void award_reset()
|
|
{
|
|
int i;
|
|
for (i = 0; i < MAX_AWARDS; i++)
|
|
gCurrentAwards[i].time = 0;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* rct2: 0x0066A86C
|
|
*/
|
|
void award_update_all()
|
|
{
|
|
int i, activeAwardTypes, freeAwardEntryIndex;
|
|
|
|
// Only add new awards if park is open
|
|
if (RCT2_GLOBAL(RCT2_ADDRESS_PARK_FLAGS, uint32) & PARK_FLAGS_PARK_OPEN) {
|
|
// Set active award types as flags
|
|
activeAwardTypes = 0;
|
|
freeAwardEntryIndex = -1;
|
|
for (i = 0; i < MAX_AWARDS; i++) {
|
|
if (gCurrentAwards[i].time != 0)
|
|
activeAwardTypes |= (1 << gCurrentAwards[i].type);
|
|
else if (freeAwardEntryIndex == -1)
|
|
freeAwardEntryIndex = i;
|
|
}
|
|
|
|
// Check if there was a free award entry
|
|
if (freeAwardEntryIndex != -1) {
|
|
// Get a random award type not already active
|
|
int awardType;
|
|
do {
|
|
awardType = (((scenario_rand() & 0xFF) * 17) >> 8) & 0xFF;
|
|
} while (activeAwardTypes & (1 << awardType));
|
|
|
|
// Check if award is deserved
|
|
if (award_is_deserved(awardType, activeAwardTypes)) {
|
|
// Add award
|
|
gCurrentAwards[freeAwardEntryIndex].type = awardType;
|
|
gCurrentAwards[freeAwardEntryIndex].time = 5;
|
|
news_item_add_to_queue(NEWS_ITEM_AWARD, STR_NEWS_ITEM_AWARD_MOST_UNTIDY + awardType, 0);
|
|
window_invalidate_by_class(WC_PARK_INFORMATION);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Decrease award times
|
|
for (i = 0; i < MAX_AWARDS; i++)
|
|
if (gCurrentAwards[i].time != 0)
|
|
if (--gCurrentAwards[i].time == 0)
|
|
window_invalidate_by_class(WC_PARK_INFORMATION);
|
|
}
|