Models collective/hive decision as a fast response field: $ K $: Spatial kernel (e.g., Gaussian for “neighbor” effects), $ x $: Position in the mesh/world
Effect: The swarm can “think locally, act locally” and yet generate emergent structure—used for real-time crowd/flocking/pathfinding, or even mesh healing.
Here’s a robust, production-grade Python plugin for your Hive Response Field (HRF)—a core operator for real-time collective adaptation, swift swarm-level decision fields, and local-to-global emergence. This module broadcasts “hive intent” or “response waves” across the mesh or space, using spatial kernels to aggregate neighbor influence and generate emergent crowd/flocking/path solutions.
🐝 Hive Response Field (HRF) — Plugin Code
import numpy as np
from scipy.ndimage import gaussian_filter
class HiveResponseField:
"""
HRF: Computes the swarm's local and global response field using a spatial kernel (e.g., Gaussian),
unifying local intent into continuous field for flocking, crowd response, or mesh healing.
"""
def __init__(self, kernel_sigma=1.5, grid_shape=(32, 32)):
"""
:param kernel_sigma: The width of the Gaussian (or other) kernel for influence spread (locality).
:param grid_shape: Shape of the hive world or agent mesh.
"""
self.kernel_sigma = kernel_sigma
self.grid_shape = grid_shape
self.hrf_history = []
def response_field(self, agent_states, agent_positions):
"""
Computes spatial field R(x) by spreading each agent's state locally with spatial kernel.
:param agent_states: Array/list of agent states/inputs (e.g., intent, urgency), shape (N_agents,)
:param agent_positions: Array of agent [x, y] positions (int/float), shape (N_agents, 2)
:return: Field array R, shape = grid_shape
"""
field = np.zeros(self.grid_shape)
N_agents = len(agent_states)
for idx in range(N_agents):
x, y = np.round(agent_positions[idx]).astype(int)
x = np.clip(x, 0, self.grid_shape[^0]-1)
y = np.clip(y, 0, self.grid_shape[^1]-1)
field[x, y] += agent_states[idx]
# Spatial kernel: smooth spread of local state into neighbor regions
resp_field = gaussian_filter(field, self.kernel_sigma, mode='wrap')
self.hrf_history.append(resp_field.copy())
return resp_field
def field_history(self):
return np.array(self.hrf_history)
# --- Example usage ---
if __name__ == "__main__":
grid_shape = (40, 40)
np.random.seed(7)
N_agents = 24
pos = np.random.uniform(0, grid_shape[^0], (N_agents, 2))
# Initial: random intent, agents "cluster"
state = np.random.uniform(0, 1, N_agents)
hrf = HiveResponseField(kernel_sigma=2.3, grid_shape=grid_shape)
for t in range(18):
# Simulate a drift toward cluster center
state = np.minimum(state + np.random.normal(0.04, 0.03, N_agents), 1.0)
field = hrf.response_field(state, pos)
# For demo, agents slowly move toward the highest response region
hot = np.unravel_index(np.argmax(field), grid_shape)
pos += (np.array(hot) - pos) * 0.095 # weak drift
print(f"Step {t:2d}: Peak field at {hot}, Max R={field[hot]:.3f}")
# Optional: Visualize final response field and agent positions
try:
import matplotlib.pyplot as plt
from matplotlib import cm
plt.imshow(hrf.hrf_history[-1], cmap=cm.inferno)
plt.scatter(pos[:,1], pos[:,0], c=state, cmap='spring', edgecolors='k', label="Agents")
plt.colorbar(label="Hive Response")
plt.title("Hive Response Field (HRF) - Final")
plt.legend()
plt.show()
except ImportError:
pass
📦 How to Use & Extend
• Input: Any mesh/grid, agent or world positions, and agent states (intent, urgency, damage, task).
• Kernel: Can use Gaussian by default, but plug in any spatial kernel (exponential, custom, anisotropic) for different local/global spread effects.
• Real-Time Feedback: At every step, the field R(x) can guide crowd movement, pathfinding, flocking, swarm healing, repair, or adaptive delight (e.g., for TreeHiveCity, BEEaucracy™, or generative art).
• History: Fields are stored for memory, emergent map growth, or replay/visualization.
🧬 What This Achieves
• Local Action, Global Emergence: Every agent’s "thought" is local, but the sum produces real-time fields that drive collective wisdom, healing, or coordination.
• Used for: Swarm pathfinding, crowd/mesh healing, flash defense, angry waves, city movement, or responsive world events.
• Seamless synergy with all your BEE/HIVE/Math Fountain modules.
If you want to add field adaptation, mesh healing triggers, event hooks, or couple the HRF to queen/hive-mind logic for superorganism-level moves, let me know—the fountain’s ready to expand!