mirror of
https://github.com/libretro/RetroArch.git
synced 2024-11-25 00:49:47 +00:00
391 lines
8.6 KiB
C
391 lines
8.6 KiB
C
/* RetroArch - A frontend for libretro.
|
|
* Copyright (C) 2010-2012 - Hans-Kristian Arntzen
|
|
*
|
|
* RetroArch 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 Found-
|
|
* ation, either version 3 of the License, or (at your option) any later version.
|
|
*
|
|
* RetroArch 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 RetroArch.
|
|
* If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "cheats.h"
|
|
#include "hash.h"
|
|
#include "dynamic.h"
|
|
#include "general.h"
|
|
#include "compat/strl.h"
|
|
#include "compat/posix_string.h"
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#ifdef HAVE_CONFIGFILE
|
|
#include "conf/config_file.h"
|
|
#endif
|
|
|
|
#include <stdlib.h>
|
|
#include <stddef.h>
|
|
#include <string.h>
|
|
|
|
#include <libxml/parser.h>
|
|
#include <libxml/tree.h>
|
|
|
|
struct cheat
|
|
{
|
|
char *desc;
|
|
bool state;
|
|
char *code;
|
|
};
|
|
|
|
struct cheat_manager
|
|
{
|
|
struct cheat *cheats;
|
|
unsigned ptr;
|
|
unsigned size;
|
|
unsigned buf_size;
|
|
};
|
|
|
|
static char *strcat_alloc(char *dest, const char *input)
|
|
{
|
|
size_t dest_len = dest ? strlen(dest) : 0;
|
|
size_t input_len = strlen(input);
|
|
size_t required_len = dest_len + input_len + 1;
|
|
|
|
char *output = (char*)realloc(dest, required_len);
|
|
if (!output)
|
|
return NULL;
|
|
|
|
if (dest)
|
|
strlcat(output, input, required_len);
|
|
else
|
|
strlcpy(output, input, required_len);
|
|
|
|
return output;
|
|
}
|
|
|
|
static bool xml_grab_cheat(struct cheat *cht, xmlNodePtr ptr)
|
|
{
|
|
if (!ptr)
|
|
return false;
|
|
|
|
memset(cht, 0, sizeof(struct cheat));
|
|
bool first = true;
|
|
|
|
for (; ptr; ptr = ptr->next)
|
|
{
|
|
if (strcmp((const char*)ptr->name, "description") == 0)
|
|
{
|
|
cht->desc = (char*)xmlNodeGetContent(ptr);
|
|
}
|
|
else if (strcmp((const char*)ptr->name, "code") == 0)
|
|
{
|
|
if (!first)
|
|
{
|
|
cht->code = strcat_alloc(cht->code, "+");
|
|
if (!cht->code)
|
|
return false;
|
|
}
|
|
|
|
xmlChar *code = xmlNodeGetContent(ptr);
|
|
if (!code)
|
|
return false;
|
|
|
|
cht->code = strcat_alloc(cht->code, (const char*)code);
|
|
xmlFree(code);
|
|
if (!cht->code)
|
|
return false;
|
|
|
|
first = false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool xml_grab_cheats(cheat_manager_t *handle, xmlNodePtr ptr)
|
|
{
|
|
for (; ptr; ptr = ptr->next)
|
|
{
|
|
if (strcmp((const char*)ptr->name, "name") == 0)
|
|
{
|
|
xmlChar *name = xmlNodeGetContent(ptr);
|
|
if (name)
|
|
{
|
|
RARCH_LOG("Found cheat for game: \"%s\"\n", name);
|
|
xmlFree(name);
|
|
}
|
|
}
|
|
else if (strcmp((const char*)ptr->name, "cheat") == 0)
|
|
{
|
|
if (handle->size == handle->buf_size)
|
|
{
|
|
handle->buf_size *= 2;
|
|
handle->cheats = (struct cheat*)realloc(handle->cheats, handle->buf_size * sizeof(struct cheat));
|
|
if (!handle->cheats)
|
|
return false;
|
|
}
|
|
|
|
if (xml_grab_cheat(&handle->cheats[handle->size], ptr->children))
|
|
handle->size++;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static void cheat_manager_apply_cheats(cheat_manager_t *handle)
|
|
{
|
|
unsigned index = 0;
|
|
pretro_cheat_reset();
|
|
for (unsigned i = 0; i < handle->size; i++)
|
|
{
|
|
if (handle->cheats[i].state)
|
|
pretro_cheat_set(index++, true, handle->cheats[i].code);
|
|
}
|
|
}
|
|
|
|
static void cheat_manager_load_config(cheat_manager_t *handle, const char *path, const char *sha256)
|
|
{
|
|
#ifdef HAVE_CONFIGFILE
|
|
if (!(*path))
|
|
return;
|
|
|
|
config_file_t *conf = config_file_new(path);
|
|
if (!conf)
|
|
return;
|
|
|
|
char *str;
|
|
if (!config_get_string(conf, sha256, &str))
|
|
{
|
|
config_file_free(conf);
|
|
return;
|
|
}
|
|
|
|
char *save;
|
|
const char *num = strtok_r(str, ";", &save);
|
|
while (num)
|
|
{
|
|
unsigned index = strtoul(num, NULL, 0);
|
|
if (index < handle->size)
|
|
handle->cheats[index].state = true;
|
|
|
|
num = strtok_r(NULL, ";", &save);
|
|
}
|
|
|
|
free(str);
|
|
config_file_free(conf);
|
|
|
|
cheat_manager_apply_cheats(handle);
|
|
|
|
#else
|
|
(void)handle;
|
|
(void)path;
|
|
(void)sha256;
|
|
#endif
|
|
}
|
|
|
|
static void cheat_manager_save_config(cheat_manager_t *handle, const char *path, const char *sha256)
|
|
{
|
|
#ifdef HAVE_CONFIGFILE
|
|
if (!(*path))
|
|
return;
|
|
|
|
config_file_t *conf = config_file_new(path);
|
|
if (!conf)
|
|
conf = config_file_new(NULL);
|
|
|
|
if (!conf)
|
|
{
|
|
RARCH_ERR("Cannot save XML cheat settings.\n");
|
|
return;
|
|
}
|
|
|
|
char conf_str[512] = {0};
|
|
char tmp[32] = {0};
|
|
|
|
for (unsigned i = 0; i < handle->size; i++)
|
|
{
|
|
if (handle->cheats[i].state)
|
|
{
|
|
snprintf(tmp, sizeof(tmp), "%u;", i);
|
|
strlcat(conf_str, tmp, sizeof(conf_str));
|
|
}
|
|
}
|
|
|
|
if (*conf_str)
|
|
conf_str[strlen(conf_str) - 1] = '\0'; // Remove the trailing ';'
|
|
|
|
config_set_string(conf, sha256, conf_str);
|
|
|
|
if (!config_file_write(conf, path))
|
|
RARCH_ERR("Failed to write XML cheat settings to \"%s\". Check permissions.\n", path);
|
|
|
|
config_file_free(conf);
|
|
|
|
#else
|
|
(void)handle;
|
|
(void)path;
|
|
(void)sha256;
|
|
#endif
|
|
}
|
|
|
|
cheat_manager_t* cheat_manager_new(const char *path)
|
|
{
|
|
LIBXML_TEST_VERSION;
|
|
|
|
pretro_cheat_reset();
|
|
|
|
xmlParserCtxtPtr ctx = NULL;
|
|
xmlDocPtr doc = NULL;
|
|
cheat_manager_t *handle = (cheat_manager_t*)calloc(1, sizeof(struct cheat_manager));
|
|
if (!handle)
|
|
return NULL;
|
|
|
|
xmlNodePtr head = NULL;
|
|
xmlNodePtr cur = NULL;
|
|
|
|
handle->buf_size = 1;
|
|
handle->cheats = (struct cheat*)calloc(handle->buf_size, sizeof(struct cheat));
|
|
if (!handle->cheats)
|
|
{
|
|
handle->buf_size = 0;
|
|
goto error;
|
|
}
|
|
|
|
ctx = xmlNewParserCtxt();
|
|
if (!ctx)
|
|
goto error;
|
|
|
|
doc = xmlCtxtReadFile(ctx, path, NULL, 0);
|
|
if (!doc)
|
|
{
|
|
RARCH_ERR("Failed to parse XML file: %s\n", path);
|
|
goto error;
|
|
}
|
|
|
|
if (ctx->valid == 0)
|
|
{
|
|
RARCH_ERR("Cannot validate XML file: %s\n", path);
|
|
goto error;
|
|
}
|
|
|
|
head = xmlDocGetRootElement(doc);
|
|
for (cur = head; cur; cur = cur->next)
|
|
{
|
|
if (cur->type == XML_ELEMENT_NODE && strcmp((const char*)cur->name, "database") == 0)
|
|
break;
|
|
}
|
|
|
|
if (!cur)
|
|
goto error;
|
|
|
|
for (cur = cur->children; cur; cur = cur->next)
|
|
{
|
|
if (cur->type != XML_ELEMENT_NODE)
|
|
continue;
|
|
|
|
if (strcmp((const char*)cur->name, "cartridge") == 0)
|
|
{
|
|
xmlChar *sha256 = xmlGetProp(cur, (const xmlChar*)"sha256");
|
|
if (!sha256)
|
|
continue;
|
|
|
|
if (strcmp((const char*)sha256, g_extern.sha256) == 0)
|
|
{
|
|
xmlFree(sha256);
|
|
break;
|
|
}
|
|
|
|
xmlFree(sha256);
|
|
}
|
|
}
|
|
|
|
if (!cur)
|
|
goto error;
|
|
|
|
if (!xml_grab_cheats(handle, cur->children))
|
|
{
|
|
RARCH_ERR("Failed to grab cheats. This should not happen.\n");
|
|
goto error;
|
|
}
|
|
|
|
if (handle->size == 0)
|
|
{
|
|
RARCH_ERR("Did not find any cheats in XML file: %s\n", path);
|
|
goto error;
|
|
}
|
|
|
|
cheat_manager_load_config(handle, g_settings.cheat_settings_path, g_extern.sha256);
|
|
|
|
xmlFreeDoc(doc);
|
|
xmlFreeParserCtxt(ctx);
|
|
return handle;
|
|
|
|
error:
|
|
cheat_manager_free(handle);
|
|
if (doc)
|
|
xmlFreeDoc(doc);
|
|
if (ctx)
|
|
xmlFreeParserCtxt(ctx);
|
|
return NULL;
|
|
}
|
|
|
|
void cheat_manager_free(cheat_manager_t *handle)
|
|
{
|
|
if (!handle)
|
|
return;
|
|
|
|
if (handle->cheats)
|
|
{
|
|
cheat_manager_save_config(handle, g_settings.cheat_settings_path, g_extern.sha256);
|
|
for (unsigned i = 0; i < handle->size; i++)
|
|
{
|
|
xmlFree(handle->cheats[i].desc);
|
|
free(handle->cheats[i].code);
|
|
}
|
|
|
|
free(handle->cheats);
|
|
}
|
|
|
|
free(handle);
|
|
}
|
|
|
|
static void cheat_manager_update(cheat_manager_t *handle)
|
|
{
|
|
msg_queue_clear(g_extern.msg_queue);
|
|
char msg[256];
|
|
snprintf(msg, sizeof(msg), "Cheat: #%u [%s]: %s", handle->ptr, handle->cheats[handle->ptr].state ? "ON" : "OFF", handle->cheats[handle->ptr].desc);
|
|
msg_queue_push(g_extern.msg_queue, msg, 1, 180);
|
|
RARCH_LOG("%s\n", msg);
|
|
}
|
|
|
|
|
|
void cheat_manager_toggle(cheat_manager_t *handle)
|
|
{
|
|
handle->cheats[handle->ptr].state ^= true;
|
|
cheat_manager_apply_cheats(handle);
|
|
cheat_manager_update(handle);
|
|
}
|
|
|
|
void cheat_manager_index_next(cheat_manager_t *handle)
|
|
{
|
|
handle->ptr = (handle->ptr + 1) % handle->size;
|
|
cheat_manager_update(handle);
|
|
}
|
|
|
|
void cheat_manager_index_prev(cheat_manager_t *handle)
|
|
{
|
|
if (handle->ptr == 0)
|
|
handle->ptr = handle->size - 1;
|
|
else
|
|
handle->ptr--;
|
|
|
|
cheat_manager_update(handle);
|
|
}
|
|
|