public void Main()
{
while (this.BroadcastListener.HasPendingMessage)
{
var message = this.BroadcastListener.AcceptMessage();
//Notice no deserializetion is needed.
// You can get your data easy like this:
var data = message.As <MyTuple <string, Vector3D, Vector3D> >();
var droneInfo = new DroneInfo
{
Name = data.Item1,
Velocity = data.Item2,
Acceleration = data.Item3
};
this.Drones[droneInfo.Name] = droneInfo;
}
foreach (var x in this.Drones.Values)
{
this.Buffer.AppendLine(x.Name)
.AppendLine("Velocity: ").Append(x.Velocity.ToString("F2")).AppendLine(" m/s")
.Append("Acceleration: ").Append(x.Acceleration.ToString("F2")).AppendLine(" m/s2");
this.Buffer.AppendLine();
}
this.TextPanel.WritePublicText(this.Buffer);
this.Buffer.Clear();
}
private void RegisterDrone(long antennaEntityId, MyEntity droneMainEntity, bool immediate = true)
{
var newInfo = DroneInfo.Allocate(antennaEntityId, MySandboxGame.TotalGamePlayTimeInMilliseconds + DRONE_DESPAWN_TIMER);
m_droneInfos.Add(droneMainEntity.EntityId, newInfo, immediate: immediate);
droneMainEntity.OnClosing += DroneMainEntityOnClosing;
PirateAntennaInfo antennaInfo = null;
if (!m_pirateAntennas.TryGetValue(antennaEntityId, out antennaInfo))
{
MyEntity entity;
if (MyEntities.TryGetEntityById(antennaEntityId, out entity))
{
var antenna = entity as MyRadioAntenna;
if (antenna != null)
{
antenna.UpdatePirateAntenna();
m_pirateAntennas.TryGetValue(antennaEntityId, out antennaInfo);
}
}
}
if (antennaInfo != null)
{
antennaInfo.SpawnedDrones++;
}
Debug.Assert(antennaEntityId == 0 || antennaInfo != null, "Antenna info not present when registering a drone!");
var remote = droneMainEntity as MyRemoteControl;
if (remote != null)
{
remote.OwnershipChanged += DroneRemoteOwnershipChanged;
}
}
private void UnregisterDrone(MyEntity entity, bool immediate = true)
{
long antennaEntityId = 0;
DroneInfo info = null;
Debug.Assert(m_droneInfos.ContainsKey(entity.EntityId), "Unregistering drone with inconsistend entity id");
m_droneInfos.TryGetValue(entity.EntityId, out info);
if (info != null)
{
antennaEntityId = info.AntennaEntityId;
DroneInfo.Deallocate(info);
}
m_droneInfos.Remove(entity.EntityId, immediate: immediate);
PirateAntennaInfo antennaInfo = null;
m_pirateAntennas.TryGetValue(antennaEntityId, out antennaInfo);
if (antennaInfo != null)
{
antennaInfo.SpawnedDrones--;
Debug.Assert(antennaInfo.SpawnedDrones >= 0, "Inconsistence in registered drone counts!");
}
entity.OnClosing -= DroneMainEntityOnClosing;
var remote = entity as MyRemoteControl;
if (remote != null)
{
remote.OwnershipChanged -= DroneRemoteOwnershipChanged;
}
}
public override void BeforeStart()
{
base.BeforeStart();
// Make sure that the pirate identity exists
if (m_piratesIdentityId != 0)
{
MyIdentity pirateIdentity = Sync.Players.TryGetIdentity(m_piratesIdentityId);
Debug.Assert(pirateIdentity != null, "The pirate identity does not exist, although its ID was saved!");
if (Sync.IsServer && pirateIdentity == null)
{
Sync.Players.CreateNewIdentity(IDENTITY_NAME, m_piratesIdentityId, null);
}
}
else
{
var identity = Sync.Players.CreateNewIdentity(IDENTITY_NAME);
m_piratesIdentityId = identity.IdentityId;
}
if (!Sync.Players.IdentityIsNpc(m_piratesIdentityId))
{
Sync.Players.MarkIdentityAsNPC(m_piratesIdentityId);
}
// Make sure that all the drone entities exist
foreach (var drone in m_droneInfos)
{
MyEntity entity;
MyEntities.TryGetEntityById(drone.Key, out entity);
if (entity == null)
{
DroneInfo.Deallocate(drone.Value);
m_droneInfos.Remove(drone.Key);
}
else
{
if (!MySession.Static.Settings.EnableDrones)
{
MyCubeGrid grid = entity as MyCubeGrid;
var remote = entity as MyRemoteControl;
if (grid == null)
{
grid = remote.CubeGrid;
}
UnregisterDrone(entity, immediate: false);
grid.SyncObject.SendCloseRequest();
}
else
{
RegisterDrone(drone.Value.AntennaEntityId, entity, immediate: false);
}
}
}
m_droneInfos.ApplyRemovals();
}
public SettingsForm(Drone drone)
{
InitializeComponent();
this.drone = drone;
this.info = drone.Info;
this.data = drone.Settings;
Bind(nameTextBox, "data.DroneName");
Bind(saveConfigCheckBox, "data.SaveConfig");
Bind(firmwareVersionTextBox, "info.BuildVersion");
Bind(buildDateTextBox, "info.BuildName");
Bind(modelTextBox, "info.ModelName");
Bind(idTextBox, "info.SerialCode");
Bind(gyroSensorTextBox, "info.GyroSensor");
Bind(magnetometerTextBox, "info.Magnetometer");
Bind(minValueTextBox, "data.ServoMin");
Bind(idleValueTextBox, "data.ServoIdle");
Bind(hoverValueTextBox, "data.ServoHover");
Bind(maxValueTextBox, "data.ServoMax");
Bind(safeMotorValueTextBox, "data.SafeServoValue");
Bind(safeTemperatureTextBox, "data.MaxTemperature");
Bind(safePitchTextBox, "data.SafePitch");
Bind(safeRollTextBox, "data.SafeRoll");
Bind(pitchKpTextBox, "data.PitchPid.Kp");
Bind(pitchKiTextBox, "data.PitchPid.Ki");
Bind(pitchKdTextBox, "data.PitchPid.Kd");
Bind(rollKpTextBox, "data.RollPid.Kp");
Bind(rollKiTextBox, "data.RollPid.Ki");
Bind(rollKdTextBox, "data.RollPid.Kd");
Bind(yawKpTextBox, "data.YawPid.Kp");
Bind(yawKiTextBox, "data.YawPid.Ki");
Bind(yawKdTextBox, "data.YawPid.Kd");
Bind(enableStabilizationCheckBox, "data.EnableStabilization");
Bind(negativeMixingCheckBox, "data.NegativeMixing");
Bind(keepMotorsOnCheckBox, "data.KeepMotorsOn");
Bind(maxThrustForFlyingTextBox, "data.MaxThrustForFlying");
Bind(onlyArmWhenStillCheckBox, "data.OnlyArmWhenStill");
Bind(gyroUseDmpCheckBox, "data.GyroUseDMP");
Bind(gyroUseRawCheckBox, "data.GyroUseRaw");
Bind(engineUseGyroCheckBox, "data.EngineUseGyro");
drone.OnSettingsChange += Drone_OnSettingsChange;
drone.OnInfoChange += Drone_OnInfoChange;
}
public SettingsForm(Drone drone)
{
InitializeComponent();
this.drone = drone;
this.info = drone.Info;
this.data = drone.Settings;
Bind(nameTextBox, "data.DroneName");
Bind(saveConfigCheckBox, "data.SaveConfig");
Bind(firmwareVersionTextBox, "info.BuildVersion");
Bind(buildDateTextBox, "info.BuildName");
Bind(modelTextBox, "info.ModelName");
Bind(idTextBox, "info.SerialCode");
Bind(gyroSensorTextBox, "info.GyroSensor");
Bind(magnetometerTextBox, "info.Magnetometer");
Bind(minValueTextBox, "data.ServoMin");
Bind(idleValueTextBox, "data.ServoIdle");
Bind(hoverValueTextBox, "data.ServoHover");
Bind(maxValueTextBox, "data.ServoMax");
Bind(safeMotorValueTextBox, "data.SafeServoValue");
Bind(safeTemperatureTextBox, "data.MaxTemperature");
Bind(safePitchTextBox, "data.SafePitch");
Bind(safeRollTextBox, "data.SafeRoll");
Bind(pitchKpTextBox, "data.PitchPid.Kp");
Bind(pitchKiTextBox, "data.PitchPid.Ki");
Bind(pitchKdTextBox, "data.PitchPid.Kd");
Bind(rollKpTextBox, "data.RollPid.Kp");
Bind(rollKiTextBox, "data.RollPid.Ki");
Bind(rollKdTextBox, "data.RollPid.Kd");
Bind(yawKpTextBox, "data.YawPid.Kp");
Bind(yawKiTextBox, "data.YawPid.Ki");
Bind(yawKdTextBox, "data.YawPid.Kd");
Bind(enableStabilizationCheckBox, "data.EnableStabilization");
Bind(negativeMixingCheckBox, "data.NegativeMixing");
Bind(keepMotorsOnCheckBox, "data.KeepMotorsOn");
Bind(maxThrustForFlyingTextBox, "data.MaxThrustForFlying");
Bind(onlyArmWhenStillCheckBox, "data.OnlyArmWhenStill");
Bind(gyroUseDmpCheckBox, "data.GyroUseDMP");
Bind(gyroUseRawCheckBox, "data.GyroUseRaw");
Bind(engineUseGyroCheckBox, "data.EngineUseGyro");
drone.OnSettingsChange += Drone_OnSettingsChange;
drone.OnInfoChange += Drone_OnInfoChange;
}
void ReturnDroneSlot(int slot)
{
DroneInfo droneInfo = droneSlots[slot];
droneInfo.occupied = false;
droneInfo.deliveryId = new EntityId(-1);
AddEnergyCost(droneInfo.energyUsed);
droneInfo.energyUsed = 0;
droneSlots[slot] = droneInfo;
usedSlots--;
}
private void UpdateInfo(DroneInfo info)
{
if (string.IsNullOrWhiteSpace(info.Name))
{
Text = string.Format("DroneControl - {0}", drone.Address);
}
else
{
Text = string.Format("DroneControl - {0}", info.Name);
}
droneInfoPropertyGrid.SelectedObject = info;
}
private void CreateDroneCamera()
{
MainMenu.EnhancedCamMenu.ResetCameras();
MainMenu.EnhancedCamMenu.droneCamera = MainMenu.EnhancedCamMenu.CreateNonAttachedCamera();
MainMenu.EnhancedCamMenu.droneCamera.FieldOfView = droneFov;
MainMenu.EnhancedCamMenu.droneCamera.IsActive = true;
drone = new DroneInfo {
velocity = Vector3.Zero,
downVelocity = 0f,
rotation = new Quaternion(0f, 0f, 0f, 1f)
};
Game.Player.CanControlCharacter = false;
}
public static DroneInfo Allocate(long antennaEntityId, int despawnTime)
{
DroneInfo info = null;
if (m_pool.Count == 0)
{
info = new DroneInfo();
}
else
{
info = m_pool[m_pool.Count - 1];
m_pool.RemoveAt(m_pool.Count - 1);
}
info.AntennaEntityId = antennaEntityId;
info.DespawnTime = despawnTime;
return info;
}
public override void Init(MyObjectBuilder_SessionComponent sessionComponent)
{
base.Init(sessionComponent);
var ob = sessionComponent as MyObjectBuilder_PirateAntennas;
m_piratesIdentityId = ob.PiratesIdentity;
int currentTime = MySandboxGame.TotalGamePlayTimeInMilliseconds;
if (ob.Drones != null)
{
foreach (var entry in ob.Drones)
{
m_droneInfos.Add(entry.EntityId, DroneInfo.Allocate(entry.AntennaEntityId, currentTime + entry.DespawnTimer), immediate: true);
}
}
}
public static DroneInfo Allocate(long antennaEntityId, int despawnTime)
{
DroneInfo info = null;
if (m_pool.Count == 0)
{
info = new DroneInfo();
}
else
{
info = m_pool[m_pool.Count - 1];
m_pool.RemoveAt(m_pool.Count - 1);
}
info.AntennaEntityId = antennaEntityId;
info.DespawnTime = despawnTime;
return(info);
}
private bool ScanDroneLogic(DroneContext droneInfo, DroneInfo drone, DroneOrder order)
{
var awaitingOrders = (order != null && order.Ordertype == OrderType.Standby);
if (awaitingOrders)
{
// log.Debug("Issuing First Scan Order");
IssueScanOrder(droneInfo);
}
else if (order != null && order.Ordertype == OrderType.Scan)
{
var droneDistance = Math.Abs((order.PrimaryLocation - drone.lastKnownPosition).Length());
if (droneDistance < 250 || (DateTime.Now - order.IssuedAt).TotalMinutes >= 2)
{
//log.Debug("Scan Order Complete");
order.PointOfIntrest.HasPendingOrder = false;
order.PointOfIntrest.Timestamp = DateTime.Now;
order.PointOfIntrest.Reached = true;
OngoingScanOrders.Remove(order);
trackingSystems.UpdateScanPoint(order.PointOfIntrest);
var nextScanPoint = trackingSystems.GetNearestScanPoint(Me.GetPosition(), 600);
if (nextScanPoint != null)
{
//log.Debug("Issuing New Scan Order "+ nextScanPoint.Location);
droneInfo.Order = new DroneOrder(log, OrderType.Scan, communicationSystems.GetMsgSntCount(), 0, drone.EntityId, nextScanPoint.Location, Vector3D.Zero, Vector3D.Zero);
droneInfo.Order.PointOfIntrest = nextScanPoint;
communicationSystems.TransmitOrder(droneInfo.Order, Me.CubeGrid.EntityId);
}
}
else
{
return(false);
}
}
else
{
return(false);
}
return(true);
}
void DroneDeploymentSuccess(EntityId droneId, DeliveryInfo deliveryInfo)
{
deliveryInfo.nextWaypoint++;
deliveriesMap.Add(droneId, deliveryInfo);
DroneInfo droneInfo = droneSlots[deliveryInfo.slot];
droneInfo.deliveryId = droneId;
droneInfo.occupied = true;
droneSlots[deliveryInfo.slot] = droneInfo;
avgWaitTime += Time.time - deliveryInfo.timestamp;
++launches;
MetricsWriter.Send(new ControllerMetrics.Update()
.SetAvgWaitTime(avgWaitTime)
.SetLaunches(launches));
UpdateDroneSlotsAndMap();
}
private void IncrementNextWaypoint(EntityId droneId, DeliveryInfo deliveryInfo, float energyUsed)
{
deliveryInfo.nextWaypoint++;
deliveryInfo.latestCheckinTime
= Time.time
+ (SimulationSettings.DroneETAConstant
* Vector3.Distance(
deliveryInfo.waypoints[deliveryInfo.nextWaypoint - 1].ToUnityVector(),
deliveryInfo.waypoints[deliveryInfo.nextWaypoint - 2].ToUnityVector())
/ SimulationSettings.MaxDroneSpeed);
deliveriesMap.Remove(droneId);
deliveriesMap.Add(droneId, deliveryInfo);
DroneInfo droneInfo = droneSlots[deliveryInfo.slot];
droneInfo.energyUsed = energyUsed;
droneSlots[deliveryInfo.slot] = droneInfo;
UpdateDroneSlotsAndMap();
}
private void UpdateDroneDespawning()
{
foreach (var entry in m_droneInfos)
{
if (entry.Value.DespawnTime < MySandboxGame.TotalGamePlayTimeInMilliseconds)
{
MyEntity droneEntity = null;
MyEntities.TryGetEntityById(entry.Key, out droneEntity);
Debug.Assert(droneEntity != null, "Could not find the drone entity to despawn!");
if (droneEntity != null)
{
MyCubeGrid grid = droneEntity as MyCubeGrid;
var remote = droneEntity as MyRemoteControl;
if (grid == null)
{
grid = remote.CubeGrid;
}
if (CanDespawn(grid, remote))
{
UnregisterDrone(droneEntity, immediate: false);
grid.SyncObject.SendCloseRequest();
}
else
{
entry.Value.DespawnTime = MySandboxGame.TotalGamePlayTimeInMilliseconds + DRONE_DESPAWN_RETRY;
}
}
else
{
DroneInfo.Deallocate(entry.Value);
m_droneInfos.Remove(entry.Key);
}
}
}
m_droneInfos.ApplyChanges();
}
private void addBtn_Click(object sender, EventArgs e)
{
String deviceName = deviceNameTextBox.Text;
String apName = apNameTextBox.Text;
int tagId = -1;
try
{
tagId = int.Parse(tagIdTextBox.Text);
}
catch (FormatException ex)
{
parent.ShowMessageBox("Please type only number in the tag textbox.");
this.Close();
}
DroneInfo dInfo = new DroneInfo(apName, tagId);
DroneList.AddDroneInfo(parent, deviceName, dInfo);
this.Close();
}
public override void BeforeStart()
{
base.BeforeStart();
MyFaction pirateFaction = MySession.Static.Factions.TryGetFactionByTag(PIRATE_FACTION_TAG);
Debug.Assert(pirateFaction != null, "No pirate faction in the world. Pirate antenan needs it.");
if (pirateFaction != null)
{
// Make sure that the pirate identity exists
if (m_piratesIdentityId != 0)
{
if (Sync.IsServer)
{
MyIdentity pirateIdentity = Sync.Players.TryGetIdentity(m_piratesIdentityId);
Debug.Assert(pirateIdentity != null, "The pirate identity does not exist, although its ID was saved!");
if (pirateIdentity == null)
{
Sync.Players.CreateNewIdentity(IDENTITY_NAME, m_piratesIdentityId, null);
}
pirateIdentity.LastLoginTime = DateTime.Now;
// Check if he is already in a faction.
MyFaction oldPirateFaction = MySession.Static.Factions.GetPlayerFaction(m_piratesIdentityId);
if (oldPirateFaction == null)
{
MyFactionCollection.SendJoinRequest(pirateFaction.FactionId, m_piratesIdentityId);
}
}
}
else
{
m_piratesIdentityId = pirateFaction.FounderId;
}
if (!Sync.Players.IdentityIsNpc(m_piratesIdentityId))
{
Sync.Players.MarkIdentityAsNPC(m_piratesIdentityId);
}
}
// Make sure that all the drone entities exist
foreach (var drone in m_droneInfos)
{
MyEntity entity;
MyEntities.TryGetEntityById(drone.Key, out entity);
if (entity == null)
{
DroneInfo.Deallocate(drone.Value);
m_droneInfos.Remove(drone.Key);
}
else
{
if (!MySession.Static.Settings.EnableDrones)
{
MyCubeGrid grid = entity as MyCubeGrid;
var remote = entity as MyRemoteControl;
if (grid == null)
{
grid = remote.CubeGrid;
}
UnregisterDrone(entity, immediate: false);
grid.Close();
//grid.SyncObject.SendCloseRequest();
}
else
{
RegisterDrone(drone.Value.AntennaEntityId, entity, immediate: false);
}
}
}
m_droneInfos.ApplyRemovals();
}
public static void Deallocate(DroneInfo toDeallocate)
{
toDeallocate.AntennaEntityId = 0;
toDeallocate.DespawnTime = 0;
m_pool.Add(toDeallocate);
}
private void UpdateInfo(DroneInfo info)
{
if (string.IsNullOrWhiteSpace(info.Name))
Text = string.Format("DroneControl - {0}", drone.Address);
else
Text = string.Format("DroneControl - {0}", info.Name);
droneInfoPropertyGrid.SelectedObject = info;
}
void HandleTargetRequest(Improbable.Entity.Component.ResponseHandle <Controller.Commands.RequestNewTarget, TargetRequest, TargetResponse> handle)
{
DeliveryInfo deliveryInfo;
if (deliveriesMap.TryGetValue(handle.Request.droneId, out deliveryInfo))
{
//Debug.LogWarning("is final waypoint?");
//final waypoint, figure out if it's back at controller or only just delivered
if (deliveryInfo.nextWaypoint < deliveryInfo.waypoints.Count)
{
handle.Respond(new TargetResponse(deliveryInfo.waypoints[deliveryInfo.nextWaypoint], TargetResponseCode.SUCCESS));
IncrementNextWaypoint(handle.Request.droneId, handle.Request.energyUsed);
}
else
{
if (deliveryInfo.returning)
{
UnsuccessfulTargetRequest(handle, TargetResponseCode.JOURNEY_COMPLETE);
DestroyDrone(handle.Request.droneId, deliveryInfo.slot);
MetricsWriter.Send(new ControllerMetrics.Update()
.SetCompletedRoundTrips(++completedRoundTrips)
.SetCosts(costs));
UpdateDroneSlotsAndMap();
}
else
{
RegisterCompletedDelivery(deliveryInfo);
MetricsWriter.Send(new ControllerMetrics.Update()
.SetCompletedDeliveries(completedDeliveries)
.SetAvgDeliveryTime(avgDeliveryTime)
.SetRevenue(revenue));
deliveryInfo.returning = true;
deliveryInfo.waypoints.Reverse();
Vector3f arrivalsGridPoint = globalLayer.GetClosestVector3fOnGrid(deliveryInfo.waypoints[0]);
arrivalsGridPoint.y = deliveryInfo.waypoints[2].y;
deliveryInfo.waypoints[1] = arrivalsGridPoint;
deliveryInfo.nextWaypoint = 2;
deliveryInfo.latestCheckinTime
= Time.time
+ (SimulationSettings.DroneETAConstant
* Vector3.Distance(
deliveryInfo.waypoints[0].ToUnityVector(),
deliveryInfo.waypoints[1].ToUnityVector())
/ SimulationSettings.MaxDroneSpeed);
deliveriesMap.Remove(handle.Request.droneId);
deliveriesMap.Add(handle.Request.droneId, deliveryInfo);
DroneInfo droneInfo = droneSlots[deliveryInfo.slot];
droneInfo.energyUsed = handle.Request.energyUsed;
droneSlots[deliveryInfo.slot] = droneInfo;
UpdateDroneSlotsAndMap();
//ignore 0 because that's the point that we've just reached
//saved as 2, but sending 1 back to drone - only 1 spatial update instead of 2 now
handle.Respond(new TargetResponse(deliveryInfo.waypoints[1], TargetResponseCode.SUCCESS));
}
}
}
else
{
UnsuccessfulTargetRequest(handle, TargetResponseCode.WRONG_CONTROLLER);
}
}
private void HandlePacket(byte[] packet)
{
// jedes Drohnen Paket ist mindestens HeaderSize Bytes lang und fangen mit "FLY" an
using (MemoryStream stream = new MemoryStream(packet))
{
PacketBuffer buffer = new PacketBuffer(stream);
if (packet.Length < HeaderSize || buffer.ReadByte() != 'F' || buffer.ReadByte() != 'L' || buffer.ReadByte() != 'Y')
return;
int revision = buffer.ReadInt();
bool isGuaranteed = buffer.ReadByte() > 0;
PacketType type = (PacketType)buffer.ReadByte();
if (Config.VerbosePacketReceive
&& type != PacketType.Ack
&& (type != PacketType.Ping || Config.LogPingPacket))
Log.Verbose("[{0}] Received: [{1}] {2}, size: {3} bytes", Address.ToString(), revision, type, packet.Length);
switch (type)
{
case PacketType.Ping:
if (packet.Length < HeaderSize + sizeof(long))
throw new InvalidDataException("Packet is not long enough.");
bool wasNotConnected = !CheckConnection();
lastPing = Environment.TickCount;
long time = buffer.ReadLong(); // time ist der Wert von stopwatch zum Zeitpunkt des Absenden des Pakets
Ping = (int)(stopwatch.ElapsedMilliseconds - time);
if (wasNotConnected)
OnConnected?.Invoke(this, EventArgs.Empty);
RemovePacketToAcknowlegde(revision);
break;
case PacketType.Ack:
IPacket acknowlegdedPacket;
if (!packetsToAcknowledge.TryGetValue(revision, out acknowlegdedPacket))
{
if (Config.VerbosePacketReceive)
Log.Verbose("[{0}] Unknown acknowlegde: [{1}]", Address.ToString(), revision);
break;
}
if (Config.VerbosePacketReceive)
Log.Verbose("[{0}] Acknowlegde: [{1}] {2}", Address.ToString(), revision, acknowlegdedPacket.Type);
RemovePacketToAcknowlegde(revision);
break;
case PacketType.Info:
Info = new DroneInfo(buffer);
Settings = DroneSettings.Read(buffer);
RemovePacketToAcknowlegde(revision);
break;
default:
throw new InvalidDataException("Invalid packet type to get sent by cluster.");
}
}
}
public static void Deallocate(DroneInfo toDeallocate)
{
toDeallocate.AntennaEntityId = 0;
toDeallocate.DespawnTime = 0;
m_pool.Add(toDeallocate);
}
public DroneContext(DroneInfo info, DroneOrder o)
{
Order = o;
Info = info;
}
public SettingsForm(Drone drone)
{
InitializeComponent();
this.drone = drone;
this.info = drone.Info;
this.originalData = drone.Settings;
this.data = drone.Settings;
try
{
Bind(nameTextBox, "data.DroneName");
Bind(saveConfigCheckBox, "data.SaveConfig");
Bind(firmwareVersionTextBox, "info.BuildVersion");
Bind(buildDateTextBox, "info.BuildName");
Bind(modelTextBox, "info.ModelName");
Bind(idTextBox, "info.SerialCode");
Bind(gyroSensorTextBox, "info.GyroSensor");
Bind(magnetometerTextBox, "info.Magnetometer");
Bind(baroSensorTextBox, "info.BaroSensor");
Bind(minValueTextBox, "data.ServoMin");
Bind(idleValueTextBox, "data.ServoIdle");
Bind(maxValueTextBox, "data.ServoMax");
Bind(safeMotorValueTextBox, "data.SafeServoValue");
Bind(ignoreSafeOrientationCheckBox, "data.IgnoreSafeOrientationWhileFlying");
Bind(safeTemperatureTextBox, "data.MaxTemperature");
Bind(safeRollTextBox, "data.SafeRoll");
Bind(safePitchTextBox, "data.SafePitch");
Bind(rollKpTextBox, "data.RollPid.Kp");
Bind(rollKiTextBox, "data.RollPid.Ki");
Bind(rollKdTextBox, "data.RollPid.Kd");
Bind(pitchKpTextBox, "data.PitchPid.Kp");
Bind(pitchKiTextBox, "data.PitchPid.Ki");
Bind(pitchKdTextBox, "data.PitchPid.Kd");
Bind(yawKpTextBox, "data.YawPid.Kp");
Bind(yawKiTextBox, "data.YawPid.Ki");
Bind(yawKdTextBox, "data.YawPid.Kd");
Bind(enableStabilizationCheckBox, "data.EnableStabilization");
Bind(maxThrustForFlyingTextBox, "data.MaxThrustForFlying");
Bind(ignoreSafeOrientationCheckBox, "data.OnlyArmWhenStill");
Bind(angleRollKpTextBox, "data.AngleRoll.Kp");
Bind(angleRollKiTextBox, "data.AngleRoll.Ki");
Bind(angleRollKdTextBox, "data.AngleRoll.Kd");
Bind(anglePitchKpTextBox, "data.AnglePitch.Kp");
Bind(anglePitchKiTextBox, "data.AnglePitch.Ki");
Bind(anglePitchKdTextBox, "data.AnglePitch.Kd");
Bind(angleYawKpTextBox, "data.AngleYaw.Kp");
Bind(angleYawKiTextBox, "data.AngleYaw.Ki");
Bind(angleYawKdTextBox, "data.AngleYaw.Kd");
Bind(rollTrim, "data.RollTrim");
Bind(pitchTrim, "data.PitchTrim");
Bind(yawTrim, "data.YawTrim");
drone.OnSettingsChange += Drone_OnSettingsChange;
drone.OnInfoChange += Drone_OnInfoChange;
}
catch (Exception e)
{
bindingError = true;
Log.Error(e);
MessageBox.Show("Could not load the settings.", "Error while loading settings", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
private void Drone_OnInfoChange(object sender, InfoChangedEventArgs e)
{
info = e.Info;
UpdateValues();
}
private bool CombatDroneLogic(DroneContext droneInfo, DroneInfo drone, DroneOrder order)
{
return(false);
}
private bool MiningDroneLogic(DroneContext droneInfo, DroneInfo drone, DroneOrder order)
{
var awaitingOrders = order != null && order.Ordertype == OrderType.Standby && drone.Docked;
if (awaitingOrders)
{
IssueMiningOrder(droneInfo);
}
else if (order != null && order.Ordertype == OrderType.Standby && !drone.Docked)
{
IssueDockOrder(droneInfo);
}
else if (order != null && order.Ordertype == OrderType.Mine && !drone.Docked)
{
var directionV = navigationSystems.GetGravityDirection();
directionV.Normalize();
var target_endpoint = order.PrimaryLocation + (directionV * 35);
var target_end_point_distance = (int)(drone.lastKnownPosition - target_endpoint).Length();
var target_between_start_and_end = (int)(order.PrimaryLocation - target_endpoint).Length();
// log.Debug("target endpoint: " + target_endpoint);
// log.Debug("Distance to finish mining: "+ target_end_point_distance);
// log.Debug("start - end distance: " + target_between_start_and_end);
if (target_end_point_distance <= 5)
{
miningOrders.Remove(order);
order.PointOfIntrest.Mined = true;
IssueDockOrder(droneInfo);
}
else
{
return(false);
}
}
else
{
return(false);
}
//else if (order != null && order.Ordertype == OrderType.Mine)
//{
// double dist = 1000000;
// for (int i = 0; i < droneInfo.Order.dockroute.Count(); i++)
// {
// var vect = droneInfo.Order.dockroute[i];
// var distance = Math.Abs((droneInfo.Info.lastKnownPosition - vect).Length());
// if (distance < dist && i > droneInfo.Order.MiningIndex)
// {
// droneInfo.Order.MiningIndex = i;
// dist = distance;
// }
// }
// log.Debug(droneInfo.Order.MiningIndex+" Mining Index");
// if(droneInfo.Order.MiningIndex == (droneInfo.Order.dockroute.Count()-1))
// {
// miningOrders.Remove(order);
// IssueStandbyOrder(droneInfo);
// }
// return false;
//}
return(true);
}
public InfoChangedEventArgs(Drone drone)
{
this.Info = drone.Info;
}
private void Drone_OnInfoChange(object sender, InfoChangedEventArgs e)
{
info = e.Info;
UpdateValues();
}
