forget and learn

server/src/cryp.rs

@@ -8,7 +8,7 @@ use failure::Error;
 use failure::err_msg;
 
 use account::Account;
-use rpc::{CrypSpawnParams};
+use rpc::{CrypSpawnParams, CrypLearnParams, CrypForgetParams};
 use skill::{Skill, Cooldown, Effect, Cast, Source};
 use game::{Log};
 
@@ -129,6 +129,16 @@ impl Cryp {
         self
     }
 
+    pub fn forget(mut self, skill: Skill) -> Result<Cryp, Error> {
+        match self.skills.iter().position(|s| s.skill == skill) {
+            Some(i) => {
+                self.skills.remove(i);
+                return Ok(self);
+            },
+            None => Err(format_err!("{:?} does not know {:?}", self.name, skill)),
+        }
+    }
+
     pub fn add_xp(mut self) -> Cryp {
         self.xp = self.xp.saturating_add(1);
         if self.xp.is_power_of_two() {
@@ -326,8 +336,6 @@ pub fn cryp_spawn(params: CrypSpawnParams, tx: &mut Transaction, account: &Accou
     let cryp = Cryp::new()
         .named(&params.name)
         .level(10)
-        .learn(Skill::Stun)
-        .learn(Skill::Block)
         .set_account(account.id)
         .create();
 
@@ -349,6 +357,18 @@ pub fn cryp_spawn(params: CrypSpawnParams, tx: &mut Transaction, account: &Accou
     return Ok(cryp);
 }
 
+pub fn cryp_learn(params: CrypLearnParams, tx: &mut Transaction, account: &Account) -> Result<Cryp, Error> {
+    let mut cryp = cryp_get(tx, params.id, account.id)?;
+    cryp = cryp.learn(params.skill);
+    return cryp_write(cryp, tx);
+}
+
+pub fn cryp_forget(params: CrypForgetParams, tx: &mut Transaction, account: &Account) -> Result<Cryp, Error> {
+    let mut cryp = cryp_get(tx, params.id, account.id)?;
+    cryp = cryp.forget(params.skill)?;
+    return cryp_write(cryp, tx);
+}
+
 pub fn cryp_write(cryp: Cryp, tx: &mut Transaction) -> Result<Cryp, Error> {
     let cryp_bytes = to_vec(&cryp)?;
 

server/src/rpc.rs

@@ -10,7 +10,7 @@ use failure::Error;
 use failure::err_msg;
 
 use net::Db;
-use cryp::{Cryp, cryp_spawn};
+use cryp::{Cryp, cryp_spawn, cryp_learn, cryp_forget};
 use game::{Game, game_state, game_pve, game_pvp, game_join, game_skill, game_target};
 use account::{Account, account_create, account_login, account_from_token, account_cryps};
 use item::{Item, items_list, item_use};
@@ -39,6 +39,8 @@ impl Rpc {
                 // match on that to determine what fn to call
                 let response = match v.method.as_ref() {
                     "cryp_spawn" => Rpc::cryp_spawn(data, &mut tx, account, client),
+                    "cryp_learn" => Rpc::cryp_learn(data, &mut tx, account, client),
+                    "cryp_forget" => Rpc::cryp_forget(data, &mut tx, account, client),
                     "game_state" => Rpc::game_state(data, &mut tx, account, client),
                     "game_pve" => Rpc::game_pve(data, &mut tx, account, client),
                     "game_pvp" => Rpc::game_pvp(data, &mut tx, account, client),
@@ -206,6 +208,49 @@ impl Rpc {
         Ok(cryp_list)
     }
 
+    fn cryp_learn(data: Vec<u8>, tx: &mut Transaction, account: Option<Account>, client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
+        let a = match account {
+            Some(a) => a,
+            None => return Err(err_msg("auth required")),
+        };
+
+        let msg = from_slice::<CrypLearnMsg>(&data).or(Err(err_msg("invalid params")))?;
+
+        Rpc::send_msg(client, RpcResponse {
+            method: "cryp_learn".to_string(),
+            params: RpcResult::CrypLearn(cryp_learn(msg.params, tx, &a)?)
+        })?;
+
+        let cryp_list = RpcResponse {
+            method: "account_cryps".to_string(),
+            params: RpcResult::CrypList(account_cryps(tx, &a)?)
+        };
+
+        Ok(cryp_list)
+    }
+
+    fn cryp_forget(data: Vec<u8>, tx: &mut Transaction, account: Option<Account>, client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
+        let a = match account {
+            Some(a) => a,
+            None => return Err(err_msg("auth required")),
+        };
+
+        let msg = from_slice::<CrypForgetMsg>(&data).or(Err(err_msg("invalid params")))?;
+
+        Rpc::send_msg(client, RpcResponse {
+            method: "cryp_forget".to_string(),
+            params: RpcResult::CrypForget(cryp_forget(msg.params, tx, &a)?)
+        })?;
+
+        let cryp_list = RpcResponse {
+            method: "account_cryps".to_string(),
+            params: RpcResult::CrypList(account_cryps(tx, &a)?)
+        };
+
+        Ok(cryp_list)
+    }
+
+
     fn account_create(data: Vec<u8>, tx: &mut Transaction, _account: Option<Account>, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
         match from_slice::<AccountCreateMsg>(&data) {
             Ok(v) => Ok(RpcResponse {
@@ -276,6 +321,8 @@ pub struct RpcResponse {
 #[derive(Debug,Clone,Serialize,Deserialize)]
 pub enum RpcResult {
     CrypSpawn(Cryp),
+    CrypForget(Cryp),
+    CrypLearn(Cryp),
     Account(Account),
     CrypList(Vec<Cryp>),
     GameState(Game),
@@ -300,6 +347,30 @@ pub struct CrypSpawnParams {
     pub name: String,
 }
 
+#[derive(Debug,Clone,Serialize,Deserialize)]
+struct CrypLearnMsg {
+    method: String,
+    params: CrypLearnParams,
+}
+
+#[derive(Debug,Clone,Serialize,Deserialize)]
+pub struct CrypLearnParams {
+    pub id: Uuid,
+    pub skill: Skill,
+}
+
+#[derive(Debug,Clone,Serialize,Deserialize)]
+pub struct CrypForgetParams {
+    pub id: Uuid,
+    pub skill: Skill,
+}
+
+#[derive(Debug,Clone,Serialize,Deserialize)]
+struct CrypForgetMsg {
+    method: String,
+    params: CrypForgetParams,
+}
+
 #[derive(Debug,Clone,Serialize,Deserialize)]
 struct GameStateMsg {
     method: String,