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

wip

Browse Source
This commit is contained in:
ntr 2019-04-25 14:20:04 +10:00
parent e908ed9a35
commit fcb224f341
9 changed files with 159 additions and 159 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
client/src/components/game.component.jsx
View File

@ -18,7 +18,7 @@ function GamePanel(props) {
setActiveSkill,
setActiveCryp,
selectSkillTarget,
sendPlayerState,
sendInstanceState,
activeCryp,
account,
showLog,
@ -50,7 +50,7 @@ function GamePanel(props) {
function backClick() {
quit();
return sendPlayerState(game.instance);
return sendInstanceState(game.instance);
}
const header = (

6
client/src/components/game.container.jsx
View File

@ -23,9 +23,9 @@ const addState = connect(
return false;
}
function sendPlayerState(instanceId) {
function sendInstanceState(instanceId) {
if (!instanceId) return false;
return ws.sendPlayerState(instanceId);
return ws.sendInstanceState(instanceId);
}
// intercept self casting skills
@ -41,7 +41,7 @@ const addState = connect(
activeSkill,
activeCryp,
selectSkillTarget,
sendPlayerState,
sendInstanceState,
};
},

4
client/src/components/menu.component.jsx
View File

@ -20,7 +20,7 @@ function Menu(args) {
cryps,
selectedCryps,
setSelectedCryps,
sendPlayerState,
sendInstanceState,
sendPlayerMmCrypsSet,
sendInstanceJoin,
sendCrypSpawn,
@ -40,7 +40,7 @@ function Menu(args) {
<button
className={`menu-instance-btn right ${globalInstance ? 'full' : ''}`}
key={instance.id}
onClick={() => sendPlayerState(instance)}>
onClick={() => sendInstanceState(instance)}>
{name}
</button>
);

6
client/src/components/menu.container.jsx
View File

@ -25,15 +25,15 @@ const addState = connect(
return ws.sendCrypSpawn(name);
}
function sendPlayerState(instance) {
return ws.sendPlayerState(instance.instance);
function sendInstanceState(instance) {
return ws.sendInstanceState(instance.instance);
}
return {
cryps,
selectedCryps,
sendInstanceJoin,
sendPlayerState,
sendInstanceState,
sendCrypSpawn,
sendPlayerMmCrypsSet,
instances,

10
client/src/socket.jsx
View File

@ -86,8 +86,8 @@ function createSocket(events) {
send({ method: 'player_mm_cryps_set', params: { cryp_ids: crypIds } });
}
function sendPlayerState(instanceId) {
send({ method: 'player_state', params: { instance_id: instanceId } });
function sendInstanceState(instanceId) {
send({ method: 'instanceState', params: { instance_id: instanceId } });
}
function sendVboxAccept(instanceId, group, index) {
@ -205,7 +205,7 @@ function createSocket(events) {
events.setZone(zone);
}
function playerState(response) {
function instanceState(response) {
const [structName, player] = response;
events.setPlayer(player);
}
@ -234,7 +234,7 @@ function createSocket(events) {
zone_create: res => console.log(res),
zone_state: zoneState,
zone_close: res => console.log(res),
player_state: playerState,
instanceState: instanceState,
};
function logout() {
@ -337,7 +337,7 @@ function createSocket(events) {
sendInstanceLobby,
sendInstanceScores,
sendPlayerMmCrypsSet,
sendPlayerState,
sendInstanceState,
sendVboxAccept,
sendVboxApply,
sendVboxReclaim,

91
server/src/instance.rs
View File

@ -9,12 +9,13 @@ use failure::err_msg;
use std::iter;
use rpc::{InstanceLobbyParams, InstanceJoinParams, InstanceReadyParams};
use rpc::{InstanceLobbyParams, InstanceJoinParams, InstanceReadyParams, InstanceStateParams};
use account::Account;
use player::{Player, Score, player_create, player_get, player_update};
use cryp::{Cryp, cryp_get};
use mob::{instance_mobs};
use game::{Game, Team, game_get, game_write, game_instance_new, game_instance_join, game_global_get, game_global_set};
use vbox::{Var};
#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
enum InstancePhase {
@ -57,6 +58,19 @@ impl Instance {
}
}
pub fn global(player: Player) -> Instance {
Instance {
id: Uuid::nil(),
players: vec![player],
rounds: vec![],
phase: InstancePhase::Vbox,
open: false,
max_players: 0,
name: "Global Matchmaking".to_string(),
password: None,
}
}
fn set_max_players(mut self, max: usize) -> Result<Instance, Error> {
if max > 16 || max % 2 != 0 {
return Err(err_msg("max players must be divisible by 2 and less than 16"));
@ -189,7 +203,10 @@ impl Instance {
fn vbox_phase_start(&mut self) -> &mut Instance {
self.phase = InstancePhase::Vbox;
self.players.iter_mut().for_each(|p| p.ready = false);
self.players.iter_mut().for_each(|p| {
p.ready = false;
p.vbox.fill();
});
self.generate_rounds();
self.bot_vbox_phase();
@ -352,6 +369,50 @@ impl Instance {
scores
}
// PLAYER ACTIONS
fn account_player(&mut self, account: Uuid) -> Result<&mut Player, Error> {
self.players
.iter_mut()
.find(|p| p.account == account)
.ok_or(err_msg("account not in instance"))
}
pub fn vbox_discard(mut self, account: Uuid) -> Result<Instance, Error> {
self.account_player(account)?
.vbox_discard()?;
Ok(self)
}
pub fn vbox_accept(mut self, account: Uuid, group: usize, index: usize) -> Result<Instance, Error> {
self.account_player(account)?
.vbox_accept(group, index)?;
Ok(self)
}
pub fn vbox_combine(mut self, account: Uuid, indices: Vec<usize>) -> Result<Instance, Error> {
self.account_player(account)?
.vbox_combine(indices)?;
Ok(self)
}
pub fn vbox_reclaim(mut self, account: Uuid, index: usize) -> Result<Instance, Error> {
self.account_player(account)?
.vbox_reclaim(index)?;
Ok(self)
}
pub fn vbox_apply(mut self, account: Uuid, index: usize, cryp_id: Uuid) -> Result<Instance, Error> {
self.account_player(account)?
.vbox_apply(index, cryp_id)?;
Ok(self)
}
pub fn vbox_unequip(mut self, account: Uuid, target: Var, cryp_id: Uuid) -> Result<Instance, Error> {
self.account_player(account)?
.vbox_unequip(target, cryp_id)?;
Ok(self)
}
}
pub fn instance_create(tx: &mut Transaction, instance: Instance) -> Result<Instance, Error> {
@ -433,7 +494,7 @@ pub fn instance_get_open(tx: &mut Transaction) -> Result<Instance, Error> {
return Ok(instance);
}
pub fn instance_lobby(params: InstanceLobbyParams, tx: &mut Transaction, account: &Account) -> Result<Player, Error> {
pub fn instance_lobby(params: InstanceLobbyParams, tx: &mut Transaction, account: &Account) -> Result<Instance, Error> {
let mut instance = Instance::new()
.set_max_players(params.players)?
.set_name(params.name)?;
@ -445,7 +506,7 @@ pub fn instance_lobby(params: InstanceLobbyParams, tx: &mut Transaction, account
}
pub fn instance_join(params: InstanceJoinParams, tx: &mut Transaction, account: &Account) -> Result<Player, Error> {
pub fn instance_join(params: InstanceJoinParams, tx: &mut Transaction, account: &Account) -> Result<Instance, Error> {
let mut instance = instance_get(tx, params.instance_id)?;
let cryps = params.cryp_ids
@ -458,12 +519,9 @@ pub fn instance_join(params: InstanceJoinParams, tx: &mut Transaction, account:
}
let player = Player::new(account.id, instance.id, &account.name, cryps);
let player = player_create(tx, player, account)?;
instance.add_player(player);
instance.add_player(player.clone());
instance_update(tx, instance)?;
return Ok(player);
instance_update(tx, instance)
}
pub fn instance_ready_global(tx: &mut Transaction, _account: &Account, player: Player) -> Result<Game, Error> {
@ -492,21 +550,16 @@ pub fn instance_scores(params: InstanceReadyParams, tx: &mut Transaction, _accou
Ok(scores)
}
pub fn instance_lobby_ready(params: InstanceReadyParams, tx: &mut Transaction, account: &Account) -> Result<Player, Error> {
pub fn instance_ready(params: InstanceReadyParams, tx: &mut Transaction, account: &Account) -> Result<Instance, Error> {
let player = player_get(tx, account.id, params.instance_id)?;
let mut instance = instance_get(tx, params.instance_id)?;
instance.player_ready(player.id)?;
if instance.can_start() {
instance.start();
for player in instance.players.iter_mut().filter(|p| !p.bot) {
player.vbox.fill();
player_update(tx, player.clone(), false)?;
}
}
instance_update(tx, instance)
}
instance_update(tx, instance)?;
Ok(player)
pub fn instance_state(params: InstanceStateParams, tx: &mut Transaction, account: &Account) -> Result<Instance, Error> {
instance_get(tx, params.instance_id)
}
// pub fn instance_ready(params: InstanceReadyParams, tx: &mut Transaction, account: &Account) -> Result<Game, Error> {

21
server/src/player.rs
View File

@ -11,8 +11,8 @@ use failure::err_msg;
use account::Account;
use cryp::{Cryp, Colours, cryp_get};
use vbox::{Vbox, Var, VarEffect};
use rpc::{PlayerStateParams, PlayerCrypsSetParams};
use instance::{instance_get, instance_update};
use rpc::{PlayerCrypsSetParams};
use instance::{Instance, instance_get, instance_update};
const DISCARD_COST: u16 = 5;
@ -353,11 +353,7 @@ pub fn player_delete(tx: &mut Transaction, id: Uuid) -> Result<(), Error> {
return Ok(());
}
pub fn player_state(params: PlayerStateParams, tx: &mut Transaction, account: &Account) -> Result<Player, Error> {
player_get(tx, account.id, params.instance_id)
}
pub fn player_mm_cryps_set(params: PlayerCrypsSetParams, tx: &mut Transaction, account: &Account) -> Result<Player, Error> {
pub fn player_mm_cryps_set(params: PlayerCrypsSetParams, tx: &mut Transaction, account: &Account) -> Result<Instance, Error> {
if params.cryp_ids.len() != 3 {
return Err(err_msg("team size is 3"));
}
@ -367,16 +363,19 @@ pub fn player_mm_cryps_set(params: PlayerCrypsSetParams, tx: &mut Transaction, a
.map(|id| cryp_get(tx, *id, account.id))
.collect::<Result<Vec<Cryp>, Error>>()?;
match player_get(tx, account.id, Uuid::nil()) {
let player = match player_get(tx, account.id, Uuid::nil()) {
Ok(mut p) => {
p.cryps = cryps;
p.vbox = Vbox::new(account.id, Uuid::nil());
player_update(tx, p, false)
player_update(tx, p, false)?
},
Err(_) => {
return player_create(tx, Player::new(account.id, Uuid::nil(), &account.name, cryps), &account)
}
player_create(tx, Player::new(account.id, Uuid::nil(), &account.name, cryps), &account)?
}
};
let instance = Instance::global(player);
Ok(instance)
}
#[cfg(test)]

115
server/src/rpc.rs
View File

@ -21,8 +21,8 @@ use account::{Account, account_create, account_login, account_from_token, accoun
use skill::{Skill};
// use zone::{Zone, zone_create, zone_join, zone_close};
use spec::{Spec};
use player::{Score, player_state, player_mm_cryps_set, Player};
use instance::{instance_lobby, instance_lobby_ready, instance_join, instance_scores};
use player::{Score, player_mm_cryps_set, Player};
use instance::{Instance, instance_state, instance_lobby, instance_ready, instance_join, instance_scores};
use vbox::{Var, vbox_accept, vbox_apply, vbox_discard, vbox_combine, vbox_reclaim, vbox_unequip};
pub struct Rpc;
@ -70,19 +70,14 @@ impl Rpc {
"cryp_spawn" => Rpc::cryp_spawn(data, &mut tx, account.unwrap(), client),
"game_state" => Rpc::game_state(data, &mut tx, account.unwrap(), client),
// "game_pve" => Rpc::game_pve(data, &mut tx, account.unwrap(), client),
"game_skill" => Rpc::game_skill(data, &mut tx, account.unwrap(), client),
// "zone_create" => Rpc::zone_create(data, &mut tx, account.unwrap(), client),
// "zone_join" => Rpc::zone_join(data, &mut tx, account.unwrap(), client),
// "zone_close" => Rpc::zone_close(data, &mut tx, account.unwrap(), client),
"instance_join" => Rpc::instance_join(data, &mut tx, account.unwrap(), client),
// "instance_ready" => Rpc::instance_ready(data, &mut tx, account.unwrap(), client),
"instance_ready" => Rpc::instance_ready(data, &mut tx, account.unwrap(), client),
"instance_lobby" => Rpc::instance_lobby(data, &mut tx, account.unwrap(), client),
"instance_scores" => Rpc::instance_scores(data, &mut tx, account.unwrap(), client),
"instance_state" => Rpc::instance_state(data, &mut tx, account.unwrap(), client),
"player_state" => Rpc::player_state(data, &mut tx, account.unwrap(), client),
"player_mm_cryps_set" => Rpc::player_mm_cryps_set(data, &mut tx, account.unwrap(), client),
"player_vbox_accept" => Rpc::player_vbox_accept(data, &mut tx, account.unwrap(), client),
"player_vbox_apply" => Rpc::player_vbox_apply(data, &mut tx, account.unwrap(), client),
@ -222,63 +217,23 @@ impl Rpc {
})
}
// fn account_zone(_data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
// Ok(RpcResponse {
// method: "zone_state".to_string(),
// params: RpcResult::ZoneState(account_zone(tx, &account)?)
// })
// }
// fn zone_create(_data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
// // let _msg = from_slice::<ZoneCreateMsg>(&data).or(Err(err_msg("invalid params")))?;
// let response = RpcResponse {
// method: "zone_state".to_string(),
// params: RpcResult::ZoneState(zone_create(tx, &account)?)
// };
// return Ok(response);
// }
// fn zone_join(data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
// let msg = from_slice::<ZoneJoinMsg>(&data).or(Err(err_msg("invalid params")))?;
// let response = RpcResponse {
// method: "game_state".to_string(),
// params: RpcResult::GameState(zone_join(msg.params, tx, &account)?)
// };
// return Ok(response);
// }
// fn zone_close(data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
// let msg = from_slice::<ZoneCloseMsg>(&data).or(Err(err_msg("invalid params")))?;
// let response = RpcResponse {
// method: "zone_close".to_string(),
// params: RpcResult::ZoneClose(zone_close(msg.params, tx, &account)?)
// };
// return Ok(response);
// }
fn instance_lobby(data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
let msg = from_slice::<InstanceLobbyMsg>(&data).or(Err(err_msg("invalid params")))?;
let response = RpcResponse {
method: "player_state".to_string(),
params: RpcResult::PlayerState(instance_lobby(msg.params, tx, &account)?)
method: "instance_state".to_string(),
params: RpcResult::InstanceState(instance_lobby(msg.params, tx, &account)?)
};
return Ok(response);
}
fn instance_lobby_ready(data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
fn instance_ready(data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
let msg = from_slice::<InstanceReadyMsg>(&data).or(Err(err_msg("invalid params")))?;
let response = RpcResponse {
method: "player_state".to_string(),
params: RpcResult::PlayerState(instance_lobby_ready(msg.params, tx, &account)?)
method: "instance_state".to_string(),
params: RpcResult::InstanceState(instance_ready(msg.params, tx, &account)?)
};
return Ok(response);
@ -288,8 +243,8 @@ impl Rpc {
let msg = from_slice::<InstanceJoinMsg>(&data).or(Err(err_msg("invalid params")))?;
let response = RpcResponse {
method: "player_state".to_string(),
params: RpcResult::PlayerState(instance_join(msg.params, tx, &account)?)
method: "instance_state".to_string(),
params: RpcResult::InstanceState(instance_join(msg.params, tx, &account)?)
};
return Ok(response);
@ -317,14 +272,12 @@ impl Rpc {
return Ok(response);
}
fn player_state(data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
let msg = from_slice::<PlayerStateMsg>(&data).or(Err(err_msg("invalid params")))?;
fn instance_state(data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
let msg = from_slice::<InstanceStateMsg>(&data).or(Err(err_msg("invalid params")))?;
let response = RpcResponse {
method: "player_state".to_string(),
params: RpcResult::PlayerState(player_state(msg.params, tx, &account)?)
method: "instance_state".to_string(),
params: RpcResult::InstanceState(instance_state(msg.params, tx, &account)?)
};
return Ok(response);
@ -334,8 +287,8 @@ impl Rpc {
let msg = from_slice::<PlayerCrypsSetMsg>(&data).or(Err(err_msg("invalid params")))?;
let response = RpcResponse {
method: "player_state".to_string(),
params: RpcResult::PlayerState(player_mm_cryps_set(msg.params, tx, &account)?)
method: "instance_state".to_string(),
params: RpcResult::InstanceState(player_mm_cryps_set(msg.params, tx, &account)?)
};
return Ok(response);
@ -345,8 +298,8 @@ impl Rpc {
let msg = from_slice::<VboxAcceptMsg>(&data).or(Err(err_msg("invalid params")))?;
let response = RpcResponse {
method: "player_state".to_string(),
params: RpcResult::PlayerState(vbox_accept(msg.params, tx, &account)?)
method: "instance_state".to_string(),
params: RpcResult::InstanceState(vbox_accept(msg.params, tx, &account)?)
};
return Ok(response);
@ -356,8 +309,8 @@ impl Rpc {
let msg = from_slice::<VboxDiscardMsg>(&data).or(Err(err_msg("invalid params")))?;
let response = RpcResponse {
method: "player_state".to_string(),
params: RpcResult::PlayerState(vbox_discard(msg.params, tx, &account)?)
method: "instance_state".to_string(),
params: RpcResult::InstanceState(vbox_discard(msg.params, tx, &account)?)
};
return Ok(response);
@ -368,8 +321,8 @@ impl Rpc {
let msg = from_slice::<VboxCombineMsg>(&data).or(Err(err_msg("invalid params")))?;
let response = RpcResponse {
method: "player_state".to_string(),
params: RpcResult::PlayerState(vbox_combine(msg.params, tx, &account)?)
method: "instance_state".to_string(),
params: RpcResult::InstanceState(vbox_combine(msg.params, tx, &account)?)
};
return Ok(response);
@ -379,8 +332,8 @@ impl Rpc {
let msg = from_slice::<VboxApplyMsg>(&data).or(Err(err_msg("invalid params")))?;
let response = RpcResponse {
method: "player_state".to_string(),
params: RpcResult::PlayerState(vbox_apply(msg.params, tx, &account)?)
method: "instance_state".to_string(),
params: RpcResult::InstanceState(vbox_apply(msg.params, tx, &account)?)
};
Rpc::send_msg(client, RpcResponse {
@ -395,8 +348,8 @@ impl Rpc {
let msg = from_slice::<VboxReclaimMsg>(&data).or(Err(err_msg("invalid params")))?;
let response = RpcResponse {
method: "player_state".to_string(),
params: RpcResult::PlayerState(vbox_reclaim(msg.params, tx, &account)?)
method: "instance_state".to_string(),
params: RpcResult::InstanceState(vbox_reclaim(msg.params, tx, &account)?)
};
return Ok(response);
@ -406,8 +359,8 @@ impl Rpc {
let msg = from_slice::<VboxUnequipMsg>(&data).or(Err(err_msg("invalid params")))?;
let response = RpcResponse {
method: "player_state".to_string(),
params: RpcResult::PlayerState(vbox_unequip(msg.params, tx, &account)?)
method: "instance_state".to_string(),
params: RpcResult::InstanceState(vbox_unequip(msg.params, tx, &account)?)
};
Rpc::send_msg(client, RpcResponse {
@ -417,8 +370,6 @@ impl Rpc {
return Ok(response);
}
}
#[derive(Debug,Clone,Serialize,Deserialize)]
@ -441,7 +392,7 @@ pub enum RpcResult {
// ZoneClose(()),
PlayerList(Vec<Player>),
PlayerState(Player),
InstanceState(Instance),
}
#[derive(Debug,Clone,Serialize,Deserialize)]
@ -601,13 +552,13 @@ pub struct InstanceReadyParams {
}
#[derive(Debug,Clone,Serialize,Deserialize)]
struct PlayerStateMsg {
struct InstanceStateMsg {
method: String,
params: PlayerStateParams,
params: InstanceStateParams,
}
#[derive(Debug,Clone,Serialize,Deserialize)]
pub struct PlayerStateParams {
pub struct InstanceStateParams {
pub instance_id: Uuid,
}

61
server/src/vbox.rs
View File

@ -15,7 +15,8 @@ use account::Account;
use rpc::{VboxAcceptParams, VboxDiscardParams, VboxCombineParams, VboxApplyParams, VboxReclaimParams, VboxUnequipParams};
use skill::{Skill};
use spec::{Spec};
use player::{Player, player_get, player_update};
use player::{Player};
use instance::{Instance, instance_get, instance_update};
use cryp::{Colours};
#[derive(Debug,Copy,Clone,Serialize,Deserialize,PartialEq,PartialOrd,Ord,Eq)]
@ -412,18 +413,14 @@ impl Vbox {
Var::Attack,
];
let mut vbox = Vbox {
Vbox {
id: Uuid::new_v4(),
account: account_id,
instance: instance_id,
free: vec![],
free: vec![vec![], vec![], vec![]],
bound: starting_items,
bits: 18,
};
// vbox.fill();
return vbox;
}
}
pub fn balance_sub(&mut self, amount: u16) -> Result<&mut Vbox, Error> {
@ -542,40 +539,40 @@ impl Vbox {
}
}
pub fn vbox_discard(params: VboxDiscardParams, tx: &mut Transaction, account: &Account) -> Result<Player, Error> {
let mut player = player_get(tx, account.id, params.instance_id)?;
player.vbox_discard()?;
return player_update(tx, player, false);
pub fn vbox_discard(params: VboxDiscardParams, tx: &mut Transaction, account: &Account) -> Result<Instance, Error> {
let instance = instance_get(tx, params.instance_id)?
.vbox_discard(account.id)?;
return instance_update(tx, instance);
}
pub fn vbox_accept(params: VboxAcceptParams, tx: &mut Transaction, account: &Account) -> Result<Player, Error> {
let mut player = player_get(tx, account.id, params.instance_id)?;
player.vbox_accept(params.group, params.index)?;
return player_update(tx, player, false);
pub fn vbox_accept(params: VboxAcceptParams, tx: &mut Transaction, account: &Account) -> Result<Instance, Error> {
let instance = instance_get(tx, params.instance_id)?
.vbox_accept(account.id, params.group, params.index)?;
return instance_update(tx, instance);
}
pub fn vbox_combine(params: VboxCombineParams, tx: &mut Transaction, account: &Account) -> Result<Player, Error> {
let mut player = player_get(tx, account.id, params.instance_id)?;
player.vbox_combine(params.indices)?;
return player_update(tx, player, false);
pub fn vbox_combine(params: VboxCombineParams, tx: &mut Transaction, account: &Account) -> Result<Instance, Error> {
let instance = instance_get(tx, params.instance_id)?
.vbox_combine(account.id, params.indices)?;
return instance_update(tx, instance);
}
pub fn vbox_reclaim(params: VboxReclaimParams, tx: &mut Transaction, account: &Account) -> Result<Player, Error> {
let mut player = player_get(tx, account.id, params.instance_id)?;
player.vbox_reclaim(params.index)?;
return player_update(tx, player, false);
pub fn vbox_reclaim(params: VboxReclaimParams, tx: &mut Transaction, account: &Account) -> Result<Instance, Error> {
let mut instance = instance_get(tx, params.instance_id)?
.vbox_reclaim(account.id, params.index)?;
return instance_update(tx, instance);
}
pub fn vbox_apply(params: VboxApplyParams, tx: &mut Transaction, account: &Account) -> Result<Player, Error> {
let mut player = player_get(tx, account.id, params.instance_id)?;
player.vbox_apply(params.index, params.cryp_id)?;
return player_update(tx, player, false);
pub fn vbox_apply(params: VboxApplyParams, tx: &mut Transaction, account: &Account) -> Result<Instance, Error> {
let mut instance = instance_get(tx, params.instance_id)?
.vbox_apply(account.id, params.index, params.cryp_id)?;
return instance_update(tx, instance);
}
pub fn vbox_unequip(params: VboxUnequipParams, tx: &mut Transaction, account: &Account) -> Result<Player, Error> {
let mut player = player_get(tx, account.id, params.instance_id)?;
player.vbox_unequip(params.target, params.cryp_id)?;
return player_update(tx, player, false);
pub fn vbox_unequip(params: VboxUnequipParams, tx: &mut Transaction, account: &Account) -> Result<Instance, Error> {
let mut instance = instance_get(tx, params.instance_id)?
.vbox_unequip(account.id, params.target, params.cryp_id)?;
return instance_update(tx, instance);
}
#[cfg(test)]