mux/Uno
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

added a lot of stuff, can draw cards, reset a deck and create a game

Browse Source
This commit is contained in:
mux 2024-08-12 21:37:10 +02:00
parent a627af3b25
commit 3f905dca89
3 changed files with 254 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Cargo.toml
View File

@ -4,3 +4,4 @@ version = "0.1.0"
edition = "2021"
[dependencies]
rand = "0.8"

251
src/lib.rs
View File

@ -0,0 +1,251 @@
extern crate rand;
use std::{
arch::global_asm,
io::{ prelude::*, BufReader, BufWriter, WriterPanicked },
net::{ TcpListener, TcpStream },
usize,
};
use rand::Rng;
#[derive(Clone)]
pub struct PlayerState<'a> {
pub player_name: &'a str,
pub cards: Vec<Card>,
}
struct PlayerConnection<'a>{
player_name : &'a str,
reader: BufReader<TcpStream>,
writer: BufWriter<TcpStream>,
}
impl PlayerState<'_> {
pub fn new(player_name : &str, cards : Vec<Card>) -> PlayerState{
PlayerState {
player_name: player_name,
cards: cards,
}
}
}
impl PlayerConnection<'_> {
pub fn new(player_name : &str, reader : BufReader<TcpStream>, writer : BufWriter<TcpStream>) -> PlayerConnection{
PlayerConnection {
player_name : player_name,
reader : reader,
writer : writer
}
}
}
struct Card {
value: CardValue,
color: CardColors,
}
impl PartialEq for Card{
fn eq(&self, other: &Self) -> bool {
self.value == other.value && self.color == other.color
}
}
type Deck = Vec<Card>;
#[derive(Clone)]
enum CardColors {
RED,
BLUE,
GREEN,
YELLOW,
BLACK,
}
impl PartialEq for CardColors{
fn eq(&self, other: &Self) -> bool {
core::mem::discriminant(self) == core::mem::discriminant(other)
}
}
impl Clone for Card {
fn clone(&self) -> Self {
Self { value: self.value.clone(), color: self.color.clone() }
}
}
#[derive(Clone)]
enum CardValue {
PLUS_TWO,
PLUS_FOUR,
ZERO,
ONE,
TWO,
THREE,
FOUR,
FIVE,
SIX,
SEVEN,
EIGHT,
NINE,
REVERSE,
SKIP,
CHANGE_COLOR,
}
impl PartialEq for CardValue{
fn eq(&self, other: &Self) -> bool {
core::mem::discriminant(self) == core::mem::discriminant(other)
}
}
pub struct GameState<'a>{
pub turns : u64,
pub current_turn : PlayerState<'a>,
deck : Deck,
pub current_card : Card,
player_states : Vec<PlayerState<'a>>,
player_connections : Vec<PlayerConnection<'a>>,
pub current_color : CardColors,
pub current_direction : Direction,
}
impl GameState<'_>{
pub fn next_turn(game : GameState) -> GameState{
return game;
}
fn new_game_helper<'a>(player_states: Vec<PlayerState<'a>>, player_connections: Vec<PlayerConnection<'a>>) -> GameState<'a>{
GameState{
turns : 0,
current_turn : player_states[0].clone(),
deck : GameState::base_deck(),
current_card : Card{ value : CardValue::ZERO, color : CardColors::RED,},
player_states : player_states.clone(),
player_connections : player_connections,
current_color : CardColors::RED,
current_direction : Direction::CLOCKWISE,
}
}
pub fn new_game<'a>(player_states : Vec<PlayerState<'a>>, player_connections: Vec<PlayerConnection<'a>>) -> GameState<'a>{
let mut new_game = GameState::new_game_helper(player_states, player_connections);
new_game.current_color = new_game.current_card.color.clone();
return new_game;
}
fn get_currently_held(&mut self) -> Vec<Card>{
let mut currently_held = vec![];
for hand in &mut self.player_states{
currently_held.append(&mut hand.cards);
}
return currently_held;
}
fn reset_deck(&mut self, currently_held : Vec<Card>) -> Deck{
self.deck = GameState::base_deck();
for current_cart in currently_held{
self.deck.remove(self.deck.iter().position(|x| *x == current_cart).expect("game integrity compromised"));
}
return vec![];
}
fn base_deck()-> Vec<Card>{
let mut deck : Deck = vec![];
//CHANGE COLOR
for _ in 0..3 {deck.push(Card {value : CardValue::CHANGE_COLOR, color : CardColors::BLACK,})};
//PLUS FOUR
for _ in 0..3 {deck.push(Card{ value : CardValue::PLUS_FOUR, color : CardColors::BLACK})};
//PLUS TWO
for _ in 0..1 {deck.push(Card{ value : CardValue::PLUS_TWO, color : CardColors::RED})};
for _ in 0..1 {deck.push(Card{ value : CardValue::PLUS_TWO, color : CardColors::BLUE})};
for _ in 0..1 {deck.push(Card{ value : CardValue::PLUS_TWO, color : CardColors::GREEN})};
for _ in 0..1 {deck.push(Card{ value : CardValue::PLUS_TWO, color : CardColors::YELLOW})};
//REVERSE
for _ in 0..1 {deck.push(Card{ value : CardValue::REVERSE, color : CardColors::RED})};
for _ in 0..1 {deck.push(Card{ value : CardValue::REVERSE, color : CardColors::BLUE})};
for _ in 0..1 {deck.push(Card{ value : CardValue::REVERSE, color : CardColors::GREEN})};
for _ in 0..1 {deck.push(Card{ value : CardValue::REVERSE, color : CardColors::YELLOW})};
//SKIP
for _ in 0..1 {deck.push(Card{ value : CardValue::SKIP, color : CardColors::RED})};
for _ in 0..1 {deck.push(Card{ value : CardValue::SKIP, color : CardColors::BLUE})};
for _ in 0..1 {deck.push(Card{ value : CardValue::SKIP, color : CardColors::GREEN})};
for _ in 0..1 {deck.push(Card{ value : CardValue::SKIP, color : CardColors::YELLOW})};
//NINE
for _ in 0..1 {deck.push(Card{ value : CardValue::NINE, color : CardColors::RED})};
for _ in 0..1 {deck.push(Card{ value : CardValue::NINE, color : CardColors::BLUE})};
for _ in 0..1 {deck.push(Card{ value : CardValue::NINE, color : CardColors::GREEN})};
for _ in 0..1 {deck.push(Card{ value : CardValue::NINE, color : CardColors::YELLOW})};
//EIGHT
for _ in 0..1 {deck.push(Card{ value : CardValue::EIGHT, color : CardColors::RED})};
for _ in 0..1 {deck.push(Card{ value : CardValue::EIGHT, color : CardColors::BLUE})};
for _ in 0..1 {deck.push(Card{ value : CardValue::EIGHT, color : CardColors::GREEN})};
for _ in 0..1 {deck.push(Card{ value : CardValue::EIGHT, color : CardColors::YELLOW})};
//SEVEN
for _ in 0..1 {deck.push(Card{ value : CardValue::SEVEN, color : CardColors::RED})};
for _ in 0..1 {deck.push(Card{ value : CardValue::SEVEN, color : CardColors::BLUE})};
for _ in 0..1 {deck.push(Card{ value : CardValue::SEVEN, color : CardColors::GREEN})};
for _ in 0..1 {deck.push(Card{ value : CardValue::SEVEN, color : CardColors::YELLOW})};
//SIX
for _ in 0..1 {deck.push(Card{ value : CardValue::SIX, color : CardColors::RED})};
for _ in 0..1 {deck.push(Card{ value : CardValue::SIX, color : CardColors::BLUE})};
for _ in 0..1 {deck.push(Card{ value : CardValue::SIX, color : CardColors::GREEN})};
for _ in 0..1 {deck.push(Card{ value : CardValue::SIX, color : CardColors::YELLOW})};
//FIVE
for _ in 0..1 {deck.push(Card{ value : CardValue::FIVE, color : CardColors::RED})};
for _ in 0..1 {deck.push(Card{ value : CardValue::FIVE, color : CardColors::BLUE})};
for _ in 0..1 {deck.push(Card{ value : CardValue::FIVE, color : CardColors::GREEN})};
for _ in 0..1 {deck.push(Card{ value : CardValue::FIVE, color : CardColors::YELLOW})};
//FOUR
for _ in 0..1 {deck.push(Card{ value : CardValue::FOUR, color : CardColors::RED})};
for _ in 0..1 {deck.push(Card{ value : CardValue::FOUR, color : CardColors::BLUE})};
for _ in 0..1 {deck.push(Card{ value : CardValue::FOUR, color : CardColors::GREEN})};
for _ in 0..1 {deck.push(Card{ value : CardValue::FOUR, color : CardColors::YELLOW})};
//THREE
for _ in 0..1 {deck.push(Card{ value : CardValue::THREE, color : CardColors::RED})};
for _ in 0..1 {deck.push(Card{ value : CardValue::THREE, color : CardColors::BLUE})};
for _ in 0..1 {deck.push(Card{ value : CardValue::THREE, color : CardColors::GREEN})};
for _ in 0..1 {deck.push(Card{ value : CardValue::THREE, color : CardColors::YELLOW})};
//TWO
for _ in 0..1 {deck.push(Card{ value : CardValue::TWO, color : CardColors::RED})};
for _ in 0..1 {deck.push(Card{ value : CardValue::TWO, color : CardColors::BLUE})};
for _ in 0..1 {deck.push(Card{ value : CardValue::TWO, color : CardColors::GREEN})};
for _ in 0..1 {deck.push(Card{ value : CardValue::TWO, color : CardColors::YELLOW})};
//ONE
for _ in 0..1 {deck.push(Card{ value : CardValue::ONE, color : CardColors::RED})};
for _ in 0..1 {deck.push(Card{ value : CardValue::ONE, color : CardColors::BLUE})};
for _ in 0..1 {deck.push(Card{ value : CardValue::ONE, color : CardColors::GREEN})};
for _ in 0..1 {deck.push(Card{ value : CardValue::ONE, color : CardColors::YELLOW})};
//ZERO
deck.push(Card{ value : CardValue::ZERO, color : CardColors::RED});
deck.push(Card{ value : CardValue::ZERO, color : CardColors::BLUE});
deck.push(Card{ value : CardValue::ZERO, color : CardColors::GREEN});
deck.push(Card{ value : CardValue::ZERO, color : CardColors::YELLOW});
return deck;
}
fn get_cards(&mut self, count : u32) -> Vec<Card>{
let mut cards_drawn = vec![];
for _ in 0..count{
let mut rng = rand::thread_rng();
let n: usize = rng.gen_range(0..self.deck.len());
cards_drawn.push(self.deck.remove(n));
}
return cards_drawn
}
pub fn draw(&mut self, player : &mut PlayerState, count : u32) -> (){
if self.deck.len() <= count as usize{
let currently_held = self.get_currently_held();
self.reset_deck(currently_held);
}
let mut cards_drawn = self.get_cards(count);
player.cards.append(&mut cards_drawn);
}
}
enum Direction {
CLOCKWISE,
COUNTER_CLOCKWISE,
}

2
src/tcp_server.rs
View File

@ -1,5 +1,5 @@
use std::{
io::{ prelude::*, BufReader, BufWriter },
io::{ prelude::*, BufReader, BufWriter, WriterPanicked },
net::{ TcpListener, TcpStream },
};