big getup for ubuntu setup, construct colour based skills

WORKLOG.md

@@ -1,4 +1,15 @@
 # WORK WORK
+
+## AUTO
+
+- server
+  - unlimited specs
+  - vbox has colour specs
+  - skill based on colour count
+
+- UI
+  - colour count
+
 ## NOW
 
 _ntr_

bin/db.sh

@@ -6,4 +6,6 @@ sudo -u postgres createuser --encrypted mnml
 
 PG_PASSWORD=$(openssl rand -hex 16)
 echo "database password is $PG_PASSWORD"
-sudo -u -E postgres psql -c "alter user mnml with encrypted password '$PG_PASSWORD';"
+sudo -u postgres psql -c "alter user mnml with encrypted password '$PG_PASSWORD';"
+sudo -u postgres psql -c "CREATE EXTENSION IF NOT EXISTS \"uuid-ossp\";"
+

bin/install.sh

@@ -4,7 +4,7 @@
 DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
 MNML_PATH=$(realpath "$DIR/../")
 
-MNML_CONF="/etc/mnml/mnml.conf"
+MNML_CONF="/etc/mnml/gs.conf"
 
 if [ ! -f $MNML_CONF ]; then
     echo "-----------------------------------------------"
@@ -26,6 +26,7 @@ source $MNML_CONF
 sudo mkdir -p /var/lib/mnml/client
 sudo mkdir -p /var/lib/mnml/data
 sudo mkdir -p /var/lib/mnml/public/imgs
+sudo mkdir -p /var/lib/mnml/data/instances/
 sudo chown -R $MNML_USER:$MNML_USER /var/lib/mnml
 
 #       /var/log/mnml
@@ -45,11 +46,14 @@ sudo cp $MNML_PATH/etc/systemd/system/mnml.service /usr/local/systemd/system/
 # POSTGRES SETUP
 sudo -u postgres createdb mnml
 sudo -u postgres createuser --encrypted mnml
-
 echo "DATABASE_URL=postgres://mnml:$MNML_PG_PASSWORD@$MNML_PG_HOST/mnml" | sudo tee -a /etc/mnml/gs.conf
 sudo -u postgres psql -c "alter user mnml with encrypted password '$MNML_PG_PASSWORD';"
 
-cd $MNML_PATH/ops && npm run migrate
+cd $MNML_PATH/ops
+npm i
+npm run migrate
+
+cd $MNML_PATH
 
 # NGINX
 if [ ! -f $MNML_PATH/etc/nginx/sites-available/mnml.gg.nginx.conf ]; then

core/src/construct.rs

@@ -236,7 +236,7 @@ impl Construct {
             green_life: ConstructStat { base: 400, value: 400, max: 400, stat: Stat::GreenLife },
             speed: ConstructStat { base: 100, value: 100, max: 100, stat: Stat::Speed },
             // evasion: ConstructStat { base: 0, value: 0, max: 0, stat: Stat::Evasion },
-            skills: vec![],
+            skills: vec![ConstructSkill::new(Skill::Attack)],
             effects: vec![],
             specs: vec![],
             colours: Colours::new(),

core/src/player.rs

@@ -7,7 +7,7 @@ use failure::err_msg;
 
 use construct::{Construct, Colours};
 use vbox::{Vbox, ItemType, VboxIndices};
-use item::{Item, ItemEffect};
+use item::{Item, ItemEffect, get_combos};
 use effect::{Effect};
 
 const DISCARD_COST: usize = 2;
@@ -297,17 +297,21 @@ impl Player {
             Some(ItemEffect::Skill) => {
                 let skill = item.into_skill().ok_or(format_err!("item {:?} has no associated skill", item))?;
                 let construct = self.construct_get(construct_id)?;
-                // done here because i teach them a tonne of skills for tests
-                let max_skills = 3;
-                if construct.skills.len() >= max_skills {
-                    return Err(format_err!("construct at max skills ({:?})", max_skills));
-                }
-
-                if construct.knows(skill) {
-                    return Err(format_err!("construct already knows skill ({:?})" , skill));
-                }
 
+                construct.skills = vec![];
                 construct.learn_mut(skill);
+
+                // // done here because i teach them a tonne of skills for tests
+                // let max_skills = 1;
+                // if construct.skills.len() >= max_skills {
+                //     return Err(format_err!("construct at max skills ({:?})", max_skills));
+                // }
+
+                // if construct.knows(skill) {
+                //     return Err(format_err!("construct already knows skill ({:?})" , skill));
+                // }
+
+                // construct.learn_mut(skill);
             },
             Some(ItemEffect::Spec) => {
                 let spec = item.into_spec().ok_or(format_err!("item {:?} has no associated spec", item))?;
@@ -318,19 +322,76 @@ impl Player {
             None => return Err(err_msg("item has no effect on constructs")),
         }
 
-        // now the item has been applied
+        let construct = self.construct_get(construct_id)?;
-        // recalculate the stats of the whole player
-        let player_colours = self.constructs.iter().fold(Colours::new(), |tc, c| {
-            Colours {
-                red: tc.red + c.colours.red,
-                green: tc.green + c.colours.green,
-                blue: tc.blue + c.colours.blue
-            }
-        });
 
-        for construct in self.constructs.iter_mut() {
+        // force 1 skill for auto
-            construct.apply_modifiers(&player_colours);
+        let mut colour_counts = vec![
-        }
+            (Item::Red, construct.colours.red),
+            (Item::Green, construct.colours.green),
+            (Item::Blue, construct.colours.blue),
+        ];
+        colour_counts.sort_unstable_by_key(|cc| cc.1);
+        colour_counts.reverse();
+
+        println!("{:?}", colour_counts);
+
+        let total = (construct.colours.red + construct.colours.green + construct.colours.blue) as f64;
+        let colour_pcts = colour_counts.iter_mut()
+            .map(|cc| (cc.0, cc.1 as f64 / total))
+            .collect::<Vec<_>>();
+
+        println!("{:?}", colour_pcts);
+
+        let skill_item = match item.into_skill().is_some() {
+            true => item,
+            false => construct.skills[0].skill.base(),
+        };
+
+        let colour_skill = {
+            // no colours
+            if colour_pcts[0].1.is_infinite() {
+                construct.skills[0].skill
+            } else {
+                let mut skill_item_combo = {
+                    if colour_pcts[0].1 > 0.75 {
+                        vec![skill_item, colour_pcts[0].0, colour_pcts[0].0]
+                    } else if colour_pcts[1].1 > 0.4 {
+                        vec![skill_item, colour_pcts[0].0, colour_pcts[1].0]
+                    } else {
+                        // special triple skill_item
+                        vec![skill_item, colour_pcts[0].0, colour_pcts[1].0]
+                    }
+                };
+
+                skill_item_combo.sort_unstable();
+
+                println!("{:?}", skill_item_combo);
+                let combos = get_combos();
+                let combo = combos.iter().find(|c| c.components == skill_item_combo)
+                    .ok_or(err_msg("no combo for colour skill"))?;
+
+                combo.item.into_skill()
+                    .ok_or(format_err!("item {:?} has no associated skill", combo.item))?
+            }
+        };
+
+        // unlearn everything
+        construct.skills = vec![];
+        construct.learn_mut(colour_skill);
+
+        // // now the item has been applied
+        // // recalculate the stats of the whole player
+        // let player_colours = self.constructs.iter().fold(Colours::new(), |tc, c| {
+        //     Colours {
+        //         red: tc.red + c.colours.red,
+        //         green: tc.green + c.colours.green,
+        //         blue: tc.blue + c.colours.blue
+        //     }
+        // });
+
+        // for construct in self.constructs.iter_mut() {
+        //     construct.apply_modifiers(&player_colours);
+        // }
 
         Ok(self)
     }

core/src/skill.rs

@@ -896,12 +896,12 @@ impl Skill {
             .collect::<Vec<Colour>>();
     }
 
-    fn _base(&self) -> Skill {
+    pub fn base(&self) -> Item {
         let bases = [Item::Attack, Item::Stun, Item::Buff, Item::Debuff, Item::Block];
         match self.components()
             .iter()
             .find(|i| bases.contains(i)) {
-                Some(i) => i.into_skill().unwrap(),
+                Some(i) => *i,
                 None => panic!("{:?} has no base item", self),
             }
     }

core/src/vbox.rs

@@ -27,11 +27,11 @@ pub enum ItemType {
     Specs,
 }
 
-const STORE_COLOURS_CAPACITY: usize = 6;
+const STORE_COLOURS_CAPACITY: usize = 0;
-const STORE_SKILLS_CAPACITY: usize = 3;
+const STORE_SKILLS_CAPACITY: usize = 2;
 const STORE_SPECS_CAPACITY: usize = 3;
-const STASH_CAPACITY: usize = 6;
+const STASH_CAPACITY: usize = 0;
-const STARTING_ATTACK_COUNT: usize = 3;
+const STARTING_ATTACK_COUNT: usize = 0;
 
 impl Vbox {
     pub fn new() -> Vbox {
@@ -92,9 +92,24 @@ impl Vbox {
         let skill_dist = WeightedIndex::new(skills.iter().map(|item| item.1)).unwrap();
 
         let specs = vec![
-            (Item::Power, 1),
+            (Item::PowerGG, 1),
-            (Item::Life, 1),
+            (Item::PowerRR, 1),
-            (Item::Speed, 1),
+            (Item::PowerBB, 1),
+            (Item::PowerRG, 1),
+            (Item::PowerGB, 1),
+            (Item::PowerRB, 1),
+            (Item::LifeGG, 1),
+            (Item::LifeRR, 1),
+            (Item::LifeBB, 1),
+            (Item::LifeRG, 1),
+            (Item::LifeGB, 1),
+            (Item::LifeRB, 1),
+            (Item::SpeedGG, 1),
+            (Item::SpeedRR, 1),
+            (Item::SpeedBB, 1),
+            (Item::SpeedRG, 1),
+            (Item::SpeedGB, 1),
+            (Item::SpeedRB, 1),
         ];
         let spec_dist = WeightedIndex::new(specs.iter().map(|item| item.1)).unwrap();
 

etc/nginx/sites-available/mnml.gg.DEV.nginx.conf

@@ -8,7 +8,6 @@ upstream mnml_ws {
     server 127.0.0.1:40055;
 }
 
-
 map $http_upgrade $connection_upgrade {
     default upgrade;
     '' close;

ops/knexfile.SAMPLE.js

@@ -3,7 +3,7 @@ module.exports = {
   connection: {
     database: 'mnml',
     user:     'mnml',
-    password: 'gggggggggg',
+    password: '62d72d2e7905d267a0910cc01164c500',
   },
   pool: {
     min: 2,

ops/migrations/20190914191207_shapes-mtx.js

@@ -2,9 +2,9 @@ const uuidv4 = require('uuid/v4');
 
 // give everybody the shapes mtx
 exports.up = async knex => {
-    await knex.raw(`
+    // await knex.raw(`
-        CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
+    //     CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
-    `);
+    // `);
 
     await knex.raw(`
         INSERT INTO mtx (id, account, variant)

ops/package.json

@@ -14,8 +14,8 @@
   "author": "",
   "license": "UNLICENSED",
   "dependencies": {
-    "knex": "^0.15.2",
+    "knex": "^0.21",
-    "pg": "^7.4.3",
+    "pg": "^8",
     "qrcode-svg": "^1.0.0",
     "request": "^2.88.0",
     "sdftosvg": "0.0.4",

server/Cargo.toml

@@ -15,8 +15,8 @@ chrono = { version = "0.4", features = ["serde"] }
 bcrypt = "0.2"
 
 postgres = { version = "0.15", features = ["with-uuid", "with-chrono"] }
-r2d2 = "*"
+r2d2 = "0.8"
-r2d2_postgres = "*"
+r2d2_postgres = "0.14"
 fallible-iterator = "0.1"
 
 failure = "0.1"

server/src/lib.rs

@@ -108,7 +108,7 @@ pub fn setup_logger() -> Result<(), fern::InitError> {
 pub fn start() {
     #[cfg(unix)]
     setup_logger().unwrap();
-    dotenv::from_path(Path::new("/etc/mnml/gs.conf")).ok();
+    dotenv::from_path(Path::new("/etc/mnml/gs.conf")).unwrap();
     info!("starting server");
 
     let pool = pg::create_pool();

server/src/pg.rs

@@ -66,6 +66,8 @@ pub fn create_pool() -> Pool<PostgresConnectionManager> {
     let url = env::var("DATABASE_URL")
         .expect("DATABASE_URL must be set");
 
+    println!("{:?}", url);
+
     let manager = PostgresConnectionManager::new(url, TlsMode::None)
         .expect("could not instantiate pg manager");