ntr/mnml
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

forget and learn

Browse Source
This commit is contained in:
ntr 2018-11-20 14:33:40 +11:00
parent 9327b4381c
commit 3e4cb096a5
8 changed files with 147 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
client/src/scenes/cryp.list.js
View File

@ -10,7 +10,6 @@ class CrypList extends Phaser.Scene {
create() {
this.registry.events.on('changedata', this.updateData, this);
this.input.on('gameobjectup', this.clickHandler, this);
console.log('creating');
return true;
}
@ -29,8 +28,6 @@ class CrypList extends Phaser.Scene {
renderCryps(cryps) {
if (!cryps) return true;
console.log(JSON.stringify(this.children.list));
console.log(this.children.length);
this.redraw();
cryps.forEach((cryp, i) => {
@ -42,7 +39,6 @@ class CrypList extends Phaser.Scene {
}
clickHandler(pointer, crypBox) {
console.log(crypBox);
this.registry.set('activeCryp', Object.create(crypBox.cryp));
}
}

42
client/src/scenes/cryp.page.js
View File

@ -1,5 +1,7 @@
const Phaser = require('phaser');
const { TEXT, SKILLS } = require('./constants');
const ROW_WIDTH = 400;
const ROW_HEIGHT = 200;
const ROW_FILL = 0x888888;
@ -11,26 +13,27 @@ const TEXT_MARGIN = 24;
const xPos = i => 0;
const yPos = i => (i * ROW_HEIGHT + ROW_MARGIN) + TOP_MARGIN;
function crypSkill(scene, skill, i) {
scene.add.text(500, 500 + (TEXT_MARGIN * (i + 1)), skill.skill, { fontFamily: 'Arial', fontSize: 24, color: '#ffffff', fontStyle: 'bold' });
return true;
}
class CrypPage extends Phaser.Scene {
constructor() {
constructor(args) {
super({ key: 'CrypPage', active: true });
}
create() {
this.registry.events.on('changedata', this.updateData, this);
this.ws = this.registry.get('ws');
return true;
}
updateData(parent, key, data) {
if (key === 'activeCryp') {
console.log(data);
this.renderCryp(data);
}
if (key === 'ws') {
this.ws = this.registry.get('ws');
}
return true;
}
@ -44,8 +47,29 @@ class CrypPage extends Phaser.Scene {
if (!cryp) return true;
this.redraw();
this.add.text(500, 500, cryp.name, { fontFamily: 'Arial', fontSize: 24, color: '#ffffff', fontStyle: 'bold' });
cryp.skills.forEach((skill, i) => crypSkill(this, skill, i));
this.add.text(500, 500, cryp.name, TEXT.HEADER);
const knownSkill = (skill, i) => {
const text = this.add.text(500, 500 + (TEXT_MARGIN * (i + 1)), skill.skill, TEXT.NORMAL)
.setInteractive();
text.on('pointerdown', () => {
this.ws.sendCrypForget(cryp.id, skill.skill);
});
};
const learnable = (skill, i) => {
const text = this.add.text(600, 0 + (TEXT_MARGIN * (i + 1)), skill, TEXT.NORMAL)
.setInteractive();
text.on('pointerdown', () => {
this.ws.sendCrypLearn(cryp.id, skill);
});
};
cryp.skills.forEach(knownSkill);
SKILLS.LEARNABLE.forEach(learnable);
return true;
}

6
client/src/scenes/cryp.row.js
View File

@ -1,5 +1,7 @@
const Phaser = require('phaser');
const { TEXT } = require('./constants');
const ROW_WIDTH = 400;
const ROW_HEIGHT = 200;
const ROW_FILL = 0x888888;
@ -21,8 +23,8 @@ function crypRow(list, cryp, i) {
.setOrigin(0);
row.cryp = cryp;
list.add.text(X_ORIGIN, Y_ORIGIN + (TEXT_MARGIN * 0), cryp.name, { fontFamily: 'Arial', fontSize: 24, color: '#ffffff', fontStyle: 'bold' });
list.add.text(X_ORIGIN, Y_ORIGIN + (TEXT_MARGIN * 1), cryp.stamina.base, { fontFamily: 'Arial', fontSize: 24, color: '#ffffff', fontStyle: 'bold' });
list.add.text(X_ORIGIN, Y_ORIGIN + (TEXT_MARGIN * 0), cryp.name, TEXT.HEADER);
list.add.text(X_ORIGIN, Y_ORIGIN + (TEXT_MARGIN * 1), cryp.stamina.base, TEXT.NORMAL);
return true;
}

3
client/src/scenes/cryps.js
View File

@ -5,7 +5,7 @@ const CrypPage = require('./cryp.page');
const Menu = require('./menu');
// const Passives = require('./passives');
function renderCryps(store) {
function renderCryps(store, socket) {
const config = {
type: Phaser.AUTO,
// parent: 'cryps',
@ -32,6 +32,7 @@ function renderCryps(store) {
store.subscribe(() => {
const state = store.getState();
game.registry.set('cryps', state.cryps);
game.registry.set('ws', state.ws);
});
window.addEventListener('resize', () => game.resize(window.innerWidth, window.innerHeight), false);

4
client/src/scenes/menu.js
View File

@ -1,12 +1,14 @@
const Phaser = require('phaser');
const { TEXT } = require('./constants');
class Menu extends Phaser.Scene {
constructor(props) {
super({ key: 'Menu', active: true });
}
create() {
this.add.text(0, 0, 'cryps.gg', { fontFamily: 'Arial', fontSize: 24, color: '#ffffff', fontStyle: 'bold' });
this.add.text(0, 0, 'cryps.gg', TEXT.HEADER);
}
}

10
client/src/socket.jsx
View File

@ -116,6 +116,14 @@ function createSocket(store) {
send({ method: 'cryp_spawn', params: { name } });
}
function sendCrypLearn(id, skill) {
send({ method: 'cryp_learn', params: { id, skill } });
}
function sendCrypForget(id, skill) {
send({ method: 'cryp_forget', params: { id, skill } });
}
function sendGameState(id) {
send({ method: 'game_state', params: { id } });
}
@ -203,6 +211,8 @@ function createSocket(store) {
sendGameSkill,
sendGameTarget,
sendCrypSpawn,
sendCrypLearn,
sendCrypForget,
sendItemUse,
connect,
};

26
server/src/cryp.rs
View File

@ -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)?;

73
server/src/rpc.rs
View File

@ -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,