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

offer draws

Browse Source
This commit is contained in:
ntr 2019-10-27 13:20:14 +11:00
parent d41ff0d4e8
commit 4593a5f203
10 changed files with 121 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
CHANGELOG.md
View File

@ -2,6 +2,24 @@
All notable changes to this project will be documented in this file.
This project adheres to [Semantic Versioning](http://semver.org/).
## [1.6.5] - 2019-10-27
# Added
- Offering of draws
- Neither player receives a point if they agree to a draw
- Bots automatically agree to draws
## [1.6.5] - 2019-10-25
# Fixed
- Stripe being blocked no longer causes unrecoverable error
- Automatic ready up is now throttled after abandons
- Player width styling
# Changed
- Improved wiggle animation
- Intercept is now considered defensive by bots
- Password restrictions relaxed
## [1.6.4] - 2019-10-24
### Changed
- Animations processing on client side reduced.

10
client/assets/styles/controls.less
View File

@ -144,7 +144,15 @@ aside {
&:active, &.confirming {
background: @red;
color: black;
border: 2px solid black;
border: 2px solid @red;
}
}
.draw:not([disabled]) {
&:active, &.confirming {
background: @gray-hover;
color: black;
border: 2px solid @gray-hover;
}
}

2
client/src/components/game.ctrl.btns.jsx
View File

@ -75,7 +75,7 @@ function GameCtrlBtns(args) {
} = args;
if (!game) return false;
const finished = game.phase === 'Finish';
const finished = game.phase === 'Finished';
function quitClick() {
getInstanceState();

23
client/src/components/game.ctrl.btns.top.jsx
View File

@ -14,10 +14,15 @@ const addState = connect(
return ws.sendInstanceAbandon(game.instance);
}
function sendDraw() {
return ws.sendGameOfferDraw(game.id);
}
return {
game,
sendAbandon,
sendDraw,
};
},
function receiveDispatch(dispatch) {
@ -37,10 +42,11 @@ function GameCtrlTopBtns(args) {
leave,
sendAbandon,
sendDraw,
} = args;
const finished = game && game.phase === 'Finished';
const { abandonState } = this.state;
const { abandonState, drawState } = this.state;
const abandonStateTrue = e => {
e.stopPropagation();
@ -48,16 +54,27 @@ function GameCtrlTopBtns(args) {
setTimeout(() => this.setState({ abandonState: false }), 2000);
};
const drawStateTrue = e => {
e.stopPropagation();
this.setState({ drawState: true });
setTimeout(() => this.setState({ drawState: false }), 2000);
};
const abandonClasses = `abandon ${abandonState ? 'confirming' : ''}`;
const abandonText = abandonState ? 'Confirm' : 'Abandon';
const abandonAction = abandonState ? sendAbandon : abandonStateTrue;
const abandonBtn = <button class={abandonClasses} disabled={finished} onClick={abandonAction}>{abandonText}</button>;
const leaveBtn = <button class='abandon confirming' onClick={leave}>Leave</button>;
const drawClasses = `draw ${drawState ? 'confirming' : ''}`;
const drawText = drawState ? 'Draw' : 'Offer';
const drawAction = drawState ? sendDraw : drawStateTrue;
const drawBtn = <button class={drawClasses} disabled={finished} onClick={drawAction}>{drawText}</button>;
return (
<div class="instance-ctrl-btns">
{finished ? leaveBtn : abandonBtn}
{abandonBtn}
{drawBtn}
</div>
);
}

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

@ -82,7 +82,7 @@ function GameFooter(props) {
const now = Date.now();
const end = Date.parse(game.phase_end);
const timerPct = ((now - zero) / (end - zero) * 100);
const displayPct = game.phase === 'Finish' || !game.phase_end
const displayPct = game.phase === 'Finished' || !game.phase_end
? 0
: Math.min(timerPct, 100);
@ -108,7 +108,7 @@ function GameFooter(props) {
return (
<footer>
{timer}
{game.phase === 'Finish' && quitBtn }
{game.phase === 'Finished' && quitBtn }
{game.phase === 'Skill' && readyBtn }
</footer>
);

6
client/src/socket.jsx
View File

@ -123,6 +123,11 @@ function createSocket(events) {
events.setActiveSkill(null);
}
function sendGameOfferDraw(gameId) {
send(['GameOfferDraw', { game_id: gameId }]);
events.setActiveSkill(null);
}
function sendGameTarget(gameId, constructId, skillId) {
send(['GameTarget', { game_id: gameId, construct_id: constructId, skill_id: skillId }]);
events.setActiveSkill(null);
@ -362,6 +367,7 @@ function createSocket(events) {
sendGameReady,
sendGameSkill,
sendGameSkillClear,
sendGameOfferDraw,
sendGameTarget,
sendInstanceAbandon,

52
server/src/game.rs
View File

@ -27,7 +27,7 @@ pub enum Phase {
Start,
Skill,
Resolve,
Finish,
Finished,
}
#[derive(Debug,Clone,Serialize,Deserialize)]
@ -325,6 +325,30 @@ impl Game {
return Ok(self);
}
fn offer_draw(mut self, player_id: Uuid) -> Result<Game, Error> {
if self.phase != Phase::Skill {
return Err(err_msg("game not in skill phase"));
}
{
let player = self.player_by_id(player_id)?;
player.draw_offered = true;
}
// bots automatically accept draws
for player in self.players.iter_mut() {
if player.bot {
player.draw_offered = true;
}
}
if self.players.iter().all(|p| p.draw_offered) {
return Ok(self.finish());
}
return Ok(self);
}
fn clear_skill(&mut self, player_id: Uuid) -> Result<&mut Game, Error> {
self.player_by_id(player_id)?;
if self.phase != Phase::Skill {
@ -564,15 +588,18 @@ impl Game {
// }
pub fn finished(&self) -> bool {
self.players.iter().any(|t| t.constructs.iter().all(|c| c.is_ko()))
self.phase == Phase::Finished || self.players.iter().any(|t| t.constructs.iter().all(|c| c.is_ko()))
}
pub fn winner(&self) -> Option<&Player> {
self.players.iter().find(|t| t.constructs.iter().any(|c| !c.is_ko()))
match self.players.iter().any(|t| t.constructs.iter().all(|c| c.is_ko())) {
true => self.players.iter().find(|t| t.constructs.iter().any(|c| !c.is_ko())),
false => None,
}
}
fn finish(mut self) -> Game {
self.phase = Phase::Finish;
self.phase = Phase::Finished;
// self.log.push(format!("Game finished."));
// {
@ -594,7 +621,7 @@ impl Game {
}
pub fn upkeep(mut self) -> Game {
if self.phase == Phase::Finish {
if self.phase == Phase::Finished {
return self;
}
@ -903,6 +930,15 @@ pub fn game_skill(tx: &mut Transaction, account: &Account, game_id: Uuid, constr
Ok(game)
}
pub fn game_offer_draw(tx: &mut Transaction, account: &Account, game_id: Uuid) -> Result<Game, Error> {
let game = game_get(tx, game_id)?
.offer_draw(account.id)?;
game_update(tx, &game)?;
Ok(game)
}
pub fn game_skill_clear(tx: &mut Transaction, account: &Account, game_id: Uuid) -> Result<Game, Error> {
let mut game = game_get(tx, game_id)?;
@ -1051,7 +1087,7 @@ mod tests {
game = game.resolve_phase_start();
assert!([Phase::Skill, Phase::Finish].contains(&game.phase));
assert!([Phase::Skill, Phase::Finished].contains(&game.phase));
return;
}
@ -1117,7 +1153,7 @@ mod tests {
game = game.resolve_phase_start();
assert!(!game.player_by_id(y_player.id).unwrap().constructs[0].is_stunned());
assert!(game.phase == Phase::Finish);
assert!(game.phase == Phase::Finished);
}
#[test]
@ -1423,7 +1459,7 @@ mod tests {
assert!(game.skill_phase_finished());
game = game.resolve_phase_start();
assert!([Phase::Skill, Phase::Finish].contains(&game.phase));
assert!([Phase::Skill, Phase::Finished].contains(&game.phase));
// kill a construct
game.player_by_id(i_player.id).unwrap().construct_by_id(i_construct.id).unwrap().green_life.reduce(u64::max_value());

44
server/src/instance.rs
View File

@ -317,7 +317,13 @@ impl Instance {
self.phase_start = Utc::now();
self.phase_end = self.time_control.vbox_phase_end();
let bits = match self.rounds.len() > 0 {
true => 12 + 6 * self.rounds.len(),
false => 0,
};
self.players.iter_mut().for_each(|p| {
p.vbox.balance_add(bits.into());
p.set_ready(false);
p.vbox.fill();
});
@ -412,38 +418,14 @@ impl Instance {
}
// if you don't win, you lose
// ties can happen if both players forfeit
// in this case we just finish the game and
// dock them 10k mmr
let winner_id = match game.winner() {
Some(w) => w.id,
None => return Ok(self.finish()),
};
let bits = 12 + 6 * self.rounds.len();
{
let loser = self.players.iter()
.find(|p| p.id != winner_id)
.map(|p| p.score)
.unwrap();
// ties can happen if both players agree to a draw
// or ticks fire and knock everybody out
if let Some(winner) = game.winner() {
let winner = self.players.iter_mut()
.find(|p| p.id == winner_id)
.find(|p| p.id == winner.id)
.unwrap();
winner.score = winner.score.add_win(&loser);
winner.vbox.balance_add(bits.into());
}
{
let loser = self.players.iter_mut()
.find(|p| p.id != winner_id)
.unwrap();
loser.score = loser.score.add_loss();
loser.vbox.balance_add(bits.into());
}
winner.score = winner.score.add_win(&Score::Zero);
};
if self.all_games_finished() {
self.next_round();
@ -799,7 +781,7 @@ pub fn instance_state(tx: &mut Transaction, instance_id: Uuid) -> Result<RpcMess
let game = game_get(tx, game_id)?;
// return the game until it's finished
if game.phase != Phase::Finish {
if game.phase != Phase::Finished {
return Ok(RpcMessage::GameState(game))
}
}

3
server/src/player.rs
View File

@ -64,6 +64,7 @@ pub struct Player {
pub bot: bool,
pub ready: bool,
pub warnings: u8,
pub draw_offered: bool,
pub score: Score,
}
@ -85,6 +86,7 @@ impl Player {
bot: false,
ready: false,
warnings: 0,
draw_offered: false,
score: Score::Zero,
})
}
@ -99,6 +101,7 @@ impl Player {
bot: false,
ready: false,
warnings: 0,
draw_offered: false,
score: Score::Zero,
}
}

6
server/src/rpc.rs
View File

@ -22,7 +22,7 @@ use account::{Account};
use account;
use construct::{Construct};
use events::{Event};
use game::{Game, game_state, game_skill, game_skill_clear, game_ready};
use game::{Game, game_state, game_skill, game_skill_clear, game_ready, game_offer_draw};
use instance::{Instance, ChatState, instance_state, instance_practice, instance_ready, instance_abandon, demo};
use item::{Item, ItemInfoCtr, item_info};
use mtx;
@ -90,6 +90,7 @@ pub enum RpcRequest {
GameReady { id: Uuid },
GameSkill { game_id: Uuid, construct_id: Uuid, target_construct_id: Uuid, skill: Skill },
GameSkillClear { game_id: Uuid },
GameOfferDraw { game_id: Uuid },
AccountState {},
AccountShop {},
@ -218,6 +219,9 @@ impl Connection {
RpcRequest::GameReady { id } =>
Ok(RpcMessage::GameState(game_ready(&mut tx, account, id)?)),
RpcRequest::GameOfferDraw { game_id } =>
Ok(RpcMessage::GameState(game_offer_draw(&mut tx, account, game_id)?)),
RpcRequest::InstancePractice {} =>
Ok(RpcMessage::InstanceState(instance_practice(&mut tx, account)?)),