/*
 * Podstawowym czynnikiem od ktorego uzalezniona bedzie szansa trafienia
 * bedzie po stronie gracza skill specjala i stat gildiowy, natomiast po
 * stronie przeciwnej dex i skill defense...
 * Po dlugim namysle zdecydowalem sie nie uzywac resolve_taska.
 * Konkretniej wygladac to bedzie tak:
 * po stronie gracza atakujacego bedzie wchit + fixnorm, gdzie wchit jest oczy-
 * wiscie zalezny od tohit broni oraz skilla (w tym przypadku bedzie to 60%
 * skilla specjala oraz 1/3 gildiowego stata - chwilowo za wysokiego stata uwa-
 * zam 120, to moze sie zmienic w przyszlosci, ale sadze, ze na razie nie be-
 * dzie za nisko), fixnorm natomiast jest modyfikatorem przyjmujacym wartosci
 * -50, 50 zaleznym od porownania obladowania / zrecznosci walczacych.
 * Za przykladem z cbase.c weight defence u obroncy bedzie obnizony o polowe
 * jesli w tej chwili _walczy_ on z innym przeciwnikiem. Jesli nie walczy z
 * nikim pozostawiam to bez zmian.
 * Nie uwzgledniam parowania po stronie obroncy bo cios z natury jest raczej
 * ciosem nieparowalnym.
 * zdecydowalem sie na prosta formule:
 * jesli (random (wchit + fixnorm) >= random (defence_przeciwnia) ) to sukces.
 * w przeciwnym wypadku porazka.
 * Daje to w miare sensowne wyniki ok. 74% szansy na trafienie rownorzednego
 * przeciwnika - tj. majacego defence na poziomie skilla atakujacego przy
 * walce porzadnym toporem o tohicie 20. Fixnorm nie wplywa na srednie prawd.
 * bo jest taka sama szansa ze gracze beda obladowani.
 */

int
fixnorm (int offence, int defence);

int
czy_trafil(object gracz, object vic, object bron)
{
    int fixnorm_mod, result;

    mixed d_gracz = allocate (6);

    /*
     * Dane gracza przedstawiaja sie w sposob nastepujacy:
     * [0] - skill zsumowany ze skilla wlasciwego i stata
     * [1] - to_hit broni
     * [2] - dexterity
     * [3] - cont_i_height
     * [4] - query_encumberance_weight
     * [5] - query_enc_vol
     */

    mixed d_vic = allocate (5);

    /*
     * Dane przciwnika:
     * [0] - defence
     * [1] - dexterity
     * [2] - cont_i_height
     * [3] - query_encumberance_weight
     * [4] - query_enc_vol
     */

    d_gracz[0] = (gracz->query_skill (WKS_TOPOR) * 60) / 100 + 
	         (gracz->query_stat (SS_OCCUP)) / 3;
    d_gracz[1] = bron->query_hit();
    d_gracz[2] = gracz->query_stat (SS_DEX);
    d_gracz[3] = gracz->query_prop (CONT_I_HEIGHT);
    d_gracz[4] = gracz->query_encumberance_weight();
    d_gracz[5] = gracz->query_encumberance_volume();
    dump_array (d_gracz);

    d_vic[0] = vic->query_skill (SS_DEFENCE);
    d_vic[1] = vic->query_stat (SS_DEX);
    d_vic[2] = vic->query_prop (CONT_I_HEIGHT);
    d_vic[3] = vic->query_encumberance_weight();
    d_vic[4] = vic->query_encumberance_volume();
    dump_array (d_vic);

    /*
     * To wzialem z cbase
     * Wywalilem tylko porownywanie CONT_I_VOLUME - ktore jak sadze jest nieco
     * bez sensu, a zastapie CONT_I_HEIGHT - wyzszym latwiej trafic
     */
    fixnorm_mod = 2 * fixnorm (d_gracz[2], d_vic[1]) - fixnorm(d_gracz[3], d_vic[2]) -
	          fixnorm (d_gracz[4] + d_gracz[5] + 5, d_vic[3] + d_vic[4] + 5);
    dump_array ("fixnorm:" + fixnorm_mod);
    /*
     * Jedyny problem z tym to to, ze za bardzo nie wiem co to tak na prawde
     * zwroci :) teoretycznie moze ow formulka przyjac wart. od -200 do 200
     * Jednakze w praktyce nie powinno to miec az tak wielkiego znaczenia.
     * Chyba zrobie loga i potem sie to najwyzej zbalansuje.
     */

    result = (random (F_TOHITMOD(d_gracz[1], d_gracz[0]) + fixnorm_mod) -
	      random (d_vic[0]) );
    dump_array ("result:" + result);

    if (result > 0)
	return 1;
}

int
fixnorm (int offence, int defence)
{
    if (offence + defence == 0)
	return 0;

    return ((100 * offence) / (offence + defence)) - 50;
}