static int parse_algorithms(const char *algos, struct list *list)
{
static const char *delim = ",";
size_t len;
char *saveptr;
char *local;
char *a;
int i = 0;
/* make local copy of algos string */
len = strlen(algos);
local = alloca(len + 1);
strcpy(local, algos);
/* tokenize into list */
a = strtok_r(local, delim, &saveptr);
while (a) {
list_add_back(list, strdup(a));
a = strtok_r(NULL, delim, &saveptr);
i++;
}
if (i == 0) {
fprintf(stderr, "%s: no algorithms provided in run control\n",
progname);
return -1;
}
return 0;
}
void tween_create(entity* ent,
int dx,
int dy,
double dSX,
double dSY,
double dR,
int time,
int delay,
double (*easing)(double),
void (*onComplete)(entity*))
{
tween* t = (tween*)malloc(sizeof(tween));
// figure out what object we are tweening
t->sx = ent->x;
t->sy = ent->y;
t->dx = dx - t->sx;
t->dy = dy - t->sy;
if (ent->t == SPRITE)
{
sprite* s = (sprite*)(ent);
t->sScaleX = s->scaleX;
t->sScaleY = s->scaleY;
t->sRotation = s->rotation;
t->dScaleX = dSX - t->sScaleX;
t->dScaleY = dSY - t->sScaleY;
t->dRotation = dR - t->sRotation;
}
// magic 0.9 :)
t->delay = delay / (1000 / 60) * 0.9;
t->time = time / (1000 / 60) * 0.9;
t->elapsed = 0;
t->obj = ent;
t->easing = NULL;
t->easing = easing;
t->onComplete = onComplete;
list_add_back(&tweens, (void*)t);
}
static struct inode *parse_dir(struct id_entry *dir, void *disk)
{
if (dir->type != ID_TYPE_DIR) {
panic("Tried to parse %s as a dir, but it's a file.\n", (char*)id_get(dir, name, disk));
}
dbg_vprintf(DBG_FS, "creating dir %s\n", (char*)id_get(dir, name, disk));
struct inode *ino = new_inode(dir, disk);
ino->flags = FS_DIR;
list_t *entries = list_create();
ino->impl = (dword)entries;
if (id_get(dir, count, disk) > 0) {
struct id_entry *entry = id_get(dir, content, disk);
while (entry) {
struct inode *e = NULL;
if (entry->type == ID_TYPE_FILE) {
e = parse_file(entry, disk);
}
else if (entry->type == ID_TYPE_DIR) {
e = parse_dir(entry, disk);
}
else {
panic("Invalid type: %d\n", entry->type);
}
list_add_back(entries, e);
entry = id_get(entry, next, disk);
}
}
dbg_vprintf(DBG_FS, "dir done!\n");
return ino;
}
static int scan_year(struct scan_state *ss)
{
DIR *root;
struct dirent ent;
struct dirent *result;
int scan_result;
int num_weeks = 0;
int i;
assert(ss->begin_week != WEEK_ID_BEGIN);
/* create path to year directory in db */
snprintf(ss->pathbuf, DB_MAX_PATH, "%s/%s/%d",
ss->state->rc.data_dir, ss->state->rc.sport, ss->year);
ss->pathbuf[DB_MAX_PATH-1] = '\0';
/* open the year directory for reading */
root = opendir(ss->pathbuf);
if (!root) {
fprintf(stderr, "%s: error reading dir '%s': %s\n",
progname, ss->pathbuf, strerror(errno));
return -1;
}
/* check each entry in the dir */
while (readdir_r(root, &ent, &result) == 0) {
if (!result)
break;
/* detect if valid week and add to filenames */
scan_result = scan_week(ss, result->d_name);
if (scan_result < 0) {
closedir(root);
return -2;
} else if (scan_result == 0) {
num_weeks++;
}
}
closedir(root);
/* update the end value since we didn't know it coming in */
if (ss->end_week == WEEK_ID_END)
ss->end_week = ss->last_week;
/* make sure that there are no holes in the data */
if (num_weeks != (ss->end_week - ss->begin_week + 1)) {
fprintf(stderr, "%s: missing data in '%s/%s/%d'; expected %d weeks: %d-%d\n",
progname,
ss->state->rc.data_dir,
ss->state->rc.sport,
ss->year,
ss->end_week - ss->begin_week + 1,
ss->begin_week,
ss->end_week);
return -1;
}
/* finally, add the files to list */
for (i = 0; i < num_weeks; i++)
list_add_back(&ss->state->db->game_files, ss->filenames[i]);
return 0;
}
sce_buffer_ctxt_t *sce_create_ctxt_from_buffer(scetool::u8 *scebuffer)
{
sce_buffer_ctxt_t *res;
if((res = (sce_buffer_ctxt_t *)malloc(sizeof(sce_buffer_ctxt_t))) == NULL)
return NULL;
memset(res, 0, sizeof(sce_buffer_ctxt_t));
res->scebuffer = scebuffer;
res->mdec = FALSE;
//Set pointer to SCE header.
res->sceh = (sce_header_t *)scebuffer;
_es_sce_header(res->sceh);
//Set pointers to file type specific headers.
switch(res->sceh->header_type)
{
case SCE_HEADER_TYPE_SELF:
{
//SELF header.
res->self.selfh = (self_header_t *)(res->scebuffer + sizeof(sce_header_t));
_es_self_header(res->self.selfh);
//Application info.
res->self.ai = (app_info_t *)(res->scebuffer + res->self.selfh->app_info_offset);
_es_app_info(res->self.ai);
//Section infos.
res->self.si = (section_info_t *)(res->scebuffer + res->self.selfh->section_info_offset);
//SCE version.
if(res->self.selfh->sce_version_offset != NULL)
{
res->self.sv = (sce_version_t *)(res->scebuffer + res->self.selfh->sce_version_offset);
_es_sce_version(res->self.sv);
}
else
res->self.sv = 0;
//Get pointers to all control infos.
scetool::u32 len = (scetool::u32)res->self.selfh->control_info_size;
if(len > 0)
{
scetool::u8 *ptr = res->scebuffer + res->self.selfh->control_info_offset;
res->self.cis = list_create();
while(len > 0)
{
control_info_t *tci = (control_info_t *)ptr;
_es_control_info(tci);
ptr += tci->size;
len -= tci->size;
list_add_back(res->self.cis, tci);
}
}
else
res->self.cis = NULL;
}
break;
case SCE_HEADER_TYPE_RVK:
//TODO
break;
case SCE_HEADER_TYPE_PKG:
//TODO
break;
case SCE_HEADER_TYPE_SPP:
//TODO
break;
default:
free(res);
return NULL;
break;
}
//Set pointers to metadata headers.
res->metai = (metadata_info_t *)(scebuffer + sizeof(sce_header_t) + res->sceh->metadata_offset);
res->metah = (metadata_header_t *)((scetool::u8 *)res->metai + sizeof(metadata_info_t));
res->metash = (metadata_section_header_t *)((scetool::u8 *)res->metah + sizeof(metadata_header_t));
return res;
}
void engine_addEntity(entity* data)
{
list_add_back(&entities, (void*)data);
}
