public HullClassifier(IMySlimBlock block) { SlimBlock = block; FatBlock = block.FatBlock; m_SubTypeName = FatBlock.BlockDefinition.SubtypeName; Class = HullClassFromSubTypeString(m_SubTypeName); }
/// <summary> /// If the class has changed, update class the fleet stored it as /// </summary> /// <param name="c">New Hull Class</param> public void setClassification(HullClass.CLASS c) { if (m_Class == c) { return; } log("changing owner class to " + c, "setClassification"); m_Fleet.remove(m_Class, m_Enforcer); m_Class = c; m_Fleet.add(m_Class, m_Enforcer); log("Owner class changed to " + m_Class, "setClassification"); }
public GridOwner(GridEnforcer ge) { m_Enforcer = ge; m_Logger = new Logger(m_Enforcer.Grid.EntityId.ToString(), "GridOwner"); log("Loaded into new grid", "ctr"); // the grid will update ownership later b/c this is initialized with the grid, // and the grid doesn't have any blocks yet m_OwnerType = OWNER_TYPE.UNOWNED; m_FleetID = getFleetID(); m_Class = ge.Class; m_Fleet = getFleet(); m_Fleet.add(m_Class, ge); }
public GridOwner(GridEnforcer ge) { m_Enforcer = ge; m_Logger = new Logger(m_Enforcer.Grid.EntityId.ToString(), "GridOwner"); log("Loaded into new grid", "ctr"); // the grid will update ownership later b/c this is initialized with the grid, // and the grid doesn't have any blocks yet m_OwnerType = OWNER_TYPE.UNOWNED; m_FleetID = getFleetID(); m_Class = ge.Class; m_Fleet = getFleet(); m_Fleet.add(m_Class, ge); }
/// <summary> /// Increments the class count for a given class /// </summary> /// <param name="c">Class to increment</param> public void add(HullClass.CLASS c, GridEnforcer ge) { log("adding class " + ge.Class, "add", Logger.severity.TRACE); int classID = (int)ge.Class; //log("m_Counts[classID] is " + m_Counts[classID], "add", Logger.severity.TRACE); updateSupportAdded(ge); m_Counts[classID] += 1; m_TotalCount++; //log("m_Counts[classID] is " + m_Counts[classID], "add", Logger.severity.TRACE); //debugPrint("add"); }
/// <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> /// Decrements the class count for a given class /// </summary> /// <param name="c">Class to decrement</param> public void remove(HullClass.CLASS c, GridEnforcer ge) { int classID = (int)c; if (m_Counts[classID] > 0) { m_Counts[classID] -= 1; m_TotalCount--; } else { log("Error: Decrementing class " + classID + " count, but already 0", "removeClass", Logger.severity.ERROR); } updateSupportRemoved(classID, ge); //debugPrint("remove"); }
public override void Init(MyObjectBuilder_EntityBase objectBuilder) { base.Init(objectBuilder); m_Grid = Container.Entity as IMyCubeGrid; m_Logger = new Logger(m_Grid.EntityId.ToString(), "GridEnforcer"); log("Loaded into new grid", "Init"); // If this is not the server we don't need this class. // When we modify the grid on the server the changes should be // sent to all clients try { m_IsServer = Utility.isServer(); log("Is server: " + m_IsServer, "Init"); if (!m_IsServer) { // No cleverness allowed :[ log("Disabled. Not server.", "Init"); m_Logger = null; m_Grid = null; return; } } catch (NullReferenceException e) { log("Exception. Multiplayer is not initialized. Assuming server for time being: " + e, "Init"); // If we get an exception because Multiplayer was null (WHY KEEN???) // assume we are the server for a little while and check again later m_IsServer = true; m_CheckServerLater = true; } // We need to only turn on our rule checking after startup. Otherwise, if // a beacon is destroyed and then the server restarts, all but the first // 25 blocks will be deleted on startup. m_Grid.NeedsUpdate |= MyEntityUpdateEnum.EACH_100TH_FRAME; m_BlockCount = 0; m_BlockTypeCounts = new int[s_Settings.BlockTypes.Length]; m_Owner = new GridOwner(this); m_Classifiers = new Dictionary<long, HullClassifier>(); m_Projectors = new Dictionary<long, InGame.IMyProjector>(); m_ReservedClass = DEFAULT_CLASS; m_ReservedRules = s_Settings.HullRules[(int)DEFAULT_CLASS]; m_EffectiveClass = DEFAULT_CLASS; m_EffectiveRules = s_Settings.HullRules[(int)DEFAULT_CLASS]; reserveEffectiveClassFromOwner(); m_Grid.OnBlockAdded += blockAdded; m_Grid.OnBlockRemoved += blockRemoved; m_Grid.OnBlockOwnershipChanged += blockOwnerChanged; m_GridSubscribed = true; }
private void setReservedTo(HullClass.CLASS newClass) { if (m_ReservedClass == newClass) { log("No change, ReservedClass remains " + m_ReservedClass, "setReservedTo"); } else { log("Changing ReservedClass from " + m_ReservedClass + " to " + newClass, "setReservedTo"); m_ReservedClass = newClass; m_ReservedRules = s_Settings.HullRules[(int)newClass]; } }
private void setEffectiveTo(HullClass.CLASS newClass) { if (m_EffectiveClass == newClass) { log("No changed, EffectiveClass remains " + m_EffectiveClass, "setEffectiveTo"); } else { log("Changing EffectiveClass from " + m_EffectiveClass + " to " + newClass, "setEffectiveTo"); m_EffectiveClass = newClass; m_EffectiveRules = s_Settings.HullRules[(int)newClass]; reserveEffectiveClassFromOwner(); m_CheckCleanupNextUpdate = true; } }
/// <summary> /// If the class has changed, update class the fleet stored it as /// </summary> /// <param name="c">New Hull Class</param> public void setClassification(HullClass.CLASS c) { if (m_Class == c) return; log("changing owner class to " + c, "setClassification"); m_Fleet.remove(m_Class, m_Enforcer); m_Class = c; m_Fleet.add(m_Class, m_Enforcer); log("Owner class changed to " + m_Class, "setClassification"); }
public bool canSupportAnother(HullClass.CLASS c) { return((countClass(c) < maxClass(c)) || (maxClass(c) < 0)); }
public uint maxClass(HullClass.CLASS c) { return(m_Maximums[(int)c]); }
/// <summary> /// /// </summary> /// <param name="c">Class to check</param> /// <returns>Count of c</returns> public uint countClass(HullClass.CLASS c) { return(m_Counts[(int)c]); }