mnml/server/src/img.rs

use uuid::Uuid;
use rand::prelude::*;
use rand::distributions::{Normal, WeightedIndex};

use std::fs::copy;
use std::fs::File;
use std::io::prelude::*;

use failure::Error;
use failure::err_msg;

pub fn molecular_write(id: Uuid) -> Result<Uuid, Error> {
    let mut rng = thread_rng();

    for _i in 0..100 {
        let mol: u32 = rng.gen_range(0, 10000);
        let src = format!("/var/lib/mnml/data/molecules/{}.svg", mol);
        let dest = format!("/var/lib/mnml/public/imgs/{}.svg", id);
        debug!("molecule src={:?}", src);
        debug!("molecule dest={:?}", dest);
        if let Ok(_bytes) = copy(&src, &dest) {
            info!("new molecule img generated src={:?} dest={:?}", src, dest);
            return Ok(id);
        }
    }

    return Err(err_msg("too many missing molecules. wrong directory?"))
}

pub fn invader_write(id: Uuid) -> Result<Uuid, Error> {
    let mut rng = thread_rng();
    let mut svg = Vec::new();

    // rounding ?
    // filters ?

    // distribution for lightness
    // bellcurve around 50%
    let l_dist = Normal::new(50.0, 10.0);
    let s_dist = Normal::new(25.0, 10.0);

    let mut colours = std::iter
        ::repeat_with(|| {
            let h = rng.gen_range(0, 360);
            let s = s_dist.sample(&mut rng) as u16;
            let l = l_dist.sample(&mut rng) as u16;
            format!("hsl({:}, {:}%, {:}%)", h, s, l)
        })
        .take(3)
        .collect::<Vec<String>>();

    colours.push("none".to_string());

    // add up to 100 for %
    // [3] is the transparent colour
    let weights = [
        5,
        5,
        65,
        25,
    ];
    let colour_dist = WeightedIndex::new(&weights)?;

    write!(&mut svg, "<svg xmlns='http://www.w3.org/2000/svg' version='1.1' viewBox='-250 -250 1000 1000' width='500' height='500'><g>")?;
    for i in 0..50 {
        let x = (i % 5) * 50;
        let y = (i / 5) * 50;

        let colour = &colours[colour_dist.sample(&mut rng)];

        write!(&mut svg, "<rect fill=\"{}\" x=\"{}\" y=\"{}\" width=\"50\" height=\"50\" />", colour, x, y)?;
        write!(&mut svg, "<rect fill=\"{}\" x=\"{}\" y=\"{}\" width=\"50\" height=\"50\" />", colour, 450 - x, y)?;
    }

    write!(&mut svg, "</g></svg>")?;

    let dest = format!("/var/lib/mnml/public/imgs/{}.svg", id);
    println!("molecule dest={:?}", dest);

    let mut file = File::create(dest)?;
    file.write_all(&svg)?;

    Ok(id)
}


// #[cfg(test)]
// mod tests {
//     use super::*;

//     #[test]
//     fn invader_img_test() {
//         for i in 0..100 {
//             invader_img_write(Uuid::new_v4()).unwrap();
//         }
//     }
// }



//     function createColor() {
//         //saturation is the whole color spectrum
//         var h = Math.floor(rand() * 360);
//         //saturation goes from 40 to 100, it avoids greyish colors
//         var s = ((rand() * 60) + 40) + '%';
//         //lightness can be anything from 0 to 100, but probabilities are a bell curve around 50%
//         var l = ((rand()+rand()+rand()+rand()) * 25) + '%';

//         var color = 'hsl(' + h + ',' + s + ',' + l + ')';
//         return color;
//     }

//     function createImageData(size) {
//         var width = size; // Only support square icons for now
//         var height = size;

//         var dataWidth = Math.ceil(width / 2);
//         var mirrorWidth = width - dataWidth;

//         var data = [];
//         for(var y = 0; y < height; y++) {
//             var row = [];
//             for(var x = 0; x < dataWidth; x++) {
//                 // this makes foreground and background color to have a 43% (1/2.3) probability
//                 // spot color has 13% chance
//                 row[x] = Math.floor(rand()*2.3);
//             }
//             var r = row.slice(0, mirrorWidth);
//             r.reverse();
//             row = row.concat(r);

//             for(var i = 0; i < row.length; i++) {
//                 data.push(row[i]);
//             }
//         }

//         return data;
//     }

//     function buildOpts(opts) {
//         var newOpts = {};

//         newOpts.seed = opts.seed || Math.floor((Math.random()*Math.pow(10,16))).toString(16);

//         seedrand(newOpts.seed);

//         newOpts.size = opts.size || 8;
//         newOpts.scale = opts.scale || 4;
//         newOpts.color = opts.color || createColor();
//         newOpts.bgcolor = opts.bgcolor || createColor();
//         newOpts.spotcolor = opts.spotcolor || createColor();

//         return newOpts;
//     }
//          ],
// -        _ => vec![
// -            (ItemAction::RerollStamina, 1),
// -            (ItemAction::RerollPhysDamage, 1),
// -            (ItemAction::RerollSpellDamage, 1),
// -            (ItemAction::RerollSpeed, 1),
// -            (ItemAction::RerollArmour, 1),
// -            (ItemAction::RerollSpellShield, 1),
// -            (ItemAction::RerollEvasion, 1),
// -        ],
// +        // _ => vec![
// +        //     (ItemAction::RerollStamina, 1),
// +        //     (ItemAction::RerollPhysDamage, 1),
// +        //     (ItemAction::RerollSpellDamage, 1),
// +        //     (ItemAction::RerollSpeed, 1),
// +        //     (ItemAction::RerollArmour, 1),
// +        //     (ItemAction::RerollSpellShield, 1),
// +        //     (ItemAction::RerollEvasion, 1),
// +        // ],
//      }
//  }

// -pub fn item_drop(tx: &mut Transaction, account_id: Uuid, mode: GameMode) -> Result<Item, Error> {
// +pub fn item_drop(tx: &mut Transaction, account_id: Uuid, mode: GameMode) -> Result<(), Error> {
//      let mut rng = thread_rng();

// -    let actions = mode_drops(mode);
// +    let log_normal = LogNormal::new(1.0, 1.0);
// +    let num_drops = log_normal.sample(&mut rng).floor() as u16;
// +
// +    println!("{:?} drops", num_drops);

// -    let dist = WeightedIndex::new(actions.iter().map(|item| item.1)).unwrap();
// -    let kind = actions[dist.sample(&mut rng)].0;
// -    let item = Item::new(kind, account_id);
// +    for _i in 0..num_drops {
// +        let actions = mode_drops(mode);

// -    println!("{:?} dropped {:?}", account_id, item);
// +        let dist = WeightedIndex::new(actions.iter().map(|item| item.1)).unwrap();
// +        let kind = actions[dist.sample(&mut rng)].0;
// +        let item = Item::new(kind, account_id);

// -    return item_create(item, tx, account_id);
// +        println!("{:?} dropped {:?}", account_id, item);
// +        item_create(item, tx, account_id)?;V