CELL make_vector_uninited(size_t len) { CELL cell = gc_alloc_extra(VECTOR, len * sizeof(CELL)); VECTOR* p = GET_VECTOR(cell); p->len = len; return cell; }
CELL make_vector_inited(size_t len, CELL init) { gc_root_1("make_vector_inited", init); CELL cell = gc_alloc_extra(VECTOR, len * sizeof(CELL)); VECTOR* p = GET_VECTOR(cell); p->len = len; int i; for(i = 0; i < len; ++i) { p->data[i] = init; } gc_unroot(); return cell; }
/***************************************** * Read nappe characterization in a file * *****************************************/ GEO * file_geo_nappe (BYTE Type, FILE *File) { GEO_NAPPE *Geo; PNT *Pnt, *PntA, *PntB, *PntC, *PntD; FCT *Fct; VECTOR U, V; REAL Real; INDEX Index; INIT_MEM (Geo, 1, GEO_NAPPE); Geo->Type = Type; GET_INDEX (Geo->NbrPnt); INIT_MEM (Geo->TabPnt, Geo->NbrPnt, PNT); GET_INDEX (Geo->NbrFct); INIT_MEM (Geo->TabFct, Geo->NbrFct, FCT); Geo->Min.x = Geo->Min.y = Geo->Min.z = INFINITY; Geo->Max.x = Geo->Max.y = Geo->Max.z = -INFINITY; for (Index = 0, Pnt = Geo->TabPnt; Index < Geo->NbrPnt; Index++, Pnt++) { GET_VECTOR (Pnt->Point); VEC_MIN (Geo->Min, Pnt->Point); VEC_MAX (Geo->Max, Pnt->Point); } for (Index = 0, Fct = Geo->TabFct; Index < Geo->NbrFct; Index++, Fct++) { if (fscanf (File, " ( %d %d %d %d )", &Fct->i, &Fct->j, &Fct->k, &Fct->l) < 4) return (FALSE); Fct->NumFct = Index; PntA = Geo->TabPnt + Fct->i; PntB = Geo->TabPnt + Fct->j; PntC = Geo->TabPnt + Fct->k; PntD = Geo->TabPnt + Fct->l; VEC_SUB (U, PntC->Point, PntA->Point); VEC_SUB (V, PntD->Point, PntB->Point); VEC_CROSS (Fct->Normal, U, V); VEC_UNIT (Fct->Normal, Real); VEC_INC (PntA->Normal, Fct->Normal); VEC_INC (PntB->Normal, Fct->Normal); VEC_INC (PntC->Normal, Fct->Normal); VEC_INC (PntD->Normal, Fct->Normal); } for (Index = 0, Pnt = Geo->TabPnt; Index < Geo->NbrPnt; Index++, Pnt++) VEC_UNIT (Pnt->Normal, Real); return ((GEO *) Geo); }
GEO * file_geo_sphere (BYTE Type, FILE *File) { GEO_SPHERE *Geo; VECTOR Vector; INIT_MEM (Geo, 1, GEO_SPHERE); Geo->Type = Type; GET_VECTOR (Geo->Point); GET_REAL (Geo->Radius); Vector.x = Vector.y = Vector.z = Geo->Radius; VEC_SUB (Geo->Min, Geo->Point, Vector); VEC_ADD (Geo->Max, Geo->Point, Vector); return ((GEO *) Geo); }
int internal_equalp(CELL obj1, CELL obj2) { while(1) { if (AS_LITERAL(obj1) == AS_LITERAL(obj2)) { return 1; } if (! (IS_POINTER(obj1) && IS_POINTER(obj2)) ) { return 0; } if (GET_POINTER_TYPE(obj1) != GET_POINTER_TYPE(obj2)) { return 0; } switch(GET_POINTER_TYPE(obj1)) { case T_CONS: // FIXME - unbounded recursion! if (!internal_equalp(CAR(obj1), CAR(obj2))) { return 0; } obj1 = CDR(obj1); obj2 = CDR(obj2); break; case T_VECTOR: case T_RECORD: { VECTOR * const vec1 = GET_VECTOR(obj1); VECTOR * const vec2 = GET_VECTOR(obj2); if (vec1->len != vec2->len) { return 0; } int i; for(i = 0; i < vec1->len; ++i) { // FIXME - unbounded recursion! if (!internal_equalp(vec1->data[i], vec2->data[i])) { return 0; } } return 1; } case T_STRING: { STRING * const p1 = GET_STRING(obj1); STRING * const p2 = GET_STRING(obj2); return p1->len == p2->len && 0 == memcmp(p1->data, p2->data, p1->len); } case T_FLOAT: return GET_FLOAT(obj1) == GET_FLOAT(obj2); case T_BIGINT: return GET_BIGINT(obj1) == GET_BIGINT(obj2); default: return 0; } } }
bool CameraDeserializer::DeserializeToFrame(FramePtr frame, const TypeInfo& info, std::ostream& log) { if (info.TypeName != "camera") { log << "[ERROR] Camera deserializer passed a type of type: " << info.TypeName.c_str() << "." << std::endl; return false; } Camera cam; bool errorbit = false; if (!GetReferenceFrame(cam.RefFrame, info, log)) errorbit = true; if (!GetPosition(cam.Position, cam.RefFrame.Velocity == ReferenceFrame::Default.Velocity, info, log)) errorbit = true; auto end = info.Values.end(); auto forward = info.Values.find("forward"); auto up = info.Values.find("up"); auto right = info.Values.find("right"); auto fovx = info.Values.find("fovx"); auto fovy = info.Values.find("fovy"); auto aspect = info.Values.find("aspect"); if (forward == end) { CHECK_PRESENT(forward, up); CHECK_PRESENT(forward, right); if (!errorbit) { GET_VECTOR(cam.Up, up); GET_VECTOR(cam.Right, right); if (!errorbit) { cam.Forward = cross(cam.Up, cam.Right); } } } else if (up == end) { CHECK_PRESENT(up, right); if (!errorbit) { GET_VECTOR(cam.Forward, forward); GET_VECTOR(cam.Right, right); if (!errorbit) { cam.Up = cross(cam.Forward, cam.Right); } } } else if (right == end) { GET_VECTOR(cam.Forward, forward); GET_VECTOR(cam.Up, up); if (!errorbit) { cam.Right = cross(cam.Forward, cam.Up); } } else { GET_VECTOR(cam.Forward, forward); GET_VECTOR(cam.Up, up); GET_VECTOR(cam.Right, right); } if (aspect == end) { if (fovx == end) { log << NOT_PRESENT(aspect, fovx, camera) << std::endl; errorbit = true; } else if (fovy == end) { log << NOT_PRESENT(aspect, fovy, camera) << std::endl; errorbit = true; } else { GET_NUMBER(cam.FovX, fovx); GET_NUMBER(cam.FovY, fovy); } } else if (fovx == end) { if (fovy == end) { log << NOT_PRESENT(fovx, fovy, camera) << std::endl; errorbit = true; } else { double aspect_; GET_NUMBER(aspect_, aspect); GET_NUMBER(cam.FovY, fovy); if (!errorbit) { cam.FovX = cam.FovY * aspect_; } } } else if (fovy == end) { double aspect_; GET_NUMBER(aspect_, aspect); GET_NUMBER(cam.FovX, fovx); if (!errorbit) { cam.FovY = cam.FovX / aspect_; } } else { GET_NUMBER(cam.FovX, fovx); GET_NUMBER(cam.FovY, fovy); } if (!errorbit) frame->Viewpoint = cam; return !errorbit; }
// process an incoming respawn info packet void multi_respawn_process_packet(ubyte *data, header *hinfo) { ubyte code,cur_link_status; char cur_primary_bank,cur_secondary_bank; ushort net_sig,ship_ets; short player_id; int player_index; vec3d v; char parse_name[1024] = ""; int offset = HEADER_LENGTH; // determine who send the packet player_index = find_player_id(hinfo->id); if(player_index == -1){ nprintf(("Network","Couldn't find player for processing respawn packet!\n")); } // get the opcode GET_DATA(code); // do something based upon the opcode switch((int)code){ case AI_RESPAWN_NOTICE: p_object *pobjp; GET_USHORT( net_sig ); pobjp = mission_parse_get_arrival_ship( net_sig ); Assert( pobjp != NULL ); multi_respawn_ai( pobjp ); break; case RESPAWN_BROADCAST: // get the respawn data GET_USHORT(net_sig); GET_VECTOR(v); GET_SHORT(player_id); GET_DATA(cur_primary_bank); GET_DATA(cur_secondary_bank); GET_DATA(cur_link_status); GET_USHORT(ship_ets); GET_STRING(parse_name); player_index = find_player_id(player_id); if(player_index == -1){ nprintf(("Network","Couldn't find player to respawn!\n")); break; } // create the ship and assign its position, net_signature, and class // respawn the player multi_respawn_player(&Net_players[player_index], cur_primary_bank, cur_secondary_bank, cur_link_status, ship_ets, net_sig, parse_name, &v); // if this is for me, I should jump back into gameplay if(&Net_players[player_index] == Net_player){ gameseq_post_event(GS_EVENT_ENTER_GAME); } break; case RESPAWN_REQUEST: // determine whether he wants to respawn as an observer or not GET_DATA(code); if(player_index == -1){ nprintf(("Network","Received respawn request from unknown player!\n")); break; } nprintf(("Network","Received respawn request for player %s\n", Net_players[player_index].m_player->callsign)); // make sure he's not making an invalid request if((code == 0) && !(Net_players[player_index].flags & NETINFO_FLAG_RESPAWNING)){ nprintf(("Network","This player shouldn't be respawning!\n")); Int3(); break; } else if((code == 1) && !(Net_players[player_index].flags & NETINFO_FLAG_LIMBO)){ nprintf(("Network","This is a respawn observer request from a player who shouldn't be respawning as an observer!\n")); Int3(); break; } // otherwise perform the operation // respawn the guy as an observer if(code){ multi_respawn_make_observer(&Net_players[player_index]); } // respawn him as normal else { // create his new ship, and change him from respawning to respawned Assert(Net_players[player_index].p_info.p_objp != NULL); if(Net_players[player_index].p_info.p_objp != NULL){ multi_respawn_player(&Net_players[player_index], Net_players[player_index].s_info.cur_primary_bank, Net_players[player_index].s_info.cur_secondary_bank,Net_players[player_index].s_info.cur_link_status, Net_players[player_index].s_info.ship_ets, 0, Net_players[player_index].p_info.p_objp->name); } } break; } PACKET_SET_SIZE(); }
void internal_generic_output(FILE* fp, CELL cell, int strict, int tab) { switch(GET_TYPE(cell)) { case T_VOID: fputs("#<void>", fp); break; case T_NULL: fputs("()", fp); break; case T_UNDEFINED: fputs("#<undefined>", fp); break; case T_EMPTY: fputs("#<empty>", fp); break; case T_BOOL: fputs(GET_BOOL(cell) ? "#t" : "#f", fp); break; case T_CHAR: { CHAR ch = GET_CHAR(cell); if (strict) { switch(ch) { case ' ': fputs("#\\space", fp); break; case 0: fputs("#\\nul", fp); break; case 27: fputs("#\\escape", fp); break; case 127: fputs("#\\rubout", fp); break; case '\a': fputs("#\\alarm", fp); break; case '\b': fputs("#\\backspace", fp); break; case '\f': fputs("#\\page", fp); break; case '\n': fputs("#\\newline", fp); break; case '\r': fputs("#\\return", fp); break; case '\t': fputs("#\\tab", fp); break; case '\v': fputs("#\\vtab", fp); break; default: fprintf(fp, "#\\%c", ch); break; } } else { fputc(ch, fp); } } break; case T_INT: fprintf(fp, "%d", GET_INT(cell)); break; case T_BIGINT: fprintf(fp, "%lld", GET_BIGINT(cell)); break; case T_FLOAT: fprintf(fp, "%f", GET_FLOAT(cell)); break; case T_STRING: { STRING* p = GET_STRING(cell); size_t len = p->len; char* data = p->data; if (strict) { // FIXME -- make this more efficient, and escape other special chars? fputc('"', fp); while(len--) { char ch = *data++; if (ch == '"' || ch == '\\') { fputc('\\', fp); } fputc(ch, fp); } fputc('"', fp); } else { fwrite(data, 1, len, fp); } } break; case T_NAME: { NAME* p = GET_NAME(cell); if (p->gensym) { fprintf(fp, "#_%d", p->gensym); } else { fwrite(GET_NAME(cell)->data, 1, GET_NAME(cell)->len, fp); } } break; case T_KEYWORD: { KEYWORD* p = GET_KEYWORD(cell); fwrite(p->data, 1, p->len, fp); fputc(':', fp); } break; case T_SLOT: fprintf(fp, "#<slot:%d>", GET_SLOT(cell)); break; // FIXME - arbitrary recursion case T_CONS: fputc('(', fp); if (tab) ++tab; int did = 0; while(1) { int pair = CONSP(CAR(cell)); if (!did && tab && pair && !CONSP(CAR(CAR(cell)))) { fprintf(fp, "\n%*s", (tab-1)*2, ""); } internal_generic_output(fp, CAR(cell), strict, tab); cell = CDR(cell); if (NULLP(cell)) { break; } did = (tab && pair); if (did) { fprintf(fp, "\n%*s", (tab-1)*2, ""); } else fputc(' ', fp); if (!CONSP(cell)) { fputs(". ", fp); internal_generic_output(fp, cell, strict, tab); break; } } fputc(')', fp); break; // FIXME - arbitrary recursion case T_VECTOR: { VECTOR *vec = GET_VECTOR(cell); fputs("#(", fp); if (vec->len > 0) { int i = 0; internal_generic_output(fp, vec->data[i++], strict, tab); while(i < vec->len) { fputc(' ', fp); internal_generic_output(fp, vec->data[i++], strict, tab); } } fputc(')', fp); break; } case T_FUNC: fprintf(fp, "#<primitive:%s>", GET_FUNC(cell)->name); break; case T_COMPILED_LAMBDA: fprintf(fp, "#<compiled-lambda:0x%08x>", AS_LITERAL(cell)); break; { if (tab) ++tab; COMPILED_LAMBDA *l = GET_COMPILED_LAMBDA(cell); fprintf(fp, "#<%s %d%s:%d/%d", l->is_macro ? "macro" : "lambda", l->argc, l->rest ? "+" : "", l->depth, l->max_slot); if (tab) { fprintf(fp, "\n%*s", (tab-1)*2, ""); } else { fputc(' ', fp); } internal_generic_output(fp, l->body, strict, tab); fputc('>', fp); } break; case T_CLOSURE: fprintf(fp, "#<closure:0x%08x>", AS_LITERAL(cell)); break; { if (tab) ++tab; CLOSURE *c = GET_CLOSURE(cell); fprintf(fp, "#<closure "); if (tab) { fprintf(fp, "\n%*s", (tab-1)*2, ""); } internal_print_env(fp, c->env); if (tab) { fprintf(fp, "\n%*s", (tab-1)*2, ""); } fputc(' ', fp); internal_generic_output(fp, c->compiled_lambda, strict, tab); fputc('>', fp); } break; case T_EXCEPTION: fputs("#<exception:", fp); fwrite(GET_EXCEPTION(cell)->data, 1, GET_EXCEPTION(cell)->len, fp); fputc('>', fp); break; case T_REIFIED_CONTINUATION: fprintf(fp, "#<continuation:0x%08x>", (int)GET_REIFIED_CONTINUATION(cell)->cont); break; case T_STACK_FRAME: { STACK_FRAME* p = GET_STACK_FRAME(cell); fputs("#<stack-frame [", fp); int i; for(i = 0; i < p->len; ++i) { if (i) fputc(' ', fp); fprintf(fp, "0x%08x", (int)p->cells[i]); } fputs("]>", fp); } break; case T_ENV: fprintf(fp, "#<env:count=%d>", GET_ENV(cell)->count); break; case T_RELOC: fprintf(fp, "#<reloc:0x%08x>", (int)GET_RELOC(cell)); break; case T_PORT: fprintf(fp, "#<port:%s>", GET_PORT(cell)->data); break; case T_DB_CONNECTION: fprintf(fp, "#<db-connection>"); break; case T_DB_RESULT: fprintf(fp, "#<db-result>"); break; case T_RECORD: fprintf(fp, "#<record>"); break; default: fprintf(fp, "#<%s-%02x:%08x>", IS_LITERAL(cell) ? "literal" : "pointer", GET_TYPE(cell), AS_LITERAL(cell) ); break; } }