/// <summary>
/// Determines whether this fleet is allowed to support this class
/// Alerts the grid and updates tracking
/// Returns true if it was supported
/// </summary>
private bool updateSupportAdded(GridEnforcer ge)
{
HullClass.CLASS hc = ge.Class;
uint c = (uint)hc;
long eID = ge.Container.Entity.EntityId;
//log("adding " + eID + " as " + c, "updateSupportAdded");
// if we have enough room, support it
if (canSupportAnother(hc)) {
log("we have enough room, supporting", "updateSupportAdded");
m_SupportedGrids[c][eID] = ge;
ge.markSupported(m_FactionId);
return true;
}
// if we don't, see if it's bigger than one of the supported ones
foreach (KeyValuePair<long, GridEnforcer> pair in m_SupportedGrids[c]) {
GridEnforcer supported = pair.Value;
// it is!
if (ge.BlockCount > supported.BlockCount) {
log("it's larger than one of our supported, supporting", "updateSupportAdded");
// remove support from the old supported one
log("removing support from " + pair.Key, "updateSupportAdded");
m_SupportedGrids[c].Remove(pair.Key);
m_UnsupportedGrids[c][pair.Key] = supported;
supported.markUnsupported(m_FactionId);
// add support to the new
log("supporting " + eID, "updateSupportAdded");
m_SupportedGrids[c][eID] = ge;
ge.markSupported(m_FactionId);
return true;
}
}
// if not, mark as unsupported
log("can't support, marking grid as unsupported", "updateSupportAdded");
m_UnsupportedGrids[c][eID] = ge;
ge.markUnsupported(m_FactionId);
return false;
}
/// <summary>
/// Returns true if the support has changed
/// </summary>
/// <remarks>
/// We should eventually call this every so often after adding blocks,
/// perhaps before a GE Violations check, since competition for support is
/// dependent on block count. Right now it's not called at all.
/// </remarks>
/// <param name="ge"></param>
/// <returns></returns>
public bool updateSupport(GridEnforcer ge)
{
uint c = (uint)ge.Class;
long eID = ge.Container.Entity.EntityId;
Dictionary<long, GridEnforcer> supportedGrids = m_SupportedGrids[c];
Dictionary<long, GridEnforcer> unsupportedGrids = m_UnsupportedGrids[c];
// if it's a supported
if (supportedGrids.ContainsKey(eID)) {
// if we're out of room and there's unsupported grids
if ((m_Counts[c] > m_Maximums[c]) && unsupportedGrids.Count > 0) {
// for any of the unsupported
foreach (long unsupportedID in unsupportedGrids.Keys) {
GridEnforcer unsupported = unsupportedGrids[unsupportedID];
// see it this is smaller
if (ge.BlockCount < unsupported.BlockCount) {
// change unsupported to supported
unsupportedGrids.Remove(unsupportedID);
supportedGrids[unsupportedID] = unsupported;
unsupported.markSupported(m_FactionId);
// change this to unsupported
supportedGrids.Remove(eID);
unsupportedGrids[eID] = ge;
ge.markUnsupported(m_FactionId);
return true;
}
}
// if it's a unsupported
} else if (unsupportedGrids.ContainsKey(eID)) {
// if we have enough room, support it
if (m_Counts[c] < m_Maximums[c]) {
unsupportedGrids.Remove(eID);
supportedGrids[eID] = ge;
ge.markSupported(m_FactionId);
return true;
}
// for any of the unsupported
foreach (long supportedID in supportedGrids.Keys) {
GridEnforcer supported = supportedGrids[supportedID];
// see if it's bigger
if (ge.BlockCount > supported.BlockCount) {
// remove support from the old
supportedGrids.Remove(supportedID);
unsupportedGrids[supportedID] = supported;
supported.markUnsupported(m_FactionId);
// add support to the existing
unsupportedGrids.Remove(eID);
supportedGrids[eID] = ge;
ge.markSupported(m_FactionId);
return true;
}
}
}
}
return false;
}
