Aterrizaje en Marte

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <math.h>       /* asin */

using namespace std;

struct punto {int X;int Y;}; //un punto marciano
struct limites{int max ; int min ; int altura_aterrizaje;}; //Maximos minimos y altura de aproximacion para aterrizar

//pi
# define PI 3.14159265358979323846

//Gravedad MARCIANA
#define GRAVEDAD 3.711

//Angulo bueno entrada en Marte , convertido en grados con 180/PI
#define angulOK (acos(GRAVEDAD/4)*(180/PI))

//Velocidad horizontal maxima 20 , velocidad vertical maxima 40
#define H_VMAX 20
#define V_VMAX 40

int const APROXIMACION_H (200);//Altura de comienzo de aterrizaje
int const TOLERANCIA (5);//Tolerancia velocidades H y V

//*******************************************************************************************
double velocidad (int velHorizontal,int velVertical){//Pitagoras con los dos componentes de la velocidad V y H recupera velocidad
    return sqrt( (velHorizontal*velHorizontal)+(velVertical*velVertical) );
}
//*******************************************************************************************
limites objetivo(vector <punto> &marte){//Analiza la zona plana de aterrizaje 1000 metros, retorna max y min 4000 5500 150
    limites zona({-1,-1,-1});//Zona de aterrizaje max,min,altura_aterrizaje
    punto memoria ({-2,-2});//Memoria punto

    for (auto p:marte){//Recorre los puntos marcianos

        if (memoria.Y == p.Y && zona.max<0){//Esta en una zona plana , no tiene el X comienzo de la zona de aterrriaje
            //Es una zona plana y el inicio no esta asignado
            zona.max=memoria.X;//Si ahora estamos en un punto Y igual al anterior es plano comienza antes la X
            zona.altura_aterrizaje=p.Y;//Recupero la altura de la plataforma de aterrizaje el area de 1000 m.

        }else if ( zona.max>0 && zona.min<0){//El MAXimo de la zona de aterrizaje se ha inicializado el MINinmo No y es zona plana
            zona.min=memoria.X;
        }
        //Memoriza el punto actual de Marte
        memoria.X=p.X;
        memoria.Y=p.Y;
    }

    return zona;//Retorna los limites de la zona de aterrizaje
}
//*******************************************************************************************
string control(vector <punto> &marte,int X,int Y,int hSpeed,int vSpeed){

    int angulo(0),potencia(4);//Angulo y potencia de la nave empieza al MAXIMO potencia 4

    //Recupera la zona de aterrizaje  ver  limites{int max ; int min ; int altura_aterrizaje;}
    limites aterrizaje(objetivo(marte));

    //Estamos encima de la zona de aterrizaje ? aterrizaje.max <---->aterrizaje.min

    if (X>=aterrizaje.max && X<=aterrizaje.min){//Estamos encima de la zona plana de aterrizaje


        if ((aterrizaje.altura_aterrizaje+APROXIMACION_H) > Y ) {//..y a la buena altura para aterrizar

            potencia=3;

        }else if ( abs(hSpeed)<= (H_VMAX -TOLERANCIA)  && abs(vSpeed )<= (V_VMAX -TOLERANCIA) ) { //Velocidad OK

            potencia=2;

        }else{

            angulo=  round (asin (hSpeed/ (velocidad(hSpeed,vSpeed))  )* (180/PI)); //Redondear ....
        }



    } else { //No esta encima de la zona plana  de aterrizaje comprendida entre  (aterrizaje.max <---->aterrizaje.min)

        //Nave fuera de la zona de aterrizaje y con hSpeed diferente de 0 o la velocidad horizontal a MATCH 4 ;)

        //if ( ((X < aterrizaje.max || X >aterrizaje.min) && (hSpeed !=0)) || abs(hSpeed) > (4 * H_VMAX) ) {
        if ( (X<aterrizaje.max && hSpeed<0 )|| (X>aterrizaje.min && hSpeed>0) || abs(hSpeed)>4*H_VMAX ) {

            //hSpeed  rapida ... o en direccion incorrecta  hay que corregir angulo
            angulo = round (asin( hSpeed/velocidad (hSpeed,vSpeed)) * (180/PI)); //Angulo en grados corregido ..

        }else if (abs(hSpeed)<2*H_VMAX) { //hSpeed velocidad Horizontal baja

            //Muy despacio en hSpeed
            if (X < aterrizaje.max){//Esta a la izquierda de la zona de aterrizaje <-------

                angulo=-angulOK;//Un angulo de 21.913245 grados

            }else if ( X > aterrizaje.min){//Esta a la derecha de la zona de aterrizaje

                angulo=angulOK;//Un angulo de 21.913245 grados

            }else{

                angulo=0;
            }

        } else if (vSpeed >=0 ) { //Si la velocidad Vertical es superior o igual a 0
            potencia=3;
        }

    }

    return to_string(angulo) + " " +to_string(potencia);//Angulo potencia
}
//*******************************************************************************************
int main()
{
    vector <punto> marte;//Superficie marciana

    int surfaceN; // Numeros de puntos de la superficie marciana
    cin >> surfaceN; cin.ignore();

    //Superficie marciana , la recupero en un vector de punto
    for (int i = 0; i < surfaceN; i++) {//Modelizacion de la superficie marciana

        int landX; // X coordinate of a surface point. (0 to 6999)
        int landY; // Y coordinate of a surface point. By linking all the points together in a sequential fashion, you form the surface of Mars.
        cin >> landX >> landY; cin.ignore();
        marte.push_back({landX,landY});//Guardo la superficie MARCIANA
    }


    // Bucle principal del juego
    while (1) {
        int X;
        int Y;
        int hSpeed; // the horizontal speed (in m/s), can be negative.
        int vSpeed; // the vertical speed (in m/s), can be negative.
        int fuel; // the quantity of remaining fuel in liters.
        int rotate; // the rotation angle in degrees (-90 to 90).
        int power; // the thrust power (0 to 4).
        cin >> X >> Y >> hSpeed >> vSpeed >> fuel >> rotate >> power; cin.ignore();

        // Write an action using cout. DON'T FORGET THE "<< endl"
        // To debug: cerr << "Debug messages..." << endl;

        // rotate power. rotate is the desired rotation angle. power is the desired thrust power.
       // cout << "-20 3" << endl;
       cout <<control(marte,X,Y,hSpeed,vSpeed)<<endl;
    }
}