// // run() - The control layer between the user and the player is here // // This method handles major game logic surrounding the player's actions. // Everything dictated by the user takes place here // // Note: The coordinates of the map are still based on curses // ie, 0,0 is top left. // void player::run() { bool done = false; while( done == false ) { command input = get_command(); switch( input ) { case WEST: case EAST: case NORTH: case SOUTH: case NW: case NE: case SW: case SE: done = move( input ); break; case QUIT: done = true; gen_map(); clear_screen(); break; case SAVE: done = true; save_game(); break; } } }
int get_option(int argc, char **argv) { int i; int flag_c; i = 1; flag_c = 0; while (i < argc) { if (argv[i][0] == '-') { if (argv[i][1] == 'c') flag_c = 1; else if (argv[i][1] == 'g') return (gen_map(argc, argv)); else { my_putstr_error("./bsq: invalid option -- '"); my_putchar_error(argv[i][1]); my_putstr_error("\'\n"); return (-1); } } i = i + 1; } return (flag_c); }
//initialize a map void load_map(Game* game, TMX_map* map){ fprintf(fpLog, "Loading map...\n"); int i, j; FILE* fp; char dir[128] = ""; //get size of map sprintf(dir, "res/maps/%s/map.map", game->active_map); fp = fopen(dir, "r"); if(game->debug && fp == NULL){ fprintf(fpLog, "File not opened map.map\n"); } get_dims(fp, &map->w, &map->l); //allocate memory for map map->tmx = (int**) malloc(map->l * sizeof(int)); for(i = 0; i < map->l; ++i){ map->tmx[i] = (int*) malloc(map->w * sizeof(int)); for(j = 0; j < map->w; ++j){ //scan in map to locaiton fscanf(fp, "%d", &map->tmx[i][j]); } } fclose(fp); //get tilemap sprintf(dir, "res/maps/%s/tilemap.bmp", game->active_map); if ((map->tilemap = load_bitmap(dir, NULL)) == NULL){ fprintf(fpLog, "Failed to load tilemap\n"); } map->blocker_values = NULL; sprintf(dir, "res/maps/%s/settings.map", game->active_map); int temp; int cR, cG, cB; fp = fopen(dir, "r"); if(game->debug && fp == NULL){ fprintf(fpLog, "File not opened settings.map\n"); } //get and set default background color fscanf(fp, "%d %d %d", &cR, &cG, &cB); map->bgCol = makecol(cR, cG, cB); i = 0; while(fscanf(fp, "%d", &temp) != EOF){ map->blocker_values = (int*) realloc(map->blocker_values, (++i) * sizeof(int)); map->blocker_values[i-1] = temp; } map->blocker_val_count = i; //generate background map->map = NULL; gen_map(map); }END_OF_FUNCTION(load_map);
static void gen_tf (const struct parse_tf *tf, FILE *out, FILE *f_strs, const array_t *arrs, int narrs) { char *buf_deps, *buf_ports; size_t sz_deps, sz_ports; FILE *f_ports = open_memstream (&buf_ports, &sz_ports); FILE *f_deps = open_memstream (&buf_deps, &sz_deps); int start = ftell (out); struct tf hdr = {ftell (f_strs) + VALID_OFS, tf->nrules}; if (tf->prefix) fwrite (tf->prefix, 1, strlen (tf->prefix) + 1, f_strs); else hdr.prefix = 0; fwrite (&hdr, sizeof hdr, 1, out); /* TODO: Alignment? */ struct rule rules[hdr.nrules]; memset (rules, 0, sizeof rules); int i = 0; for (struct parse_rule *r = tf->rules.head; r; r = r->next, i++) { struct rule *tmp = &rules[i]; tmp->idx = r->idx; tmp->in = gen_ports (ARR (r->in), r->in.n, f_ports); tmp->out = gen_ports (ARR (r->out), r->out.n, f_ports); tmp->match = arr_find (r->match, arrs, narrs); tmp->mask = arr_find (r->mask, arrs, narrs); tmp->rewrite = arr_find (r->rewrite, arrs, narrs); if (r->deps.head) tmp->deps = gen_deps (&r->deps, f_deps, f_ports, arrs, narrs); //tmp->desc = barfoo; } fclose (f_ports); fclose (f_deps); qsort (rules, hdr.nrules, sizeof *rules, rule_cmp); fwrite (rules, hdr.nrules, sizeof *rules, out); hdr.map_ofs = ftell (out) - start; gen_map (out, &tf->in_map, rules, ARR_LEN (rules)); hdr.ports_ofs = ftell (out) - start; fwrite (buf_ports, 1, sz_ports, out); free (buf_ports); hdr.deps_ofs = ftell (out) - start; fwrite (buf_deps, 1, sz_deps, out); free (buf_deps); int end = ftell (out); fseek (out, start, SEEK_SET); fwrite (&hdr, sizeof hdr, 1, out); fseek (out, end, SEEK_SET); }
int main(){ cout<<"Begin---"<<endl; Timer gen_timer, main_timer; gen_timer.start(); gen_map(); gen_timer.stop(); cout<<"Generating the grid took "<<gen_timer.getTime() << " seconds."<<endl; main_timer.start(); for( int i=0; i<iterations; i++){ update( map, back); swap( map, back); } main_timer.stop(); cout<<"Performed "<<iterations<<" steps of a grid with a side lenth of "<<side_length<< " in "<<main_timer.getTime()<<" seconds."<<endl; cout<<"END-----"<<endl; }
int load_maps() { int shmid; key_t shmkey = 12345; size_t shmsize = sizeof(McMap) * 3 * 5; shmid = shmget(shmkey, shmsize, 0); if (shmid < 0) { shmid = shmget(shmkey, shmsize, IPC_CREAT | 0644); maps = shmat(shmid, NULL, 0); if((void*)maps == (void*)-1) return -1; memset(maps, 0, shmsize); maps[0].row = 18; maps[0].col = 32; maps[0].lvl= 3; return gen_map(&maps[0], 0.618); } else { maps = shmat(shmid, NULL, 0); } if((void*)maps == (void*)-1) return -1; return 0; }
static void gen_rse( qli_nod* node, qli_req* request) { /************************************** * * g e n _ r s e * ************************************** * * Functional description * Generate a record selection expression. * **************************************/ qli_rlb* rlb = CHECK_RLB(request->req_blr); if ((nod_t) (IPTR) node->nod_arg[e_rse_join_type] == nod_nothing) STUFF(blr_rse); else STUFF(blr_rs_stream); STUFF(node->nod_count); // Check for aggregate case qli_nod* list; qli_ctx* context = (qli_ctx*) node->nod_arg[e_rse_count]; if (context->ctx_sub_rse) { STUFF(blr_aggregate); STUFF(context->ctx_context); gen_rse(context->ctx_sub_rse, request); STUFF(blr_group_by); if (list = node->nod_arg[e_rse_group_by]) { request->req_flags |= REQ_group_by; STUFF(list->nod_count); qli_nod** ptr = list->nod_arg; for (const qli_nod* const* const end = ptr + list->nod_count; ptr < end; ++ptr) { gen_expression(*ptr, request); } request->req_flags &= ~REQ_group_by; } else STUFF(0); gen_map(context->ctx_map, request); if (list = node->nod_arg[e_rse_having]) { STUFF(blr_boolean); gen_expression(list, request); } if (list = node->nod_arg[e_rse_sort]) gen_sort(list, request, blr_sort); STUFF(blr_end); return; } // Make relation clauses for all relations qli_nod** ptr = &node->nod_arg[e_rse_count]; for (const qli_nod* const* const end = ptr + node->nod_count; ptr < end; ++ptr) { context = (qli_ctx*) *ptr; if (context->ctx_stream) gen_rse(context->ctx_stream, request); else { const qli_rel* relation = context->ctx_relation; STUFF(blr_rid); STUFF_WORD(relation->rel_id); STUFF(context->ctx_context); } } // Handle various clauses if (list = node->nod_arg[e_rse_first]) { STUFF(blr_first); gen_expression(list, request); } if (list = node->nod_arg[e_rse_boolean]) { STUFF(blr_boolean); gen_expression(list, request); } if (list = node->nod_arg[e_rse_sort]) gen_sort(list, request, blr_sort); if (list = node->nod_arg[e_rse_reduced]) gen_sort(list, request, blr_project); const nod_t join_type = (nod_t) (IPTR) node->nod_arg[e_rse_join_type]; if (join_type != nod_nothing && join_type != nod_join_inner) { STUFF(blr_join_type); switch (join_type) { case nod_join_left: STUFF(blr_left); break; case nod_join_right: STUFF(blr_right); break; default: STUFF(blr_full); } } STUFF(blr_end); }