Best way to implement a collection of items for copying? - rust

Question

I am writing my first program in Rust that takes a list of Cards and attempts to find the best deck from those cards.
I want to have a catalog of Cards that can be copied to decks. I'm trying to find an idiomatic way of doing this. My first thought was a vector or array containing one of every card and a function to return a copy of that card to a deck.
Here is my code:
pub trait Card {
fn get_name(&self) -> &String;
fn get_card_type(&self) -> &CardType;
fn get_cost(&self) -> Option<&i32>;
fn play(&self){
println!("Played {} for {} mana.", self.get_name(), self.get_cost().unwrap());
}
}
pub enum CardType {
Creature,
Spell,
Land,
}
pub struct Creature {
pub name: String,
pub card_type: CardType,
pub cost: i32,
pub attack: i32,
pub defense: i32,
pub tapped: bool,
}
impl Card for Creature{
fn get_name(&self) -> &String {
&self.name
}
fn get_card_type(&self) -> &CardType {
&self.card_type
}
fn get_cost(&self) -> Option<&i32> {
Some(&self.cost)
}
}
pub struct Spell {
pub name: String,
pub card_type: CardType,
pub cost: i32,
pub damage: i32,
}
impl Card for Spell{
fn get_name(&self) -> &String {
&self.name
}
fn get_card_type(&self) -> &CardType {
&self.card_type
}
fn get_cost(&self) -> Option<&i32> {
Some(&self.cost)
}
}
pub struct Land {
pub name: String,
pub card_type: CardType,
pub tapped: bool,
}
impl Card for Land{
fn play(&self) {
println!("Played {}.", self.get_name());
}
fn get_name(&self) -> &String {
&self.name
}
fn get_card_type(&self) -> &CardType {
&self.card_type
}
fn get_cost(&self) -> Option<&i32> {
None
}
}
pub fn get_random_card() -> Box<Card> {
Box::new( Creature{
name: "My Card".to_string(),
card_type: CardType::Creature,
cost: 1,
attack: 2,
defense: 2,
tapped: false,
})
}
The get_random_card() function contains a sample card. So essentially I just need a static array or vector of cards and a function to copy them in to a deck, but I haven't been able to implement it.
Any suggestions? Feel free to point out anything else I am doing wrong.
Edit: Some clarification -
The code here works, but I want a variable containing a list of available cards. For example
// some pseudocode, in file cards.rs
let cards = [
Creature {
name = "Creature 1"
//...
},
Land {
name = "Land 1"
//...
},
Spell {
name = "Spell 1"
//...
},
];
fn get_card(name) -> mut Card {
// return a mutable copy/clone of a card, not a reference
}
And I would prefer to have it declared outside of the main function, in a separate file. I've tried several different things trying to make the compiler happy, but I'm pretty sure I'm missing something obvious. Memory isn't a big concern at the moment, there won't be that many cards in the "cards" var. But decks will be generated dynamically, so I need somewhere to get the cards in the deck from.
Thanks.

Answer 1

If you aren't worried about allocating too much memory, you have everything you need right now:
fn main() {
let hand: Vec<_> = (0..5).map(|_| get_random_card()).collect();
for card in &hand {
println!("{}", card.get_name());
}
}
We simply grab 5 cards and store them in a Vec. We can then iterate over the vector and print out the card names.
If you are worried about memory and you are going to have a bunch of cards you want to "reuse", you could do as above and then take references to them:
fn main() {
let deck: Vec<_> = (0..52).map(|_| get_random_card()).collect();
let hand1 = &deck[0..5];
let hand2 = &deck[5..10];
let hand3 = &deck[10..15];
let hand4 = &deck[15..20];
for card in hand1 {
println!("{}", card.get_name());
}
}
Here, the compiler will prevent you from attempting to use a card after the deck goes out of scope. If you need more flexibility, you could use Rc in addition to Box:
use std::rc::Rc;
pub fn get_random_card() -> Rc<Box<Card>> {
Rc::new(Box::new(Creature {
name: "My Card".to_string(),
card_type: CardType::Creature,
cost: 1,
attack: 2,
defense: 2,
tapped: false,
}))
}
fn main() {
let deck: Vec<_> = (0..52).map(|_| get_random_card()).collect();
let hand1 = deck[0..5].to_owned();
let hand2 = deck[5..10].to_owned();
let hand3 = deck[10..15].to_owned();
let hand4 = deck[15..20].to_owned();
for card in &hand1 {
println!("{}", card.get_name());
}
}
This lets each card manage a reference-count of active references. When the references go to 0, the card is freed.
Note In the Rust nightlies, you can use just Rc<T> instead of Rc<Box<T>>.
Feel free to point out anything else I am doing wrong.
Three things stood out to me:
You should probably use #[derive(Debug)] on every struct. Other things to potentially derive are Copy and/or Clone, PartialEq and Hash. Of course, you can wait until you need one of those before adding it, but Debug is super useful right away.
Return &str instead of &String. 99.9% of the time, you want to use &str instead of &String — it's more flexible.
There's no reason to return references to small types like CardType or i32 - just return them directly.