Hinweis zum Ende des Supports: Am 20. Mai 2026 AWS endet der Support für AWS SimSpace Weaver. Nach dem 20. Mai 2026 können Sie nicht mehr auf die SimSpace Weaver Konsole oder SimSpace Weaver die Ressourcen zugreifen. Weitere Informationen finden Sie unter [AWS SimSpace Weaver Ende des Supports](https://docs.aws.amazon.com/simspaceweaver/latest/userguide/simspaceweaver-end-of-support.html). 

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Verwenden der Nachrichtenübermittlung APIs
<a name="working-with_messaging_using"></a>

Die Nachrichten APIs sind im SimSpace Weaver App-SDK (Mindestversion 1.16.0) enthalten. Messaging wird in C\+\+, Python und unseren Integrationen mit Unreal Engine 5 und Unity unterstützt.

Es gibt zwei Funktionen, die Nachrichtentransaktionen verarbeiten: `SendMessage` und. `ReceiveMessages` Alle gesendeten Nachrichten enthalten ein Ziel und eine Nutzlast. Die `ReceiveMessages` API gibt eine Liste der Nachrichten zurück, die sich derzeit in der Warteschlange für eingehende Nachrichten einer App befinden.

------
#### [ C\+\+ ]

**Nachricht senden**

```
AWS_WEAVERRUNTIME_API Result<void> SendMessage(
    Transaction& txn,
    const MessagePayload& payload,
    const MessageEndpoint& destination,
    MessageDeliveryType deliveryType = MessageDeliveryType::BestEffort
    ) noexcept;
```

**Empfangen Sie Nachrichten**

```
AWS_WEAVERRUNTIME_API Result<MessageList> ReceiveMessages(
    Transaction& txn) noexcept;
```

------
#### [ Python ]

**Nachricht senden**

```
api.send_message(
 txn, # Transaction
 payload, # api.MessagePayload
 destination, # api.MessageDestination
 api.MessageDeliveryType.BestEffort # api.MessageDeliveryType
)
```

**Empfangen Sie Nachrichten**

```
api.receive_messages(
 txn, # Transaction
) -> api.MessageList
```

------

**Topics**
+ [Senden von Nachrichten](#working-with_messaging_using_send)
+ [Empfangen von Nachrichten](#working-with_messaging_using_receive)
+ [Dem Absender antworten](#working-with_messaging_using_reply)

## Senden von Nachrichten
<a name="working-with_messaging_using_send"></a>

Nachrichten bestehen aus einer Transaktion (ähnlich wie bei anderen Weaver-API-Aufrufen), einer Nutzlast und einem Ziel.

### Nachrichten-Payload
<a name="working-with_messaging_using_send_payload"></a>

Die Nachrichtennutzlast ist eine flexible Datenstruktur mit bis zu 256 Byte. Wir empfehlen Folgendes als bewährte Methode für die Erstellung Ihrer Nachrichtennutzlasten.

**Um die Nachrichten-Payload zu erstellen**

1. Erstellen Sie eine Datenstruktur (z. B. eine `struct` in C\+\+), die den Inhalt der Nachricht definiert.

1. Erstellen Sie die Nachrichtennutzlast, die die Werte enthält, die in Ihrer Nachricht gesendet werden sollen.

1. Erstellen Sie das Objekt `MessagePayload`.

### Ziel der Nachricht
<a name="working-with_messaging_using_send_destination"></a>

Das Ziel einer Nachricht wird durch das `MessageEndpoint` Objekt definiert. Dies beinhaltet sowohl einen Endpunkttyp als auch eine Endpunkt-ID. Derzeit wird nur der Endpunkttyp unterstützt`Partition`, der es Ihnen ermöglicht, Nachrichten an andere Partitionen in der Simulation zu adressieren. Die Endpunkt-ID ist die Partitions-ID Ihres Zielziels.

Sie können in einer Nachricht nur eine Zieladresse angeben. Erstellen und senden Sie mehrere Nachrichten, wenn Sie Nachrichten an mehr als eine Partition gleichzeitig senden möchten.

Hinweise zum Auflösen eines Nachrichtenendpunkts von einer Position aus finden Sie unter[Tipps für die Arbeit mit Nachrichten](working-with_messaging_tips.md).

### Senden Sie die Nachricht
<a name="working-with_messaging_using_send_send"></a>

Sie können die `SendMessage` API verwenden, nachdem Sie die Ziel- und Payload-Objekte erstellt haben.

------
#### [ C\+\+ ]

```
Api::SendMessage(transaction, payload, destination, MessageDeliveryType::BestEffort);
```

------
#### [ Python ]

```
api.send_message(txn, payload, destination, api.MessageDeliveryType.BestEffort)
```

------

**Vollständiges Beispiel für das Senden von Nachrichten**  
Das folgende Beispiel zeigt, wie Sie eine generische Nachricht erstellen und senden können. In diesem Beispiel werden 16 einzelne Nachrichten gesendet. Jede Nachricht enthält eine Nutzlast mit einem Wert zwischen 0 und 15 und den aktuellen Simulationstick.

**Example**  

```
// Message struct definition
struct MessageTickAndId
{
    uint32_t id;
    uint32_t tick;
};

Aws::WeaverRuntime::Result<void> SendMessages(Txn& txn) noexcept
{
     // Fetch the destination MessageEndpoint with the endpoint resolver
    WEAVERRUNTIME_TRY(
        Api::MessageEndpoint destination,
        Api::Utils::MessageEndpointResolver::ResolveFromPosition(
        txn,
            "MySpatialSimulation",
            Api::Vector2F32 {231.3, 654.0}
        )
    );
    Log::Info("destination: ", destination);

    WEAVERRUNTIME_TRY(auto tick, Api::CurrentTick(txn));

    uint16_t numSentMessages = 0;
    for (std::size_t i=0; i<16; i++)
    {
        // Create the message that'll be serialized into payload
        MessageTickAndId message {i, tick.value};
        
        // Create the payload out of the struct
        const Api::MessagePayload& payload = Api::Utils::CreateMessagePayload(
            reinterpret_cast<const std::uint8_t*>(&message), 
            sizeof(MessageTickAndId)
        );
        
        // Send the payload to the destination
        Result<void> result = Api::SendMessage(txn, payload, destination);
        if (result.has_failure())
        {
            // SendMessage has failure modes, log them
            auto error = result.as_failure().error();
            std::cout<< "SendMessage failed, ErrorCode: " << error << std::endl;
            continue;
        }
        
        numSentMessages++;
    }

    std::cout << numSentMessages << " messages is sent to endpoint" 
       << destination << std::endl;
    return Aws::WeaverRuntime::Success();
}
```

```
# Message data class
@dataclasses.dataclass
class MessageTickAndId:
    tick: int = 0
    id: int = 0
    
# send messages
def _send_messages(self, txn):
    tick = api.current_tick(txn)
    num_messages_to_send = 16

    # Fetch the destination MessageEndpoint with the endpoint resolver
    destination = api.utils.resolve_endpoint_from_domain_name_position(
       txn,
       "MySpatialSimulation",
       pos
   )
    Log.debug("Destination_endpoint = %s", destination_endpoint)

   for id in range(num_messages_to_send):
       # Message struct that'll be serialized into payload
        message_tick_and_id = MessageTickAndId(id = id, tick = tick.value)
        
       # Create the payload out of the struct
        message_tick_and_id_data = struct.pack(
           '<ii',
           message_tick_and_id.id,
           message_tick_and_id.tick
       )
        payload = api.MessagePayload(list(message_tick_and_id_data))

        # Send the payload to the destination
        Log.debug("Sending message: %s, endpoint: %s",
           message_tick_and_id,
           destination
       )
        api.send_message(
           txn,
           payload,
           destination,
           api.MessageDeliveryType.BestEffort
       )

    Log.info("Sent %s messages to %s", num_messages_to_send, destination)
    return True
```

## Empfangen von Nachrichten
<a name="working-with_messaging_using_receive"></a>

SimSpace Weaver übermittelt Nachrichten in die Warteschlange für eingehende Nachrichten einer Partition. Verwenden Sie die `ReceiveMessages` API, um ein `MessageList` Objekt abzurufen, das die Nachrichten aus der Warteschlange enthält. Verarbeiten Sie jede Nachricht mit der `ExtractMessage` API, um die Nachrichtendaten abzurufen.

**Example**  

```
Result<void> ReceiveMessages(Txn& txn) noexcept
{
     // Fetch all the messages sent to the partition owned by the app
    WEAVERRUNTIME_TRY(auto messages, Api::ReceiveMessages(txn));
    std::cout << "Received" << messages.messages.size() << " messages" << std::endl;
    for (Api::Message& message : messages.messages)
    {
        std::cout << "Received message: " << message << std::endl;

         // Deserialize payload to the message struct
        const MessageTickAndId& receivedMessage 
            = Api::Utils::ExtractMessage<MessageTickAndId>(message);
        std::cout << "Received MessageTickAndId, Id: " << receivedMessage.id 
            <<", Tick: " << receivedMessage.tick << std::endl;
    }

    return Aws::WeaverRuntime::Success();
}
```

```
# process incoming messages
def _process_incoming_messages(self, txn):
    messages = api.receive_messages(txn)
    for message in messages:
        payload_list = message.payload.data
        payload_bytes = bytes(payload_list)
        message_tick_and_id_data_struct 
           = MessageTickAndId(*struct.unpack('<ii', payload_bytes))

        Log.debug("Received message. Header: %s, message: %s", 
                    message.header, message_tick_and_id_data_struct)

    Log.info("Received %s messages", len(messages))
    return True
```

## Dem Absender antworten
<a name="working-with_messaging_using_reply"></a>

Jede empfangene Nachricht enthält einen Nachrichtenkopf mit Informationen über den ursprünglichen Absender der Nachricht. Sie können den message.header.source\_endpoint verwenden, um eine Antwort zu senden.

**Example**  

```
Result<void> ReceiveMessages(Txn& txn) noexcept
{
     // Fetch all the messages sent to the partition owned by the app
    WEAVERRUNTIME_TRY(auto messages, Api::ReceiveMessages(txn));
    std::cout << "Received" << messages.messages.size() << " messages" << std::endl;
    for (Api::Message& message : messages.messages)
    {
        std::cout << "Received message: " << message << std::endl;

         // Deserialize payload to the message struct
        const MessageTickAndId& receivedMessage 
            = Api::Utils::ExtractMessage<MessageTickAndId>(message);
        std::cout << "Received MessageTickAndId, Id: " << receivedMessage.id 
            <<", Tick: " << receivedMessage.tick << std::endl;
        
        // Get the sender endpoint and payload to bounce the message back
        Api::MessageEndpoint& sender = message.header.source_endpoint;
        Api::MessagePayload& payload = message.payload;
        Api::SendMessage(txn, payload, sender);
    }

    return Aws::WeaverRuntime::Success();
}
```

```
# process incoming messages
def _process_incoming_messages(self, txn):
    messages = api.receive_messages(txn)
    for message in messages:
        payload_list = message.payload.data
        payload_bytes = bytes(payload_list)
        message_tick_and_id_data_struct 
           = MessageTickAndId(*struct.unpack('<ii', payload_bytes))

        Log.debug("Received message. Header: %s, message: %s", 
                    message.header, message_tick_and_id_data_struct)
       # Get the sender endpoint and payload 
       # to bounce the message back
       sender = message.header.source_endpoint
       payload = payload_list
       api.send_message(
           txn,
           payload_list,
           sender,
           api.MessageDeliveryType.BestEffort

    Log.info("Received %s messages", len(messages))
    return True
```