Struct veloren_common::trade::PendingTrade

pub struct PendingTrade {
    pub parties: [Uid; 2],
    pub offers: [HashMap<InvSlotId, u32>; 2],
    pub phase: TradePhase,
    pub accept_flags: [bool; 2],
}

Items are not removed from the inventory during a PendingTrade: all the items are moved atomically (if there’s space and both parties agree) upon completion

Since this stores InvSlotIds (i.e. references into inventories) instead of items themselves, there aren’t any duplication/loss risks from things like dropped connections or declines, since the server doesn’t have to move items from a trade back into a player’s inventory.

On the flip side, since they are references to slots, if a player could swap items in their inventory during a trade, they could mutate the trade, enabling them to remove an item from the trade even after receiving the counterparty’s phase2 accept. To prevent this, we disallow all forms of inventory manipulation in server::events::inventory_manip if there’s a pending trade that’s past phase1 (in phase1, the trade should be mutable anyway).

Inventory manipulation in phase1 may be beneficial to trade (e.g. splitting a stack of items, once that’s implemented), but should reset both phase1 accept flags to make the changes more visible.

Another edge case prevented by using InvSlotIds is that it disallows trading currently-equipped items (since EquipSlots are disjoint from InvSlotIds), which avoids the issues associated with trading equipped bags that may still have contents.

Fields

parties: [Uid; 2]

parties[0] is the entity that initiated the trade, parties[1] is the other entity that’s being traded with

offers: [HashMap<InvSlotId, u32>; 2]

offers[i] represents the items and quantities of the party i’s items being offered

phase: TradePhase

The current phase of the trade

accept_flags: [bool; 2]

accept_flags indicate that which parties wish to proceed to the next phase of the trade

Implementations

impl PendingTrade

pub fn new(party: Uid, counterparty: Uid) -> PendingTrade

pub fn phase(&self) -> TradePhase

pub fn should_commit(&self) -> bool

pub fn which_party(&self, party: Uid) -> Option<usize>

pub fn is_empty_trade(&self) -> bool

pub fn process_trade_action( &mut self, who: usize, action: TradeAction, inventories: &[&Inventory], )

Invariants:

• A party is never shown as offering more of an item than they own
• Offers with a quantity of zero get removed from the trade
• Modifications can only happen in phase 1
• Whenever a trade is modified, both accept flags get reset
• Accept flags only get set for the current phase

Trait Implementations

impl Clone for PendingTrade

fn clone(&self) -> PendingTrade

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PendingTrade

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PendingTrade

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for PendingTrade

fn eq(&self, other: &PendingTrade) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for PendingTrade

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for PendingTrade

impl StructuralPartialEq for PendingTrade