#############################################################################

# Configuration rules and options for SimCity

#
# This script both defines what the various game options
# do, and sets defaults for them based on the video
# card, sound card, CPU, and other factors.
#
# It also sets some properties determining what the
# hardware will support.
#

#############################################################################
# Constants
#

set Off 0
set On 1

set Min 0
set Low 1
set Medium 2
set High 3
set Ultra 4

set ModernFail -1
set ProbablyFail -2
set DefinitelyFail -3

# Shader paths -- must match with Material/config.mtl

seti shaderPathMin 0 # Not well supported
seti shaderPathLow 1
seti shaderPathRecommended 2
seti shaderPathMax 3

#############################################################################
# Set up
#

setVariables

setb isMac false

setb isWin7 false
setb isXP false
setb isVista false

if (match("${platform}", "OSX*"))
# Set mac-specific options here
output "Running on OSX"
setb isMac true
boolProp RenderTargetCorrection false

if( match("${graphicsCard}", "*HD Graphics 3000*") )

if( match("${OSVersion}", "10.7.*") )
alert "Your Intel HD 3000 video card driver version provided by Apple
for OS X Lion will cause graphical errors and corruption with SimCity. Please
upgrade to OS X Mountain Lion or a newer version of OS X to prevent these errors."
2005 -warning
elseif( match("${OSVersion}", "10.8.0") )
 alert "Please update your Mac OS X to version 10.8.3 or newer.
Graphical errors and corruption will occur without this update." 2006 -error
endif
endif
else

setb isWin7 (match("${OSVersion}", "6.1.*"))

if ($isWin7 and $os64Bit and (not $has64BitExceptionFix))

alert "To get proper crash handling it is recommended you install this
hotfix:\n http://support.microsoft.com/default.aspx/kb/976038\n\nIt is available
from:\n \\maxislocalbuild\Builds\Install\n\n" 2004 -warning
endif

setb isVista false

if (match("${OSName}", "*Windows Vista*"))
setb isVista true
endif

setb isXP false

if (match("${OSName}", "*Windows XP*"))
setb isXP true
endif

if ($isVista and $vistaKB940105Required)

alert "The game may run out of address space with some configurations\nand
video cards, resulting in stability problems.\n\nIt is recommended that you install
the latest Windows Vista Service Pack\nand check for updated video drivers.\n\nFor
details see the Microsoft Knowledge Base article\n\n
http://support.microsoft.com/default.aspx/kb/940105\n\n" 2003 -warning
endif

endif

#############################################################################
# Initial defaults.
#
# These may be overridden below according to CPU or card.

setOption OptionShadows $High

setOption OptionTextureDetail $Medium
setOption OptionEffects $High
setOption OptionLighting $High
setOption OptionGameQuality $High
setOption OptionPeopleQuality $High
setOption OptionSignQuality $High
setOption OptionCityImpostorQuality $High
setOption OptionAudioPerformance $Medium
setOption OptionGeometryDetail $High
setOption OptionAnimationDetail $High
setOption OptionFXAA $Off
setOption OptionPictureFilter $Off
setOption OptionNoWindowBorders $Off

setOption OptionPhotoRes $Medium

setOption OptionVideoRes $High
#############################################################################
# Identify graphics adapter
#

# set some config variables based on a card table and vendor specific rules
# sets isCardFound, cardVendor, and cardName
setb isCardFound false
set cardVendor Unknown
set cardName Unknown
include "VideoCards.txt"

# Fallback on the card name text supplied by the card itself.

# Assumes that at least the cardVendor has been matched, since
# vendor name is not contained in some vendor card names.
# Note that specific vendors are overridden to a default card.
# For AMD -> Radeon 9800 Pro
# For NVIDIA -> NVIDIA GeForceFX 5200 SE

if (not $isCardFound)
set cardName "${graphicsCard}"
endif

#############################################################################
#
# Testing Code
#

# For testing
setb doTestCPU 0
setb doTestGPU 0

if ($doTestCPU)
seti pentium4 0
seti cpuCount 1

seti cpuSpeed 2000

set cpuBrand "AMD Athlon64"
endif

if ($doTestGPU)
# test some 2.0/3.0 cards
#set cardVendor "AMD"
#set cardName "FirePro W5000"

set cardVendor "Intel"

set cardName "Intel HD Graphics 4000"

#set cardVendor "NVIDIA"

#set cardName "Quadro FX 5800"

#seti testShaderModel 3
#seti maxVertexProgramVersionHW ($testShaderModel*256)
#seti maxPixelProgramVersion ($testShaderModel*256)

# have to set this, since some overrides fallback on graphicsCard string

set graphicsCard "$cardName"
endif
#############################################################################
#
# Option Levels
#

seti cpuLevelHigh 3
seti cpuLevelMedium 2
seti cpuLevelLow 1

seti gpuLevelHigh 3
seti gpuLevelMedium 2
seti gpuLevelLow 1
seti gpuLevelMin 0

#############################################################################
#
# CPU Assessment
#

seti adjustedCPU $cpuSpeed

setb cpuAMD false

if (match("${cpuBrand}", "*AMD*"))
setb cpuAMD true
endif

seti cpuCutoffLow 2000

seti cpuCutoffMed 2400

if ($pentium4 > 0)
# intel p4 hyperthread or multiprocessor
if ($hyperthreading > 0)
# only count real cpus
seti cpuCount (floor(${cpuCount} / 2))
endif

if ($cpuCount > 1)
seti adjustedCPU (round($adjustedCPU * 1.3334))
endif

seti cpuCutoffLow 2400

seti cpuCutoffMed 2800

elseif ($cpuCount == 1)
if ($cpuAMD)
# amd single core (xp, 64)
seti cpuCutoffLow 1800
seti cpuCutoffMed 2000
else
# pentium m, celeron, etc
seti cpuCutoffLow 2000
seti cpuCutoffMed 2200
endif
else
if ($cpuAMD)
# amd multicore (athlon 64x2)
seti cpuCutoffLow 1600
seti cpuCutoffMed 1900
 else
# intel multicore (core duo, core2 duo)
seti cpuCutoffLow 1800
seti cpuCutoffMed 2100
endif
endif

# rate the cpu

if ($adjustedCPU < $cpuCutoffLow)
seti cpuLevel $cpuLevelLow
elseif ($adjustedCPU < $cpuCutoffMed)
seti cpuLevel $cpuLevelMedium
else
seti cpuLevel $cpuLevelHigh
endif

#############################################################################
#
# GPU Assessment
#

# track specific vendors

setb isNvidia false
#setb isNvidiaIntegrated false

setb isAMD false

#setb isAMDIntegrated false

setb isIntel false

setb isIntelIntegrated false

setb isS3 false

setb isVendorUnknown false

setb isLimitedVideoMemory false

# convert to major version

if (not $isMac)
seti vsVersion (floor($maxVertexProgramVersionHW / 256))
seti psVersion (floor($maxPixelProgramVersion / 256))
else
seti vsVersion (floor($maxVertexProgramVersionHW / 1))
seti psVersion (floor($maxPixelProgramVersion / 1))
endif

# if not in database, assume any new card is "high"

seti gpuLevel $gpuLevelHigh

if (match("${cardVendor}", "AMD") or match("${cardVendor}", "ATI"))

setb isAMD true
elseif (match("${cardVendor}", "NVIDIA"))
setb isNvidia true
elseif (match("${cardVendor}", "INTEL"))
setb isIntel true
elseif (match("${cardVendor}", "S3"))
setb isS3 true
else
setb isVendorUnknown true
endif

# old driver build detection/warning

setb oldDriver false # Triggers a warning the first time the game is
run
setb isOldDriverBuildExit false # Set this if we know the game won't function
with the current drivers

setb isMultiGpu false

if ($gpuCount > 1)
setb isMultiGpu true
endif

seti oldDriverBuild 0 # Spurious setting necessary because variables are still

expanded in skipped clauses =(

if (not match("${platform}", "OSX*"))

if (not $doTestGPU)
# test each vendor against specific known driver builds
if ($isNvidia)

seti oldDriverBuild 13069

if ($isMultiGpu)
seti oldDriverBuild 130697
#setb isOldDriverBuildExit true
endif

if ($driverBuild < $oldDriverBuild)

setb oldDriver true
endif

elseif ($isIntel)
seti oldDriverBuild 102875 # this numbering scheme is not continuous with
the old drivers for series 4 cards

if ($driverBuild < $oldDriverBuild)

setb oldDriver true
endif

elseif ($isAMD)
if (not $isXP)
seti oldDriverBuild 101140 # Cat 13.1 TODO: update

if ($isMultiGpu)
seti oldDriverBuild 101140 # Cat 13.1 TODO: update
endif
else
seti oldDriverBuild 101140 # Cat 13.1 TODO: update

if ($isMultiGpu)
seti oldDriverBuild 101140 # Cat 13.1 TODO: update
#setb isOldDriverBuildExit true
endif
endif

if ($driverBuild < $oldDriverBuild)

setb oldDriver true
endif
 endif

# this alert is only displayed the first time the game is launched, or when the
preferences are deleted
if ($oldDriver)
if ($isOldDriverBuildExit)
if ($isMultiGpu)
alert "An older video driver is detected.\n\nTo ensure correct
visuals and gameplay with multiple gpus,\ninstalling the latest video driver is
required,\nor multiple gpu mode must be disabled.\nThe game will not run.\nPlease
see the README for details.\n\n" 1012
else
alert "An older video driver is detected.\n\nTo ensure correct
visuals and gameplay,\ninstalling the latest video driver is required.\nThe game
will not run. Please see the README for details.\n\n" 1011
endif
else
alert "An older video driver is detected.\n\nTo ensure correct visuals
and gameplay,\ninstalling the latest video driver is recommended.\n\n" 1010 -info
endif
endif
endif
# OSX check
endif

if ($isNvidia)
# rules don't apply to Quadro numbering, if not renamed in db assume medium
if (not match("${cardName}", "*Quadro*"))
# default to medium
seti gpuLevel $gpuLevelMedium

# classify failure
if (match("${cardName}", "*5??0*"))
seti gpuLevel $ProbablyFail
elseif (match("${cardName}", "*6??0*"))
seti gpuLevel $ProbablyFail

#7xxx series
elseif (match("${cardName}", "*7??0*"))
if (match("${cardName}", "*79?0*"))
seti gpuLevel $gpuLevelMin
elseif (match("${cardName}", "*78?0*"))
seti gpuLevel $gpuLevelMin
else
seti gpuLevel $ProbablyFail
endif

#8xxx series
elseif (match("${cardName}", "*8??0*"))
if (match("${cardName}", "*81?0*"))
seti gpuLevel $ProbablyFail
elseif (match("${cardName}", "*82?0*"))
seti gpuLevel $ProbablyFail
elseif (match("${cardName}", "*83?0*"))
seti gpuLevel $ProbablyFail
elseif (match("${cardName}", "*84?0*"))
seti gpuLevel $ModernFail
elseif (match("${cardName}", "*85?0*"))
 seti gpuLevel $ModernFail
elseif (match("${cardName}", "*86?0*"))
seti gpuLevel $gpuLevelMin
elseif (match("${cardName}", "*88?0*"))
seti gpuLevel $gpuLevelLow
endif

#9xxx series
elseif (match("${cardName}", "*9??0*"))
if (match("${cardName}", "*91?0*"))
seti gpuLevel $ProbablyFail
elseif (match("${cardName}", "*92?0*"))
seti gpuLevel $ProbablyFail
elseif (match("${cardName}", "*93?0*"))
seti gpuLevel $ProbablyFail
elseif (match("${cardName}", "*94?0*"))
seti gpuLevel $ModernFail
elseif (match("${cardName}", "*95?0*"))
seti gpuLevel $ModernFail
elseif (match("${cardName}", "*96?0*"))
seti gpuLevel $gpuLevelMin
elseif (match("${cardName}", "*98?0*"))
seti gpuLevel $gpuLevelLow
endif

#1xx series - strange outlier, rebranded 9xxx cards

elseif (match("${cardName}", "*1?0*"))
if (match("${cardName}", "*100*"))
seti gpuLevel $ProbablyFail
elseif (match("${cardName}", "*120*"))
seti gpuLevel $ProbablyFail
elseif (match("${cardName}", "*130*"))
seti gpuLevel $ProbablyFail
elseif (match("${cardName}", "*140*"))
seti gpuLevel $gpuLevelLow
elseif (match("${cardName}", "*150*"))
seti gpuLevel $gpuLevelLow
endif

#2xx series
elseif (match("${cardName}", "*2?0*") or match("${cardName}", "*2?5*"))
if (match("${cardName}", "*205*"))
seti gpuLevel $ProbablyFail
elseif (match("${cardName}", "*210*"))
seti gpuLevel $ModernFail
elseif (match("${cardName}", "*220*"))
seti gpuLevel $ModernFail
elseif (match("${cardName}", "*230*"))
seti gpuLevel $ModernFail
elseif (match("${cardName}", "*240*"))
if (match("${cardName}", "*GTS*"))
seti gpuLevel $gpuLevelLow
else
seti gpuLevel $gpuLevelMin
endif
elseif (match("${cardName}", "*250*"))
seti gpuLevel $gpuLevelLow
elseif (match("${cardName}", "*260*"))
seti gpuLevel $gpuLevelMedium
 elseif (match("${cardName}", "*27?*"))
seti gpuLevel $gpuLevelMedium
elseif (match("${cardName}", "*28?*"))
seti gpuLevel $gpuLevelMedium
elseif (match("${cardName}", "*29?*"))
seti gpuLevel $gpuLevelHigh
endif

#3xx series - rebrand budget parts

elseif (match("${cardName}", "*3?0*") or match("${cardName}", "*3?5*"))
if (match("${cardName}", "*31?*"))
seti gpuLevel $ModernFail
elseif (match("${cardName}", "*32?*"))
seti gpuLevel $gpuLevelMin
elseif (match("${cardName}", "*33?*"))
seti gpuLevel $gpuLevelMin
elseif (match("${cardName}", "*34?*"))
seti gpuLevel $gpuLevelMin
endif

#4xx series!
elseif (match("${cardName}", "*4?0*") or match("${cardName}", "*4?5*"))
if (match("${cardName}", "*405*"))
seti gpuLevel $ModernFail
elseif (match("${cardName}", "*420*"))
seti gpuLevel $ModernFail
elseif (match("${cardName}", "*430*"))
seti gpuLevel $gpuLevelMin
elseif (match("${cardName}", "*440*"))
seti gpuLevel $gpuLevelLow
elseif (match("${cardName}", "*450*"))
seti gpuLevel $gpuLevelMedium
elseif (match("${cardName}", "*46?*"))
seti gpuLevel $gpuLevelMedium
elseif (match("${cardName}", "*470*"))
seti gpuLevel $gpuLevelMedium
elseif (match("${cardName}", "*480*"))
seti gpuLevel $gpuLevelHigh
endif

#5xx series!
elseif (match("${cardName}", "*5?0*") or match("${cardName}", "*5?5*"))
if (match("${cardName}", "*510*"))
seti gpuLevel $ModernFail
elseif (match("${cardName}", "*520*"))
seti gpuLevel $ModernFail
elseif (match("${cardName}", "*525*"))
seti gpuLevel $gpuLevelLow
elseif (match("${cardName}", "*530*"))
seti gpuLevel $gpuLevelMin
elseif (match("${cardName}", "*540*")) #this is actually only for the
540M
seti gpuLevel $gpuLevelLow
elseif (match("${cardName}", "*545*"))
seti gpuLevel $gpuLevelLow
elseif (match("${cardName}", "*55?*"))
seti gpuLevel $gpuLevelMedium
elseif (match("${cardName}", "*560*"))
 seti gpuLevel $gpuLevelMedium
elseif (match("${cardName}", "*570*"))
seti gpuLevel $gpuLevelMedium
elseif (match("${cardName}", "*580*"))
seti gpuLevel $gpuLevelHigh
elseif (match("${cardName}", "*590*"))
seti gpuLevel $gpuLevelHigh
endif

elseif (match("${cardName}", "*6?0*") or match("${cardName}", "*6?5*"))

if (match("${cardName}", "*605*"))
seti gpuLevel $ModernFail
elseif (match("${cardName}", "*610*"))
seti gpuLevel $ModernFail
elseif (match("${cardName}", "*620*"))
seti gpuLevel $ModernFail
elseif (match("${cardName}", "*630M*"))
seti gpuLevel $gpuLevelLow # will bump down to min
elseif (match("${cardName}", "*630*"))
seti gpuLevel $gpuLevelMin
elseif (match("${cardName}", "*64?*"))
seti gpuLevel $gpuLevelLow
elseif (match("${cardName}", "*650*"))
seti gpuLevel $gpuLevelMedium
elseif (match("${cardName}", "*660*"))
seti gpuLevel $gpuLevelHigh
elseif (match("${cardName}", "*670*"))
seti gpuLevel $gpuLevelHigh
elseif (match("${cardName}", "*675*"))
seti gpuLevel $gpuLevelHigh
elseif (match("${cardName}", "*680*"))
seti gpuLevel $gpuLevelHigh
elseif (match("${cardName}", "*690*"))
seti gpuLevel $gpuLevelHigh
endif
elseif (match("${cardName}", "* 7?0*"))
seti gpuLevel $gpuLevelHigh
endif

#if it's a mobile card, kick it down a notch

if ((match("${cardName}", "*Go*") or match("${cardName}", "*M*")) and
($gpuLevel >= $gpuLevelMin) )
seti gpuLevel ($gpuLevel-1)
endif
else
seti gpuLevel $ProbablyFail

if ( match("${cardName}", "*FX*") )
if (match("${cardName}", "*3500*"))
seti gpuLevel $gpuLevelLow
elseif (match("${cardName}", "*3700*"))
seti gpuLevel $gpuLevelLow
elseif (match("${cardName}", "*3800*"))
seti gpuLevel $gpuLevelLow
elseif (match("${cardName}", "*4600*"))
seti gpuLevel $gpuLevelLow
elseif (match("${cardName}", "*4800*"))
seti gpuLevel $gpuLevelLow
 elseif (match("${cardName}", "*5500*"))
seti gpuLevel $gpuLevelMin
elseif (match("${cardName}", "*5600*"))
seti gpuLevel $gpuLevelMedium
elseif (match("${cardName}", "*5800*"))
seti gpuLevel $gpuLevelHigh
else
seti gpuLevel $ProbablyFail
endif
else
if (match("${cardName}", "*2000*"))
seti gpuLevel $gpuLevelLow
elseif (match("${cardName}", "*4000*"))
seti gpuLevel $gpuLevelMedium
elseif (match("${cardName}", "*5000K*"))
seti gpuLevel $gpuLevelHigh
elseif (match("${cardName}", "*5000*"))
seti gpuLevel $gpuLevelMedium
elseif (match("${cardName}", "*6000*"))
seti gpuLevel $gpuLevelHigh
endif
endif

#if it's a mobile card, kick it down a notch

if ((match("${cardName}", "*Go*") or match("${cardName}", "*M*")) and
($gpuLevel >= $gpuLevelMin) )
seti gpuLevel ($gpuLevel-1)
endif
endif
endif

if ($isAMD)
# rules don't apply to FireGL/FireMV numbering, if not renamed in db assume
medium
if (not match("${cardName}", "*Fire*")) # FireGL/MV

if (match("${cardName}", "*Radeon R?*"))

seti gpuLevel $gpuLevelMedium # Default to medium if AMD comes out with
some new types of cards we're not aware of
if (match("${cardName}", "*R5*"))
seti gpuLevel $gpuLevelLow
elseif (match("${cardName}", "*R7*"))
seti gpuLevel $gpuLevelMedium
elseif (match("${cardName}", "*R9*"))
seti gpuLevel $gpuLevelHigh
endif
elseif (match("${cardName}", "*HD*"))
if (match("${cardName}", "*2??0*"))
if (match("${cardName}", "*23?0*"))
seti gpuLevel $ProbablyFail
elseif (match("${cardName}", "*24?0*"))
seti gpuLevel $ProbablyFail
elseif (match("${cardName}", "*26?0*"))
seti gpuLevel $gpuLevelMin
elseif (match("${cardName}", "*29?0*"))
seti gpuLevel $gpuLevelLow
else
seti gpuLevel $gpuLevelLow
endif
 elseif (match("${cardName}", "*3??0*"))
if (match("${cardName}", "*34?0*"))
seti gpuLevel $ProbablyFail
elseif (match("${cardName}", "*36?0*"))
seti gpuLevel $gpuLevelMin
elseif (match("${cardName}", "*3850*"))
seti gpuLevel $gpuLevelLow
elseif (match("${cardName}", "*38?0*"))
seti gpuLevel $gpuLevelMedium
else
seti gpuLevel $ProbablyFail
endif
elseif (match("${cardName}", "*4??0*"))
if (match("${cardName}", "*42?0*"))
seti gpuLevel $ProbablyFail
elseif (match("${cardName}", "*43?0*"))
seti gpuLevel $ProbablyFail
elseif (match("${cardName}", "*45?0*"))
seti gpuLevel $ModernFail
elseif (match("${cardName}", "*46?0*"))
seti gpuLevel $gpuLevelMin
elseif (match("${cardName}", "*4730*"))
seti gpuLevel $gpuLevelMin
elseif (match("${cardName}", "*47?0*"))
seti gpuLevel $gpuLevelLow
elseif (match("${cardName}", "*4870*") or match("${cardName}",
"*4890*"))
seti gpuLevel $gpuLevelMedium
elseif (match("${cardName}", "*48?0*"))
seti gpuLevel $gpuLevelMedium
else
seti gpuLevel $gpuLevelLow
endif

elseif (match("${cardName}", "*5??0*"))

if (match("${cardName}", "*54?0*"))
seti gpuLevel $ModernFail
elseif (match("${cardName}", "*55?0*"))
seti gpuLevel $gpuLevelMin
elseif (match("${cardName}", "*56?0*"))
seti gpuLevel $gpuLevelLow
elseif (match("${cardName}", "*57?0*"))
seti gpuLevel $gpuLevelMedium
elseif (match("${cardName}", "*58?0*"))
seti gpuLevel $gpuLevelMedium
elseif (match("${cardName}", "*59?0*"))
seti gpuLevel $gpuLevelHigh
else
seti gpuLevel $gpuLevelLow
endif

elseif (match("${cardName}", "*6??0*"))

if (match("${cardName}", "*62?0*") or match("${cardName}",
"*6310*") or match("${cardName}", "*6320*"))
#integrated parts
seti gpuLevel $ModernFail
elseif (match("${cardName}", "*6???D*"))
#integrated
seti gpuLevel $gpuLevelLow
 elseif (match("${cardName}", "*6???G*"))
#integrated mobile
seti gpuLevel $gpuLevelLow
elseif (match("${cardName}", "*63?0*"))
seti gpuLevel $ModernFail
elseif (match("${cardName}", "*64?0*"))
seti gpuLevel $ProbablyFail
elseif (match("${cardName}", "*65?0*"))
seti gpuLevel $gpuLevelLow
#GPU 6600 and 6700 strings are both in cardName string. If you
have a 6700 gpu
#you will have the settings of a 6600.
elseif (match("${cardName}", "*66?0*"))
seti gpuLevel $gpuLevelLow
elseif (match("${cardName}", "*67?0*"))
seti gpuLevel $gpuLevelLow
elseif (match("${cardName}", "*68?0*"))
seti gpuLevel $gpuLevelHigh
elseif (match("${cardName}", "*69?0*"))
seti gpuLevel $gpuLevelHigh
else
seti gpuLevel $gpuLevelMedium
endif

elseif (match("${cardName}", "*7??0*"))

if (match("${cardName}", "*7???D*"))
#integrated
seti gpuLevel $gpuLevelMin
elseif (match("${cardName}", "*73?0*"))
seti gpuLevel $ModernFail
elseif (match("${cardName}", "*74?0*"))
seti gpuLevel $gpuLevelMin
elseif (match("${cardName}", "*75?0*"))
seti gpuLevel $gpuLevelLow
elseif (match("${cardName}", "*76?0*"))
seti gpuLevel $gpuLevelMedium
elseif (match("${cardName}", "*77?0*"))
seti gpuLevel $gpuLevelMedium
elseif (match("${cardName}", "*78?0*"))
seti gpuLevel $gpuLevelHigh
elseif (match("${cardName}", "*79?0*"))
seti gpuLevel $gpuLevelHigh
else
seti gpuLevel $gpuLevelMedium
endif

elseif (match("${cardName}", "*8??0*"))

if (match("${cardName}", "*83?0*"))
seti gpuLevel $ModernFail
elseif (match("${cardName}", "*84?0*"))
seti gpuLevel $gpuLevelLow
elseif (match("${cardName}", "*85?0*"))
seti gpuLevel $gpuLevelLow
elseif (match("${cardName}", "*86?0*"))
seti gpuLevel $gpuLevelMedium
elseif (match("${cardName}", "*87?0*"))
seti gpuLevel $gpuLevelHigh
elseif (match("${cardName}", "*88?0*"))
seti gpuLevel $gpuLevelHigh
 elseif (match("${cardName}", "*99?0*"))
seti gpuLevel $gpuLevelHigh
else
seti gpuLevel $gpuLevelMedium
endif
endif

#if it's a mobile card, kick it down a notch

if ((match("${cardName}", "*Mobility*") or match("${cardName}", "*M*"))
and ($gpuLevel >= $gpuLevelMin))
seti gpuLevel ($gpuLevel-1)
endif
else
#non "HD" or "R5/7/9" are all pre-min
seti gpuLevel $ProbablyFail
endif
else
seti gpuLevel $ProbablyFail

if (match("${cardName}", "*V4800*"))
seti gpuLevel $gpuLevelLow
elseif (match("${cardName}", "*V4900*"))
seti gpuLevel $gpuLevelLow
elseif (match("${cardName}", "*V5700*"))
seti gpuLevel $gpuLevelMin
elseif (match("${cardName}", "*V5800*"))
seti gpuLevel $gpuLevelLow
elseif (match("${cardName}", "*V5900*"))
seti gpuLevel $gpuLevelLow
elseif (match("${cardName}", "*V7800*"))
seti gpuLevel $gpuLevelMedium
elseif (match("${cardName}", "*V7900*"))
seti gpuLevel $gpuLevelMedium
elseif (match("${cardName}", "*V87?0*"))
seti gpuLevel $gpuLevelLow
elseif (match("${cardName}", "*V8800*"))
seti gpuLevel $gpuLevelMedium
elseif (match("${cardName}", "*V9800*"))
seti gpuLevel $gpuLevelMedium
elseif (match("${cardName}", "*W600*"))
seti gpuLevel $gpuLevelLow
elseif (match("${cardName}", "*W5000*"))
seti gpuLevel $gpuLevelLow
elseif (match("${cardName}", "*S7000*"))
seti gpuLevel $gpuLevelMedium
elseif (match("${cardName}", "*W7000*"))
seti gpuLevel $gpuLevelMedium
elseif (match("${cardName}", "*W8000*"))
seti gpuLevel $gpuLevelHigh
elseif (match("${cardName}", "*S9000*"))
seti gpuLevel $gpuLevelHigh
elseif (match("${cardName}", "*W9000*"))
seti gpuLevel $gpuLevelHigh
elseif (match("${cardName}", "*S10000*"))
seti gpuLevel $gpuLevelHigh
elseif (match("${cardName}", "*RG5000*"))
seti gpuLevel $gpuLevelHigh
endif
 #if it's a mobile card, kick it down a notch
if ((match("${cardName}", "*Mobility*") or match("${cardName}", "*M*")) and
($gpuLevel >= $gpuLevelMin))
seti gpuLevel ($gpuLevel-1)
endif
endif
endif

if ($isIntel)
if (match("${cardName}", "*915*") or match("${cardName}", "*945*"))
seti gpuLevel $ProbablyFail
setb isIntelIntegrated true
boolProp IsIntelIntegratedGPU true
elseif (match("${cardName}", "*HD Graphics*") or match("${cardName}",
"*Iris*"))
seti gpuLevel $gpuLevelMin
setb isIntelIntegrated true
boolProp IsIntelIntegratedGPU true
if (match("${cardName}", "*5???*"))
seti gpuLevel $gpuLevelLow
endif
endif

setb isLimitedVideoMemory true

endif

if ($isS3)
seti gpuLevel $ProbablyFail
setb isLimitedVideoMemory true
endif

# drop gpu level if less than 256MB of video memory, below minspec
if (not $isMac)
if ($textureMemory < 250)
seti gpuLevel $ProbablyFail
endif
endif

############################################################################
# Handle bad video cards
#

if ($gpuLevel == $ModernFail)
alert "While your graphics card is newer than our minimum specified graphics
card, it might actually be pretty slow. We've set the game to low settings, but
you may still encounter less than optimal performance.~br~Please see the README for
details." 2004 -info
seti gpuLevel $gpuLevelMin
elseif ($gpuLevel == $ProbablyFail)
alert "Sorry, your graphics card is below our min spec.~br~The game will
attempt to run but may fail or perform poorly.~br~Please see the README for
details." 2002 -info
seti gpuLevel $gpuLevelMin
elseif ($gpuLevel == $DefinitelyFail)
alert "Sorry, your graphics card is below our min spec.~br~The game will not
run.~br~Please see the README for details." 2001
seti gpuLevel $gpuLevelMin
endif
############################################################################
# Set base shader path
#

seti shaderPathToSet $shaderPathMax

if (not $isMac)
if ($psVersion >= 3)
seti shaderPathToSet $shaderPathMax
else
alert "Sorry, your graphics card is below our min spec.~br~The game will not
run.~br~Please see the README for details.\n\n" 2001
endif
else
if ($psVersion >= 1)
seti shaderPathToSet $shaderPathMax
endif
endif

# NOTE: do not override this for special cases, unless the card will
# actually crash or has bugs. Instead setOption OptionLighting to
# reduce the path by default to what we recommend.
intProp shaderPath $shaderPathToSet

#############################################################################
# Instancing support

if ($instancing)
trace "=== Instancing can be enabled"
boolProp effectsInstancing true

# rendering artifacts using instancing on hw tnl based intel cards

# dropping to swvp does not help
if ($isIntel)
boolProp effectsInstancing true
endif
endif

# Report classification

trace "==="
trace "=== GPU level ${gpuLevel}"
trace "=== Card ${cardName}, Vendor ${cardVendor}, Driver ${driverBuild}, $
{instancing}"
trace "==="
trace "=== CPU level ${cpuLevel}"
trace "=== CPU ${cpuCount}, Speed ${adjustedCPU}, HT ${hyperthreading}, P4 $
{pentium4}"
trace "=== GPU Texture Memory ${textureMemory}"

#############################################################################
# Set options based on cpu / gpu
#

setOption OptionEffects $cpuLevel

setOption OptionAudioPerformance $cpuLevel
setOption OptionGameQuality $cpuLevel

setOption OptionPeopleQuality $gpuLevel

setOption OptionSignQuality $gpuLevel

if ($gpuLevel <= 1)
setOption OptionGeometryDetail 1
else
setOption OptionGeometryDetail $gpuLevel
endif

if ($gpuLevel <= 1)
setOption OptionTextureDetail 1
else
setOption OptionTextureDetail $gpuLevel
endif

if ($gpuLevel <= 1)
setOption OptionAnimationDetail 1
else
setOption OptionAnimationDetail $gpuLevel
endif

#############################################################################
# MRT
#

boolProp MRT 0
if ( $numSimultaneousRTs > 1 )
boolProp MRT 1
endif

############################################################################
# Resolution
#
seti resolutionTarget (1024 * 768) # 4x3

if ($isMac )
if ($gpuLevel > $gpuLevelHigh)
seti resolutionTarget (3840 * 2400) # 16x10
elseif ($gpuLevel > $gpuLevelMedium)
seti resolutionTarget (1920 * 1200) # 16x10
elseif ($gpuLevel >= $gpuLevelLow)
seti resolutionTarget (1280 * 800) # 16x10
endif

else
if ($gpuLevel >= $gpuLevelHigh)
seti resolutionTarget (3840 * 2160) # 16x9
elseif ($gpuLevel >= $gpuLevelMedium)
seti resolutionTarget (1920 * 1080) # 16x9
elseif ($gpuLevel >= $gpuLevelLow)
seti resolutionTarget (1280 * 720) # 16x9
endif
endif

setResolution $resolutionTarget

############################################################################
# Shadow settings
#
#seti shadowOption $cpuLevel
#if ($gpuLevel < $cpuLevel)
#seti shadowOption $gpuLevel
#endif

seti shadowOption $gpuLevel

trace "=== Shadow setting ${shadowOption}"

setOption OptionShadows $shadowOption

############################################################################
# Event Query
#

# Note: Vista and now Windows 7 exhibits hangs when using D3DQUERYTYPE_EVENT.
# Clearly this is not something they'll fix, so now we only enable on XP.

#trace "OS = ${OSName}"

if (not $isXP)
trace "=== Win7/Vista/Mac: avoiding GPU flush"
intProp NumFramesToBuffer 3 # avoid GPU lock to reduce buffering -- leave it
to the driver
endif

############################################################################
# Lighting level controls shaders that run. Can be set higher.

setOption OptionLighting $gpuLevel

if ($gpuLevel > $gpuLevelMedium)

setOption OptionFXAA $On
endif

if ($cpuLevel == $cpuLevelLow)
# this sets the minspec shader path
setOption OptionLighting $Min
endif

############################################################################
# Drop CPU Settings By GPU
#

if ($gpuLevel == $gpuLevelMedium)
# prevent high cpu level from pushing too many batches to medium gpu
# this helps medium gpu classification apply to more cards
if ($cpuLevel == $cpuLevelHigh)
setOption OptionEffects $Medium
setOption OptionGameQuality $Medium
endif

elseif ($gpuLevel == $gpuLevelLow)

setOption OptionEffects $Low
setOption OptionGameQuality $Low

# swvp needs more cpu processing

 if ($isIntelIntegrated)
setOption OptionAudioPerformance $Low
endif
endif

#######################################
# Misc
#
#Mac fails to parse the below freeVirtualMemory conditional, so we are turning this
off for Mac 04/11/2013
if (not $isMac)
if ($freeVirtualMemory <= 2500)
intProp modelMeshLODOffsetOverride 1 -list @SimCityNonSim_ecoUnit!
TemplateBuilding
intProp rasterMipOffset 1

#bump this up for 'low' otherwise they get knocked down two levels
if ($gpuLevel >= $gpuLevelLow)
setOption OptionTextureDetail $Medium
endif
else
intProp modelMeshLODOffsetOverride 0 -list @SimCityNonSim_ecoUnit!
TemplateBuilding
intProp rasterMipOffset 0
endif
endif

#######################################
# Specific OSX settings
if ($isMac)
if ($isNvidia)
if (match("${cardName}", "*650*"))
setOption OptionLighting $Medium
setOption OptionTextureDetail $Medium
endif
endif
endif

#######################################
# Safe mode
#

# Set options to safe values. In safe mode, all options will

# be reset to their defaults, but the prefs won't be saved.

# Basically setting anything that might trigger bad hardware behaviour to low.
if ($safeMode)
trace "=== SAFE MODE"

alert "Running in safe mode" 8888 -info

setOption OptionLighting $Low

setOption OptionShadows $Low
setOption OptionEffects $Low
setOption OptionTextureDetail $Medium
setOption OptionAudioPerformance $Low
setOption OptionPhotoRes $Low
setOption OptionVideoRes $Low
endif
# These are all of the alert dialogs localized if text is present (from
AppConfig.txt)
#set showConfigAlerts 1
if (varExists(showConfigAlerts) and ($showConfigAlerts))
trace "=== Test Alerts"

alert "not localized" 1000 -info -always # 3e8

alert "not localized" 1001 -info -always # 3e9
alert "not localized" 1002 -info -always # 3ea
alert "not localized" 1004 -info -always # 3ec
alert "not localized" 1005 -info -always # 3ed

alert "not localized" 1010 -info -always # 3f2

alert "not localized" 1011 -info -always # 3f3
alert "not localized" 1012 -info -always # 3f4

alert "not localized" 2000 -info -always # 7d0

alert "not localized" 2001 -info -always # 7d1
alert "not localized" 2002 -info -always # 7d2
alert "not localized" 2003 -info -always # 7d3

alert "not localized" 2004 -info -always # 7d4

alert "not localized" 2005 -info -always # 7d5
alert "not localized" 2006 -info -always # 7d6
alert "not localized" 2007 -info -always # 7d7

endif