/* every other field in the player structure should be valid when this call is made */
void initialize_player_physics_variables(
short player_index)
{
struct player_data *player= get_player_data(player_index);
struct monster_data *monster= get_monster_data(player->monster_index);
struct object_data *object= get_object_data(monster->object_index);
struct physics_variables *variables= &player->variables;
struct physics_constants *constants= get_physics_constants_for_model(static_world->physics_model, 0);
//#ifdef DEBUG
obj_set(*variables, 0x80);
//#endif
variables->head_direction= 0;
variables->adjusted_yaw= variables->direction= INTEGER_TO_FIXED(object->facing);
variables->adjusted_pitch= variables->elevation= 0;
variables->angular_velocity= variables->vertical_angular_velocity= 0;
variables->velocity= 0, variables->perpendicular_velocity= 0;
variables->position.x= WORLD_TO_FIXED(object->location.x);
variables->position.y= WORLD_TO_FIXED(object->location.y);
variables->position.z= WORLD_TO_FIXED(object->location.z);
variables->last_position= variables->position;
variables->last_direction= variables->direction;
/* .floor_height, .ceiling_height and .media_height will be calculated by instantiate, below */
variables->external_angular_velocity= 0;
variables->external_velocity.i= variables->external_velocity.j= variables->external_velocity.k= 0;
variables->actual_height= constants->height;
variables->step_phase= 0;
variables->step_amplitude= 0;
variables->action= _player_stationary;
variables->old_flags= variables->flags= 0; /* not recentering, not above ground, not below ground (i.e., on floor) */
/* setup shadow variables in player_data structure */
instantiate_physics_variables(get_physics_constants_for_model(static_world->physics_model, 0),
&player->variables, player_index, true, true);
#ifdef DIVERGENCE_CHECK
if (!saved_point_iterations)
{
saved_points= new world_point3d[SAVED_POINT_COUNT];
saved_thetas= new angle[SAVED_POINT_COUNT];
}
saved_point_count= 0;
saved_point_iterations+= 1;
saved_divergence_warning= false;
#endif
}
/**
** evaluate byte code.
** @param f: Frame
** @return evaluated value.
*/
Object tm_eval(TmFrame* f) {
Object* locals = f->locals;
Object* top = f->stack;
Object cur_fnc = f->fnc;
Object globals = get_globals(cur_fnc);
// TODO use code cache to replace unsigned char*
unsigned char* pc = f->pc;
const char* func_name_sz = get_func_name_sz(cur_fnc);
Object x, k, v;
Object ret = NONE_OBJECT;
int i;
#if INTERP_DB
printf("File \"%s\": enter function %s\n",get_func_file_sz(cur_fnc), get_func_name_sz(cur_fnc));
#endif
while (1) {
i = (pc[1] << 8) | pc[2];
#if INTERP_DB
printf("%30s%2d: %d frame = %d, top = %d\n","", pc[0], i, tm->cur, (int) (top - f->stack));
#endif
switch (pc[0]) {
case OP_NUMBER: {
double d = atof((char*)pc + 3);
pc += i;
v = tm_number(d);
/* obj_append(tm->constants,v);*/
dict_set(tm->constants, v, NONE_OBJECT);
break;
}
case OP_STRING: {
v = string_alloc((char*)pc + 3, i);
pc += i;
/* obj_append(tm->constants,v); */
dict_set(tm->constants, v, NONE_OBJECT);
break;
}
case OP_IMPORT: {
// TODO
// tm_import(globals)
Object import_func = tm_get_global(globals, "_import");
arg_start();
arg_push(globals);
Object modname, attr;
if (i == 1) {
modname = TM_POP();
arg_push(modname); // arg1
} else {
attr = TM_POP();
modname = TM_POP();
arg_push(modname);
arg_push(attr);
}
call_function(import_func);
break;
}
case OP_CONSTANT: {
TM_PUSH(GET_CONST(i));
break;
}
case OP_NONE: {
TM_PUSH(NONE_OBJECT);
break;
}
case OP_LOAD_LOCAL: {
TM_PUSH(locals[i]);
break;
}
case OP_STORE_LOCAL:
locals[i] = TM_POP();
break;
case OP_LOAD_GLOBAL: {
/* tm_printf("load global %o\n", GET_CONST(i)); */
int idx = dict_get_attr(GET_DICT(globals), i);
if (idx == -1) {
idx = dict_get_attr(GET_DICT(tm->builtins), i);
if (idx == -1) {
tm_raise("NameError: name %o is not defined", GET_CONST(i));
} else {
Object value = GET_DICT(tm->builtins)->nodes[idx].val;
// OPTIMIZE
// set the builtin to `globals()`
obj_set(globals, GET_CONST(i), value);
idx = dict_get_attr(GET_DICT(globals), i);
pc[0] = OP_FAST_LD_GLO;
code16(pc+1, idx);
// OPTIMIZE END
TM_PUSH(value);
}
} else {
TM_PUSH(GET_DICT(globals)->nodes[idx].val);
pc[0] = OP_FAST_LD_GLO;
code16(pc+1, idx);
}
break;
}
case OP_STORE_GLOBAL: {
x = TM_POP();
int idx = dict_set_attr(GET_DICT(globals), i, x);
pc[0] = OP_FAST_ST_GLO;
code16(pc+1, idx);
break;
}
case OP_FAST_LD_GLO: {
TM_PUSH(GET_DICT(globals)->nodes[i].val);
break;
}
case OP_FAST_ST_GLO: {
GET_DICT(globals)->nodes[i].val = TM_POP();
break;
}
case OP_LIST: {
TM_PUSH(list_new(2));
FRAME_CHECK_GC();
break;
}
case OP_APPEND:
v = TM_POP();
x = TM_TOP();
tm_assert(IS_LIST(x), "tm_eval: OP_APPEND require list");
list_append(GET_LIST(x), v);
break;
case OP_DICT_SET:
v = TM_POP();
k = TM_POP();
x = TM_TOP();
tm_assert(IS_DICT(x), "tm_eval: OP_DICT_SET require dict");
obj_set(x, k, v);
break;
case OP_DICT: {
TM_PUSH(dict_new());
FRAME_CHECK_GC();
break;
}
TM_OP(OP_ADD, obj_add)
TM_OP(OP_SUB, obj_sub)
TM_OP(OP_MUL, obj_mul)
TM_OP(OP_DIV, obj_div)
TM_OP(OP_MOD, obj_mod)
TM_OP(OP_GET, obj_get)
case OP_SLICE: {
Object second = TM_POP();
Object first = TM_POP();
*top = obj_slice(*top, first, second);
break;
}
case OP_EQEQ: { *(top-1) = tm_number(obj_equals(*(top-1), *top)); top--; break; }
case OP_NOTEQ: { *(top-1) = tm_number(!obj_equals(*(top-1), *top)); top--; break; }
case OP_LT: {
*(top-1) = tm_number(obj_cmp(*(top-1), *top)<0);
top--;
break;
}
case OP_LTEQ: {
*(top-1) = tm_number(obj_cmp(*(top-1), *top)<=0);
top--;
break;
}
case OP_GT: {
*(top-1) = tm_number(obj_cmp(*(top-1), *top)>0);
top--;
break;
}
case OP_GTEQ: {
*(top-1) = tm_number(obj_cmp(*(top-1), *top)>=0);
top--;
break;
}
case OP_IN: {
*(top-1) = tm_number(obj_in(*(top-1), *top));
top--;
break;
}
case OP_AND: {
*(top-1) = tm_number(is_true_obj(*(top-1)) && is_true_obj(*top));
top--;
break;
}
case OP_OR: {
*(top-1) = tm_number(is_true_obj(*(top-1)) || is_true_obj(*top));
top--;
break;
}
case OP_NOT:{
*top = tm_number(!is_true_obj(*top));
break;
}
case OP_SET:
k = TM_POP();
x = TM_POP();
v = TM_POP();
#if INTERP_DB
tm_printf("Self %o, Key %o, Val %o\n", x, k, v);
#endif
obj_set(x, k, v);
break;
case OP_POP: {
top--;
break;
}
case OP_NEG:
TM_TOP() = obj_neg(TM_TOP());
break;
case OP_CALL: {
f->top = top;
top -= i;
arg_set_arguments(top + 1, i);
Object func = TM_POP();
TM_PUSH(call_function(func));
// TM_PUSH(call_function(func));
tm->frame = f;
FRAME_CHECK_GC();
break;
}
case OP_APPLY: {
f->top = top;
Object args = TM_POP();
tm_assert_type(args, TYPE_LIST, "tm_eval: OP_APPLY");
arg_set_arguments(LIST_NODES(args), LIST_LEN(args));
Object func = TM_POP();
x = call_function(func);
TM_PUSH(x);
tm->frame = f;
FRAME_CHECK_GC();
break;
}
case OP_LOAD_PARAMS: {
int parg = pc[1];
int varg = pc[2];
if (tm->arg_cnt < parg || tm->arg_cnt > parg + varg) {
tm_raise("ArgError,parg=%d,varg=%d,given=%d",
parg, varg, tm->arg_cnt);
}
for(i = 0; i < tm->arg_cnt; i++){
locals[i] = tm->arguments[i];
}
break;
}
case OP_LOAD_PARG: {
int parg = i;
for (i = 0; i < parg; i++) {
locals[i] = arg_take_obj(func_name_sz);
}
break;
}
case OP_LOAD_NARG: {
int arg_index = i;
Object list = list_new(tm->arg_cnt);
while (arg_remains() > 0) {
obj_append(list, arg_take_obj(func_name_sz));
}
locals[arg_index] = list;
break;
}
case OP_ITER: {
*top = iter_new(*top);
break;
}
case OP_NEXT: {
Object *next = next_ptr(*top);
if (next != NULL) {
TM_PUSH(*next);
break;
} else {
pc += i * 3;
continue;
}
break;
}
case OP_DEF: {
Object mod = GET_FUNCTION(cur_fnc)->mod;
Object fnc = func_new(mod, NONE_OBJECT, NULL);
pc = func_resolve(GET_FUNCTION(fnc), pc);
GET_FUNCTION_NAME(fnc) = GET_CONST(i);
TM_PUSH(fnc);
continue;
}
case OP_RETURN: {
ret = TM_POP();
goto end;
}
case OP_ROT: {
int half = i / 2;
int j;
for (j = 0; j < half; j++) {
Object temp = *(top - j);
*(top-j) = *(top - i + j + 1);
*(top-i+j+1) = temp;
}
break;
}
case OP_UNPACK: {
x = TM_POP();
tm_assert_type(x, TYPE_LIST, "tm_eval:UNPACK");
int j;
for(j = LIST_LEN(x)-1; j >= 0; j--) {
TM_PUSH(LIST_GET(x, j));
}
break;
}
case OP_DEL: {
k = TM_POP();
x = TM_POP();
obj_del(x, k);
break;
}
case OP_POP_JUMP_ON_FALSE: {
if (!is_true_obj(TM_POP())) {
pc += i * 3;
continue;
}
break;
}
case OP_JUMP_ON_TRUE: {
if (is_true_obj(TM_TOP())) {
pc += i * 3;
continue;
}
break;
}
case OP_JUMP_ON_FALSE: {
if (!is_true_obj(TM_TOP())) {
pc += i * 3;
continue;
}
break;
}
case OP_UP_JUMP:
pc -= i * 3;
continue;
case OP_JUMP:
pc += i * 3;
continue;
case OP_EOP:
case OP_EOF: {
ret = NONE_OBJECT;
goto end;
}
case OP_LOAD_EX: { top = f->last_top; TM_PUSH(tm->ex); break; }
case OP_SETJUMP: { f->last_top = top; f->jmp = pc + i * 3; break; }
case OP_CLR_JUMP: { f->jmp = NULL; break;}
case OP_LINE: { f->lineno = i; break;}
case OP_DEBUG: {
#if 0
Object fdebug = tm_get_global(globals, "__debug__");
f->top = top;
tm_call(0, fdebug, 1, tm_number(tm->frame - tm->frames));
break;
#endif
}
case OP_FILE: {
// module name here.
break;
}
default:
tm_raise("BAD INSTRUCTION, %d\n globals() = \n%o", pc[0],
GET_FUNCTION_GLOBALS(f->fnc));
goto end;
}
pc += 3;
}
end:
/*
if (top != f->stack) {
tm_raise("tm_eval: operand stack overflow");
}*/
pop_frame();
return ret;
}
