/*!
* \brief Read IP and boot configuration from non-volatile memory.
*/
int BootConfigRead(void)
{
int rc;
#ifdef EE_CONFNET
rc = -1;
NvMemInit();
DEBUG("CONFNET ");
if (ConfigGet(EE_CONFNET) == sizeof(CONFNET)) {
DEBUG("OK\n");
rc = NvMemRead(EE_CONFNET, &confnet, sizeof(CONFNET));
#ifdef EE_CONFBOOT
DEBUG("CONFBOOT ");
if (rc == 0 && ConfigGet(EE_CONFBOOT) == sizeof(CONFBOOT)) {
DEBUG(" OK\n");
rc = NvMemRead(EE_CONFBOOT, &confboot, sizeof(CONFBOOT));
} else {
DEBUG("No\n");
}
#endif
} else {
DEBUG("No\n");
}
#else
rc = 0;
#endif
return rc;
}
bool ConfigTrySetFromString(Config *c, const char *name, const char *value)
{
Config *child = ConfigGet(c, name);
switch (child->Type)
{
case CONFIG_TYPE_STRING:
CASSERT(false, "unimplemented");
return false;
case CONFIG_TYPE_INT:
ConfigSetInt(c, name, atoi(value));
return true;
case CONFIG_TYPE_FLOAT:
ConfigSetFloat(c, name, atof(value));
return true;
case CONFIG_TYPE_BOOL:
child->u.Bool.Value = strcmp(value, "true") == 0;
return false;
case CONFIG_TYPE_ENUM:
CASSERT(false, "unimplemented");
return false;
case CONFIG_TYPE_GROUP:
CASSERT(false, "Cannot set group config");
return false;
default:
CASSERT(false, "Unknown config type");
return false;
}
}
static void ConfigRead(unsigned int loc, void *buf, size_t n)
{
unsigned char *cp = buf;
while (n--) {
*cp++ = ConfigGet(loc);
loc++;
}
}
void BootConfigRead(void)
{
#ifdef EE_CONFNET
DEBUG("CONFNET ");
if (ConfigGet(EE_CONFNET) == sizeof(CONFNET)) {
DEBUG("OK\n");
ConfigRead(EE_CONFNET, &confnet, sizeof(CONFNET));
#ifdef EE_CONFBOOT
DEBUG("CONFBOOT ");
if (ConfigGet(EE_CONFBOOT) == sizeof(CONFBOOT)) {
DEBUG(" OK\n");
ConfigRead(EE_CONFBOOT, &confboot, sizeof(CONFBOOT));
}
else {
DEBUG("No\n");
}
#endif
}
else {
DEBUG("No\n");
}
#endif
}
void KeyInit(keyboard_t *keyboard)
{
memset(keyboard, 0, sizeof *keyboard);
keyboard->modState = KMOD_NONE;
keyboard->ticks = 0;
keyboard->repeatedTicks = 0;
keyboard->isFirstRepeat = 1;
for (int i = 0; i < MAX_KEYBOARD_CONFIGS; i++)
{
char buf[256];
sprintf(buf, "Input.PlayerKeys%d", i);
keyboard->PlayerKeys[i] = KeyLoadPlayerKeys(ConfigGet(&gConfig, buf));
}
}
char *
Ns_ConfigGetValue(char *section, char *key)
{
return ConfigGet(section, key, 0);
}
char *
Ns_ConfigGetValueExact(char *section, char *key)
{
return ConfigGet(section, key, 1);
}
bool GameOptions(const GameMode gm)
{
// Create selection menus
const int w = gGraphicsDevice.cachedConfig.Res.x;
const int h = gGraphicsDevice.cachedConfig.Res.y;
MenuSystem ms;
MenuSystemInit(
&ms, &gEventHandlers, &gGraphicsDevice,
Vec2iZero(), Vec2iNew(w, h));
ms.align = MENU_ALIGN_CENTER;
ms.allowAborts = true;
AllowedWeaponsData awData;
AllowedWeaponsDataInit(&awData, &gMission.Weapons);
switch (gm)
{
case GAME_MODE_DEATHMATCH:
ms.root = ms.current = MenuCreateNormal(
"",
"",
MENU_TYPE_OPTIONS,
0);
MenuAddConfigOptionsItem(
ms.current, ConfigGet(&gConfig, "Game.PlayerHP"));
MenuAddConfigOptionsItem(
ms.current, ConfigGet(&gConfig, "Deathmatch.Lives"));
MenuAddConfigOptionsItem(
ms.current, ConfigGet(&gConfig, "Game.HealthPickups"));
MenuAddConfigOptionsItem(
ms.current, ConfigGet(&gConfig, "Game.Ammo"));
MenuAddSubmenu(ms.current,
MenuCreateAllowedWeapons("Weapons...", &awData));
MenuAddSubmenu(ms.current, MenuCreateSeparator(""));
MenuAddSubmenu(ms.current, MenuCreateReturn("Done", 0));
break;
case GAME_MODE_DOGFIGHT:
ms.root = ms.current = MenuCreateNormal(
"",
"",
MENU_TYPE_OPTIONS,
0);
MenuAddConfigOptionsItem(
ms.current, ConfigGet(&gConfig, "Dogfight.PlayerHP"));
MenuAddConfigOptionsItem(
ms.current, ConfigGet(&gConfig, "Dogfight.FirstTo"));
MenuAddSubmenu(ms.current,
MenuCreateAllowedWeapons("Weapons...", &awData));
MenuAddSubmenu(ms.current, MenuCreateSeparator(""));
MenuAddSubmenu(ms.current, MenuCreateReturn("Done", 0));
break;
default:
CASSERT(false, "unknown game mode");
break;
}
MenuAddExitType(&ms, MENU_TYPE_RETURN);
MenuLoop(&ms);
const bool ok = !ms.hasAbort;
if (ok)
{
ConfigApply(&gConfig);
// Save options for later
ConfigSave(&gConfig, GetConfigFilePath(CONFIG_FILE));
// Set allowed weapons
// First check if the player has unwittingly disabled all weapons
// if so, enable all weapons
bool allDisabled = true;
for (int i = 0, j = 0; i < (int)awData.allowed.size; i++, j++)
{
const bool *allowed = CArrayGet(&awData.allowed, i);
if (*allowed)
{
allDisabled = false;
break;
}
}
if (!allDisabled)
{
for (int i = 0, j = 0; i < (int)awData.allowed.size; i++, j++)
{
const bool *allowed = CArrayGet(&awData.allowed, i);
if (!*allowed)
{
CArrayDelete(&gMission.Weapons, j);
j--;
}
}
}
}
AllowedWeaponsDataTerminate(&awData);
MenuSystemTerminate(&ms);
return ok;
}
static void Gfx_ModeSet(const Vec2i *mode)
{
ConfigGet(&gConfig, "Graphics.ResolutionWidth")->u.Int.Value = mode->x;
ConfigGet(&gConfig, "Graphics.ResolutionHeight")->u.Int.Value = mode->y;
}
int main(int argc, char *argv[])
{
int wait = 0;
int controllerFlag = SDL_INIT_GAMECONTROLLER;
credits_displayer_t creditsDisplayer;
memset(&creditsDisplayer, 0, sizeof creditsDisplayer);
custom_campaigns_t campaigns;
memset(&campaigns, 0, sizeof campaigns);
int forceResolution = 0;
int err = 0;
const char *loadCampaign = NULL;
ENetAddress connectAddr;
memset(&connectAddr, 0, sizeof connectAddr);
srand((unsigned int)time(NULL));
LogInit();
PrintTitle();
if (getenv("DEBUG") != NULL)
{
debug = true;
char *dbg;
if ((dbg = getenv("DEBUG_LEVEL")) != NULL)
{
debug_level = CLAMP(atoi(dbg), D_NORMAL, D_MAX);
}
}
SetupConfigDir();
gConfig = ConfigLoad(GetConfigFilePath(CONFIG_FILE));
LoadCredits(&creditsDisplayer, colorPurple, colorDarker);
AutosaveInit(&gAutosave);
AutosaveLoad(&gAutosave, GetConfigFilePath(AUTOSAVE_FILE));
if (enet_initialize() != 0)
{
LOG(LM_MAIN, LL_ERROR, "An error occurred while initializing ENet.");
err = EXIT_FAILURE;
goto bail;
}
NetClientInit(&gNetClient);
// Print command line
char buf[CDOGS_PATH_MAX];
buf[0] = '\0';
for (int i = 0; i < argc; i++)
{
strcat(buf, " ");
// HACK: for OS X, blank out the -psn_XXXX argument so that it doesn't
// break arg parsing
#ifdef __APPLE__
if (strncmp(argv[i], "-psn", strlen("-psn")) == 0)
{
argv[i] = "";
}
#endif
strcat(buf, argv[i]);
}
LOG(LM_MAIN, LL_INFO, "Command line (%d args):%s", argc, buf);
{
struct option longopts[] =
{
{"fullscreen", no_argument, NULL, 'f'},
{"scale", required_argument, NULL, 's'},
{"screen", required_argument, NULL, 'c'},
{"forcemode", no_argument, NULL, 'o'},
{"nosound", no_argument, NULL, 'n'},
{"nojoystick", no_argument, NULL, 'j'},
{"wait", no_argument, NULL, 'w'},
{"shakemult", required_argument, NULL, 'm'},
{"connect", required_argument, NULL, 'x'},
{"debug", required_argument, NULL, 'd'},
{"log", required_argument, NULL, 1000},
{"help", no_argument, NULL, 'h'},
{0, 0, NULL, 0}
};
int opt = 0;
int idx = 0;
while ((opt = getopt_long(argc, argv, "fs:c:onjwm:xd\0h", longopts, &idx)) != -1)
{
switch (opt)
{
case 'f':
ConfigGet(&gConfig, "Graphics.Fullscreen")->u.Bool.Value = true;
break;
case 's':
ConfigSetInt(&gConfig, "Graphics.ScaleFactor", atoi(optarg));
break;
case 'c':
sscanf(optarg, "%dx%d",
&ConfigGet(&gConfig, "Graphics.ResolutionWidth")->u.Int.Value,
&ConfigGet(&gConfig, "Graphics.ResolutionHeight")->u.Int.Value);
LOG(LM_MAIN, LL_DEBUG, "Video mode %dx%d set...",
ConfigGetInt(&gConfig, "Graphics.ResolutionWidth"),
ConfigGetInt(&gConfig, "Graphics.ResolutionHeight"));
break;
case 'o':
forceResolution = 1;
break;
case 'n':
LOG(LM_MAIN, LL_INFO, "Sound to 0 volume");
ConfigGet(&gConfig, "Sound.SoundVolume")->u.Int.Value = 0;
ConfigGet(&gConfig, "Sound.MusicVolume")->u.Int.Value = 0;
break;
case 'j':
debug(D_NORMAL, "nojoystick\n");
controllerFlag = 0;
break;
case 'w':
wait = 1;
break;
case 'm':
{
ConfigGet(&gConfig, "Graphics.ShakeMultiplier")->u.Int.Value =
MAX(atoi(optarg), 0);
printf("Shake multiplier: %d\n",
ConfigGetInt(&gConfig, "Graphics.ShakeMultiplier"));
}
break;
case 'h':
PrintHelp();
goto bail;
case 'd':
// Set debug level
debug = true;
debug_level = CLAMP(atoi(optarg), D_NORMAL, D_MAX);
break;
case 1000:
{
char *comma = strchr(optarg, ',');
if (comma)
{
// Set logging level for a single module
// The module and level are comma separated
*comma = '\0';
const LogLevel ll = StrLogLevel(comma + 1);
LogModuleSetLevel(StrLogModule(optarg), ll);
printf("Logging %s at %s\n", optarg, LogLevelName(ll));
}
else
{
// Set logging level for all modules
const LogLevel ll = StrLogLevel(optarg);
for (int i = 0; i < (int)LM_COUNT; i++)
{
LogModuleSetLevel((LogModule)i, ll);
}
printf("Logging everything at %s\n", LogLevelName(ll));
}
}
break;
case 'x':
if (enet_address_set_host(&connectAddr, optarg) != 0)
{
printf("Error: unknown host %s\n", optarg);
}
break;
default:
PrintHelp();
// Ignore unknown arguments
break;
}
}
if (optind < argc)
{
// non-option ARGV-elements
for (; optind < argc; optind++)
{
// Load campaign
loadCampaign = argv[optind];
}
}
}
debug(D_NORMAL, "Initialising SDL...\n");
const int sdlFlags =
SDL_INIT_TIMER | SDL_INIT_AUDIO | SDL_INIT_VIDEO | SDL_INIT_HAPTIC;
if (SDL_Init(sdlFlags | controllerFlag) != 0)
{
LOG(LM_MAIN, LL_ERROR, "Could not initialise SDL: %s", SDL_GetError());
err = EXIT_FAILURE;
goto bail;
}
if (SDLJBN_Init() != 0)
{
LOG(LM_MAIN, LL_ERROR, "Could not initialise SDLJBN: %s",
SDLJBN_GetError());
err = EXIT_FAILURE;
goto bail;
}
SDL_EventState(SDL_DROPFILE, SDL_DISABLE);
GetDataFilePath(buf, "");
LOG(LM_MAIN, LL_INFO, "data dir(%s)", buf);
LOG(LM_MAIN, LL_INFO, "config dir(%s)", GetConfigFilePath(""));
SoundInitialize(&gSoundDevice, "sounds");
if (!gSoundDevice.isInitialised)
{
LOG(LM_MAIN, LL_ERROR, "Sound initialization failed!");
}
LoadHighScores();
debug(D_NORMAL, "Loading song lists...\n");
LoadSongs();
MusicPlayMenu(&gSoundDevice);
EventInit(&gEventHandlers, NULL, NULL, true);
NetServerInit(&gNetServer);
if (wait)
{
printf("Press the enter key to continue...\n");
getchar();
}
if (!PicManagerTryInit(
&gPicManager, "graphics/cdogs.px", "graphics/cdogs2.px"))
{
LOG(LM_MAIN, LL_ERROR, "Failed to initialize graphics");
err = EXIT_FAILURE;
goto bail;
}
memcpy(origPalette, gPicManager.palette, sizeof(origPalette));
GraphicsInit(&gGraphicsDevice, &gConfig);
GraphicsInitialize(&gGraphicsDevice, forceResolution);
if (!gGraphicsDevice.IsInitialized)
{
LOG(LM_MAIN, LL_WARN, "Cannot initialise video; trying default config");
ConfigResetDefault(ConfigGet(&gConfig, "Graphics"));
GraphicsInit(&gGraphicsDevice, &gConfig);
GraphicsInitialize(&gGraphicsDevice, forceResolution);
}
if (!gGraphicsDevice.IsInitialized)
{
LOG(LM_MAIN, LL_ERROR, "Video didn't init!");
err = EXIT_FAILURE;
goto bail;
}
FontLoadFromJSON(&gFont, "graphics/font.png", "graphics/font.json");
PicManagerLoadDir(&gPicManager, "graphics");
ParticleClassesInit(&gParticleClasses, "data/particles.json");
AmmoInitialize(&gAmmo, "data/ammo.json");
BulletAndWeaponInitialize(
&gBulletClasses, &gGunDescriptions,
"data/bullets.json", "data/guns.json");
CharacterClassesInitialize(&gCharacterClasses, "data/character_classes.json");
LoadPlayerTemplates(
&gPlayerTemplates, &gCharacterClasses, PLAYER_TEMPLATE_FILE);
PickupClassesInit(
&gPickupClasses, "data/pickups.json", &gAmmo, &gGunDescriptions);
MapObjectsInit(&gMapObjects, "data/map_objects.json");
CollisionSystemInit(&gCollisionSystem);
CampaignInit(&gCampaign);
LoadAllCampaigns(&campaigns);
PlayerDataInit(&gPlayerDatas);
GrafxMakeRandomBackground(
&gGraphicsDevice, &gCampaign, &gMission, &gMap);
debug(D_NORMAL, ">> Entering main loop\n");
// Attempt to pre-load campaign if requested
if (loadCampaign != NULL)
{
LOG(LM_MAIN, LL_INFO, "Loading campaign %s...", loadCampaign);
gCampaign.Entry.Mode =
strstr(loadCampaign, "/" CDOGS_DOGFIGHT_DIR "/") != NULL ?
GAME_MODE_DOGFIGHT : GAME_MODE_NORMAL;
CampaignEntry entry;
if (!CampaignEntryTryLoad(&entry, loadCampaign, GAME_MODE_NORMAL) ||
!CampaignLoad(&gCampaign, &entry))
{
LOG(LM_MAIN, LL_ERROR, "Failed to load campaign %s", loadCampaign);
}
}
else if (connectAddr.host != 0)
{
if (NetClientTryScanAndConnect(&gNetClient, connectAddr.host))
{
ScreenWaitForCampaignDef();
}
else
{
printf("Failed to connect\n");
}
}
LOG(LM_MAIN, LL_INFO, "Starting game");
MainLoop(&creditsDisplayer, &campaigns);
bail:
debug(D_NORMAL, ">> Shutting down...\n");
MapTerminate(&gMap);
PlayerDataTerminate(&gPlayerDatas);
MapObjectsTerminate(&gMapObjects);
PickupClassesTerminate(&gPickupClasses);
ParticleClassesTerminate(&gParticleClasses);
AmmoTerminate(&gAmmo);
WeaponTerminate(&gGunDescriptions);
BulletTerminate(&gBulletClasses);
CharacterClassesTerminate(&gCharacterClasses);
MissionOptionsTerminate(&gMission);
NetClientTerminate(&gNetClient);
atexit(enet_deinitialize);
EventTerminate(&gEventHandlers);
GraphicsTerminate(&gGraphicsDevice);
PicManagerTerminate(&gPicManager);
FontTerminate(&gFont);
AutosaveSave(&gAutosave, GetConfigFilePath(AUTOSAVE_FILE));
AutosaveTerminate(&gAutosave);
ConfigSave(&gConfig, GetConfigFilePath(CONFIG_FILE));
SavePlayerTemplates(&gPlayerTemplates, PLAYER_TEMPLATE_FILE);
CArrayTerminate(&gPlayerTemplates);
FreeSongs(&gMenuSongs);
FreeSongs(&gGameSongs);
SaveHighScores();
UnloadCredits(&creditsDisplayer);
UnloadAllCampaigns(&campaigns);
CampaignTerminate(&gCampaign);
SoundTerminate(&gSoundDevice, true);
ConfigDestroy(&gConfig);
SDLJBN_Quit();
SDL_Quit();
return err;
}
const char *ConfigGetString(Config *c, const char *name)
{
c = ConfigGet(c, name);
CASSERT(c->Type == CONFIG_TYPE_STRING, "wrong config type");
return c->u.String.Value;
}
void ConfigSetInt(Config *c, const char *name, const int value)
{
c = ConfigGet(c, name);
CASSERT(c->Type == CONFIG_TYPE_INT, "wrong config type");
c->u.Int.Value = CLAMP(value, c->u.Int.Min, c->u.Int.Max);
}
void ConfigSetFloat(Config *c, const char *name, const double value)
{
c = ConfigGet(c, name);
CASSERT(c->Type == CONFIG_TYPE_FLOAT, "wrong config type");
c->u.Float.Value = CLAMP(value, c->u.Float.Min, c->u.Float.Max);
}
CArray *ConfigGetGroup(Config *c, const char *name)
{
c = ConfigGet(c, name);
CASSERT(c->Type == CONFIG_TYPE_GROUP, "wrong config type");
return &c->u.Group;
}
int ConfigGetEnum(Config *c, const char *name)
{
c = ConfigGet(c, name);
CASSERT(c->Type == CONFIG_TYPE_ENUM, "wrong config type");
return c->u.Enum.Value;
}
bool ConfigGetBool(Config *c, const char *name)
{
c = ConfigGet(c, name);
CASSERT(c->Type == CONFIG_TYPE_BOOL, "wrong config type");
return c->u.Bool.Value;
}
double ConfigGetFloat(Config *c, const char *name)
{
c = ConfigGet(c, name);
CASSERT(c->Type == CONFIG_TYPE_FLOAT, "wrong config type");
return c->u.Float.Value;
}
int ConfigGetInt(Config *c, const char *name)
{
c = ConfigGet(c, name);
CASSERT(c->Type == CONFIG_TYPE_INT, "wrong config type");
return c->u.Int.Value;
}
void ConfigLoadJSON(Config *config, const char *filename)
{
FILE *f = fopen(filename, "r");
json_t *root = NULL;
int version;
if (f == NULL)
{
printf("Error loading config '%s'\n", filename);
goto bail;
}
if (json_stream_parse(f, &root) != JSON_OK)
{
printf("Error parsing config '%s'\n", filename);
goto bail;
}
LoadInt(&version, root, "Version");
ConfigLoadVisit(config, root);
// Old config version stuff
if (version < 5)
{
json_t *node = JSONFindNode(root, "Game");
if (node != NULL)
{
bool moveWhenShooting = false;
LoadBool(&moveWhenShooting, node, "MoveWhenShooting");
Config *c = ConfigGet(config, "Game.FireMoveStyle");
c->u.Enum.Value = moveWhenShooting ? FIREMOVE_NORMAL : FIREMOVE_STOP;
}
}
if (version < 6)
{
json_t *node = JSONFindNode(root, "Input/Keys");
if (node != NULL)
{
for (int i = 0; i < 2 && node != NULL; i++)
{
char buf[256];
sprintf(buf, "Input.PlayerKeys%d", i);
Config *c = ConfigGet(config, buf);
ConfigLoadVisit(c, node->child);
node = node->next;
}
}
}
if (version < 4)
{
json_t *node = JSONFindNode(root, "Interface");
if (node != NULL)
{
bool splitscreenAlways;
LoadBool(&splitscreenAlways, node, "SplitscreenAlways");
Config *c = ConfigGet(config, "Interface.Splitscreen");
c->u.Enum.Value =
splitscreenAlways ? SPLITSCREEN_ALWAYS : SPLITSCREEN_NORMAL;
}
}
bail:
json_free_value(&root);
if (f != NULL)
{
fclose(f);
}
}
static void Gfx_ModeSet(const GraphicsMode *mode)
{
ConfigGet(&gConfig, "Graphics.ResolutionWidth")->u.Int.Value = mode->Width;
ConfigGet(&gConfig, "Graphics.ResolutionHeight")->u.Int.Value = mode->Height;
ConfigGet(&gConfig, "Graphics.ScaleFactor")->u.Int.Value = mode->ScaleFactor;
}
