std::string Game::getMessage() { std::string ret = ""; switch (stage) { case GameIntro: ret = get_intro(); stage = FirstChoice; break; case GameRules: ret = get_rules(1); ret += get_rules(2); stage = FirstChoice; break; case StartTurn: ret = get_state(); if (state.cur_year > 1) { ret += get_visir_message(); } if (state.caravane_year == 5) { ret += get_caravan_arrival(); state.caravane_year = 0; } if (random(100) < 25) { stage = Crisis; } else { stage = Trade; } break; case StartExchange: make_prices(); ret = get_exchange(); stage = ChooseGoods; break; case NoMoney: ret = get_no_money(); stage = next_stage; break; case Crisis: ret = get_crisis(); stage = EquipCaravane; break; case RobCaravane: if (state.caravane_year > 1 && random(100) < 20) { ret = get_loot_caravan(); } stage = RequestMetropolitan; // stage = FinishGame; break; default: break; } return ret; }
int main(int argc, char **argv) { int debug = 0, conftest = 0, nodaemon = 0; int i = 0; unsigned int clilen; struct sockaddr_in cliaddr; struct timeval start, end; char *cnfg = DEF_CNFG; char localhost[MAXNAMLEN + 1], path[MAXNAMLEN + 1]; FILE *pidfp; octet_t oct; ruleset_t *rs; /* * Who am I running as ? */ uname(&myname); /* * spocp_err = 0 ; */ memset(&srv, 0, sizeof(srv_t)); pthread_mutex_init(&(srv.mutex), NULL); pthread_mutex_init(&(srv.mlock), NULL); gethostname(localhost, MAXNAMLEN); #ifdef HAVE_GETDOMAINNAME getdomainname(path, MAXNAMLEN); #else { char *pos; if(pos = strstr(localhost, ".")) strncpy(path, pos+1, MAXNAMLEN); else strcpy(path, ""); } #endif if (0) printf("Domain: %s\n", path); srv.hostname = Strdup(localhost); /* * truncating input strings to reasonable length */ for (i = 0; i < argc; i++) if (strlen(argv[i]) > 512) argv[i][512] = '\0'; while ((i = getopt(argc, argv, "Dhrtf:d:")) != EOF) { switch (i) { case 'D': nodaemon = 1; break; case 'f': cnfg = Strdup(optarg); break; case 'd': debug = atoi(optarg); if (debug < 0) debug = 0; break; case 't': conftest = 1; break; case 'r': srv.readonly = 1; case 'h': default: fprintf(stderr, "Usage: %s [-t] ", argv[0]); fprintf(stderr, "[-f configfile] "); fprintf(stderr, "[-D] [-d debuglevel]\n"); exit(0); } } srv.root = ruleset_new(0); if (srv_init(&srv, cnfg) < 0) exit(1); if (srv.port && srv.uds) { fprintf(stderr, "Sorry are not allowed to listen on both a unix domain socket and a port\n"); exit(1); } if (srv.logfile) spocp_open_log(srv.logfile, debug); else if (debug) spocp_open_log(0, debug); if (srv.name){ localcontext = (char *) Calloc(strlen(srv.name) + strlen("//") + 1, sizeof(char)); /* Flawfinder: ignore */ sprintf(localcontext, "//%s", srv.name); } else { localcontext = (char *) Calloc(strlen(localhost) + strlen("//") + 1, sizeof(char)); /* Flawfinder: ignore */ sprintf(localcontext, "//%s", localhost); } /* * where I put the access rules for access to this server and its * rules */ snprintf(path, MAXNAMLEN, "%s/server", localcontext); oct_assign(&oct, path); if ((rs = ruleset_create(&oct, srv.root)) == 0) exit(1); rs->db = db_new(); /* * access rules for operations */ snprintf(path, MAXNAMLEN, "%s/operation", localcontext); oct_assign(&oct, path); if ((rs = ruleset_create(&oct, srv.root)) == 0) exit(1); rs->db = db_new(); LOG(SPOCP_INFO) { traceLog(LOG_INFO, "Local context: \"%s\"", localcontext); traceLog(LOG_INFO, "initializing backends"); if (srv.root->db) plugin_display(srv.plugin); } if (srv.plugin) { run_plugin_init(&srv); } if ( get_rules( &srv ) != SPOCP_SUCCESS ) exit(1); /*ruleset_tree( srv.root, 0);*/ /* If only testing configuration and rulefile this is as far as I go */ if (conftest) { traceLog(LOG_INFO,"Configuration was OK"); exit(0); } gettimeofday(&start, NULL); if (srv.port || srv.uds) { /* * stdin and stdout will not be used from here on, close to * save file descriptors */ fclose(stdin); fclose(stdout); #ifdef HAVE_SSL /* * ---------------------------------------------------------- */ /* * build our SSL context, whether it will ever be used or not */ /* * mutex'es for openSSL to use */ THREAD_setup(); if (srv.certificateFile && srv.privateKey && srv.caList) { traceLog(LOG_INFO,"Initializing the TLS/SSL environment"); if (!(srv.ctx = tls_init(&srv))) { return FALSE; } } /* * ---------------------------------------------------------- */ #endif #ifdef HAVE_SASL { int r = sasl_server_init(sasl_cb, "spocp"); if (r != SASL_OK) { traceLog( LOG_ERR, "Unable to initialized SASL library: %s", sasl_errstring(r, NULL, NULL)); return FALSE; } } #endif saci_init(); if( nodaemon == 0 ) { #ifdef HAVE_DAEMON if (daemon(1, 1) < 0) { fprintf(stderr, "couldn't go daemon\n"); exit(1); } #else daemon_init("spocp", 0); #endif } if (srv.pidfile) { /* * Write the PID file. */ pidfp = fopen(srv.pidfile, "w"); if (pidfp == (FILE *) 0) { fprintf(stderr, "Couldn't open pidfile \"%s\"\n", srv.pidfile); exit(1); } fprintf(pidfp, "%d\n", (int) getpid()); fclose(pidfp); } if (srv.port) { LOG(SPOCP_INFO) traceLog( LOG_INFO, "Asked to listen on port %d", srv.port); if ((srv.listen_fd = spocp_stream_socket(srv.port)) < 0) exit(1); srv.id = (char *) Malloc(16); sprintf(srv.id, "spocp-%d", srv.port); srv.type = AF_INET; } else { LOG(SPOCP_INFO) traceLog(LOG_INFO,"Asked to listen on unix domain socket"); if ((srv.listen_fd = spocp_unix_domain_socket(srv.uds)) < 0) exit(1); srv.id = (char *) Malloc(7 + strlen(srv.uds)); /* Flawfinder: ignore */ sprintf(srv.id, "spocp-%s", srv.uds); srv.type = AF_UNIX; } xsignal(SIGCHLD, sig_chld); xsignal(SIGPIPE, sig_pipe); xsignal(SIGINT, sig_int); xsignal(SIGTERM, sig_term); xsignal(SIGUSR1, sig_usr1); clilen = sizeof(cliaddr); DEBUG(SPOCP_DSRV) traceLog(LOG_DEBUG,"Creating threads"); /* * returns the pool the threads are picking work from */ srv.work = tpool_init(srv.threads, 64, 1); spocp_srv_run(&srv); } else { conn_t *conn; saci_init(); DEBUG(SPOCP_DSRV) traceLog(LOG_DEBUG,"---->"); LOG(SPOCP_INFO) traceLog(LOG_INFO,"Reading STDIN"); /* * If I want to use this I have to do init_server() first * conn = spocp_open_connection( STDIN_FILENO, &srv ) ; */ /* * this is much simpler */ conn = conn_new(); conn_setup(conn, &srv, STDIN_FILENO, "localhost", "127.0.0.1"); LOG(SPOCP_INFO) traceLog(LOG_INFO,"Running server"); spocp_server((void *) conn); gettimeofday(&end, NULL); print_elapsed("query time:", start, end); conn_free( conn ); } srv_free( &srv ); if (cnfg != DEF_CNFG) Free( cnfg ); exit(0); }
void render_group_symbolizer(group_symbolizer const& sym, feature_impl & feature, attributes const& vars, proj_transform const& prj_trans, box2d<double> const& clipping_extent, renderer_common & common, render_thunk_list_dispatch & render_thunks) { // find all column names referenced in the group rules and symbolizers std::set<std::string> columns; group_attribute_collector column_collector(columns, false); column_collector(sym); auto props = get<group_symbolizer_properties_ptr>(sym, keys::group_properties); // create a new context for the sub features of this group context_ptr sub_feature_ctx = std::make_shared<mapnik::context_type>(); // populate new context with column names referenced in the group rules and symbolizers for (auto const& col_name : columns) { sub_feature_ctx->push(col_name); } // keep track of the sub features that we'll want to symbolize // along with the group rules that they matched std::vector< std::pair<group_rule_ptr, feature_ptr> > matches; // create a copied 'virtual' common renderer for processing sub feature symbolizers // create an empty detector for it, so we are sure we won't hit anything virtual_renderer_common virtual_renderer(common); // keep track of which lists of render thunks correspond to // entries in the group_layout_manager. std::list<render_thunk_list> layout_thunks; // layout manager to store and arrange bboxes of matched features group_layout_manager layout_manager(props->get_layout()); layout_manager.set_input_origin(common.width_ * 0.5, common.height_ * 0.5); // run feature or sub feature through the group rules & symbolizers // for each index value in the range value_integer start = get<value_integer>(sym, keys::start_column); value_integer end = start + get<value_integer>(sym, keys::num_columns); for (value_integer col_idx = start; col_idx < end; ++col_idx) { // create sub feature with indexed column values feature_ptr sub_feature = feature_factory::create(sub_feature_ctx, col_idx); // copy the necessary columns to sub feature for(auto const& col_name : columns) { if (col_name.find('%') != std::string::npos) { if (col_name.size() == 1) { // column name is '%' by itself, so give the index as the value sub_feature->put(col_name, col_idx); } else { // indexed column std::string col_idx_str; if (mapnik::util::to_string(col_idx_str,col_idx)) { std::string col_idx_name = col_name; boost::replace_all(col_idx_name, "%", col_idx_str); sub_feature->put(col_name, feature.get(col_idx_name)); } } } else { // non-indexed column sub_feature->put(col_name, feature.get(col_name)); } } // add a single point geometry at pixel origin double x = common.width_ / 2.0, y = common.height_ / 2.0, z = 0.0; common.t_.backward(&x, &y); prj_trans.forward(x, y, z); // note that we choose a point in the middle of the screen to // try to ensure that we don't get edge artefacts due to any // symbolizers with avoid-edges set: only the avoid-edges of // the group symbolizer itself should matter. geometry::point<double> origin_pt(x,y); sub_feature->set_geometry(origin_pt); // get the layout for this set of properties for (auto const& rule : props->get_rules()) { if (util::apply_visitor(evaluate<feature_impl,value_type,attributes>(*sub_feature,common.vars_), *(rule->get_filter())).to_bool()) { // add matched rule and feature to the list of things to draw matches.emplace_back(rule, sub_feature); // construct a bounding box around all symbolizers for the matched rule box2d<double> bounds; render_thunk_list thunks; render_thunk_extractor extractor(bounds, thunks, *sub_feature, common.vars_, prj_trans, virtual_renderer, clipping_extent); for (auto const& _sym : *rule) { // TODO: construct layout and obtain bounding box util::apply_visitor(extractor, _sym); } // add the bounding box to the layout manager layout_manager.add_member_bound_box(bounds); layout_thunks.emplace_back(std::move(thunks)); break; } } } // create a symbolizer helper std::list<box_element> box_elements; for (size_t i = 0; i < matches.size(); ++i) { group_rule_ptr match_rule = matches[i].first; feature_ptr match_feature = matches[i].second; value_unicode_string rpt_key_value = ""; // get repeat key from matched group rule expression_ptr rpt_key_expr = match_rule->get_repeat_key(); // if no repeat key was defined, use default from group symbolizer if (!rpt_key_expr) { rpt_key_expr = get<expression_ptr>(sym, keys::repeat_key); } // evaluate the repeat key with the matched sub feature if we have one if (rpt_key_expr) { rpt_key_value = util::apply_visitor( evaluate<feature_impl,value_type,attributes>(*match_feature,common.vars_), *rpt_key_expr).to_unicode(); } box_elements.emplace_back(layout_manager.offset_box_at(i), rpt_key_value); } agg::trans_affine tr; auto transform = get_optional<transform_type>(sym, keys::geometry_transform); if (transform) { evaluate_transform(tr, feature, common.vars_, *transform, common.scale_factor_); } label_placement::placement_params params { prj_trans, common.t_, tr, sym, feature, vars, box2d<double>(0, 0, common.width_, common.height_), common.query_extent_, common.scale_factor_, common.symbol_cache_ }; using traits = label_placement::group_symbolizer_traits; text_placement_info_ptr placement_info = mapnik::get<text_placements_ptr>( sym, keys::text_placements_)->get_placement_info(common.scale_factor_, feature, vars, common.symbol_cache_); group_layout_generator layout_generator(params, *common.detector_, common.font_manager_, *placement_info, box_elements); const label_placement_enum placement_type = layout_generator.get_text_props().label_placement; label_placement::finder<traits>::apply(placement_type, layout_generator, params); for (pixel_position const& pos : layout_generator.placements_) { size_t layout_i = 0; for (auto const& thunks : layout_thunks) { pixel_position const& offset = layout_manager.offset_at(layout_i); pixel_position render_offset = pos + offset; render_thunks.render_list(thunks, render_offset); ++layout_i; } } }