int main(int , char** argv)
{
Tr tr;
C2T3 c2t3(tr);
std::ifstream ifs(argv[1]);
if( !ifs )
{
std::cerr << "Usage:\n"
<< " " << argv[0] << " FILE\n"
<< "\n"
<< " FILE must be " << format_cgal_description
<< "\n";
return EXIT_FAILURE;
}
std::cout << " Reading " << argv[1] << std::endl;
if( CGAL::Mesh_3::input_mesh(ifs, c2t3,
true,
&std::cerr) )
// if( CGAL::input_pslg_from_medit(ifs,
// c2t3,
// true, // debug
// &std::cout) ) // debug to cout
{
display_faces_counts(tr, " ", &std::cout);
std::cout << "\n Statistics:\n";
std::cout << "(vertices)\n";
display_vertices_by_surface_indices_statistics(tr, " ", &std::cout);
std::cout << "(facets)\n";
display_facets_by_surface_indices_statistics(c2t3, " ", &std::cout);
Compute_min_angle<Tr> min_angle(tr);
double min = 180;
for(Tr::Finite_cells_iterator cit = tr.finite_cells_begin();
cit != tr.finite_cells_end();
++cit)
if(cit->is_in_domain())
{
const double angle = min_angle(cit);
if( angle < min ) min = angle;
}
std::cout << "\nmin angle: " << min << "\n";
return EXIT_SUCCESS;
}
else
return EXIT_FAILURE;
}
void LayerTriangulation::triangulate1(int layer0, int layer1, const std::vector<Point2D> &points)
{
std::vector<int> &idx0 = layers[layer0];
std::vector<int> &idx1 = layers[layer1];
int point0 = lowest[layer0], point1 = 0;
real min_dist = distance(points[idx0[point0]], points[idx1[point1]]);
for (int index = 1; index < idx1.size(); ++index) {
real dist = distance(points[idx0[point0]], points[idx1[index]]);
if (dist < min_dist) {
point1 = index;
min_dist = dist;
}
}
int end0 = point0, end1 = point1;
do {
edges.push_back(std::make_pair(idx0[point0], idx1[point1]));
int next0 = (point0 + 1) % idx0.size(), next1 = (point1 + 1) % idx1.size();
if ((point0 == end0 && next1 == end1 && idx1.size() > 1) || (point1 == end1 && next0 == end0))
break;
if (!is_ccw(points[idx0[point0]], points[idx1[point1]], points[idx1[next1]])) {
// Check if we can build next triangle
if (!is_ccw(points[idx0[next0]], points[idx1[point1]], points[idx1[next1]])) {
// Check triangle with minimum angle
real angle0 = std::min(min_angle(points[idx0[point0]], points[idx1[point1]], points[idx1[next1]]),
min_angle(points[idx0[point0]], points[idx1[next1]], points[idx0[next0]]));
real angle1 = std::min(min_angle(points[idx0[point0]], points[idx0[next0]], points[idx1[point1]]),
min_angle(points[idx0[next0]], points[idx1[next1]], points[idx1[point1]]));
if (angle0 > angle1) {
point1 = next1;
} else {
point0 = next0;
}
} else {
point1 = next1;
}
} else {
point0 = next0;
}
} while (point0 != end0 || point1 != end1);
}
void ai_easy(unit local_bot, int map_layout[MAX_X][MAX_Y])
{
int mini_angle = min_angle(local_bot);//searching for minimal angle
int maxi_angle = 90;
int ai_shoot_angle;
while(true)
{
ai_shoot_angle = find_random(mini_angle,maxi_angle);
if(player.x > local_bot.x)ai_shoot_angle = 180 - ai_shoot_angle;
//if(raycast(local_bot, ai_shoot_angle, map_layout[MAX_X][MAX_Y]) == false)break;
}
int ai_shoot_power = find_random(1,100);
//printf("ai_shoot angle = %d ai_shoot_power = %d",ai_shoot_angle,ai_shoot_power );
//in easy AI, shoot angle and shoot velocity (power) is random
//take_a_shot(bot.x,bot.y,ai_shoot_angle,ai_shoot_power);
//we are waiting for complex function which take a shoot from given arguments like coords of unit, angle and power of the shoot
//testShot(ENEMY, ai_shoot_power, ai_shoot_angle, local_bot.x, local_bot.y);
missile_data *missile;
missile = initializeMissile(local_bot.x, local_bot.y);
playerShot(missile, ai_shoot_power, ai_shoot_angle, map_layout);
}
typename viennagrid::result_of::coord<ElementT>::type skewness_impl(ElementT const & element, NumericLimitsT, viennagrid::triangle_tag)
{
typedef typename viennagrid::result_of::point<ElementT>::type PointType;
typedef typename viennagrid::result_of::coord<PointType>::type NumericType;
NumericType max_angle_ = max_angle(element);
NumericType min_angle_ = min_angle(element);
NumericType equi_angle_ = M_PI/3;
return std::max((max_angle_ - equi_angle_)/(2 * M_PI/3), (equi_angle_ - min_angle_)/equi_angle_);
}
