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

Merge branch 'master' of ssh://mnml.gg:40022/~/mnml

Browse Source
This commit is contained in:
Mashy 2019-05-29 16:17:50 +10:00
commit b8abd7f973
9 changed files with 63 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
WORKLOG.md
View File

@ -46,9 +46,8 @@
* eth adapter
* pay for rerolls
* remove test variants of skills
* itemise all skills and warn on some
* warden
* set upkeep_at timestamp for games and instances
## SOON
@ -63,6 +62,11 @@
* skills
* private fields for opponents
* matchmaking
* elo
* password on MM game to prevent direct joins
* flavour text
* chat wheel trash talk
* KO animations and trash talk

11
client/index.html
View File

@ -18,14 +18,5 @@
</head>
<body>
</body>
<!-- <script>
// Check that service workers are registered
if ('serviceWorker' in navigator) {
// Use the window load event to keep the page load performant
window.addEventListener('load', () => {
navigator.serviceWorker.register('./service.worker.js');
});
}
</script>
--> <script src="./index.js"></script>
<script src="./index.js"></script>
</html>

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

@ -83,7 +83,7 @@ function GamePanel(props) {
return null;
}
const zero = Date.parse(game.phase_end) - (1000 * 60);
const zero = Date.parse(game.phase_start);
const now = Date.now();
const end = Date.parse(game.phase_end);
const timerPct = ((now - zero) / (end - zero) * 100);

5
client/src/components/info.component.jsx
View File

@ -117,7 +117,9 @@ function InfoComponent(args) {
function Combos() {
if (!player) return false;
if (!(combiner.every(u => u === null))) {
// show recipe for what's in combiner
if (combiner.some(u => u !== null)) {
const filteredCombos = itemInfo.combos
.filter(combo => combiner.every(u => u === null
|| combo.components.includes(player.vbox.bound[u])));
@ -136,6 +138,7 @@ function InfoComponent(args) {
);
}
if (!info) return false;
const vboxCombos = itemInfo.combos.filter(c => c.components.includes(info));
if (vboxCombos.length > 6) return false;
return (

2
client/src/components/instance.component.jsx
View File

@ -64,7 +64,7 @@ function Instance(args) {
: null;
// TIMER
const zero = Date.parse(instance.phase_end) - (1000 * 120);
const zero = Date.parse(instance.phase_start);
const now = Date.now();
const end = Date.parse(instance.phase_end);
const timerPct = ((now - zero) / (end - zero) * 100);

2
client/src/components/instance.equip.jsx
View File

@ -64,8 +64,6 @@ function Equipment(props) {
const isSkill = fullInfo && fullInfo.skill;
const isSpec = fullInfo && fullInfo.spec;
console.log('isSkill', isSkill, fullInfo);
function skillClick(e, i) {
if (itemUnequip && activeConstruct) return false;
// const value = vbox.bound[i];

1
client/src/constants.jsx
View File

@ -1,6 +1,5 @@
module.exports = {
TIMES: {
RESOLUTION_TIME_MS: 1000,
START_SKILL: 700,
END_SKILL: 700,
POST_SKILL: 1000,

11
server/src/game.rs
View File

@ -162,13 +162,14 @@ impl Game {
return self.finish();
}
self.skill_phase_start()
self.skill_phase_start(0)
}
fn skill_phase_start(mut self) -> Game {
fn skill_phase_start(mut self, num_resolutions: usize) -> Game {
let phase_add_time_ms = 60000 + num_resolutions * 2500;
self.phase_start = Utc::now();
self.phase_end = Utc::now()
.checked_add_signed(Duration::seconds(60))
.checked_add_signed(Duration::milliseconds(phase_add_time_ms as i64))
.expect("could not set phase end");
for player in self.players.iter_mut() {
@ -426,12 +427,14 @@ impl Game {
// temp vec of this round's resolving skills
// because need to check cooldown use before pushing them into the complete list
let mut casts = vec![];
let mut turn_events = 0;
while let Some(cast) = self.stack.pop() {
// info!("{:} casts ", cast);
let mut resolutions = resolution_steps(&cast, &mut self);
resolutions.reverse();
turn_events += resolutions.len();
while let Some(resolution) = resolutions.pop() {
self.log_resolution(cast.speed, &resolution);
// the results go into the resolutions
@ -455,7 +458,7 @@ impl Game {
return self.finish()
}
self.skill_phase_start()
self.skill_phase_start(turn_events)
}
fn progress_durations(&mut self, resolved: &Vec<Cast>) -> &mut Game {

62
server/src/instance.rs
View File

@ -30,6 +30,12 @@ enum InstancePhase {
Finished,
}
#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
enum Format {
Standard,
RoundRobin,
}
#[derive(Debug,Clone,Serialize,Deserialize)]
struct Round {
player_ids: Vec<Uuid>,
@ -40,15 +46,21 @@ struct Round {
#[derive(Debug,Clone,Serialize,Deserialize)]
pub struct Instance {
id: Uuid,
pub name: String,
players: Vec<Player>,
phase: InstancePhase,
rounds: Vec<Vec<Round>>,
open: bool,
max_players: usize,
max_rounds: usize,
password: Option<String>,
pub name: String,
phase: InstancePhase,
phase_end: DateTime<Utc>,
phase_start: DateTime<Utc>,
format: Format,
}
impl Instance {
@ -64,6 +76,9 @@ impl Instance {
name: String::new(),
password: None,
phase_end: Utc::now(),
phase_start: Utc::now(),
format: Format::RoundRobin,
}
}
@ -78,7 +93,10 @@ impl Instance {
max_rounds: 1,
name: "Global Matchmaking".to_string(),
password: None,
phase_start: Utc::now(),
phase_end: Utc::now(),
format: Format::Standard,
}
}
@ -131,12 +149,8 @@ impl Instance {
Ok(self)
}
fn set_max_rounds(mut self, rounds: usize) -> Result<Instance, Error> {
if rounds == 0 {
return Err(err_msg("max rounds must be nonzero"));
}
self.max_rounds = rounds;
fn set_format(mut self, format: Format) -> Result<Instance, Error> {
self.format = format;
Ok(self)
}
@ -273,16 +287,17 @@ impl Instance {
}
fn next_round(&mut self) -> &mut Instance {
self.phase = InstancePhase::InProgress;
self.phase_end = Utc::now()
.checked_add_signed(Duration::seconds(15000))
.expect("could not set phase end");
if self.rounds.len() >= self.max_rounds {
if self.win_condition() {
return self.finish();
}
self.phase = InstancePhase::InProgress;
self.phase_start = Utc::now();
self.phase_end = Utc::now()
.checked_add_signed(Duration::seconds(120))
.expect("could not set phase end");
self.players.iter_mut().for_each(|p| {
p.set_ready(false);
p.vbox.fill();
@ -294,6 +309,13 @@ impl Instance {
self
}
fn win_condition(&self) -> bool {
match self.format {
Format::Standard => self.players.iter().any(|p| p.score.wins > 2),
Format::RoundRobin => self.rounds.len() == self.players.len() / 2,
}
}
fn finish(&mut self) -> &mut Instance {
self.phase = InstancePhase::Finished;
self
@ -732,7 +754,7 @@ mod tests {
fn instance_pve_test() {
let mut instance = Instance::new()
.set_max_players(16).expect("unable to set max players")
.set_max_rounds(2).expect("max rounds failure")
.set_format(Format::RoundRobin).expect("format failure")
.add_bots();
let player_account = Uuid::new_v4();
@ -747,12 +769,12 @@ mod tests {
assert_eq!(instance.phase, InstancePhase::Finished);
assert_eq!(instance.rounds[0].len(), 8);
assert_eq!(instance.rounds.len(), 2);
assert_eq!(instance.rounds.len(), 8);
}
#[test]
fn instance_bot_vbox_test() {
let instance = Instance::new();
let _instance = Instance::new();
let player_account = Uuid::new_v4();
let constructs = instance_mobs(player_account);
let _player = Player::new(player_account, &"test".to_string(), constructs).set_bot(true);
@ -802,8 +824,8 @@ mod tests {
#[test]
fn instance_upkeep_test() {
let mut instance = Instance::new()
.set_max_players(2)
.expect("could not create instance");
.set_max_players(2).expect("could not create instance")
.set_format(Format::Standard).expect("format err");
let player_account = Uuid::new_v4();
let constructs = instance_mobs(player_account);