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

ez mode tutorial and updates to the auth and anon user structs

Browse Source
This commit is contained in:
ntr
2020-01-08 17:17:05 +10:00
parent d7931bc3bb
commit 549b9cdf65
12 changed files with 168 additions and 63 deletions
Download Patch File Download Diff File Expand all files Collapse all files
server/src/pg.rs
+9 -2
View File
@@ -695,11 +695,17 @@ pub fn instance_practice(tx: &mut Transaction, account: &Account) -> Result<Inst
}
pub fn instance_demo(account: &Account) -> Result<Instance, Error> {
let bot = bot_player();
let mut bot = bot_player();
let bot_id = bot.id;
// generate imgs for the client to see
for c in bot.constructs.iter() {
for c in bot.constructs.iter_mut() {
// smash these nubs
c.green_life.force(64);
c.red_life.force(0);
c.blue_life.force(0);
img::shapes_write(c.img)?;
}
@@ -709,6 +715,7 @@ pub fn instance_demo(account: &Account) -> Result<Instance, Error> {
let player = anon_player(account.id);
// smash these noobs
for c in player.constructs.iter() {
img::shapes_write(c.img)?;
}
server/src/rpc.rs
+12 -16
View File
@@ -2,7 +2,6 @@ use mnml_core::item::ItemInfoCtr;
use mnml_core::instance::ChatState;
use std::collections::HashMap;
use std::time::{Instant};
use std::thread::{spawn};
use std::str;
@@ -23,7 +22,7 @@ use account;
use events::{Event};
use user_anonymous::{Anonymous};
use user_authenticated::{Authorised};
use user_authenticated::{Authenticated};
use mnml_core::construct::{Construct};
use mnml_core::game::{Game};
@@ -37,7 +36,7 @@ use mnml_core::instance::{Instance};
use mtx;
use mail::Email;
use pg::{Db};
use pg::{PgPool};
use http::{AUTH_CLEAR, TOKEN_HEADER};
@@ -63,6 +62,7 @@ pub enum RpcMessage {
Pong(()),
StartTutorial(()),
PromptRegister(()),
QueueRequested(()),
QueueJoined(()),
@@ -126,9 +126,9 @@ pub enum RpcRequest {
}
pub trait User {
fn receive(&mut self, data: Vec<u8>, db: &Db, begin: Instant, events: &CbSender<Event>, stripe: &StripeClient) -> Result<RpcMessage, Error>;
fn connected(&mut self, db: &Db, events: &CbSender<Event>, ws: &CbSender<RpcMessage>) -> Result<(), Error>;
fn send(&mut self, msg: RpcMessage, events: &CbSender<Event>, ws: &CbSender<RpcMessage>) -> Result<(), Error>;
fn receive(&mut self, data: Vec<u8>, stripe: &StripeClient) -> Result<RpcMessage, Error>;
fn connected(&mut self) -> Result<(), Error>;
fn send(&mut self, msg: RpcMessage) -> Result<(), Error>;
}
struct Connection {
@@ -165,20 +165,16 @@ impl Connection {
// when it encounters errors
impl Handler for Connection {
fn on_open(&mut self, _: ws::Handshake) -> ws::Result<()> {
let db = self.pool.get().unwrap();
self.user.connected(&db, &self.events, &self.ws).unwrap();
self.user.connected().unwrap();
Ok(())
}
fn on_message(&mut self, msg: Message) -> ws::Result<()> {
match msg {
Message::Binary(msg) => {
let begin = Instant::now();
let db_connection = self.pool.get().unwrap();
match self.user.receive(msg, &db_connection, begin, &self.events, &self.stripe) {
match self.user.receive(msg, &self.stripe) {
Ok(msg) => {
self.user.send(msg, &self.events, &self.ws).unwrap();
self.user.send(msg).unwrap();
},
Err(e) => {
warn!("{:?}", e);
@@ -220,7 +216,7 @@ impl Handler for Connection {
if cookie.name() == TOKEN_HEADER {
let db = self.pool.get().unwrap();
match account::from_token(&db, &cookie.value().to_string()) {
Ok(a) => self.user = Box::new(Authorised { id: a.id, account: a }),
Ok(a) => self.user = Box::new(Authenticated::new(a, self.ws.clone(), self.events.clone(), self.pool.clone())),
Err(_) => return unauth(),
}
}
@@ -268,11 +264,11 @@ pub fn start(pool: PgPool, events_tx: CbSender<Event>, stripe: StripeClient) {
DeflateHandler::new(
Connection {
id,
ws: tx,
ws: tx.clone(),
pool: pool.clone(),
stripe: stripe.clone(),
events: events_tx.clone(),
user: Box::new(Anonymous { id, account: anon_account, game: None, instance: None })
user: Box::new(Anonymous::new(anon_account, tx))
}
)
})
server/src/user_anonymous.rs
+24 -10
View File
@@ -1,4 +1,3 @@
use std::time::Instant;
use uuid::Uuid;
use failure::Error;
@@ -9,11 +8,8 @@ use crossbeam_channel::{Sender as CbSender};
use serde_cbor::{from_slice};
use stripe::{Client as StripeClient};
use account::{Account};
use pg::{Db};
use pg;
use events::{Event};
use rpc::{RpcMessage, RpcRequest, User};
use mnml_core::game::Game;
@@ -26,10 +22,24 @@ pub struct Anonymous {
pub id: Uuid,
pub instance: Option<Instance>,
pub game: Option<Game>,
ws: CbSender<RpcMessage>,
}
impl Anonymous {
pub fn new(account: Account, ws: CbSender<RpcMessage>) -> Anonymous {
Anonymous {
id: account.id,
account,
ws,
instance: None,
game: None,
}
}
}
impl User for Anonymous {
fn send(&mut self, msg: RpcMessage, _events: &CbSender<Event>, ws: &CbSender<RpcMessage>) -> Result<(), Error> {
fn send(&mut self, msg: RpcMessage) -> Result<(), Error> {
// if the user queries the state of something
// we tell events to push updates to them
match msg {
@@ -40,21 +50,21 @@ impl User for Anonymous {
_ => (),
};
ws.send(msg)?;
self.ws.send(msg)?;
Ok(())
}
fn connected(&mut self, _db: &Db, events: &CbSender<Event>, ws: &CbSender<RpcMessage>) -> Result<(), Error> {
fn connected(&mut self) -> Result<(), Error> {
info!("anonymous connection");
self.send(RpcMessage::AccountState(self.account.clone()), events, ws)?;
self.send(RpcMessage::StartTutorial(()), events, ws)?;
self.ws.send(RpcMessage::AccountState(self.account.clone()))?;
self.ws.send(RpcMessage::StartTutorial(()))?;
Ok(())
}
fn receive(&mut self, data: Vec<u8>, _db: &Db, _begin: Instant, _events: &CbSender<Event>, _stripe: &StripeClient) -> Result<RpcMessage, Error> {
fn receive(&mut self, data: Vec<u8>, _stripe: &StripeClient) -> Result<RpcMessage, Error> {
match from_slice::<RpcRequest>(&data) {
Ok(v) => {
let get_instance = || {
@@ -139,6 +149,10 @@ impl User for Anonymous {
game = game.resolve_phase_start();
}
if game.finished() {
self.ws.send(RpcMessage::PromptRegister(()))?;
}
Ok(RpcMessage::GameState(game))
},
server/src/user_authenticated.rs
+48 -27
View File
@@ -37,72 +37,90 @@ use events::{Event};
use mtx;
use mail;
use payments;
use pg::{Db};
use pg::{PgPool};
use rpc::{RpcMessage, RpcRequest, User};
#[derive(Debug,Clone)]
pub struct Authorised {
pub struct Authenticated {
pub account: Account,
pub id: Uuid
pub id: Uuid,
events: CbSender<Event>,
ws: CbSender<RpcMessage>,
pool: PgPool,
}
impl User for Authorised {
fn send(&mut self, msg: RpcMessage, events: &CbSender<Event>, ws: &CbSender<RpcMessage>) -> Result<(), Error> {
impl Authenticated {
pub fn new(account: Account, ws: CbSender<RpcMessage>, events: CbSender<Event>, pool: PgPool) -> Authenticated {
Authenticated {
id: account.id,
account,
ws,
events,
pool,
}
}
}
impl User for Authenticated {
fn send(&mut self, msg: RpcMessage) -> Result<(), Error> {
// if the user queries the state of something
// we tell events to push updates to them
match msg {
RpcMessage::AccountState(ref v) => {
events.send(Event::Subscribe(self.id, v.id))?
self.events.send(Event::Subscribe(self.id, v.id))?
},
RpcMessage::GameState(ref v) =>
events.send(Event::Subscribe(self.id, v.id))?,
self.events.send(Event::Subscribe(self.id, v.id))?,
RpcMessage::InstanceState(ref v) =>
events.send(Event::Subscribe(self.id, v.id))?,
self.events.send(Event::Subscribe(self.id, v.id))?,
_ => (),
};
ws.send(msg)?;
self.ws.send(msg)?;
Ok(())
}
fn connected(&mut self, db: &Db, events: &CbSender<Event>, ws: &CbSender<RpcMessage>) -> Result<(), Error> {
fn connected(&mut self) -> Result<(), Error> {
info!("authenticated connection account={:?}", self.account);
let a = &self.account;
ws.send(RpcMessage::AccountAuthenticated(a.clone()))?;
self.ws.send(RpcMessage::AccountAuthenticated(a.clone()))?;
// tell events we have connected
events.send(Event::Connect(self.id, a.clone(), ws.clone()))?;
self.events.send(Event::Connect(self.id, a.clone(), self.ws.clone()))?;
ws.send(RpcMessage::AccountState(a.clone()))?;
events.send(Event::Subscribe(self.id, a.id))?;
self.ws.send(RpcMessage::AccountState(a.clone()))?;
self.events.send(Event::Subscribe(self.id, a.id))?;
// check if they have an image that needs to be generated
account::img_check(&a)?;
let db = self.pool.get()?;
let mut tx = db.transaction()?;
// send account constructs
let account_constructs = account::constructs(&mut tx, &a)?;
ws.send(RpcMessage::AccountConstructs(account_constructs))?;
self.ws.send(RpcMessage::AccountConstructs(account_constructs))?;
// get account instances
// and send them to the client
let account_instances = account::account_instances(&mut tx, &a)?;
ws.send(RpcMessage::AccountInstances(account_instances))?;
self.ws.send(RpcMessage::AccountInstances(account_instances))?;
let shop = mtx::account_shop(&mut tx, &a)?;
ws.send(RpcMessage::AccountShop(shop))?;
self.ws.send(RpcMessage::AccountShop(shop))?;
let team = account::team(&mut tx, &a)?;
ws.send(RpcMessage::AccountTeam(team))?;
self.ws.send(RpcMessage::AccountTeam(team))?;
let wheel = account::chat_wheel(&db, a.id)?;
ws.send(RpcMessage::ChatWheel(wheel))?;
self.ws.send(RpcMessage::ChatWheel(wheel))?;
if let Some(instance) = account::tutorial(&mut tx, &a)? {
ws.send(RpcMessage::InstanceState(instance))?;
self.ws.send(RpcMessage::InstanceState(instance))?;
}
// tx should do nothing
@@ -111,8 +129,11 @@ impl User for Authorised {
Ok(())
}
fn receive(&mut self, data: Vec<u8>, db: &Db, begin: Instant, events: &CbSender<Event>, stripe: &StripeClient) -> Result<RpcMessage, Error> {
fn receive(&mut self, data: Vec<u8>, stripe: &StripeClient) -> Result<RpcMessage, Error> {
// cast the msg to this type to receive method name
let begin = Instant::now();
let db = self.pool.get()?;
match from_slice::<RpcRequest>(&data) {
Ok(v) => {
let request = v.clone();
@@ -123,19 +144,19 @@ impl User for Authorised {
return Ok(RpcMessage::GameState(anim_test_game(skill))),
RpcRequest::InstanceQueue {} => {
events.send(Event::Queue(self.id))?;
self.events.send(Event::Queue(self.id))?;
Ok(RpcMessage::QueueRequested(()))
},
RpcRequest::InstanceInvite {} => {
events.send(Event::Invite(self.id))?;
self.events.send(Event::Invite(self.id))?;
Ok(RpcMessage::InviteRequested(()))
},
RpcRequest::InstanceJoin { code } => {
events.send(Event::Join(self.id, code))?;
self.events.send(Event::Join(self.id, code))?;
Ok(RpcMessage::Joining(()))
},
RpcRequest::InstanceLeave {} => {
events.send(Event::Leave(self.id))?;
self.events.send(Event::Leave(self.id))?;
Ok(RpcMessage::Processing(()))
},
@@ -147,7 +168,7 @@ impl User for Authorised {
let wheel = account::chat_wheel(&db, self.account.id)?;
if let Some(c) = wheel.get(index) {
events.send(Event::Chat(self.id, instance_id, c.to_string()))?;
self.events.send(Event::Chat(self.id, instance_id, c.to_string()))?;
} else {
return Err(err_msg("invalid chat index"));
}
@@ -172,7 +193,7 @@ impl User for Authorised {
Ok(RpcMessage::EmailState(mail::select_account(&db, self.account.id)?)),
RpcRequest::SubscriptionState {} =>
Ok(RpcMessage::SubscriptionState(payments::account_subscription(db, stripe, &self.account)?)),
Ok(RpcMessage::SubscriptionState(payments::account_subscription(&db, stripe, &self.account)?)),
// RpcRequest::AccountShop {} =>
// Ok(RpcMessage::AccountShop(mtx::account_shop(&mut tx, &account)?)),