Пример #1
0
int Mv_management::get_dir(int i)
{
    if (data->vcEvents[i].vcPage[0].Movement_type==0)//do not move
        return(5);
    if (data->vcEvents[i].vcPage[0].Movement_type==1)// random
    {
        return(random_move( i));
    }
    if (data->vcEvents[i].vcPage[0].Movement_type==2)// up down
    {
        return(up_down(i));
    }
    if (data->vcEvents[i].vcPage[0].Movement_type==3)// left right
    {
        return(left_right(i));
    }
    if (data->vcEvents[i].vcPage[0].Movement_type==4)// go to the hero
    {
        return(to_hero(i));
    }
    if (data->vcEvents[i].vcPage[0].Movement_type==5)// run frome the hero
    {
        return(escape_hero(i));
    }
    if (data->vcEvents[i].vcPage[0].Movement_type==6)// use the stack
    {
     return(custom(i));
    }

    return(5);
}
Пример #2
0
counter move_one_polyhedron(int id, polyhedron *p, int N, const double periodic[3],
                         const double walls[3], bool real_walls, double neighborR,
                        double dist, double angwidth, int max_neighbors, double dr) {
  const double len[3] = {periodic[0]+walls[0], periodic[1]+walls[1], periodic[2]+walls[2]};
  polyhedron temp = random_move(p[id], dist, angwidth, len);
  counter move;
  move.totalmoves ++;
  if (in_cell(temp, walls, real_walls)) {
    bool overlaps = overlaps_with_any(temp, p, periodic);
    if (!overlaps) {
      const bool get_new_neighbors =
        (periodic_diff(temp.pos, temp.neighbor_center, periodic).normsquared() >
         sqr(neighborR/2.0));
      if (get_new_neighbors) {
        // If we've moved too far, then the overlap test may have given a false
        // negative. So we'll find our new neighbors, and check against them.
        // If we still don't overlap, then we'll have to update the tables
        // of our neighbors that have changed.
        temp.neighbors = new int[max_neighbors];
        update_neighbors(temp, id, p, N, neighborR + 2*dr, periodic);
        move.updates ++;
        // However, for this check (and this check only), we don't need to
        // look at all of our neighbors, only our new ones.
        // fixme: do this!
        //int *new_neighbors = new int[max_neighbors];

        overlaps = overlaps_with_any(temp, p, periodic);
        if (!overlaps) {
          // Okay, we've checked twice, just like Santa Clause, so we're definitely
          // keeping this move and need to tell our neighbors where we are now.
          temp.neighbor_center = temp.pos;
          inform_neighbors(temp, p[id], id, p);
          move.informs ++;
          delete[] p[id].neighbors;
        }
        else delete[] temp.neighbors;
      }
      if (!overlaps) {
        p[id] = temp;
        move.workingmoves ++; // move sucessful
        return move;
      }
    }
  }
  return move; // move unsucessful
}
Пример #3
0
int main()
{
   int board[BOARD_SIZE_HORIZ][BOARD_SIZE_VERT] = { {0} };
   int player_num, computer_num;
   int last_move; 


   /* Ask Alice if she wants to go first */
   player_num = print_welcome();
   if (player_num == 1) computer_num = 2;
   else computer_num = 1;

   /* If Alice wants to go first, let her make a move */
   if (player_num == 1)
   {
      display_board(board);
      last_move = player_move(board,player_num);
      display_board(board);
   }


   /* The main loop */
   
   while (1)
   {
      /* Make a computer move, then display the board */
      last_move = random_move(board,computer_num);
      printf("Computer moved in column: %d\n", last_move);
      display_board(board);

      /* Check whether the computer has won */
      if (check_win_or_tie(board,last_move)) return 0;


      /* Let Alice make a move, then display the board */
      last_move = player_move(board,player_num);
      display_board(board);

      /* Check whether Alice has won */
      if (check_win_or_tie(board,last_move)) return 0;


   } /* end of while (1) */

} /* end of main() */
Пример #4
0
int do_train(string arg)
{
	object me, where;
	me=this_player();
	where=environment(me);
/*
	if( where->query("no_fight") )
		return notify_fail("安全区内不能训兽!\n");
*/
	if( !arg )
		return notify_fail("你要驯服什么?\n");
	if( arg != (string)this_object()->query("id") )
		return notify_fail("你要驯服什么?\n");
	if( this_object()->query_temp("rider") )
		return notify_fail("这匹坐骑上已经有人了。\n");
	if( (string)this_object()->query("owner")==(string)me->query("id") )
		return notify_fail("这匹坐骑已经是你的了。\n");
	if( this_object()->is_fighting() )
		return notify_fail("这匹坐骑已经分身不暇了。\n");
	if( !living(this_object()) )
		return notify_fail("现在耍什么威风?\n");
	if( where->query("no_fight") ) {
		random_move();
		return 1;
	}


	message_vision(HIM"$N冲上前去和$n扭打成一团。\n"NOR, me, this_object());

       	this_object()->set_temp("owner",me->query("id"));
	reset_status();
	this_object()->kill_ob(me);
	me->fight_ob(this_object());

	return 1;
}
Пример #5
0
static inline void
filter (void)
{
  static void (* overlap)(guchar *, const guchar *);
  GimpPixelRgn  src;
  GimpPixelRgn  dst;
  GimpRGB       color;
  guchar     pixel[4];
  gint       division_x;
  gint       division_y;
  gint       offset_x;
  gint       offset_y;
  Tile      *tiles;
  gint       numof_tiles;
  Tile      *t;
  gint       i;
  gint       x;
  gint       y;
  gint       move_max_pixels;
  gint       clear_x0;
  gint       clear_y0;
  gint       clear_x1;
  gint       clear_y1;
  gint       clear_width;
  gint       clear_height;
  guchar    *pixels;
  guchar    *buffer;
  gint       dindex;
  gint       sindex;
  gint       px, py;
  GRand     *gr;

  gr = g_rand_new ();

  /* INITIALIZE */
  gimp_pixel_rgn_init (&src, p.drawable, 0, 0,
                       p.drawable->width, p.drawable->height, FALSE, FALSE);
  gimp_pixel_rgn_init (&dst, p.drawable, 0, 0,
                       p.drawable->width, p.drawable->height, TRUE, TRUE);
  pixels = g_new (guchar,
                  p.drawable->bpp * p.drawable->width * p.drawable->height);
  buffer = g_new (guchar,
                  p.drawable->bpp * p.params.tile_width * p.params.tile_height);

  overlap = p.drawable_has_alpha ? overlap_RGBA : overlap_RGB;

  gimp_progress_init (_("Paper Tile"));

  gimp_drawable_mask_bounds (p.drawable->drawable_id,
                             &p.selection.x0, &p.selection.y0,
                             &p.selection.x1, &p.selection.y1);
  p.selection.width  = p.selection.x1 - p.selection.x0;
  p.selection.height = p.selection.y1 - p.selection.y0;

  gimp_tile_cache_ntiles (2 * (p.selection.width / gimp_tile_width () + 1));

  /* TILES */
  division_x = p.params.division_x;
  division_y = p.params.division_y;
  if (p.params.fractional_type == FRACTIONAL_TYPE_FORCE)
    {
      if (0 < p.drawable->width  % p.params.tile_width) division_x++;
      if (0 < p.drawable->height % p.params.tile_height) division_y++;
      if (p.params.centering)
        {
          if (1 < p.drawable->width % p.params.tile_width)
            {
              division_x++;
              offset_x =
                (p.drawable->width % p.params.tile_width) / 2 -
                p.params.tile_width;
            }
          else
            {
              offset_x = 0;
            }

          if (1 < p.drawable->height % p.params.tile_height)
            {
              division_y++;
              offset_y =
                (p.drawable->height % p.params.tile_height) / 2 -
                p.params.tile_height;
            }
          else
            {
              offset_y = 0;
            }
        }
      else
        {
          offset_x = 0;
          offset_y = 0;
        }
    }
  else
    {
      if (p.params.centering)
        {
          offset_x = (p.drawable->width  % p.params.tile_width) / 2;
          offset_y = (p.drawable->height % p.params.tile_height) / 2;
        }
      else
        {
          offset_x = 0;
          offset_y = 0;
        }
    }

  move_max_pixels = p.params.move_max_rate * p.params.tile_width / 100.0;
  numof_tiles = division_x * division_y;
  t = tiles = g_new(Tile, numof_tiles);

  for (y = 0; y < division_y; y++)
    {
      gint srcy = offset_y + p.params.tile_height * y;

      for (x = 0; x < division_x; x++, t++)
        {
          gint srcx = offset_x + p.params.tile_width * x;

          if (srcx < 0)
            {
              t->x     = 0;
              t->width = srcx + p.params.tile_width;
            }
          else if (srcx + p.params.tile_width < p.drawable->width)
            {
              t->x     = srcx;
              t->width = p.params.tile_width;
            }
          else
            {
              t->x     = srcx;
              t->width = p.drawable->width - srcx;
            }

          if (srcy < 0)
            {
              t->y      = 0;
              t->height = srcy + p.params.tile_height;
            }
          else if (srcy + p.params.tile_height < p.drawable->height)
            {
              t->y      = srcy;
              t->height = p.params.tile_height;
            }
          else
            {
              t->y      = srcy;
              t->height = p.drawable->height - srcy;
            }

          t->z = g_rand_int (gr);
          random_move (&t->move_x, &t->move_y, move_max_pixels);
        }
    }

  qsort (tiles, numof_tiles, sizeof *tiles, tile_compare);

  gimp_pixel_rgn_get_rect (&src, pixels, 0, 0, p.drawable->width,
                           p.drawable->height);

  if (p.params.fractional_type == FRACTIONAL_TYPE_IGNORE)
    {
      clear_x0     = offset_x;
      clear_y0     = offset_y;
      clear_width  = p.params.tile_width * division_x;
      clear_height = p.params.tile_height * division_y;
    }
  else
    {
      clear_x0     = 0;
      clear_y0     = 0;
      clear_width  = p.drawable->width;
      clear_height = p.drawable->height;
    }

  clear_x1 = clear_x0 + clear_width;
  clear_y1 = clear_y0 + clear_height;

  switch (p.params.background_type)
    {
    case BACKGROUND_TYPE_TRANSPARENT:
      for (y = clear_y0; y < clear_y1; y++)
        {
          for (x = clear_x0; x < clear_x1; x++)
            {
              dindex = p.drawable->bpp * (p.drawable->width * y + x);
              for (i = 0; i < p.drawable->bpp; i++)
                {
                  pixels[dindex+i] = 0;
                }
            }
        }
      break;

    case BACKGROUND_TYPE_INVERTED:
      for (y = clear_y0; y < clear_y1; y++)
        {
          for (x = clear_x0; x < clear_x1; x++)
            {
              dindex = p.drawable->bpp * (p.drawable->width * y + x);
              pixels[dindex+0] = 255 - pixels[dindex+0];
              pixels[dindex+1] = 255 - pixels[dindex+1];
              pixels[dindex+2] = 255 - pixels[dindex+2];
            }
        }
      break;

    case BACKGROUND_TYPE_IMAGE:
      break;

    case BACKGROUND_TYPE_FOREGROUND:
      gimp_context_get_foreground (&color);
      gimp_rgb_get_uchar (&color, &pixel[0], &pixel[1], &pixel[2]);
      pixel[3] = 255;
      for (y = clear_y0; y < clear_y1; y++)
        {
          for (x = clear_x0; x < clear_x1; x++)
            {
              dindex = p.drawable->bpp * (p.drawable->width * y + x);
              for (i = 0; i < p.drawable->bpp; i++)
                {
                  pixels[dindex+i] = pixel[i];
                }
            }
        }
      break;

    case BACKGROUND_TYPE_BACKGROUND:
      gimp_context_get_background (&color);
      gimp_rgb_get_uchar (&color, &pixel[0], &pixel[1], &pixel[2]);
      pixel[3] = 255;
      for (y = clear_y0; y < clear_y1; y++)
        {
          for (x = clear_x0; x < clear_x1; x++)
            {
              dindex = p.drawable->bpp * (p.drawable->width * y + x);
              for(i = 0; i < p.drawable->bpp; i++)
                {
                  pixels[dindex+i] = pixel[i];
                }
            }
        }
      break;

    case BACKGROUND_TYPE_COLOR:
      gimp_rgba_get_uchar (&p.params.background_color,
                           pixel, pixel + 1, pixel + 2, pixel + 3);
      for (y = clear_y0; y < clear_y1; y++)
        {
          for (x = clear_x0; x < clear_x1; x++)
            {
              dindex = p.drawable->bpp * (p.drawable->width * y + x);
              for(i = 0; i < p.drawable->bpp; i++)
                {
                  pixels[dindex+i] = pixel[i];
                }
            }
        }
      break;
    }

  /* DRAW */
  for (t = tiles, i = 0; i < numof_tiles; i++, t++)
    {
      gint x0 = t->x + t->move_x;
      gint y0 = t->y + t->move_y;

      gimp_pixel_rgn_get_rect (&src, buffer, t->x, t->y, t->width, t->height);

      for (y = 0; y < t->height; y++)
        {
          py = y0 + y;
          for (x = 0; x < t->width; x++)
            {
              px = x0 + x;
              sindex = p.drawable->bpp * (t->width * y + x);
              if (0 <= px && px < p.drawable->width &&
                  0 <= py && py < p.drawable->height)
                {
                  dindex = p.drawable->bpp * (p.drawable->width * py + px);
                  overlap(&pixels[dindex], &buffer[sindex]);
                }
              else if (p.params.wrap_around)
                {
                  px = (px + p.drawable->width)  % p.drawable->width;
                  py = (py + p.drawable->height) % p.drawable->height;
                  dindex = p.drawable->bpp * (p.drawable->width * py + px);
                  overlap(&pixels[dindex], &buffer[sindex]);
                }
            }
        }

      gimp_progress_update ((gdouble) i / (gdouble) numof_tiles);
    }

  gimp_pixel_rgn_set_rect (&dst, pixels, 0, 0, p.drawable->width,
                           p.drawable->height);

  gimp_progress_update (1.0);
  gimp_drawable_flush (p.drawable);
  gimp_drawable_merge_shadow (p.drawable->drawable_id, TRUE);
  gimp_drawable_update (p.drawable->drawable_id,
                        p.selection.x0, p.selection.y0,
                        p.selection.width, p.selection.height);

  g_rand_free (gr);
  g_free (buffer);
  g_free (pixels);
  g_free (tiles);
}
/*** Main Triangulation Function ***/
int main() 
{
  initialize_api(); // Initializes the robot API
  robot_connect("127.0.0.1"); // This always needs to be 127.0.0.1 to connect to the robot
  
  barcode_configure(2 /*number of digits*/, 10 /*barcodes per pass*/, 2 /*kept passes*/, 
                    2 /*skip pixel width*/, 2 /*min bar width*/, 100 /* Allowed skew */, -1 /*Otsu thresholding*/,
                    image_width /*image width*/, image_height /*image height*/);
  sleep(1);
  
  int** barcodes; // Pointer for a two-dimensional array, will hold returned barcodes
  int* xy; // Pointer to an array [x,y]
  camera_set(CAM_ANGLE); // Sets the tilt on the camera to the current defined camera angle
  
  // Create a thread to handle grabbing images for checking barcodes
  pthread_create(&vision_thread, NULL, barcode_start, NULL);
  
  // The final x and y coordinates of the three barcodes
  double x1,y1,x2,y2,x3,y3;
  x1 = y1 = x2 = y2 = x3 = y3 = 0.0;

  // Grab the current seen barcodes
  barcode_frame_wait(); // Waits for the next frame from the current counter
  barcodes = barcode_get_barcodes(); // Retrieves the barcodes in the 2D array
  
  int num_codes = (int)barcodes[0];  // Number of barcodes detected
  int num_digits = (int)barcodes[1]; // Number of digits per barcode (will be 2)
  printf("Detected %d barcodes %d digits long:\n", num_codes, num_digits);
  
  
  // Find three barcodes if we didn't see three at first 
  while (num_codes < 3) {
    // Code to shutdown when the high bump is pressed. Just in case we never find the cans...
    if (get_high_bump() == 1) {
      free(barcodes);
      robot_stop();
      
      /*** Teardown Code ***/
      vision_running = 0; // Tells the background thread to nicely finish
      pthread_join(vision_thread, NULL); // Waits nicely for the barcode module to shutdown
      shutdown_api(); // Shuts down the robot API
      return 0; // Returns 0
    }
    printf("Didn't see 3 barcodes. Moving to find them...\n\n");
    random_move((int)barcodes[0]);
    free(barcodes);
    sleep(3);
    barcode_frame_wait_start(); // Reset the frame wait counter to wait for next full frame
    barcode_frame_wait(); // Waits for the next frame from the current counter
    barcodes = barcode_get_barcodes(); // Retrieves the barcodes in the 2D array
    
    num_codes = (int)barcodes[0];  // Number of barcodes detected
    num_digits = (int)barcodes[1]; // Number of digits per barcode (will be 2)
    printf("Detected %d barcodes %d digits long:\n", num_codes, num_digits);
  }
    
  int i;
  /* Runs through the barcodes detected, which start at index [2] */
  for(i = 2; i < num_codes+2; i++)
    {
      /* This block converts the raw digits into actual numbers */
      int j;
      uint32_t sum = 0;
      for(j = 0; j < num_digits; j++)
	{
	  sum += barcodes[i][j] * pow(10,(num_digits-1)-j);
	}
      
      /* Get the X and Y positions of the cans relative to the robot */
      xy = barcode_get_cur_xy(sum);
      int bottom_y = convert_camera_y(barcodes[i][j+3]);
      double x_pos = can_xpos(bottom_y);
      double y_pos = can_ypos(x_pos,convert_camera_x(xy[0]));
      
      printf("Barcode: %d\tX_CAM: %d\tY_CAM: %d\n",sum,convert_camera_x(xy[0]),bottom_y);
      printf("X_POS: %f\n",x_pos);
      printf("Y_POS: %f\n",y_pos);
      
      // Save the (x,y) coordinates in the proper variables for use later
      switch(i - 1) {
      case 1:
	x1 = x_pos;
	y1 = y_pos;
	break;
      case 2:
	x2 = x_pos;
	y2 = y_pos;
	break;
      case 3:
	x3 = x_pos;
	y3 = y_pos;
	break;
      default:
	break;
      }    
      
      free(xy);
    }

  // We don't need the camera or barcodes any more, so free them up
  vision_running = 0; // Tells the background thread to nicely finish
  pthread_join(vision_thread, NULL); // Waits nicely for the barcode module to shutdown
  free(barcodes);

  /*** Calculate the centroid, and the distance and angle of rotation to it ***/
  double x_centroid = (x1 + x2 + x3) / 3.0;
  double y_centroid = (y1 + y2 + y3) / 3.0;
  double dist_centroid = sqrt((x_centroid * x_centroid) + (y_centroid * y_centroid));
  int16_t dist_cm = (int16_t) round(dist_centroid);
  double theta_centroid = atan((y_centroid / x_centroid));
  int16_t theta_deg = (int16_t) round(DEG_CONV * (theta_centroid * calculate_error_damp(dist_centroid)));
  printf("\n\nCentroid X: %f\nCentroid Y: %f\nDistance: %f\nAngle: %d\n\n",x_centroid,y_centroid,dist_centroid,theta_deg);

  // Use the distance and angle calculations to set the proper robot turn and move values
  int8_t speed;
  if(theta_deg >= 0){
    speed = ROBOT_SPEED;
  }
  else{ // If the angle is negative, turn clockwise (= negative speed)
    speed = ROBOT_SPEED * (-1);
    theta_deg = theta_deg*(-1); // Angle must be positive for turn_robot_wait()
  }
  printf("Turning by %d degrees\n", theta_deg);
  turn_robot_wait(speed,theta_deg);
  printf("Moving %d cm\n",dist_cm);
  move_distance_wait(ROBOT_SPEED,dist_cm);

  // Make sure the robot has stopped
  robot_stop();

  /*** Teardown Code ***/
  shutdown_api(); // Shuts down the robot API
  return 0; // Returns 0
 }
Пример #7
0
static void
randomize_tiles (GeglProperties      *o,
                 const GeglRectangle *rect,
                 gint                 division_x,
                 gint                 division_y,
                 gint                 offset_x,
                 gint                 offset_y,
                 gint                 n_tiles,
                 Tile                *tiles)
{
  Tile  *t = tiles;
  gint   move_max_pixels = o->move_rate * o->tile_width / 100;
  gint   x;
  gint   y;
  GRand *gr;

  gr = g_rand_new ();

  for (y = 0; y < division_y; y++)
    {
      gint srcy = offset_y + o->tile_height * y;

      for (x = 0; x < division_x; x++, t++)
        {
          gint srcx = offset_x + o->tile_width * x;

          if (srcx < 0)
            {
              t->x     = 0;
              t->width = srcx + o->tile_width;
            }
          else if (srcx + o->tile_width < rect->width)
            {
              t->x     = srcx;
              t->width = o->tile_width;
            }
          else
            {
              t->x     = srcx;
              t->width = rect->width - srcx;
            }

          if (srcy < 0)
            {
              t->y      = 0;
              t->height = srcy + o->tile_height;
            }
          else if (srcy + o->tile_height < rect->height)
            {
              t->y      = srcy;
              t->height = o->tile_height;
            }
          else
            {
              t->y      = srcy;
              t->height = rect->height - srcy;
            }

          t->z = g_rand_int (gr);
          random_move (&t->move_x, &t->move_y, move_max_pixels, gr);
        }
    }

  qsort (tiles, n_tiles, sizeof (*tiles), tile_compare);
}
Пример #8
0
Файл: 2048.c Проект: Frky/2048
int main(void) {
    int dir;
    srand(time(NULL));
    uint8_t nb_empty_box, nb_merge;
#if USE_BIN 
    /* Creation of a grid */
    grid_t grid = create_empty_grid_bin();
    /* Grid backup */
    grid_t saved_grid;
    /* Initialisation of the grid */
    grid = init_grid_bin(grid, &nb_empty_box);
    /* Display the grid */
    display_grid_bin(grid);
    /* Main loop for a game */
    while (nb_empty_box > 0 || merge_possible_bin(grid)) {
        do {
            saved_grid = grid;
            /* While the move does not lead to a change on the grid */
            // dir = random_move();
            dir = best_move_bin(grid, nb_empty_box);
            /* Trying to play the move */
            grid = move_bin(grid, dir, &nb_merge);
            nb_empty_box += nb_merge;
        } while (grid == saved_grid);
        /* Add tile */
        grid = add_tile_bin(grid);
        nb_empty_box--;
        /* Display the new grid */
        display_grid_bin(grid);
        printf("Empty boxes: %u\n", nb_empty_box);
    }
#else
    /* Creation of a grid */
    uint16_t **grid = create_empty_grid();
    /* Initialisation of the grid */
    init_grid(grid);
    /* Display the grid */
    display_grid(grid);
#if DEBUG
    printf("Value: %i\n", evaluate(grid));
#endif
    /* Main loop for a game */
    while (!game_over(grid)) {
        /* While the move does not lead to a change on the grid */
        do {
#if IA
#if RANDOM
            dir = random_move();
#else
            dir = best_move(grid);
#endif
#else
            dir = ask_dir();
#endif
        /* Trying to play the move */
        } while (!move(grid, dir));
        /* Add a new tile at the end of each round */
        add_tile(grid);
        /* Display the new grid */
        display_grid(grid);
#if DEBUG
        printf("Value: %i\n", evaluate(grid));
#endif
    }
#endif
    return 0;
}