static void hole_init_rc(const char *filename)
{
fs_file fin;
char buff[MAXSTR];
hole = 0;
player = 0;
count = 0;
done = 0;
/* Load the holes list. */
if ((fin = fs_open(filename, "r")))
{
/* Skip shot and description. */
if (fs_gets(buff, sizeof (buff), fin) &&
fs_gets(buff, sizeof (buff), fin))
{
/* Read the list. */
while (fs_gets(buff, sizeof (buff), fin) &&
sscanf(buff, "%s %s %d %s",
hole_v[count].file,
hole_v[count].back,
&hole_v[count].par,
hole_v[count].song) >= 1)
count++;
}
fs_close(fin);
}
}
static int course_load(struct course *course, const char *filename)
{
fs_file fin;
int rc = 0;
memset(course, 0, sizeof (*course));
strncpy(course->holes, filename, MAXSTR - 1);
if ((fin = fs_open(filename, "r")))
{
if (fs_gets(course->shot, sizeof (course->shot), fin) &&
fs_gets(course->desc, sizeof (course->desc), fin))
{
strip_newline(course->shot);
strip_newline(course->desc);
rc = 1;
}
fs_close(fin);
}
return rc;
}
static int check_gdi_image(file_t fd) {
char line[MAX_FN_LEN];
uint32 track_count;
fs_seek(fd, 0, SEEK_SET);
if(fs_gets(fd, line, MAX_FN_LEN) == NULL) {
#ifdef DEBUG
dbglog(DBG_DEBUG, "%s: Not a GDI image\n", __func__);
#endif
return -1;
}
track_count = strtoul(line, NULL, 0);
if(track_count == 0 || track_count > 99) {
#ifdef DEBUG
dbglog(DBG_DEBUG, "%s: Invalid GDI image\n", __func__);
#endif
return -1;
}
return (int)track_count;
}
static int get_score(fs_file fp, struct score *s)
{
char line[MAXSTR];
int i;
for (i = RANK_HARD; i <= RANK_EASY; i++)
{
int n = -1;
if (!fs_gets(line, sizeof (line), fp))
return 0;
strip_newline(line);
if (sscanf(line, "%d %d %n", &s->timer[i], &s->coins[i], &n) < 2)
return 0;
if (n < 0)
return 0;
SAFECPY(s->player[i], line + n);
}
return 1;
}
static void set_load_hs(void)
{
struct set *s = SET_GET(sets, curr);
fs_file fp;
if ((fp = fs_open(config_cheat() ? s->cheat_scores : s->user_scores, "r")))
{
char buf[MAXSTR];
if (fs_gets(buf, sizeof (buf), fp))
{
strip_newline(buf);
if (sscanf(buf, "version %d", &score_version) == 1)
{
switch (score_version)
{
case 2: set_load_hs_v2(fp, s, buf, sizeof (buf)); break;
}
}
else
set_load_hs_v1(fp, s, buf, sizeof (buf));
}
fs_close(fp);
}
}
static void set_load_hs_v2(fs_file fp, struct set *s, char *buf, int size)
{
struct score time_score;
struct score coin_score;
int set_score = 0;
int set_match = 1;
while (fs_gets(buf, size, fp))
{
int version = 0;
int flags = 0;
int n = 0;
strip_newline(buf);
if (strncmp(buf, "set ", 4) == 0)
{
get_score(fp, &time_score);
get_score(fp, &coin_score);
set_score = 1;
}
else if (sscanf(buf, "level %d %d %n", &flags, &version, &n) >= 2)
{
struct level *l;
if ((l = find_level(s, buf + n)))
{
/* Always prefer "locked" flag from the score file. */
l->is_locked = !!(flags & LEVEL_LOCKED);
/* Only use "completed" flag and scores on version match. */
if (version == l->version_num)
{
l->is_completed = !!(flags & LEVEL_COMPLETED);
get_score(fp, &l->scores[SCORE_TIME]);
get_score(fp, &l->scores[SCORE_GOAL]);
get_score(fp, &l->scores[SCORE_COIN]);
}
else set_match = 0;
}
else set_match = 0;
}
}
if (set_match && set_score)
{
s->time_score = time_score;
s->coin_score = coin_score;
}
}
void light_load(void)
{
static char buf[MAXSTR];
int light = -1;
fs_file fp;
float v[4];
int i;
light_reset();
if ((fp = fs_open("lights.txt", "r")))
{
while (fs_gets(buf, sizeof (buf), fp))
{
strip_newline(buf);
if (sscanf(buf, "light %d", &i) == 1)
{
if (i >= 0 && i < LIGHT_MAX)
light = i;
}
else if (sscanf(buf, "position %f %f %f %f",
&v[0], &v[1], &v[2], &v[3]) == 4)
{
if (light >= 0)
q_cpy(lights[light].p, v);
}
else if (sscanf(buf, "diffuse %f %f %f %f",
&v[0], &v[1], &v[2], &v[3]) == 4)
{
if (light >= 0)
q_cpy(lights[light].d, v);
}
else if (sscanf(buf, "ambient %f %f %f %f",
&v[0], &v[1], &v[2], &v[3]) == 4)
{
if (light >= 0)
q_cpy(lights[light].a, v);
else
q_cpy(light_ambient, v);
}
else if (sscanf(buf, "specular %f %f %f %f",
&v[0], &v[1], &v[2], &v[3]) == 4)
{
if (light >= 0)
q_cpy(lights[light].s, v);
}
}
fs_close(fp);
}
}
int theme_load(struct theme *theme, const char *name)
{
char buff[MAXSTR];
fs_file fp;
float s[4] = { 0.25f, 0.25f, 0.25f, 0.25f };
int i;
if (theme && name && *name)
{
memset(theme, 0, sizeof (*theme));
/* Load description. */
if ((fp = fs_open(theme_path(name, "theme.txt"), "r")))
{
while ((fs_gets(buff, sizeof (buff), fp)))
{
strip_newline(buff);
if (strncmp(buff, "slice ", 6) == 0)
sscanf(buff + 6, "%f %f %f %f", &s[0], &s[1], &s[2], &s[3]);
}
fs_close(fp);
}
else
{
log_printf("Failure to open \"%s\" theme file\n", name);
}
theme->s[0] = 0.0f;
theme->s[1] = s[0];
theme->s[2] = (1.0f - s[1]);
theme->s[3] = 1.0f;
theme->t[0] = 1.0f;
theme->t[1] = (1.0f - s[2]);
theme->t[2] = s[3];
theme->t[3] = 0.0f;
/* Load textures. */
for (i = 0; i < ARRAYSIZE(theme_images); i++)
theme->tex[i] = theme_image(theme_path(name, theme_images[i]));
return 1;
}
return 0;
}
static int read_line (lua_State *L, int f) {
luaL_Buffer b;
luaL_buffinit(L, &b);
for (;;) {
size_t l;
char *p = luaL_prepbuffer(&b);
if (fs_gets(p, LUAL_BUFFERSIZE, f) == NULL) { /* eof? */
luaL_pushresult(&b); /* close buffer */
return (lua_objlen(L, -1) > 0); /* check whether read something */
}
l = c_strlen(p);
if (l == 0 || p[l-1] != '\n')
luaL_addsize(&b, l);
else {
luaL_addsize(&b, l - 1); /* do not include `eol' */
luaL_pushresult(&b); /* close buffer */
return 1; /* read at least an `eol' */
}
}
}
GDI_header_t *gdi_open(file_t fd, const char *filename) {
int track_count;
if((track_count = check_gdi_image(fd)) < 0) {
return NULL;
}
#ifdef DEBUG
dbglog(DBG_DEBUG, "%s: %d tracks in image\n", __func__, track_count);
#endif
int track_no, i, rc;
char line[MAX_FN_LEN], fname[MAX_FN_LEN / 2];
char *path = NULL;
GDI_header_t *hdr;
hdr = (GDI_header_t*)malloc(sizeof(GDI_header_t));
if(hdr == NULL) {
return NULL;
}
memset_sh4(hdr, 0, sizeof(GDI_header_t));
hdr->track_count = (uint32)track_count;
hdr->track_fd = FILEHND_INVALID;
hdr->track_current = GDI_MAX_TRACKS;
path = getFilePath(filename);
for(i = 0; i < hdr->track_count; i++) {
if(fs_gets(fd, line, sizeof(line)) == NULL) {
#ifdef DEBUG
dbglog(DBG_DEBUG, "%s: Unexpected end of file\n", __func__);
#endif
goto error;
}
hdr->tracks[i] = (GDI_track_t*)malloc(sizeof(GDI_track_t));
if(hdr->tracks[i] == NULL) {
goto error;
}
#ifdef DEBUG
dbglog(DBG_DEBUG, "%s: %s", __func__, line);
#endif
rc = sscanf(line, "%d %ld %ld %ld %s %ld",
&track_no,
&hdr->tracks[i]->start_lba,
&hdr->tracks[i]->flags,
&hdr->tracks[i]->sector_size,
fname,
&hdr->tracks[i]->offset);
if(rc < 6) {
#ifdef DEBUG
dbglog(DBG_DEBUG, "%s: Invalid line in GDI: %s\n", __func__, line);
#endif
goto error;
}
snprintf(hdr->tracks[i]->filename, MAX_FN_LEN, "%s/%s", path, fname);
}
free(path);
return hdr;
error:
if(path) {
free(path);
}
gdi_close(hdr);
return NULL;
}
