From 46c9bc8d420ca9983c1ad1ece955718d32939523 Mon Sep 17 00:00:00 2001 From: IonutParau Date: Tue, 7 Apr 2026 20:07:24 +0200 Subject: [PATCH] initial work on an ambitious library --- src/neonucleus.h | 4 -- src/netlib.h | 151 +++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 151 insertions(+), 4 deletions(-) create mode 100644 src/netlib.h diff --git a/src/neonucleus.h b/src/neonucleus.h index 25d9454..7bdcc88 100644 --- a/src/neonucleus.h +++ b/src/neonucleus.h @@ -1662,14 +1662,10 @@ typedef nn_Exit (nn_ModemHandler)(nn_ModemRequest *req); nn_Component *nn_createModem(nn_Universe *universe, const char *address, const nn_Modem *modem, void *state, nn_ModemHandler *handler); typedef struct nn_Tunnel { - // maximum range. Set to 0 for wired modems - size_t maxRange; // maximum values in a packet size_t maxValues; // maximum logical packet size. Note that the encoding is more efficient than the packet size algorithm estimates size_t maxPacketSize; - // the maximum amount of open ports - size_t maxOpenPorts; } nn_Tunnel; extern nn_Tunnel nn_defaultTunnel; diff --git a/src/netlib.h b/src/netlib.h new file mode 100644 index 0000000..5521696 --- /dev/null +++ b/src/netlib.h @@ -0,0 +1,151 @@ +#ifndef NN_NETLIB +#define NN_NETLIB + +#include "neonucleus.h" + +// should be sent by computers when they start, +// in order to mount every component accessible +#define NET_COMPDISCOVER "componentDiscover" +#define NET_COMPADDED "componentAdded" +#define NET_COMPREMOVED "componentRemoved" +#define NET_OCMESSAGE "modemMessage" +#define NET_RADIOMESSAGE "radioMessage" + +typedef struct net_ModemMessageData { + // NULL for broadcast + const char *target; + size_t port; + const nn_EncodedNetworkContents *contents; + size_t packetSize; +} net_ModemMessageData; + +typedef struct net_RadioMessageData { + double frequency; + size_t len; + char *data; +} net_RadioMessageData; + +typedef struct net_NetworkLimits { + // maximum radio lifespan in ticks + size_t maxRadioLifespan; + // radio speed in coordinates per second + double radioSpeed; + // maximum connections in a device + size_t maxConnections; + // maximum amount of devices in a octo-tree node. + // For efficient wireless comms, the devices are stored in an octo-tree, the 3D version of a quadtree. + size_t maxTreeNodeSize; + // maximum number of hops past which the packet gets dropped. + // Set to 0 for infinite hops, but then it is possible to stackoverflow. + size_t maxHops; + // maximum amount of devices in a single channel + size_t maxChannel; +} net_NetworkLimits; + +typedef struct net_Network net_Network; +typedef struct net_Device net_Device; + +typedef struct net_DevicePosition { + // the dimension this lives in, in the case of Minecraft + size_t dimensionID; + // xyz within network + double x, y, z; +} net_DevicePosition; + +typedef enum net_MessagePropagation { + // direct connections + NET_MESSAGE_DIRECT, + // entire connected web + NET_MESSAGE_NETWORK, + // propagate wirelessly to physically nearby devices + NET_MESSAGE_WIRELESS, + // only to a specific slot + NET_MESSAGE_SLOT, + // send over named channel + NET_MESSAGE_CHANNEL, +} net_MessagePropagation; + +typedef struct net_Message { + // the ID; used for de-duplication. + // Deduplication only happens if the last received packet has the same ID + size_t id; + // the issued sender, technically. + // Relays may edit this field. + net_Device *sender; + const char *type; + void *data; + size_t hops; + union { + // for NET_MESSAGE_WIRELESS + size_t range; + // for NET_MESSAGE_SLOT + size_t slot; + // for NET_MESSAGE_CHANNEL + const char *channel; + }; +} net_Message; + +// Allowed to mutate the mesasge, but please be careful. Do note that relaying gives them a pointer to a copy of the message struct after you mutate it. +// If you return false, the packet will be dropped. +// Hops is automatically incremented. +typedef bool (net_Filter)(net_Device *device, net_Device *forwarder, net_Message *message); +typedef void (net_TickFunc)(net_Device *device, size_t tickCount); + +net_Network *net_createNetwork(nn_Universe *universe, const net_NetworkLimits *limits); +void net_destroyNetwork(net_Network *network); + +net_Device *net_createDevice(net_Network *network, const char *type, size_t slotCount, net_DevicePosition position); +void net_destroyDevice(net_Device *device); +void net_lockDevice(net_Device *device); +void net_unlockDevice(net_Device *device); + +nn_Exit net_addToChannel(net_Device *device, const char *channel); +void net_removeFromChannel(net_Device *device, const char *channel); + +// will automatically give the message an ID and hops count, so don't bother +// this will lock the network for its entire duration +void net_emit(net_Device *device, const net_Message *message); + +void net_setDevicePosition(net_Device *device, net_DevicePosition position); +net_DevicePosition net_getDevicePosition(net_Device *device); +void net_setDeviceState(net_Device *device, void *state); +void *net_getDeviceState(net_Device *device); +// the filter is also meant to be used as a listener +void net_setDeviceFilter(net_Device *device, net_Filter *filter); +void net_setDeviceTick(net_Device *device, net_TickFunc *tick); +void net_setDeviceComponent(net_Device *device, nn_Component *component); +nn_Component *net_getDeviceComponent(net_Device *device); +size_t net_getDeviceSlotCount(net_Device *device); + +net_Device *net_getDeviceSlot(net_Device *device, size_t slot); +// returns -1 if not directly connected +int net_getSlotOfDevice(net_Device *device, net_Device *target); +// establishes a 1-WAY connection from device to target on a slot. Each slot may only have one, so previous ones are disconnected +void net_setDeviceSlot(net_Device *device, size_t slot, net_Device *target); +// adds a 1-WAY connection form device to target, but on not slot. +nn_Exit net_mountDevice(net_Device *device, net_Device *target); +// removes ALL 1-WAY connections from device to target +void net_removeDeviceOneWay(net_Device *device, net_Device *target); +// disconnects the devices both-ways +void net_disconnectDevices(net_Device *deviceA, net_Device *deviceB); + +void net_tickNetwork(net_Network *network); + +// network devices + +// a simple non-rewriting relay, which does not contribute to the hop counter +net_Device *net_createJoint(net_Network *network); + +net_Device *net_createModem(net_Network *network, const nn_Modem *modem); + +net_Device *net_createTunnel(net_Network *network, const nn_Tunnel *tunnel, const char *channel); + +// TODO: the arguments. Also, relay configs can change +net_Device *net_createRelay(net_Network *network); + +net_Device *net_createNetSplitter(net_Network *network); + +// has slots matching the sides defined in neonucleus.h +net_Device *net_createRack(net_Network *network); + +#endif