// FICHERO DE INICIALIZACION DE LA IA DEL PCCICLISMO // EL FORMATO ES id = valor, y // AL PRINCIPIO DE LA LINEA // CONSTITUYE UN COMENTARIO // Renombrar a ia+.ini para su uso con Eurotour++ // ///////////////////////////// // // FICHEROS Y CONFIGURACION VARIA // ///////////////////////////// // // usar fichero de grupos (debug) // Si vale 1, la situación de partida de carrera se lee del fichero grupos.ini // En grupos.ini se define la posición y el rol de los ciclistas en carrera use_grupos_file = 0 grupos_file = scripts/grupos.ini // fichero de mensajes // Contiene los mensajes que se muestran en carrera, en la ventana más ancha // Puedes personalizarlo a tu gusto. Cuidado con el formato mensajes_file = scripts/mensajes.ini // Si vale 1, se mostrarán mensajes de estado sobre todos los corredores, no sólo de tu equipo mensajes_todos = 0 // ordenes a todos los equipos o sólo al humano? // Si vale 1, puedes dar órdenes a cualquier ciclista, forzándoles por ejemplo a colaborar, o // a dejar de tirar. Si no se abusa de ello, puede mejorar el realismo order_all = 1 // ///////////////// // // BUFFER IA // ///////////////// // // Ni idea buffer_ia_size = 10; // (10) // /////////////////////////// // // REGISTRO DE TRAZA Y EVENTOS // /////////////////////////// // // Mejor dejarlo todo a cero. log_file = .\ialog.txt log_enabled = 0 // ¿activar trazas? (1) log_mov_info = 0 // registrar informacion de movimiento log_grp_info = 0 // registrar informacion de grupos log_ipos_info = 0 // registrar posiciones ideales solicitadas log_sprint = 0 // registrar resultados de sprints log_fus_sep_grupos = 0 // registrar fusion y separacion de grupos log_estado_fisico = 0 // registrar el estado fisico de los corredores log_llegadas = 0 // registrar pasos por metas // /////////////////////////////// // SUCESOS ////////////////////////////////// // Ni idea sc_file = scripts/sucesos.ini sc_enabled = 0 // ¿activar sucesos especiales? // //////////////////////////////////////// // // GENERACION DE POSICIONES EN LA PANTALLA // //////////////////////////////////////// // // RUIDO // Mejor no tocar estos parámetros. Sirven para controlar la presentación tr_frecuencia_minima = 20 // cada cuanto (ms por frame) como maximo modificamos el ruido tr_incremento_aproximacion = 0.01 // velocidad de aproximacion al ruido desde la posicion actual tr_maximo_modulo = 0.20 // maxima distancia a la posicion ideal (en unidades) // ///////////////////////////////////// // // PARAMETROS GENERALES DE LA SIMULACION // ///////////////////////////////////// // // //////////////////////////// // ADMINISTRADOR DE GRUPOS // //////////////////////////// // Estos parámetros sirven para fijar equiparar la posición de un grupo a un rectángulo // En Eurotour++ no se leen de aquí, si no que están fijados a los siguientes valores gm_frecuencia_chk_rejilla = 50 // en ticks gm_margen_sup_rejilla = 25 // en puntos gm_margen_inf_rejilla = 5 // idem (15) // Estos parámetros controlan las condiciones de fusión de grupos. Eurotour++ tampoco // los lee de aquí, utiliza valores fijos gm_referencia_fusion = 25 // tiempo en ticks para comenzar una fusion (25) gm_alarma_fusion = 15 // distancia en puntos para sincronizar (25) gm_referencia_separacion = 50 // tiempo durante la que forzamos una separacion // /////////////////////////////// // // STATUS PARA ANIMACIONES // /////////////////////////////// // // Aquí se controla qué animaciones se muestran (ascenso, descenso, sprint) en // función de la velocidad, la pendiente y el esfuerzo st_velocidad_normal = 35.0 // en Km/H st_poca_pendiente = 3.5 // en % (6.0) st_mucha_pendiente = 10.0 // en % st_cansado = 50.0 // en % sobre energia total st_mucho_esfuerzo = 80 // en u.esfuerzo. st_inclinacion = 6.0 // escalado de fuerza lateral st_max_inclinacion = 0.55 // en radianes // /////////////////////////////// // // VIGILANTE DE ETAPA // /////////////////////////////// // // Condiciones de salida. No sirven de mucho ve_pos_salida_normal = 200 ve_pos_salida_crono = 0 ve_vel_ini_normal = 10.0 // (5.0) ve_vel_ini_crono = 10.0 // (20.0) ve_int_salida_crono = 1200 // (1200) ve_int_aviso_crono = 1050 // (1050) // /////////////////////////////// // // CICLISTA // /////////////////////////////// // // Tiempo a esperar entre fallos de peticiones al fisico // Ni idea. Influye cuando un corredor está extenuado, pero no sé cómo cl_tiempo_dormir = 2 // influye en la respuesta // ////////////////////////////// // // CEREBRO // ///////////////////////////// // // Ni idea ce_margen_esfuerzo = 20.0 ce_muy_cansado = 90.0 // ////////////////////////////// // // REACCIONES // ///////////////////////////// // // Ni idea rc_margen_esfuerzo = 20.0 rc_muy_cansado = 90.0 // ////////////////////////////// // // ACCIONES // ///////////////////////////// // // RETRASARSE // Controla el tiempo que tarda en quedarse un corredor desde que empieza a // hacerlo. 100 ticks equivale a 10 sg (1 tick es una décima de segundo) // El tiempo que pasa desde que un corredor alcanza la extenuación hasta que // empieza a quedarse no es configurable ar_tiempo_de_espera = 100 // ticks para comenzar a retrasarse (100) ar_tiempo_de_abandonar = 200 // ticks para esperar a los que se quieran pirar (200) // ATACAR // Apenas influye aa_tiempo_espera_c = 2 // ticks para comenzar a atacar // Tiempo en que se determina qué corredores cogen la escapada aa_tiempo_espera_a = 150 // ticks para descartar a los que no puedan // Pues eso aa_muy_cansado = 75.0 // nivel de cansancio para abortar el ataque (70.0) // Cuanto mayor sea, más corredores cojerán la fuga aa_muy_lejos_lider = 24 // lejania del lider del ataque para abortar (20) aa_esfuerzo_objetivo = 89.0 // esfuerzio objetivo al atacar (89.0) // ////////////////////////////// // // ORDENES // ///////////////////////////// // // Autoexplicativos or_distancia_vigilar = 20 (20) or_esfuerzo_vigilar = 80.0 or_distancia_ayudar = 35 (30) or_esfuerzo_ayudar = 85.0 or_espera_retraso = 10 or_abandonar_retraso = 500 or_tirar_esfuerzo = 92.0 // objetivo de esfuerzo al tirar (89.0) or_tirar_cansancio = 90.0 // cansancio para dejar de tirar // ////////////////////////////// // // FISICO // ///////////////////////////// // // TIEMPO DE TRANSICION EN UN MOVIMIENTO // la formula empleada: tiempo = tiempo_base + // (PRIORIDAD_MAXIMA-PRIORIDAD)*multiplicador_prioridad - // velocidadEnKmHora*multiplicador_velocidad + // aleatorio(de 0 a fudge_factor-1) // con un minimo de tiempo minimo // Con estos parámetros se controla la velocidad de los movimientos. // Cuanta mayor sea la prioridad, más rápido // Si se quieren acelerar los movimientos, hay que bajar tiempo_base y multi_velocidad fc_tiempo_base = 8 // en ticks (8) fc_tiempo_minimo = 2 // en ticks (2) fc_multiplicador_prioridad = 1.25 // ticks por nivel de prioridad (1.25) fc_multiplicador_velocidad = 0.10 // ticks por kilometro hora, ¡cuidado con valores altos! (0.10) fc_fudge_factor = 2 // valor aleatorio, en ticks fc_tiempo_liberacion = 1 // n de ticks en liberar la posicion ocupada en caso de moverse fc_tiempo_anti_meneos = 5 // tiempo en permintir moviento contrario al último fc_frecuencia_est_fis = 5 // cada cuanto calculamos el estado fisico (5) // ESTADO FISICO // Parametros que gobiernan el ritmo de gasto de energia del ciclista // No configurable en Eurotour++ fc_energia_escala = 1000.0 // escala de e a reprensentacion interna u.e. // Cuanto mayor sea, más energía perderán los corredores. El valor ideal depende de otros // parámetros, e incluso de la carrera . 0.625 me parece demasiado alto para el Tour, por ejemplo fc_energia_x_tick = 0.495 // gasto de u.e. medio por tick (0.625) fc_energia_poca = 10000.0 // u.e. minimas (10 energia) fc_energia_minima = 500.0 // u.e. minimas (0.5 energia) // Nivel de cansancio a partir del que baja el esfuerzo máximo. El esfuerzo máximo se calcula fc_cansancio_cansado = 0.4 // (0.5) // En extenuación, el corredor empieza el proceso de quedarse, que tarda unos dos minutos // en pelotón y 30 sg en un grupo de escapados // Cualquier valor por encima de 0.95 está bien fc_cansancio_extenuacion = 0.95 // cansancio que se considera extenuacion (tanto por uno) (0.95) // No vale la pena modificarlo fc_delta_esfuerzo = 2.5 // variacion maxima del esfuerzo por actualizacion // Esfuerzo a partir del que se acumula cansancio fc_esfuerzo_alto = 80.0 // (80.0) // Esfuerzo al que corresponde la velocidad normal // Entre el esfuerzo normal y el alto, a mayor esfuerzo, menor recuperación // Por debajo de este esfuerzo, la recuperación de cansancio no aumenta // Cuanto menor sea, menos se recuperan los ciclistas, y más rápido irán fc_esfuerzo_normal = 55.0 // esfuerzo normal del ciclista (70.0) // Esfuerzo para que la velocidad sea del 50% (en Eurotour++ no se usa) fc_esfuerzo_bajo = 30.0 // esfuerzo muy bajo del ciclista (30.0) fc_esfuerzo_bajo = 30.0 // esfuerzo muy bajo del ciclista (30.0) // Creo que no sirve para nada fc_esfuerzo_extenuacion = 64.0 // esfuerzo objetivo maximo en caso de extenuacion (60.0) // Por encima del umbral, el cansancio crece de forma acelerada. fc_umbral_anaerobico = 93 // % de esfuerzo a partir del cual (90) // Cansancio acumulado a esfuerzo = 100. Recomiendo reducirlo // 0.15 corresponde a 1.5 unidades por segundo, es decir, en un minuto el cansancio sube a 90 fc_g_max = 0.15 // acumulación máxima de cansancio por tick, en energia (0.25) // Cansancio acumulado a esfuerzo = umbral (y recuperado a esfuerzo = esfuerzo_normal) // Cuanto mayor sea la forma, se acumula menos cansancio y la recuperación es mayor // Recomiendo aumentarlo fc_g_normal = 0.02 // acumulación normal de cansancio por tick (0.005) // Controla las retiradas fc_maximo_gasto_forma = 10 // maximo de p.f. que perdemos antes de retirarnos fc_km_meta_llegar_siempre = 8 // si queda solo esto, siempre llegamos // Parametro nuevo en Eurotour++ // Determina la influencia de la forma. Cuanto mayor sea, menor es la influencia fc_forma_div_bonus = 1.7 // divisor del bonus/malus por forma // Parametro no usado en Eurotour++ // Determina la influencia de la moral. Cuanto mayor sea, menor es la influencia fc_moral_div_bonus = 5.0 // divisor del bonus/malus por motivacion // Estos tres parámetros controlan el esfuerzo máximo cuando un ciclista está cansado // Es importante que fc_cansancio_cansado sea 0.4. Si es mayor habría que bajar este parámetro // Por ejemplo, con fc_cansancio_cansado = 0.5 el valor recomendado es 70.0 fc_max_esf_obj_extenuado = 76.0 // base del esfuerzo objetivo máximo máximo extenuado // El de arriba es el límite cuando se está en forma. El de abajo, cuando la forma es baja fc_min_esf_obj_extenuado = 64.0 // base del esfuerzo objetivo máximo mínimo extenuado // A mayor combatividad, máyor será el límite. Una combatividad de 80 aumentará el límite // en 80 / 10.0 = 8 puntos. Subiendo este valor, la combatividad influye menos en el límite fc_extenuado_div_bonus = 10.0 // divisor del bonus por combatividad (10.0) // Evidente fc_ataque_prob_base = 55.0 // prob maxima de éxito en un ataque (50.0) // Cuanto menor sea, más influyen la combatividad y la experiencia, y en // general la probabilidad de éxito será mayor. En combinación con el // anterior te da la probabilidad real fc_ataque_div_bonus = 5.0 // divisor del bonus por comb y exp (5.0) // No sé fc_vigilar_dif_base = 15.0 // dificultad base de éxito en vigilar (sin unidades) // Como cualquier divisor, cuanto menor sea, más influye la combatividad fc_vigilar_div_bonus = 5.0 // divisor del bonus por combatividad // No sé fc_corte_div_bonus = 5.0 // bonus por combatividad (5.0) // Autodescriptivos fc_n_raciones_max = 2 // numero maximo de raciones fc_n_raciones_inicial = 1 // numero de raciones al comenzar (2) fc_tiempo_absorcion = 3600 // 5 minutos (3000) fc_tiempo_recuperacion = 3000 // 1 minuto (600) fc_energia_recuperada = 13 // energia recuperada por racion (10) // ///////////////////////////////////// // // PARAMETROS DEL NAVEGADOR DE MOVILES // ///////////////////////////////////// // // No sé nv_long_antes = 7 // en puntos*(velocidad_en_m/sg + 10) nv_long_despues = 7 // idem nv_prioridad_base = 3 // prioridad base del navegador nv_mult_curvatura = 0.10 // cada cuantos radianes se aumenta en 1 la prioridad de una curva nv_mult_longitud = 25 // cada cuantos puntos (50cm) se disminuye la prioridad en 1 // ///////////////////////// // // NAVEGADOR DE GRUPOS // ///////////////////////// // // velocidad normal // la velocidad normal será el resultado de multiplicar max_pdte y mult_base. Es decir, la // velocidad media se controla con los dos parámetros (12*3.2=38.4 en este caso) // Con mult_base se controla la variación de velocidad en función de la pendiente ng_max_pendiente = 12.0 // en % de subida (o bajada) por metro recorrido (20.0) ng_mult_base = 3.2 // ajuste para velocidad normal en llano (2.0) // Corrector de la aceleración cuesta abajo. El valor real de aceleración es la suma // de mult_bas más mod_pdte ng_mod_pendiente = 0.0 // aceleracion cuesta bajo, en KmH por % de pendiente (1.5) // Controla la redución de velocidad en curva. ng_mult_curvatura = 0.25 // cada x radianes aumentamos en 1 la dificultad de la curva (0.20) ng_mult_longitud = 40.0 // cada x puntos disminuimos la dificultad de la curva (40.0) // Velocidad mínima. Si la velocidad es demasiado baja, las distancias entre grupos serán // muy pequeñas, con el resultado de que los que se quedan no tardan en volver a enlazar, // y es difícil seleccionar la carrera ng_vel_minima = 9.0 // velocidad minima en cualquier caso (en Km/h) // velocidad maxima // Diferencia máxima entre los buenos y los malos ng_max_veces_normal = 2.0 // velocidad_normal * x, como maximo (2.0) // A mayor pendiente, menor diferencia. Yo prefiero dejar esto a cero para que // no sea así ng_suavizacion_extremos = 0.0 // (ng_max_veces - x*(pend^2/max_pend^2))*vel_normal // grano de los cambios de ritmo // Velocidad de aceleración/frenado mínima. Creo que, cuanto menor sea, mejor. Incrementos // del 5% no son realistas ng_paso_ritmo = 0.02 // 'velocidad' de aceleracion y frenado // A menor calma, más rápida la aceleración o el frenado ng_calma_frenar = 4 // (4) ng_calma_acelerar = 1 // (1) // ///////////////////////// // // ARBITRAJE DE VELOCIDADES // ///////////////////////// // // Cada cuanto tiempo se cambia la velocidad. 5 ticks (medio segundo) está bien av_frecuencia_arbitrio = 5 // cada cuantos ticks // ////////////////////////////////////////////////////////////////////////////////// // COMPORTAMIENTOS // ////////////////////////////////////////////////////////////////////////////////// // ///////////////////////////////// // PARAMETROS DEL PELOTON // ///////////////////////////////// // Global pl_factor_forma = 0.2 // ( > 0 y <= 1 ) 0.1 -> maximo estiramiento (0.5) pl_factor_velocidad = 10.0 // ( > 0 ) velocidad, en mt/sg, de estiramiento normal pl_ciclistas_por_linea = 11 // numero maximo de ciclistas en una linea de peloton // Número mínimo de ciclistas que relevan en un pelotón. En etapas de montaña puede // interesar reducirlo pl_ciclistas_cabeza = 5 // numero de ciclistas que componen la cabeza (5) // Número máximo de ciclistas que relevan. Yo prefiero un valor alto (con valores bajos // es más dificil pasar a relevar) pl_max_ciclistas_cabeza = 16 // numero maximo de ciclistas en la cabeza del peloton (10) pl_tiempo_recalculo = 25 // cada cuantos ticks se recalcula la forma del peloton pl_tiempo_recalculo_vc = 600 // cada cuantos ticks se recalculan los valores de cabeza // No tocar pl_altura_base = 10 // a que altura relativa en el grupo comienza el peloton pl_prioridad_base = 1 // prioridad base del comportamiento pl_prioridad_maxima = 6 // prioridad maxima del comportamiento // Mal implementado en el Eurotour original, arreglado en Eurotour++ pl_preponderancia_cabeza = 3.0 // veces que cuenta el lider en la votacion de velocidad (2.0) // Parámetros para controlar los cortes. En general, a mí no me gusta que haya cortes, y // dejo la probabilidad a cero. En carreras de un dia puede ser interesante permitir // cortes, por ejemplo, en Paris-Roubaix pl_tiempo_corte = 1600 // tiempo minimo entre cortes (1800) pl_ciclistas_corte = 30 // numero minimo de ciclistas (30) pl_distancia_corte = 1500 // cada cuanto se calcula la p de corte (1000) pl_p_base_corte = 0.0 // probabilidad base pl_corte_mod_pendiente = 0.0 // modificador por cada grado de pendiente > 0 (2.0) pl_corte_mod_ritmo = 0.0 // iden por cada 0.1 de ritmo > 1.0 (0.5) pl_corte_factor_tamanio = 150 // probabilidad para un peloton de cuantos ciclistas (200) pl_tiempo_guarda = 80 // tiempo de guarda de cortes a grupos cercanos (100) // Individual // Duración de los relevos en llano y bajada (5 sg) pl_t_lider_normal = 50 // tiempo, en ticks, de mantenimiento de un lider en cabeza // Duración de los relevos subiendo (12 sg me parece más apropiado que 30) pl_t_lider_subida = 120 // en llano (y badada no muy pronunciada) y subida (300) pl_mult_t_lider = 4.0 // variabilidad aleatoria de lo anterior (3.0) // No idea el resto pl_espaciamiento = 4 // cuantas casillas por nivel pl_variacion = 4 // casilla arriba, casilla abajo, aleatorio desde nivel pl_impo_lat = 0.5 // importancia dada la distancia lateral pl_impo_lon = 0.5 // importancia que se le da a la distancia longitudinal pl_probabilidad_meneo = 0.05 // probabilidad de moverse ligeramente de posicion pl_probabilidad_meneo_lider = 0.01 // idem, del lider de cruzar de lado a lado pl_tendencia_derecha = 20 // 1/p probabilidad del lider de pegarse a la derecha // Los siguientes parametros determinan el esfuerzo relativo segun la posicion en el // peloton, es decir, el beneficio de ir a rueda. Eurotour++ ajusta este beneficio // teniendo en cuenta la velocidad, de modo que en subida la ventaja de ir a rueda // es menor. Para eso se añaden los parametros p_rueda_0 y p_rueda_1 (al final) // Esfuerzo relativo de los corredores de la parte delantera del pelotón, en llano // y descenso pl_esfuerzo_normal = 0.86 // grupo del peloton, al comienzo (0.9) // Esfuerzo relativo de los corredores en cabeza (entrando al relevo, salvo el lider) // en llano y descenso // En subida, es el esfuerzo relativo de todo el pelotón, salvo el líder // En el Eurotour original, para aumentar la selección, basta con subir este parámetro. // En etapas de montaña un valor de 1.05 funciona bien // En Eurotour++, mejor controlar la seleccion con p_rueda_0 pl_esfuerzo_cabeza = 0.89 // componentes de la cabeza (1.0) // Esfuerzo relativo de los corredores a cola, en llano y descenso pl_esfuerzo_cola = 0.75 // los que se quedan en la parte trasera (0.8) // Esfuerzo relativo del líder pl_esfuerzo_lider = 1.1 // el lider (1.1) // Como disminuye el esfuerzo del cuerpo por linea, al movernos hacia la cola // El esfuerzo nunca es inferior al pl_esfuerzo_cola // Con este valor, 0.0075, a partir de la séptima fila (15*0.0075 es aprox 0.11) // el esfuerzo relativo ya es el de cola pl_esfuerzo_x_altura = 0.0075 // como aumenta el esfuerzo del cuerpo por linea (0.0075) // //////////////////////////////// // PARAMETROS DE SPRINT // //////////////////////////////// // Marco // Con esto se controla la velocidad en un sprint, no sé exactamente cómo. No me gustan // velocidades de sprint excesivas porque de esa forma se resta/gana demasiado tiempo // en el sprint respecto a alguien que va solo. sp_marco_vel_normal = 1.3 (2.2) sp_marco_vel_escalada = 1.2 (1.9) sp_marco_mod_pendiente = 0.01 (0.1) // Distancia de sprint. 1000 es un 1 km sp_marco_tiempo_comienzo = 1000 // momento en que se resuelve el sprint, últimos 150 m en este caso sp_marco_tiempo_sprint = 150 // (150) // Tiempo en que tira un lanzador sp_tiempo_minimo_lanzador = 200 // (300) // condiciones de sprint // No sé muy bien para qué sirve. Aunque se ponga a cero, la gente sprinta sp_meta_salida = 0 sp_meta_meta = 20 sp_meta_1km = 0 sp_meta_2km = 0 sp_meta_10km = 0 sp_meta_20km = 0 sp_meta_especial = 3 // (3) sp_meta_puerto_especial = 12 // (12) sp_meta_puerto_primera = 10 // (10) sp_meta_puerto_segunda = 10 // (10) sp_meta_puerto_tercera = 5 // (5) sp_meta_cuarta_categoria = 3 // (3) sp_meta_avituallamiento = 0 sp_meta_punto_crono = 0 // grupo // Velocidad en los últimos metros. No sé exactamente cómo funciona sp_max_factor_velocidad = 1.6 // un numero entre 1 y 3 aceleracion en el sprint (meta final) (2.0) sp_nor_factor_velocidad = 1.3 // idem (el resto) (1.5) // No tocar sp_altura_base = 10 // a que altura pretenden ponerse los grupos // Ni idea sp_bonus_x_lanzador = 10 // bonus a la tirada de sprint por cada ayudante // No conviene que el máximo sea muy grande, o los sprints no se resuelven del todo bien sp_max_sprinters = 10 // máximo numero de sprinters en la recta final (5) // individual // Como no me gusta que los escalador se agoten en el sprint del puerto, pongo esfuerzos bajos sp_esfuerzo_base = 0.9 // esfuerzo base (1.1) sp_esfuerzo_lider = 0.95 // esfuerzo del cabeza de un grupo de sprint (1.25) sp_esfuerzo_sprint = 1.0 // esfuerzo al sprintar (1.8) sp_esfuerzo_acabado = 0.6 // esfuerzo cuando acaban y se van para atras (0.8) // Afecta a la velocidad de los movimientos sp_prioridad_normal = 8 // prioridad de los que siguen sp_prioridad_lider = 6 // prioridad del cabeza de un grupo de sprint (6) sp_prioridad_sprint = 20 // prioridad al sprintar al final (20) // //////////////////////////////// // PARAMETROS ATACAR // //////////////////////////////// at_distancia_minima = 20 // del ultimo escapado al resto del peloton, antes de separar // Velocidad del movimiento de ataque at_prioridad_base = 9 // (7) at_prioridad_maxima = 20 // Ni idea at_n_avances = 6 // (6) at_cerca_seguir = 70 // (100) // 1.4 no es nada realista. 1.15 es más apropiado (sólo un poco más de esfuerzo que el líder) at_esfuerzo_normal = 1.15 // (1.4) // //////////////////////////////// // PARAMETROS ESCAPADOS // //////////////////////////////// // Global es_estiramiento = 10.0 // entre 8 (mas) y 12 (menos) // Ni idea es_proporcion_cabeza = 0.5 // proporcion media de escapados a la cabeza (0.5) es_frecuencia_recalculo = 100 // cada cuanto recalculamos la distribucion del paquete (100) // Individual // No tocar es_altura_base = 10 // altura objetivo del lider. No tocar (20) es_prioridad_base = 3 // prioridad base del comportamiento es_prioridad_alta = 7 // prioridad alta del comportamiento es_t_lider_normal = 70 // igual que en el peloton, estos tres valores (75) es_t_lider_subida = 140 // gobiernan el tiempo de lider en ticks (200) es_mult_t_lider = 3.0 // Sólo afecta a los movimientos de lado a lado es_probabilidad_meneo = 0.005 // probabilidad de ir de lado a lado de la carretera (0.001) // No me parece realista que un escapado se canse más que quien tira de un pelotón, así // que utilizo esfuerzos similares. Igualmente, el esfuerzo de ir a rueda en un grupo // pequeño es el mismo tanto si se entra al relevo como si no (aun así, la gente que // entra al relevo se cansará más cuando pasa a la cabeza) es_esfuerzo_lider = 1.1 // (1.25) es_esfuerzo_relevando = 0.9 // (1.13) es_esfuerzo_paquete = 0.9 // (1.03) // //////////////////////////////// // PARAMETROS RETRASARSE // //////////////////////////////// // Global // Ni idea re_tiempo_recalculo = 50 // (50) // Individual // A mayor prioridad, más rápido se rezaga un corredor re_prioridad_base = 7 // (7) // Cuanto menor sea, más se recupera un ciclista mientras se queda // Recomiendo un valor medio re_esfuerzo = 1.00 // (0.8) // Distancia para que un ciclista o grupo quede retrasado. re_bastante_atras = 8 // (10) // //////////////////////////////// // PARAMETROS CORTE // //////////////////////////////// // Ni idea // Global ct_ancho_busqueda = 2 // Individual ct_prioridad_base = 11 // (8) // //////////////////////////////// // PARAMETROS SEGUIR A // //////////////////////////////// // Ni idea // busqueda sg_margen_por_defecto = 2 // distancia de la cola del objetivo sg_proximidad = 20 // a que llamamos cerca sg_acotacion_busqueda = 500 // n maximo de nodos a explorar // individual sg_prioridad_base = 6 sg_tiempo_recalculo = 50 sg_distancia_objetivo = 4 // //////////////////////////////// // PARAMETROS CONTRARELOJ // //////////////////////////////// // grupo // También recomiendo valores bajos cc_margen_ritmos = 0.01 // Cuantos ciclistas se pueden juntar en un doblaje cc_max_miembros = 3 // individual cc_prioridad_base = 8 // prioridad base del comportamiento cc_altura_base = 10 // altura base del corredor en el grupo cc_separacion = 30 // separacion entre corredores // Cuanto menor sea, más velocidad cc_esfuerzo_base = 0.96 // esfuerzo base del comportamiento (1.1) // Significado evidente. En cronoescaladas recomiendo 0.7 - 0.3 cc_peso_esfuerzo_base = 0.4 // los dos siguientes deben sumar 1 (0.5) cc_peso_parametro_crono = 0.6 // y sirven para relajar la influencia del param. (0.5) cc_prob_base_meneo = 0.01 // probabilidad base de menearse hacia los lados cc_prob_cero_meneo = 90 // parametro para el que menearse no ocurre cc_tamanio_max_meneo = 4 // cantidad de carriles maxima en el meneo // //////////////////////////////// // EUROTOUR-PLUS // //////////////////////////////// // Estos tres parametros controlan el ritmo del peloton al principio, a mitad y al final // de una etapa. // Recomiendo ajustarlos en función de la etapa // Etapa llana: 82-90-94 (para consentir escapadas 78-86-94) // Media montaña: 80-88-93 // Alta montaña: 80-86-90 p_esfuerzo_1 = 82 p_esfuerzo_2 = 89 p_esfuerzo_3 = 93 // Con estos dos parametros se ajusta el beneficio de ir a rueda en funcion de la velocidad // A velocidad igual o menor que p_rueda_0, no hay ventaja por ir a rueda (pendiente > 10%) // A velocidad mayor que p_rueda_1, la ventaja es la que fijan los parametros pl_esfuerzo_x // Entremedias, la reduccion de esfuerzo es proporcional a la velocidad // Formula: esf_real = esf_teor + (esf_lider - esf_teor)*(vel - p_rueda_0)/(p_rueda_1 - p_rueda_0) // Ejemplo: pl_esfuerzo_lider = 1.1 y pl_esfuerzo_normal = 0.8 (beneficio de hasta el 30%) // pdte = 10 % -> vel = 12 -> esf_real = 1.1 beneficio = 0% // pdte = 8% -> vel = 25 -> esf_real = 1.02 beneficio = 8% // pdte = 4% -> vel = 35 -> esf_real = 0.95 beneficio = 15% // pdte = 0% -> vel = 45 -> esf_real = 0.88 beneficio = 22% // pdte = -8% -> vel = 60 -> esf_real = 0.8 beneficio = 30% // Aumentar p_rueda_0 para mayor seleccion en montaña // Aumentar p_rueda_1 para menor recuperacion en llano p_rueda_0 = 15.0 p_rueda_1 = 55.0