miss chance, rng, and some code experiments

st.lcg_rand_state = st.lcg_rand_state * 22695477 + 1;
return (st.lcg_rand_state >> 16) & 0x7fff;

fp8 unit_dodge_chance(const unit_t* u) const {
    if (u_flying(u)) return 0_fp8;
    if (unit_is_under_dark_swarm(u)) return 255_fp8;
    if (st.tiles[tile_index(u->sprite->position)].flags & tile_t::flag_provides_cover) return 119_fp8;
    return 0_fp8;
}

fp8 unit_target_miss_chance(const unit_t* u, const unit_t* target) const {
    fp8 r = unit_dodge_chance(target);
    if (!u_flying(u) && !u_flying(target)) {
        if (get_ground_height_at(target->sprite->position) > get_ground_height_at(u->sprite->position)) {
            if (r < 119_fp8) r = 119_fp8;
        }
    }
    return r;
}

fp8::from_raw(lcg_rand(1) & 0xff) <= unit_target_miss_chance(bullet_owner_unit, target_unit)

use std::num::Wrapping;

fn main() {
    /////////////////////////////////////////////////////////////////
    // constants to tweak here
    let reroll_count = 65536; // how much should we reroll off a starting seed
    
    // 0 normally, 119 for shooting uphill/under trees
    let target = 0;
    //let target = 119;
    
    // -trial_range to trial_range as seed
    let trial_range = 10000;
    
    // how many misses in a row is weird
    let outlier_chain_length = 10;
    
    // the LCG seems to behave very mildly worse centered around initial seed 0
    // so this gets added to +-trial_range
    let trial_offset = 0;
    // no more constants
    /////////////////////////////////////////////////////////////////
    
    
    
    // finding outliers
    let expected_to_find = (reroll_count * (target+1)) / 256;
    
    let found_threshold = expected_to_find / 4;
    
    let found_threshold_high = expected_to_find + found_threshold;
    let found_threshold_low = expected_to_find - found_threshold;
    //
    
    
    let mut found_count = 0;
    let mut trial_count = 0;
    let mut sequential_found_count = 0;
    let mut sequential_not_found_count = 0;
    
    let mut unusual_chain_count = 0;
    let mut longest_chain = 0;
    
    let mut loop_body = |start_state| {
        let prev_found = found_count;
        
        let mut lcg_rand_state = Wrapping(start_state);
        
        let mut previous_roll_was_found = false;
        let mut chain_length = 0;
        
        for _ in 0..reroll_count
        {
            let (new_state, result) = lcg_rand(lcg_rand_state);
        
            lcg_rand_state = new_state;
        
            if (result & Wrapping(0xFF)) <= Wrapping(target)
            {
                found_count += 1;
                
                if previous_roll_was_found {
                    sequential_found_count += 1;
                }
                
                previous_roll_was_found = true;
                chain_length += 1;
            } else {
                if !previous_roll_was_found {
                    sequential_not_found_count += 1;
                }
                
                previous_roll_was_found = false;
                
                if chain_length > outlier_chain_length {
                    unusual_chain_count += 1;
                }
                
                if chain_length > longest_chain {
                    longest_chain = chain_length;
                }
                chain_length = 0;
            }
        }
        
        // finding outliers
        let delta_found = found_count - prev_found;
        if delta_found > found_threshold_high || delta_found < found_threshold_low {
            println!("unusual number {} found for start seed {} outside range {} to {} centered around {}", delta_found, start_state, found_threshold_low, found_threshold_high, expected_to_find);
        }
        
        trial_count += 1;
    };
    
    // uncomment this and comment out the loop to test a specific seed
    //loop_body(7);
    
    for start_state
        in -trial_range+trial_offset..trial_range+trial_offset
    {
        loop_body(start_state);
    }
    
    let total_count = trial_count * reroll_count;
    println!(
        "{} instances found in {} trials of {} rolls ({} total rolls)",
        found_count, trial_count, reroll_count, total_count);
    println!("{} were sequential misses", sequential_found_count);
    println!();
    
    //let reroll_count = reroll_count as f64;
    let found_count = found_count as f64;
    let total_count = total_count as f64;
    let miss_rate = (found_count / total_count) * 100.0;
    let miss_in = total_count / found_count;
    let expected_rate = ((target as f64 + 1.0)/256.0) * 100.0;
    println!("\n\t{}% miss rate", miss_rate);
    println!("or roughly  1 in {}", miss_in as usize);
    println!("in contrast to\n\t{}% expected", expected_rate);
    println!("off by\n\t{}%", miss_rate - expected_rate);
    
    println!();
    
    let sequential_found_count = sequential_found_count as f64;
    let sequential_miss_rate = sequential_found_count/found_count * 100.0;
    let sequential_miss_in = found_count / sequential_found_count;
    
    println!("{}% sequential miss rate",sequential_miss_rate);
    println!("or roughly  1 in {}", sequential_miss_in as usize);
    println!("in contrast to\n\t{}% expected", expected_rate);
    println!("off by\n\t{}%", sequential_miss_rate - expected_rate);
    
    println!();
    let sequential_not_found_count = sequential_not_found_count as f64;
    let sequential_hit_rate = sequential_not_found_count/(total_count-found_count) * 100.0;
    println!("{}% sequential hit rate",sequential_hit_rate);
    println!("in contrast to\n\t{}% expected", 100.0-expected_rate);
    println!("off by\n\t{}%", sequential_hit_rate - (100.0-expected_rate));
    
    println!();
    println!("found {} chains of {} or more misses in a row", unusual_chain_count, outlier_chain_length);
    println!("longest chain was {} misses in a row", longest_chain);
}


fn lcg_rand(lcg_rand_state : Wrapping<i32>) -> (Wrapping<i32>, Wrapping<i32>) {
    let lcg_rand_state = lcg_rand_state * Wrapping(22695477) + Wrapping(1);
    
    (lcg_rand_state, (lcg_rand_state >> 16) & Wrapping(0x7fff))
}