Struct FirePDU 

pub struct FirePDU {
    pub pdu_header_record: PDUHeaderRecord,
    pub firing_entity_id_record: EntityIDRecord,
    pub target_entity_id_record: EntityIDRecord,
    pub munition_id_record: EntityIDRecord,
    pub event_id_record: EventIDRecord,
    pub fire_mission_index_field: u32,
    pub location_in_world_record: WorldCoordinateRecord,
    pub burst_descriptor_record: BurstDescriptorRecord,
    pub velocity_record: VelocityVectorRecord,
    pub range_field: f32,
}

Fire PDU as defined in IEEE 1278.1 standard. Used to communicate a weapon firing during the simulation.

Fields

pdu_header_record: PDUHeaderRecord

firing_entity_id_record: EntityIDRecord

target_entity_id_record: EntityIDRecord

munition_id_record: EntityIDRecord

event_id_record: EventIDRecord

fire_mission_index_field: u32

location_in_world_record: WorldCoordinateRecord

burst_descriptor_record: BurstDescriptorRecord

velocity_record: VelocityVectorRecord

range_field: f32

Implementations

impl FirePDU

pub fn default() -> Self

Provides a blank FirePDU with all IDs set to 1 (as 0 is not allowed within the DIS protocol).

Examples

Creating a blank FirePDU:

let fire_pdu = FirePDU::default();

Populating a bank FirePDU’s firing_entity_id_record:

let mut fire_pdu = FirePDU::default();
fire_pdu.firing_entity_id_record = EntityIDRecord::default(2);

Examples found in repository

examples/broadcast_pdus.rs (line 26)

fn main() {
    let src_addr = format!("192.168.1.134:{}", SRC_PORT);
    println!("binding to {} for sending", src_addr.as_str());
    let socket = UdpSocket::bind(src_addr).expect("bind should succeed");

    socket.set_broadcast(true).expect("set_broadcast to true should succeed");

    // Send FirePDU
    let data_to_send = FirePDU::default();
    println!("broadcasting data: {:?}", data_to_send);
    let mut buffer = BytesMut::new();
    PDU::serialise(&data_to_send, &mut buffer);
    socket
        .send_to(&buffer, format!("255.255.255.255:{}", SRC_PORT))
        .expect("couldn't send data");

    // Send EventReportPDU
    let data_to_send = EventReportPDU::default();
    println!("broadcasting data: {:?}", data_to_send);
    let mut buffer = BytesMut::new();
    PDU::serialise(&data_to_send, &mut buffer);
    socket
        .send_to(&buffer, format!("255.255.255.255:{}", SRC_PORT))
        .expect("couldn't send data");


    // Send EntityStatePDU
    let data_to_send = EntityStatePDU::default();
    println!("broadcasting data: {:?}", data_to_send);
    let mut buffer = BytesMut::new();
    PDU::serialise(&data_to_send, &mut buffer);
    socket
        .send_to(&buffer, format!("255.255.255.255:{}", SRC_PORT))
        .expect("couldn't send data");

    // Send DetonationPDU
    let data_to_send = DetonationPDU::default();
    println!("broadcasting data: {:?}", data_to_send);
    let mut buffer = BytesMut::new();
    PDU::serialise(&data_to_send, &mut buffer);
    socket
        .send_to(&buffer, format!("255.255.255.255:{}", SRC_PORT))
        .expect("couldn't send data");
}

Trait Implementations

impl Clone for FirePDU

fn clone(&self) -> FirePDU

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FirePDU

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

Formats the value using the given formatter.

impl PDU for FirePDU

fn serialise(&self, buf: &mut BytesMut)

Fills a BytesMut struct with a FirePDU serialised into binary. This buffer is then ready to be sent via UDP to the simluation network.

fn deserialise(buffer: BytesMut) -> Result<Self, DISError>

where Self: Sized,

Creates a PDU from a BytesMut struct.

fn as_any(&self) -> &dyn Any

fn deserialise_without_header( buffer: BytesMut, pdu_header: PDUHeaderRecord, ) -> Result<Self, DISError>

where Self: Sized,

Creates a PDU from a BytesMut struct.

impl Copy for FirePDU