/**
* @brief Returns whether the specified point is inside this rectangle.
* @param x x coordinate of the point
* @param y y coordinate of the point
* @return true if the point is in this rectangle
*/
bool Rectangle::contains(int x, int y) const {
return x >= get_x() && x < get_x() + get_width() && y >= get_y() && y < get_y() + get_height();
}
IMPCORE_BEGIN_NAMESPACE
void XYZR::show(std::ostream &out) const {
out << "(" << get_x() << ", " << get_y() << ", " << get_z() << ": "
<< get_radius() << ")";
}
void
update_enemies (void)
{
int i;
for (i = 0; i < NUM_ENEMIES; i++)
{
if (enemies[i].live == 1)
{
enemies[i].location.x += enemies[i].acceleration.x;
enemies[i].location.y += enemies[i].acceleration.y;
if (enemies[i].puller != NULL) //i.e., this enemy ship is being pulled
{
if (enemies[i].puller->live == 0) //The puller is dead; stop following him!
{
enemies[i].acceleration = enemy_random_acceleration ();
}
}
//Unstuck enemies
if(enemies[i].acceleration.x == 0 || enemies[i].acceleration.y == 0)
{
enemies[i].acceleration = enemy_random_acceleration ();
}
//Enemy ship x-axis alignment to the player ship:
if (enemies[i].follow_player == 1)
{
if (enemies[i].location.x > get_x ())
{
if (enemies[i].acceleration.x > 0)
enemies[i].acceleration.x *= -1; //Reverse acceleration.
}
else if (enemies[i].location.x < get_x ())
{
if (enemies[i].acceleration.x < 0)
{
enemies[i].acceleration.x *= -1;
}
}
else if (enemies[i].location.x == get_x ())
{
enemies[i].acceleration.x = 0;
}
}
//Enemy ships can't leave the display
if (enemies[i].location.x > SCREEN_W - ENEMY_W)
{
if (enemies[i].acceleration.x > 0)
enemies[i].acceleration.x *= -1; //Reverse X acceleration
}
if (enemies[i].location.x < 0)
{
if (enemies[i].acceleration.x < 0)
{
enemies[i].acceleration.x *= -1; //Reverse X acceleration
}
}
//Enemy ships can't go too high or too close to the player ship
if (enemies[i].location.y < 0 || enemies[i].location.y > ENEMY_Y_THRESHOLD)
{
enemies[i].acceleration.y *= -1; //Reverse Y acceleration.
}
}
//Cleanup dead enemies
if (enemies[i].health_pts <= 0)
{
enemies[i].live = 0;
}
}
}
/**
* @brief Moves the object.
* @param dx number of pixels of the move on x
* @param dy number of pixels of the move on y
*/
void Movement::translate_xy(int dx, int dy) {
set_xy(get_x() + dx, get_y() + dy);
}
static void train_estimated_velocity_update(int index, DisplayData *data, int velocity) {
if (data->velocity == velocity) return;
data->velocity = velocity;
char command[128];
char *pos = &command[0];
pos += sprintf(pos, "\0337");
int offset = strlen(ESTIMATED_SPEED_STRING);
pos += sprintf(pos, "\033[%u;%uH", get_y(index, TRAIN_ESTIMATED_VELOCITY_HEIGHT), get_x(index) * TRAIN_COLUMN_WIDTH + 1 + offset);
char velocity_buf[TRAIN_COLUMN_WIDTH];
sprintf(velocity_buf, "%dum/tick", velocity);
pos += sputw(pos, TRAIN_COLUMN_WRITABLE_WIDTH - offset, ' ', velocity_buf);
pos += sprintf(pos, "\0338");
Write(COM2, command, pos - command);
}
/**
* \brief Updates the position of the object controlled by this movement.
*
* This function is called repeatedly.
*/
void StraightMovement::update() {
if (!is_suspended()) {
uint32_t now = System::now();
bool x_move_now = x_move != 0 && now >= next_move_date_x;
bool y_move_now = y_move != 0 && now >= next_move_date_y;
while (x_move_now || y_move_now) { // while it's time to move
// save the current coordinates
Rectangle old_xy(get_x(), get_y());
if (x_move_now) {
// it's time to make an x move
if (y_move_now) {
// but it's also time to make a y move
if (next_move_date_x <= next_move_date_y) {
// x move first
update_x();
if (now >= next_move_date_y) {
update_y();
}
}
else {
// y move first
update_y();
if (now >= next_move_date_x) {
update_x();
}
}
}
else {
update_x();
}
}
else {
update_y();
}
if (!is_suspended() && get_entity() != NULL && !finished) {
// the movement was successful if the entity's coordinates have changed
// and the movement was not stopped
bool success = (get_x() != old_xy.get_x() || get_y() != old_xy.get_y())
&& (x_move != 0 || y_move != 0);
if (!success) {
notify_obstacle_reached();
}
}
now = System::now();
if (!finished && max_distance != 0 && Geometry::get_distance(initial_xy.get_x(),
initial_xy.get_y(), get_x(), get_y()) >= max_distance) {
set_finished();
}
else {
x_move_now = x_move != 0 && now >= next_move_date_x;
y_move_now = y_move != 0 && now >= next_move_date_y;
}
}
}
// Do this at last so that Movement::update() knows whether we are finished.
Movement::update();
}
branch_obj *select_branching_object(lp_prob *p, int *cuts)
{
LPdata *lp_data = p->lp_data;
var_desc **vars;
row_data *rows;
int m;
#ifndef MAX_CHILDREN_NUM
int maxnum;
double *objval, *pobj;
int *termcode, *pterm, *feasible, *pfeas, *iterd, *piter;
#ifdef COMPILE_FRAC_BRANCHING
int *frnum, *pfrnum, **frind, **pfrind;
double **frval, **pfrval;
#endif
#endif
int i, j, k, branch_var, branch_row;
double lb, ub, oldobjval;
cut_data *cut;
branch_obj *can, *best_can = NULL;
#ifdef COMPILE_FRAC_BRANCHING
int *xind;
double *xval;
#endif
double *pseudo_costs_zero, *pseudo_costs_one;
/* These are the return values from select_candidates_u() */
int cand_num = 0, new_vars = 0;
branch_obj **candidates = NULL;
#ifdef STATISTICS
int itlim = 0, cnum = 0;
#endif
#if 0
if (p->bc_level == 0){
lp_data->pseudo_costs_zero = (double *) calloc(lp_data->n, DSIZE);
lp_data->pseudo_costs_one = (double *) calloc(lp_data->n, DSIZE);
#if 0
memcpy((char *)pseudo_costs_one, (char *)lp_data->obj, lp_data->n*DSIZE);
memcpy((char *)pseudo_costs_zero,(char *)lp_data->obj, lp_data->n*DSIZE);
#endif
}
pseudo_costs_one = lp_data->pseudo_costs_one;
pseudo_costs_zero = lp_data->pseudo_costs_zero;
#endif
/*------------------------------------------------------------------------*\
* First we call branch_u() to select candidates. It can
* -- return with DO_BRANCH and a bunch of candidates, or
* -- return with DO_NOT_BRANCH along with a bunch of violated cuts
* in the matrix and/or among the slack_cuts, or
* -- return with DO_NOT_BRANCH__FATHOMED, i.e., the node can be fathomed.
\*------------------------------------------------------------------------*/
j = select_candidates_u(p, cuts, &new_vars, &cand_num, &candidates);
switch (j){
case DO_NOT_BRANCH__FATHOMED:
*cuts = -1;
return(NULL);
case DO_NOT_BRANCH:
if (cand_num)
*cuts += add_violated_slacks(p, cand_num, candidates);
#ifdef DO_TESTS
if (*cuts == 0 && new_vars == 0){
printf("Told not to branch, but there are no cuts!\n");
exit(-1);
}
#endif
/* Free the candidates */
if (candidates){
for (i=0; i<cand_num; i++){
free_candidate(candidates + i);
}
FREE(candidates);
}
return(NULL);
case DO_BRANCH:
break;
}
/* OK, now we have to branch. */
/* First of all, send everything to the cutpool that hasn't been sent
before and send the current node description to the TM. */
p->comp_times.strong_branching += used_time(&p->tt);
#pragma omp critical(cut_pool)
send_cuts_to_pool(p, -1);
send_node_desc(p, NODE_BRANCHED_ON);
p->comp_times.communication += used_time(&p->tt);
/* Add all the branching cuts */
if (p->par.branch_on_cuts)
add_slacks_to_matrix(p, cand_num, candidates);
m = lp_data->m;
rows = lp_data->rows;
#ifndef MAX_CHILDREN_NUM
/* The part below is not needed when we have MAX_CHILDREN_NUM specified */
/* Count how many objval/termcode/feasible entry we might need
and allocate space for it */
for (maxnum = candidates[0]->child_num, j=0, i=1; i<cand_num; i++){
if (maxnum < candidates[i]->child_num)
maxnum = candidates[i]->child_num;
}
objval = (double *) malloc(maxnum * DSIZE);
termcode = (int *) malloc(maxnum * ISIZE);
feasible = (int *) malloc(maxnum * ISIZE);
iterd = (int *) malloc(maxnum * ISIZE);
#ifdef COMPILE_FRAC_BRANCHING
frval = (double **) malloc(maxnum * sizeof(double *));
pfrval = (double **) malloc(maxnum * sizeof(double *));
frind = (int **) malloc(maxnum * sizeof(int *));
pfrind = (int **) malloc(maxnum * sizeof(int *));
frnum = (int *) malloc(maxnum * ISIZE);
pfrnum = (int *) malloc(maxnum * ISIZE);
#endif
pobj = (double *) malloc(maxnum * DSIZE);
pterm = (int *) malloc(maxnum * ISIZE);
pfeas = (int *) malloc(maxnum * ISIZE);
piter = (int *) malloc(maxnum * ISIZE);
#endif
/* Set the iteration limit */
if (p->par.max_presolve_iter > 0)
set_itlim(lp_data, p->par.max_presolve_iter);
vars = lp_data->vars;
/* Look at the candidates one-by-one and presolve them. */
oldobjval = lp_data->objval;
for (i=0; i<cand_num; i++){
can = candidates[i];
#ifndef MAX_CHILDREN_NUM
can->objval = pobj;
can->termcode = pterm;
can->feasible = pfeas;
can->iterd = piter;
#ifdef COMPILE_FRAC_BRANCHING
can->frac_num = pfrnum;
can->frac_ind = pfrind;
can->frac_val = pfrval;
#endif
#endif
#ifdef STATISTICS
cnum += can->child_num;
#endif
/* Now depending on the type, adjust ub/lb or rhs/range/sense */
switch (can->type){
case CANDIDATE_VARIABLE:
branch_var = can->position;
if (lp_data->status[branch_var] & PERM_FIXED_TO_LB ||
lp_data->status[branch_var] & PERM_FIXED_TO_UB){
printf("Error -- candidate is fixed. Discarding.\n\n");
continue;
}
#if 0
if (pseudo_costs_one[can->position] ||
pseudo_costs_zero[can->position]){
can->objval[1] = oldobjval + (1 - lp_data->x[can->position]) *
pseudo_costs_one[can->position];
can->objval[0] = oldobjval + lp_data->x[can->position] *
pseudo_costs_zero[can->position];
break;
}
#endif
lb = vars[branch_var]->lb;
ub = vars[branch_var]->ub;
for (j = 0; j < can->child_num; j++){
switch (can->sense[j]){
case 'E':
change_lbub(lp_data, branch_var, can->rhs[j], can->rhs[j]);
break;
case 'R':
change_lbub(lp_data, branch_var, can->rhs[j],
can->rhs[j] + can->range[j]);
break;
case 'L':
change_lbub(lp_data, branch_var, lb, can->rhs[j]);
break;
case 'G':
change_lbub(lp_data, branch_var, can->rhs[j], ub);
break;
}
check_ub(p);
/* The original basis is in lp_data->lpbas */
can->termcode[j] = dual_simplex(lp_data, can->iterd+j);
can->objval[j] = lp_data->objval;
if (can->termcode[j] == LP_OPTIMAL){
/* is_feasible_u() fills up lp_data->x, too!! */
if (is_feasible_u(p) == IP_FEASIBLE){
can->termcode[j] = LP_OPT_FEASIBLE;
/*NOTE: This is confusing but not all that citical...*/
/*The "feasible" field is only filled out for the
purposes of display (in vbctool) to keep track of
where in the tree the feasible solutions were
found. Since this may not be the actual candidate
branched on, we need to pass this info on to whatever
candidate does get branched on so the that the fact that
a feasible solution was found in presolve can be recorded*/
if (best_can)
best_can->feasible[j] = TRUE;
else
can->feasible[j] = TRUE;
}
}
#ifdef COMPILE_FRAC_BRANCHING
else
if (can->termcode[j] != LP_ABANDONED)
get_x(lp_data);
if (can->termcode[j] != LP_ABANDONED){
xind = lp_data->tmp.i1; /* n */
xval = lp_data->tmp.d; /* n */
can->frac_num[j] = collect_fractions(p, lp_data->x, xind, xval);
if (can->frac_num[j] > 0){
can->frac_ind[j] = (int *) malloc(can->frac_num[j] * ISIZE);
can->frac_val[j] = (double *) malloc(can->frac_num[j]*DSIZE);
memcpy(can->frac_ind[j], xind, can->frac_num[j] * ISIZE);
memcpy(can->frac_val[j], xval, can->frac_num[j] * DSIZE);
}
}else{
can->frac_num[j] = 0;
}
#endif
#ifdef STATISTICS
if (can->termcode[j] == LP_D_ITLIM)
itlim++;
#endif
}
change_lbub(lp_data, branch_var, lb, ub);
#if 0
pseudo_costs_one[can->position] =
(can->objval[1] - oldobjval)/lp_data->x[can->position];
pseudo_costs_zero[can->position] =
(can->objval[0] - oldobjval)/lp_data->x[can->position];
#endif
break;
case CANDIDATE_CUT_IN_MATRIX:
branch_row = can->position;
for (j = 0; j < can->child_num; j++){
change_row(lp_data, branch_row,
can->sense[j], can->rhs[j], can->range[j]);
check_ub(p);
/* The original basis is in lp_data->lpbas */
can->termcode[j] = dual_simplex(lp_data, can->iterd+j);
can->objval[j] = lp_data->objval;
if (can->termcode[j] == LP_OPTIMAL){
/* is_feasible_u() fills up lp_data->x, too!! */
if (is_feasible_u(p) == IP_FEASIBLE){
can->termcode[j] = LP_OPT_FEASIBLE;
/*NOTE: This is confusing but not all that citical...*/
/*The "feasible" field is only filled out for the
purposes of display (in vbctool) to keep track of
where in the tree the feasible solutions were
found. Since this may not be the actual candidate
branched on, we need to pass this info on to whatever
candidate does get branched on so the that the fact that
a feasible solution was found in presolve can be recorded*/
if (best_can)
best_can->feasible[j] = TRUE;
else
can->feasible[j] = TRUE;
}
}
#ifdef COMPILE_FRAC_BRANCHING
else
if (can->termcode[j] != LP_ABANDONED)
get_x(lp_data);
if (can->termcode[j] != LP_ABANDONED){
xind = lp_data->tmp.i1; /* n */
xval = lp_data->tmp.d; /* n */
can->frac_num[j] = collect_fractions(p, lp_data->x, xind, xval);
if (can->frac_num[j] > 0){
can->frac_ind[j] = (int *) malloc(can->frac_num[j] * ISIZE);
can->frac_val[j] = (double *) malloc(can->frac_num[j]*DSIZE);
memcpy(can->frac_ind[j], xind, can->frac_num[j] * ISIZE);
memcpy(can->frac_val[j], xval, can->frac_num[j] * DSIZE);
}
}else{
can->frac_num[j] = 0;
}
#endif
#ifdef STATISTICS
if (can->termcode[j] == LP_D_ITLIM)
itlim++;
#endif
}
cut = rows[branch_row].cut;
change_row(lp_data, branch_row, cut->sense, cut->rhs, cut->range);
free_row_set(lp_data, 1, &branch_row);
break;
}
switch ((j = compare_candidates_u(p, oldobjval, best_can, can))){
case FIRST_CANDIDATE_BETTER:
case FIRST_CANDIDATE_BETTER_AND_BRANCH_ON_IT:
free_candidate(candidates + i);
break;
case SECOND_CANDIDATE_BETTER:
case SECOND_CANDIDATE_BETTER_AND_BRANCH_ON_IT:
#ifndef MAX_CHILDREN_NUM
if (best_can == NULL){
pobj = objval;
pterm = termcode;
pfeas = feasible;
piter = iterd;
#ifdef COMPILE_FRAC_BRANCHING
pfrnum = frnum;
pfrind = frind;
pfrval = frval;
#endif
}else{
pobj = best_can->objval;
pterm = best_can->termcode;
pfeas = best_can->feasible;
piter = best_can->iterd;
#ifdef COMPILE_FRAC_BRANCHING
pfrnum = best_can->frac_num;
pfrind = best_can->frac_ind;
pfrval = best_can->frac_val;
#endif
}
#endif
if (best_can){
for (k = can->child_num - 1; k >= 0; k--){
/* Again, this is only for tracking that there was a feasible
solution discovered in presolve for display purposes */
if (best_can->feasible[k])
can->feasible[k] = TRUE;
}
free_candidate(&best_can);
}
best_can = can;
candidates[i] = NULL;
break;
}
if ((j & BRANCH_ON_IT))
break;
}
#ifndef MAX_CHILDREN_NUM
FREE(pobj); FREE(pterm); FREE(pfeas); FREE(piter);
# ifdef COMPILE_FRAC_BRANCHING
FREE(pfrnum); FREE(pfrind); FREE(pfrval);
# endif
#endif
if (p->par.max_presolve_iter > 0)
set_itlim(lp_data, -1);
#ifdef STATISTICS
PRINT(p->par.verbosity, 5,
("Itlim reached %i times out of %i .\n\n", itlim, cnum));
#endif
for (i++; i<cand_num; i++){
/* Free the remaining candidates */
free_candidate(candidates + i);
}
FREE(candidates);
return(best_can);
}
void gaming_print_map(int y,int x)
{
gotoxy(get_x(x),get_y(y) );
printf("%s",get_shape(map[y][x]));
}
const double Point::operator[](int x)
{
if(x==0)
return get_x();
return get_y();
}
int infoGuanacosPatch(){
add_guanacospatch_message(get_x(), get_y(), get_adultos(), get_season());
return 0;
}
Vector
Surface::get_position() const
{
return Vector(get_x(), get_y());
}
inline F64 get_x() const {
return get_x(point.get_X());
};
inline bool is_inside(const Uint16 x, const Uint16 y)
{
return (x >= get_x()) && (y >= get_y()) &&
(x < (get_x() + get_width())) &&
(y< (get_y() + get_height()));
}
double vert(coordinate d, double f, double R, double t, double r, double g){
double s;
double tmp;
double rt = R-t; //안쪽 반지름
char st; //첫 gap(삼각형일때)
double tx1, tx2, ty1, ty2; //임시변수
double th; //각도
double savedx = d.x;
s = 0;
st = 1;
while(d.x*d.x + d.y*d.y < rt*rt){
if((d.y+g)*(d.y+g)+(d.x+g)*(d.x+g) > rt*rt){
if((d.x+g)*(d.x+g)+d.y*d.y > rt*rt){
if(st){
tx1 = get_x(d.y, rt);
ty1 = rt / sqrt(2);
tx2 = get_x(ty1, rt);
th = get_theta(tx1, d.y, tx2, ty1, rt);
tmp = ((ty1 - d.y)*(tx1 - d.x) / 2.0); // 삼각형 면적
tmp += area_arc(th, rt);
st = 0;
}else{
if((d.y+g)*(d.y+g)+d.x*d.x > rt*rt){
tx1 = get_x(d.y, rt);
ty1 = get_y(d.x, rt);
th = get_theta(tx1, d.y, d.x, ty1, rt);
tmp = (tx1-d.x)*(ty1-d.y)/2 + area_arc(th, rt);
}else{
double a1, a2;
tx1 = get_x(d.y, rt);
a1 = (tx1-d.x)*g/2.0;
tx2 = get_x(d.y+g, rt);
a2 = (tx2-d.x)*g/2.0;
tmp = a1+a2;
th = get_theta(tx1, d.y, tx2, d.y+g, rt);
tmp += area_arc(th, rt);
}
}
}else{
if(st){
double a1, a2, a3;
tx1 = d.x+g;
ty2 = rt/sqrt(2.0);
tx2 = get_x(ty2, rt);
ty1 = get_y(tx1, rt);
a1 = (tx2 - d.x)*(ty2-d.y)/2.0;
a2 = (ty1-d.y)*(tx1-tx2);
a3 = (ty2-ty1)*(tx1-tx2)/2.0;
th = get_theta(tx1, ty1, tx2, ty2, rt);
tmp = a1+a2+a3+area_arc(th, rt);
st = 0;
}else{
double a1, a2, a3;
tx1 = d.x+g;
ty1 = get_y(tx1, rt);
ty2 = d.y+g;
tx2 = get_x(ty2, rt);
a1 = (tx2-d.x)*g;
a2 = (ty1-d.y)*(d.x+g-tx2);
a3 = (ty2-ty1)*(tx1-tx2)/2.0;
th = get_theta(tx1, ty1, tx2, ty2, rt);
tmp = a1+a2+a3+area_arc(th, rt);
}
}
} else{
if(st){
tmp = g*g/2.0;
st = 0;
}else{
tmp = g*g;
}
}
d.x += g+2*r;
s += tmp;
}
d.x = savedx;
return s;
}
bool game_over_hr(cgame g) {
return (get_x(g->piece_list[0])==4) && (get_y(g->piece_list[0])==3);
}
int VWindowGUI::translation_event()
{
mwindow->session->vwindow_x = get_x();
mwindow->session->vwindow_y = get_y();
return 0;
}
// @brief Check if the piece p is out of the grid of the game g.
bool out_of_grid(cpiece p, cgame g) {
//used only once but enhances readibility
return (get_x(p)<0||get_x(p)+get_width(p)>game_width(g)||(get_y(p)<0||get_y(p)+get_height(p)>game_height(g)));
}
int main(int argc, char ** argv)
{
if (stdout_is_piped()) // other wise you don't see the seg fault
setup_segfault_handling(argv);
assert_stdin_is_piped();
//assert_stdout_is_piped();
//assert_stdin_or_out_is_piped();
static char clamp_bbox_char[1000] = "";
static int debug = 0;
static double clamp_bbox[4] = {-FLT_MAX, -FLT_MAX, FLT_MAX, FLT_MAX};
int c;
while (1) {
static struct option long_options[] = {
{"bbox", required_argument, 0, 'b'},
{"debug", no_argument, &debug, 1},
{0, 0, 0, 0}
};
int option_index = 0;
c = getopt_long(argc, argv, "b:", long_options, &option_index);
if (c == -1) break;
switch (c) {
case 0: break;
case 'b': strncpy(clamp_bbox_char, optarg, sizeof(clamp_bbox_char)); break;
default: abort();
}
}
if (clamp_bbox_char[0] != 0) {
char * ptr = strtok(clamp_bbox_char, " ,");
if (ptr == NULL) fprintf(stderr, "ERROR: Usage: %s --bbox=\"0,0,1,1\" (min_x,max_x,min_y,max_y)", argv[0]);
clamp_bbox[0] = atof(ptr);
ptr = strtok(NULL, " ,");
if (ptr == NULL) fprintf(stderr, "ERROR: Usage: %s --bbox=\"0,0,1,1\" (min_x,min_y,max_x,max_y)", argv[0]);
clamp_bbox[1] = atof(ptr);
ptr = strtok(NULL, " ,");
if (ptr == NULL) fprintf(stderr, "ERROR: Usage: %s --bbox=\"0,0,1,1\" (min_x,min_y,max_x,max_y)", argv[0]);
clamp_bbox[2] = atof(ptr);
ptr = strtok(NULL, " ,");
if (ptr == NULL) fprintf(stderr, "ERROR: Usage: %s --bbox=\"0,0,1,1\" (min_x,min_y,max_x,max_y)", argv[0]);
clamp_bbox[3] = atof(ptr);
fprintf(stderr, "clamp x,y to: {%f,%f,%f,%f}\n", clamp_bbox[0], clamp_bbox[1], clamp_bbox[2], clamp_bbox[3]);
}
struct Block * block = NULL;
while ((block = read_block(stdin))) {
if (clamp_bbox_char[0] != 0) {
block = add_command(block, argc, argv);
}
double bbox[2][2] = {{FLT_MAX, -FLT_MAX}, {FLT_MAX, -FLT_MAX}};
int i;
for (i = 0 ; i < block->num_rows ; i++) {
double x = get_x(block, i);
double y = get_y(block, i);
if (x < bbox[0][0]) bbox[0][0] = x; if (x > bbox[0][1]) bbox[0][1] = x;
if (y < bbox[1][0]) bbox[1][0] = y; if (y > bbox[1][1]) bbox[1][1] = y;
}
if (clamp_bbox_char[0] != 0) {
double dx = clamp_bbox[0] - clamp_bbox[2];
double dy = clamp_bbox[1] - clamp_bbox[3];
for (i = 0 ; i < block->num_rows ; i++) {
double x = get_x(block, i);
double y = get_y(block, i);
//fprintf(stderr, "%f inside %f,%f (%f), dx = %f\n", x, bbox[0][0], bbox[0][1], ((x-bbox[0][0])/(bbox[0][1]-bbox[0][0])), dx);
//fprintf(stderr, "%f,%f\n", x, y);
set_xy(block, i, ((x-bbox[0][0])/(bbox[0][1]-bbox[0][0]))*dx+clamp_bbox[0], ((y-bbox[1][0])/(bbox[1][1]-bbox[1][0]))*dy+clamp_bbox[1]);
x = get_x(block, i);
y = get_y(block, i);
//fprintf(stderr, "becomes %f,%f\n", x, y);
}
} else {
long * offsets = alloca(sizeof(long)*block->num_columns);
memset(offsets, 0, sizeof(long)*block->num_columns);
int i,j;
for (i = 0 ; i < block->num_columns ; i++)
offsets[i] = get_cell(block, 0, i) - get_row(block, 0);
for (i = 0 ; i < block->num_columns ; i++)
{
struct Column * column = get_column(block, i);
if (column->type == TYPE_INT && column->bsize == 4)
{
int min = *(int*)(get_row(block, 0)+offsets[i]);
int max = min;
for (j = 0 ; j < block->num_rows ; j++)
{
void * row = get_row(block, j);
int value = *(int*)(row+offsets[i]);
if (value > max) max = value;
if (value < min) min = value;
}
fprintf(stderr, "%s: %d to %d\n", column_get_name(column), min, max);
}
else if (column->type == TYPE_INT && column->bsize == 8)
{
long min = *(long*)(get_row(block, 0)+offsets[i]);
long max = min;
for (j = 0 ; j < block->num_rows ; j++)
{
void * row = get_row(block, j);
long value = *(long*)(row+offsets[i]);
if (value > max) max = value;
if (value < min) min = value;
}
fprintf(stderr, "%s: %ld to %ld\n", column_get_name(column), min, max);
}
else if (column->type == TYPE_FLOAT && column->bsize == 4)
{
float min = *(float*)(get_row(block, 0)+offsets[i]);
float max = min;
for (j = 0 ; j < block->num_rows ; j++)
{
void * row = get_row(block, j);
float value = *(float*)(row+offsets[i]);
if (value > max) max = value;
if (value < min) min = value;
}
fprintf(stderr, "%s: %f to %f\n", column_get_name(column), min, max);
}
else if (column->type == TYPE_FLOAT && column->bsize == 8)
{
double min = *(double*)(get_row(block, 0)+offsets[i]);
double max = min;
for (j = 0 ; j < block->num_rows ; j++)
{
void * row = get_row(block, j);
double value = *(double*)(row+offsets[i]);
if (value > max) max = value;
if (value < min) min = value;
}
fprintf(stderr, "%s: %lf to %lf\n", column_get_name(column), min, max);
}
else if (column->type == TYPE_CHAR)
{
int max = 0, count = 0;
for (j = 0 ; j < block->num_rows ; j++)
{
void * row = get_row(block, j);
int value = strlen((char*)(row+offsets[i]));
if (value > max) { max = value; count = 1; }
else if (value == max) count++;
}
fprintf(stderr, "%s: max strlen = %d (field size is %d), %d rows at that length\n", column_get_name(column), max, column->bsize, count);
}
else
fprintf(stderr, "doesn't do %s %d\n", column_get_name(column), column->type);
}
}
if (stdout_is_piped()) {
write_block(stdout, block);
}
free_block(block);
}
}
int Active::get_action_x()
{
return get_x() + action_x;
}
// FUNCTION : generate a public key
//
// Input : username,
// a4, a6 -> elliptic curve constants
// xp, yp -> point's coordinate
// prime field
// passphrase
// Output : file username.pkf which contains all
// of those information
//
// AUTHOR : TH <*****@*****.**>, Jan 2000
//
void gen_pubkey(const char* pkfilename, int blocksize)
{
// declaration of variables
char username[MAX];
point P,H;
bigmod a4,a6,xp,yp;
bigint xdp,ydp,q;
banner();
cout<<"Before you can use encryption/decryption you must generate your public key.";
cout<<"\nThe following process will guide you through generating your public key.";
cout<<"\n\nTo achieve a cryptographically secure elliptic curve cryptosystem, you must ";
cout<<"\nsupply a relatively big prime finite field (q), a good a, b";
cout<<"\nfor elliptic curve equation and a point that lies on the curve.";
//get EC parameters from user
cout<<"\n\nGENERATE PUBLIC KEY\n";
cout<<"-------------------";
cout<<"\nPlease enter your user name : ";cin>>username;
get_ecparm(a4,a6,xp,yp,q);
// EC initialization
P.init_curve(a4,a6);
P.set_point(xp,yp);
if (pkfilename==" ")
pkfilename=PKFILENAME;
// open public key file
FILE* pkfile;
pkfile=fopen(pkfilename,"a+");
if(!pkfile)
{
cout<<"\nAZTECC ERROR : Error writing file ["<<pkfilename<<"]"<<endl;
exit(1);
}
bigint d;
get_passphrase(d,blocksize,username);
// multiply the private key with EC point
mul_point(H,d,P);
// compute hash(d)
char* sd=new char[MAX];
bigint_to_string(d,sd);
char* hash_d=new char[MAX];
hash_d=MD5_hex_digest(sd);
// convert the EC coordinate to string
get_x(xdp,H);
char* sxdp=new char[MAX];
bigint_to_string(xdp,sxdp);
get_y(ydp,H);
char* sydp=new char[MAX];
bigint_to_string(ydp,sydp);
// convert a4, a6, xp, yp to string
char* sa4=new char[MAX];
bigmod_to_string(a4,sa4);
char* sa6=new char[MAX];
bigmod_to_string(a6,sa6);
char* sxp=new char[MAX];
bigmod_to_string(xp,sxp);
char* syp=new char[MAX];
bigmod_to_string(yp,syp);
char* sq=new char[MAX];
bigint_to_string(q,sq);
// save all the info to public key file
fputc('\n',pkfile);
fprintf(pkfile,"%s#%s#%s#%s#%s#%s#%s#%s#%s",username,hash_d,sa4,sa6,sxp,syp,sxdp,sydp,sq);
fclose(pkfile);
cout<<"\nDone saving your public key to ["<<pkfilename<<"]"<<endl;
//cleaning up
delete[] sd;
delete[] sxdp;
delete[] sydp;
delete[] sa4;
delete[] sa6;
delete[] sxp;
delete[] syp;
delete[] sq;
}
/**
* @brief Sets the y position of the object controlled by this movement.
* @param y the new y position
*/
void Movement::set_y(int y) {
set_xy(get_x(), y);
}
//---------------------------------------------------------------------------
int uv_widget::get_absolute_x()
{
if(myparent)
return (myparent->get_absolute_x()+get_x());
return 0;
};
void update_map() {
static U8 ready=FALSE;
static int last_pos_x = 0;
static int last_pos_y = 0;
//Stores the average value of walls
static int count_front_walls = 0;
static int count_left_walls = 0;
static int count_right_walls = 0;
// If not ready (not enough inside the cell), return
if(!ready) {
if(is_inside_square(get_realX(),get_realY(),MAPPING_RES)) ready=TRUE;
return;
}
int pos_x = get_x();
int pos_y = get_y();
// If out of the map, return
if (is_out_of_map(pos_x,pos_y)) return;
U8 data;
// If just enter in a new cell
if ( ( last_pos_y != pos_y ) || ( last_pos_x != pos_x ) ) {
count_front_walls = 0;
count_left_walls = 0;
count_right_walls = 0;
ready=FALSE;
if(pos_x<__min_x) __min_x=pos_x;
else if(pos_x>__max_x) __max_x=pos_x;
if(pos_y<__min_y) __min_y=pos_y;
else if(pos_y>__max_y) __max_y=pos_y;
int direction = direction_of_next_cell(pos_x,pos_y,last_pos_x,last_pos_y);
last_pos_x = pos_x;
last_pos_y = pos_y;
coord_to_table_index(&pos_x,&pos_y);
data = _map[pos_x][pos_y];
if(direction != NO_CARD) {
set_wall_state(&data, direction, NO_WALL);
_map[pos_x][pos_y]=data;
}
return;
}
else {
coord_to_table_index(&pos_x,&pos_y);
data = _map[pos_x][pos_y];
}
int cardinal_point = get_cardinal_point();
// Do measurements only if in a good direction
if(is_cp(cardinal_point)) {
int left_wall = detect_wall(get_distanceL());
int right_wall = detect_wall(get_distanceR());
int front_wall = detect_wall(get_distanceF());
//Add plus one for is wall and substract one for no wall
count_front_walls = front_wall ? count_front_walls + 1 : count_front_walls - 1;
count_left_walls = left_wall ? count_left_walls + 1 : count_left_walls - 1;
count_right_walls = right_wall ? count_right_walls + 1 : count_right_walls - 1;
if(count_front_walls>0) set_wall_state(&data, cardinal_point, IS_WALL);
else set_wall_state(&data, cardinal_point, NO_WALL);
if(count_right_walls>0) set_wall_state(&data, next_cp(cardinal_point), IS_WALL);
else set_wall_state(&data, next_cp(cardinal_point), NO_WALL);
if(count_left_walls>0) set_wall_state(&data, previous_cp(cardinal_point), IS_WALL);
else set_wall_state(&data, previous_cp(cardinal_point), NO_WALL);
}
_map[pos_x][pos_y]=data;
}
void recurssive_define_paths(adjacency_t *adj, int *allowed, int *traversed,
int pos, int size, int offset, int prev)
{
int x, y, top, right, bottom, left, i;
int top_left, top_right, bot_left, bot_right;
int check_top, check_right, check_bot, check_left;
int can_move = 1;
int direction[] = {NORTH, EAST, SOUTH, WEST};
check_top = check_right = check_bot = check_left = 1;
x = get_x(pos, offset);
y = get_y(pos, offset);
if(check_out_of_bounds(x, y, offset, offset))
{
return;
}
if(traversed[pos] == 1)
{
return;
}
top = pos + 1;
bottom = pos - 1;
left = pos - offset;
right = pos + offset;
top_left = pos + 1 - offset;
top_right = pos + 1 + offset;
bot_left = pos - 1 - offset;
bot_right = pos - 1 + offset;
if(y == offset - 1)
{
// upper most cell .`. dont check top
check_top = 0;
check_right = 0;
}
if(y == 0)
{
// lowest most cell .`. dont check bottom
check_bot = 0;
check_left = 0;
}
if(x == 0)
{
// closest cell .`. don't check left
check_top = 0;
check_left = 0;
}
if(x == offset - 1)
{
//furthest most cell .`. don't check right
check_bot = 0;
check_right = 0;
}
if(check_top)
{
check_valid_move(top, top_left, left, allowed, &can_move);
}
if(check_right)
{
check_valid_move(right, top_right, top, allowed, &can_move);
}
if(check_bot)
{
check_valid_move(bottom, bot_right, right, allowed, &can_move);
}
if(check_left)
{
check_valid_move(left, bot_left, bottom, allowed, &can_move);
}
allowed[pos] = can_move;
traversed[pos] = 1;
shuffle_array(direction, 4, prev);
for(i=0; i<4; i++)
{
switch (direction[i])
{
case 0:
recurssive_define_paths(adj, allowed, traversed, top, size, offset, SOUTH);
break;
case 1:
recurssive_define_paths(adj, allowed, traversed, right, size, offset, WEST);
break;
case 2:
recurssive_define_paths(adj, allowed, traversed, bottom, size, offset, NORTH);
break;
case 3:
recurssive_define_paths(adj, allowed, traversed, left, size, offset, EAST);
break;
}
}
}
/**
* \brief Updates the enemy.
*/
void Enemy::update() {
Detector::update();
if (is_suspended() || !is_enabled()) {
return;
}
uint32_t now = System::now();
if (being_hurt) {
// see if we should stop the animation "hurt"
if (now >= stop_hurt_date) {
being_hurt = false;
set_movement_events_enabled(true);
if (life <= 0) {
kill();
}
else if (is_immobilized()) {
clear_movement();
set_animation("immobilized");
notify_immobilized();
}
else {
clear_movement();
restart();
}
}
}
if (life > 0 && invulnerable && now >= vulnerable_again_date && !being_hurt) {
invulnerable = false;
}
if (life > 0 && !can_attack && !is_immobilized()
&& can_attack_again_date != 0 && now >= can_attack_again_date) {
can_attack = true;
}
if (is_immobilized() && !is_killed() && now >= end_shaking_date &&
get_sprite().get_current_animation() == "shaking") {
restart();
}
if (is_immobilized() && !is_killed() && !is_being_hurt() && now >= start_shaking_date &&
get_sprite().get_current_animation() != "shaking") {
end_shaking_date = now + 2000;
set_animation("shaking");
}
if (exploding) {
uint32_t now = System::now();
if (now >= next_explosion_date) {
// create an explosion
Rectangle xy;
xy.set_x(get_top_left_x() + Random::get_number(get_width()));
xy.set_y(get_top_left_y() + Random::get_number(get_height()));
get_entities().add_entity(new Explosion("", LAYER_HIGH, xy, false));
Sound::play("explosion");
next_explosion_date = now + 200;
nb_explosions++;
if (nb_explosions >= 15) {
exploding = false;
}
}
}
if (is_killed() && is_dying_animation_finished()) {
// Create the pickable treasure if any.
get_entities().add_entity(Pickable::create(get_game(),
"", get_layer(), get_x(), get_y(),
treasure, FALLING_HIGH, false));
// Remove the enemy.
remove_from_map();
// Notify Lua that this enemy is dead.
// We need to do this after remove_from_map() so that this enemy is
// considered dead in functions like map:has_entities(prefix).
notify_dead();
}
get_lua_context().entity_on_update(*this);
}
bool TGLobject_FX_explosion2::cycle(VirtualController *k,class TGLmap *map,GLTManager *GLTM,SFXManager *SFXM,int sfx_volume)
{
// Wave
if (m_cycle==0) {
map->insert_auxiliary_front_object(new TGLobject_FX_particle(get_x(),get_y(),0,0,0,0,false,
0.5f,0.5f,
0.5f,0.5f,
1,1,
1,0,m_maxsize/512.0f,m_maxsize/32.0f,m_duration,GLTM->get("objects/ripple-back")));
map->add_auxiliary_front_object(new TGLobject_FX_particle(get_x(),get_y(),0,0,0,0,false,
0.5f,0.5f,
0.5f,0.5f,
1,1,
1,0,m_maxsize/512.0f,m_maxsize/32.0f,m_duration,GLTM->get("objects/ripple-front")));
} // if
// fire:
{
int i;
int range=100;
range=int(m_maxsize/16);
if (range<1) range=1;
for(i=0;i<(m_duration-m_cycle*4);i+=8) {
int r=rand()%range;
int a=rand()%360;
if ((rand()%128)==0) {
map->insert_auxiliary_front_object(new TGLobject_FX_particle(get_x(),get_y(),rand()%360,float(r*cos_degree(a))/16,float(r*sin_degree(a))/16,4,true,
0.5f,0.5f,
0.5f,0.5f,
0.5f,0.5f,
1,0,0.25f,0.35f,m_duration/2,GLTM->get("objects/explosion")));
} else {
if (r<range/2) {
map->add_auxiliary_front_object(new TGLobject_FX_particle(get_x(),get_y(),rand()%360,float(r*cos_degree(a))/32,float(r*sin_degree(a))/32,4,false,
1,1,
1,1,
1,1,
1,0,0.25f,0.35f,m_duration/4,GLTM->get("objects/explosion")));
} else {
map->insert_auxiliary_front_object(new TGLobject_FX_particle(get_x(),get_y(),rand()%360,float(r*cos_degree(a))/32,float(r*sin_degree(a))/32,4,false,
0.5f,0.5f,
0.5f,0.5f,
1,1,
1,0,0.25f,0.35f,m_duration/4,GLTM->get("objects/explosion")));
} // if
} // if
} // for
}
// smoke:
// ...
// particles:
if (m_cycle==0) {
int i;
int range=100;
range=int(m_maxsize);
if (range<1) range=1;
for(i=0;i<m_duration/2;i++) map->add_auxiliary_back_object(new TGLobject_FX_particle(get_x(),get_y(),rand()%60,float((rand()%(range*2+1))-range),float((rand()%(range*2+1))-range),4,true,0.5f,0.5f,0.5f,0.5f,1,1,1.0f,0,0.25f,0.25f,m_duration,GLTM->get("objects/particle1")));
} // if
m_cycle++;
if (m_cycle>m_duration) return false;
return true;
} /* TGLobject_FX_explosion2::cycle */
/*
*--------------------------------------------------------------------------------------
* Class: Point
* Method: set_y
*--------------------------------------------------------------------------------------
*/
void Point::set_y ( uint64_t value ) {
set_xy( get_x(), value ); // there may be faster ways of doing this
} /* ----- end of method Point::set_y ----- */
int ChannelEditWindow::translation_event()
{
channel_picker->mwindow->session->channels_x = get_x();
channel_picker->mwindow->session->channels_y = get_y();
return 0;
}
void Score::draw()
{
if(score_img!=NULL)
SDLW::draw_surf(score_img, Engine::get_buffer(),(int)get_x(),(int)get_y());
}
/**
* @brief Returns the center point of this rectangle
* @return the center point (represented as a zero-sized rectangle)
*/
Rectangle Rectangle::get_center() {
return Rectangle(get_x() + get_width() / 2, get_y() + get_height() / 2);
}