private void AddSourceEntry(SourceEntry sourceEntry)
{
//Console.WriteLine($"adding {sourceEntry}");
if (!Entries.ContainsKey(sourceEntry.ThisHash))
{
Entries.Add(sourceEntry.ThisHash, new List <SourceEntry> {
sourceEntry
});
}
else
{
Entries[sourceEntry.ThisHash].Add(sourceEntry);
}
if (!FilesToTokens.ContainsKey(sourceEntry.FileHash))
{
FilesToTokens.Add(sourceEntry.FileHash, new List <int> {
sourceEntry.ThisHash
});
}
else
{
FilesToTokens[sourceEntry.FileHash].Add(sourceEntry.ThisHash);
}
}
/// <summary>
/// Searches for a given file entry in the file list.
/// </summary>
/// <param name="directory">Directory to search in.</param>
/// <param name="fileName">File name to find, without the extension.</param>
/// <param name="extension">File extension, without the leading dot.</param>
public PackageEntry FindEntry(string directory, string fileName, string extension)
{
if (directory == null)
{
throw new ArgumentNullException(nameof(directory));
}
if (fileName == null)
{
throw new ArgumentNullException(nameof(fileName));
}
if (extension == null)
{
throw new ArgumentNullException(nameof(extension));
}
if (!Entries.ContainsKey(extension))
{
return(null);
}
// We normalize path separators when reading the file list
// And remove the trailing slash
directory = directory.Replace('\\', DirectorySeparatorChar).Trim(DirectorySeparatorChar);
// If the directory is empty after trimming, set it to a space to match Valve's behaviour
if (directory.Length == 0)
{
directory = " ";
}
return(Entries[extension].Find(x => x.DirectoryName == directory && x.FileName == fileName));
}
/// <summary>
/// Accesses a stored value
/// </summary>
/// <param name="Key">The name of the stored value</param>
/// <returns>If the given key is present, returns the value being stored, otherwise returns null</returns>
public dynamic this[string Key]
{
get
{
lock (Entries)
{
if (Entries.ContainsKey(Key))
{
return(Entries[Key]);
}
else
{
return(null);
}
}
}
set
{
lock (Entries)
{
if (Entries.ContainsKey(Key))
{
Entries[Key] = value;
}
else
{
Entries.Add(Key, value);
}
}
}
}
public override void ProcessKill(Mobile victim, Mobile damager)
{
var bc = victim as BaseCreature;
if (bc == null || bc.Map != Map.TerMur || damager.Map != Map.TerMur)
{
return;
}
Type type = bc.GetType();
if (!Entries.ContainsKey(type))
{
return;
}
if (damager is BaseCreature && (((BaseCreature)damager).Controlled || ((BaseCreature)damager).Summoned))
{
damager = ((BaseCreature)damager).GetMaster();
}
if (damager == null)
{
return;
}
if (bc.GetHighestDamager() == damager)
{
AwardPoints(damager, Entries[type].Item1, false);
}
else
{
AwardPoints(damager, Entries[type].Item2, false);
}
}
public void AddPending(BODType type, int points)
{
if (Entries.ContainsKey(type))
{
Entries[type].PendingRewardPoints = points;
}
}
public override void ProcessKill(BaseCreature victim, Mobile damager, int index)
{
if (victim.Map != Map.TerMur || damager.Map != Map.TerMur)
{
return;
}
Type type = victim.GetType();
if (damager is BaseCreature && (((BaseCreature)damager).Controlled || ((BaseCreature)damager).Summoned))
{
damager = ((BaseCreature)damager).GetMaster();
}
if (damager == null)
{
return;
}
if (index == 0)
{
if (Entries.ContainsKey(type))
{
AwardPoints(damager, Entries[type].Item1, false);
}
}
else
{
if (Entries.ContainsKey(type))
{
AwardPoints(damager, Entries[type].Item2, false);
}
}
}
protected void RemoveLease(TLease lease)
{
if (Entries.ContainsKey(lease.Id) == true)
{
Entries.Remove(lease.Id);
}
}
protected IQueryable <GeoDataEntry> Search(string searchTerm, BoundingBox boundingBox, int maxResults)
{
lock (Entries)
{
//always want to query at least DataProviderMinResults # of entries so that
//Ranking logic is (most) accurately applied
maxResults = Math.Max(maxResults, DataProviderMinResults);
//remove entry if it already exists and is expired
var newKey = new ServiceCacheKey(StringComparer, boundingBox, searchTerm, maxResults);
ServiceCacheKey existingKey = Entries.ContainsKey(newKey) ? Entries.Keys.Single(k => k.Equals(newKey)) : null;
if (existingKey != null && IsFlushable(existingKey))
{
Entries.Remove(existingKey);
existingKey = null;
}
//if this set of args hasn't been queried before, or
//if it has but for a lower number of maxResults, refresh cache for this key
if (existingKey == null || existingKey.MaxResults < maxResults)
{
if (boundingBox != null)
{
Entries[newKey] = DataProvider.SearchNear(searchTerm, boundingBox, maxResults);
}
else
{
Entries[newKey] = DataProvider.Search(searchTerm.Trim(), maxResults);
}
}
return(Entries[newKey]);
}
}
public void RemovePending(BODType type)
{
if (Entries.ContainsKey(type))
{
Entries[type].PendingRewardPoints = 0;
}
}
public void TestStoragePopulatedDeleteEntryExist()
{
storage.DeleteEntry("foo2");
Assert.That(Entries.ContainsKey("foo2"), Is.False);
if (m_server)
{
Assert.That(IdMap, Has.Count.GreaterThanOrEqualTo(2));
Assert.That(IdMap[1], Is.Null);
}
if (m_server)
{
Assert.That(outgoing, Has.Count.EqualTo(1));
Assert.That(outgoing[0].only, Is.Null);
Assert.That(outgoing[0].except, Is.Null);
var msg = outgoing[0].msg;
Assert.That(msg.Type, Is.EqualTo(Message.MsgType.EntryDelete));
Assert.That(msg.Id, Is.EqualTo(1));
}
else
{
Assert.That(outgoing, Is.Empty);
}
}
protected void RemoveEntry(Guid id)
{
if (Entries.ContainsKey(id) == true)
{
TLease lease = Entries[id];
LatestLeases.Remove(lease);
Entries.Remove(id);
}
}
public int GetPendingRewardFor(BODType type)
{
if (Entries.ContainsKey(type))
{
return(Entries[type].PendingRewardPoints);
}
return(0);
}
protected override void When(DomainEvent domainEvent)
{
DHCPv4Lease lease = null;
switch (domainEvent)
{
case DHCPv4LeaseCreatedEvent e:
DHCPv4Lease leaseToAdd = new DHCPv4Lease(
e.EntityId,
e.Address,
e.StartedAt,
e.ValidUntil,
e.RenewalTime,
e.PreferredLifetime,
e.ClientIdenfier == null ? DHCPv4ClientIdentifier.Empty : DHCPv4ClientIdentifier.FromOptionData(e.ClientIdenfier),
e.UniqueIdentifier,
e.AncestorId,
_additonalApplier
);
if (Entries.ContainsKey(e.EntityId) == false)
{
AddEntry(e.EntityId, leaseToAdd);
CleanEntries();
}
break;
case DHCPv4LeaseRemovedEvent e:
RemoveEntry(e.EntityId);
break;
case DHCPv4LeaseCanceledEvent e:
lease = GetLeaseAndRemoveEntry(e.EntityId);
break;
case DHCPv4LeaseReleasedEvent e:
lease = GetLeaseAndRemoveEntry(e.EntityId);
break;
case DHCPv4LeaseRevokedEvent e:
lease = GetLeaseAndRemoveEntry(e.EntityId);
break;
case DHCPv4ScopeRelatedEvent e:
lease = GetLeaseById(e.EntityId);
break;
default:
break;
}
if (domainEvent?.IsHandled() == false)
{
ApplyToEnity(lease, domainEvent);
}
}
public override Entry GetEntry(uint id)
{
if (Entries.ContainsKey(id))
{
return(Entries[id]);
}
return(null);
}
public new void Load(string path)
{
base.Load(path);
if (Entries.ContainsKey("IniVersion") && Entries["IniVersion"].Count > 0)
{
Entries["IniVersion"].Remove(Entries["IniVersion"].Last().Key);
}
}
public virtual Entry GetEntry(uint id)
{
if (EntriesPerTexture <= 0 && Entries.ContainsKey(id))
{
return(Entries[id]);
}
else if (Entries?.ContainsKey((uint)(id % EntriesPerTexture)) ?? false)
{
return(Entries[(uint)(id % EntriesPerTexture)]);
}
return(null);
}
public override void ProcessQuest(Mobile from, Type type)
{
if (from == null || type == null)
{
return;
}
if (Entries.ContainsKey(type))
{
AwardPoints(from, Entries[type].Item1, true);
}
}
public virtual Entry GetEntry(Enum id)
{
if (Entries.ContainsKey(Convert.ToUInt32(id)))
{
return(Entries[Convert.ToUInt32(id)]);
}
if (Entries.ContainsKey((uint)(Convert.ToUInt32(id) % EntriesPerTexture)))
{
return(Entries[(uint)(Convert.ToUInt32(id) % EntriesPerTexture)]);
}
return(null);
}
public BaseStatsEntry this[byte level] {
get
{
if (Entries.ContainsKey(level))
{
return(Entries[level]);
}
else
{
return(null);
}
}
}
public void UpdateTimestamp(string baseFile)
{
var numTimestamps = 0;
if (Entries.ContainsKey("IniVersion"))
{
numTimestamps = Entries["IniVersion"].Count;
}
var newTimestamp = new DateTimeOffset(File.GetLastWriteTimeUtc(baseFile)).ToUnixTimeSeconds() + ".000000";
Add("IniVersion", numTimestamps.ToString(), newTimestamp);
}
public virtual PvPProfileHistoryEntry EnsureEntry(PvPSeason season, bool replace = false)
{
if (!Entries.ContainsKey(season.Number))
{
Entries.Add(season.Number, new PvPProfileHistoryEntry(season.Number));
}
else if (replace)
{
Entries[season.Number] = new PvPProfileHistoryEntry(season.Number);
}
return(Entries[season.Number] ?? (Entries[season.Number] = new PvPProfileHistoryEntry(season.Number)));
}
public override void ProcessQuest(Mobile from, BaseQuest quest)
{
if (from == null || quest == null)
{
return;
}
Type type = quest.GetType();
if (Entries.ContainsKey(type))
{
AwardPoints(from, Entries[type].Item1, true);
}
}
private void GeneratePages(ID label, ID label_pg1, byte count, sbyte offset)
{
if (!Entries.ContainsKey(label_pg1) && !Entries.ContainsKey(label) && !Entries.ContainsKey(ID.Size_08x08_P_))
{
return;
}
count = (byte)MathHelper.Clamp(count, 1, 99);
var P_ = Entries[ID.Size_08x08_P_][0].Clone();
P_.Offset.X += Entries[label][0].Width + offset;
P_.CustomPalette = 2;
var _ = new Entry[10];
_[1] = Entries[ID.Num_8x8_1_1][0].Clone();
_[1].Offset.X += P_.Offset.X + P_.Width + 2;
_[1].CustomPalette = 7;
for (byte i = 2; i <= 9 && i <= count; i++)
{
_[i] = Entries[ID.Num_8x8_1_1 + i - 1][0].Clone();
_[i].Offset.X = _[1].Offset.X;
_[i].CustomPalette = _[1].CustomPalette;
}
Entry[] __ = null;
if (count > 9)
{
__ = new Entry[10];
__[0] = Entries[ID.Num_8x8_1_0][0].Clone();
__[0].Offset.X += P_.Offset.X + P_.Width + 2 + _[1].Width;
__[0].CustomPalette = 7;
for (byte i = 1; i <= 9; i++)
{
__[i] = _[i].Clone();
__[i].Offset.X = __[0].Offset.X;
}
}
for (byte i = 1; i <= count; i++)
{
if (i < 10)
{
Entries[label_pg1 + i - 1] = new EntryGroup(Entries[label][0], P_, _[i]);
}
else if (i >= 10 && __ != null)
{
Entries[label_pg1 + i - 1] = new EntryGroup(Entries[label][0], P_, _[i / 10], __[i % 10]);
}
}
}
public object Get(string key)
{
object value = null;
cache.TryGetValue(key, out value);
if (value != null)
{
//test for expired entry
if (Entries.ContainsKey(key) && Entries[key].CompareTo(DateTime.Now) <= 0)
{
value = null;
}
}
return(value);
}
public TLease GetAncestor(TLease lease)
{
if (lease.HasAncestor() == false)
{
return(null);
}
if (Entries.ContainsKey(lease.AncestorId.Value) == false)
{
return(null);
}
else
{
return(Entries[lease.AncestorId.Value]);
}
}
public void CreateEntry(string query, Expression <Func <TEntity, object> > predicate)
{
ArgumentHelper.ThrowIfNullOrEmpty(query, nameof(query));
ArgumentHelper.ThrowIfNull(predicate, nameof(predicate));
if (Entries.ContainsKey(query))
{
throw new ArgumentException("An entry with the same query name already exists.", nameof(query));
}
Entries.Add(query, new SortDefinition <TEntity, TId>()
{
Name = query,
Predicate = predicate
});
}
/// <summary>
/// Create a new setting. The setting is saved to drive and loaded automatically.
/// Each definition can be used to add only one setting, trying to add a second setting will throw an exception.
/// </summary>
/// <typeparam name="T">Type of the value contained in this setting.</typeparam>
/// <param name="configDefinition">Section and Key of the setting.</param>
/// <param name="defaultValue">Value of the setting if the setting was not created yet.</param>
/// <param name="configDescription">Description of the setting shown to the user and other metadata.</param>
public ConfigEntry <T> AddSetting <T>(ConfigDefinition configDefinition, T defaultValue, ConfigDescription configDescription = null)
{
if (!TomlTypeConverter.CanConvert(typeof(T)))
{
throw new ArgumentException($"Type {typeof(T)} is not supported by the config system. Supported types: {string.Join(", ", TomlTypeConverter.GetSupportedTypes().Select(x => x.Name).ToArray())}");
}
lock (_ioLock)
{
if (Entries.ContainsKey(configDefinition))
{
throw new ArgumentException("The setting " + configDefinition + " has already been created. Use GetSetting to get it.");
}
try
{
_disableSaving = true;
var entry = new ConfigEntry <T>(this, configDefinition, defaultValue, configDescription);
Entries[configDefinition] = entry;
if (HomelessEntries.TryGetValue(configDefinition, out string homelessValue))
{
entry.SetSerializedValue(homelessValue);
HomelessEntries.Remove(configDefinition);
}
_disableSaving = false;
if (SaveOnConfigSet)
{
Save();
}
return(entry);
}
finally
{
_disableSaving = false;
}
}
}
public BODContext(GenericReader reader)
{
int version = reader.ReadInt();
ConfigEntries();
this.PointsMode = (PointsMode)reader.ReadInt();
BOBFilter = new BOBFilter(reader);
int count = reader.ReadInt();
for (int i = 0; i < count; i++)
{
BODType type = (BODType)reader.ReadInt();
BODEntry entry = new BODEntry(reader);
if (Entries.ContainsKey(type))
{
Entries[type] = entry;
}
}
}
public void ProjectileHitEnemy(float damage, bool fatal, HealthHaver enemy)
{
CustomEnemyTagsSystem tags = enemy.gameObject.GetComponent <CustomEnemyTagsSystem>();
if (tags != null && tags.ignoreForGoodMimic == true)
{
return;
}
if (enemy != null && enemy.aiActor != null && ((fatal && !enemy.IsBoss) || (enemy.IsBoss && canChangeToBossWeapon)))
{
int GunID = -1;
if (enemy.aiActor.aiShooter != null && enemy.aiActor.aiShooter.CurrentGun != null)
{
if (SpecialOverrideGuns.ContainsKey(enemy.aiActor.EnemyGuid))
{
GunID = SpecialOverrideGuns[enemy.aiActor.EnemyGuid];
}
else
{
GunID = enemy.aiActor.aiShooter.CurrentGun.PickupObjectId;
}
}
else if (Entries.ContainsKey(enemy.aiActor.EnemyGuid))
{
GunID = Entries[enemy.aiActor.EnemyGuid];
}
if (GunID > 0)
{
if (enemy.IsBoss)
{
canChangeToBossWeapon = false;
Invoke("ResetBossWeaponCooldown", 2.5f);
}
TransformToTargetGunSpecial((PickupObjectDatabase.GetById(GunID) as Gun));
}
}
}
/// <summary>添加文件。
/// 必须指定文件路径<paramref name="fileName"/>，如果不指定实体名<paramref name="entryName"/>，则使用文件名，并加到顶级目录。</summary>
/// <param name="fileName">文件路径</param>
/// <param name="entryName">实体名</param>
/// <param name="stored">是否仅存储，不压缩</param>
/// <returns></returns>
public ZipEntry AddFile(String fileName, String entryName = null, Boolean?stored = false)
{
if (String.IsNullOrEmpty(fileName))
{
throw new ArgumentNullException("fileName");
}
if (String.IsNullOrEmpty(entryName))
{
entryName = Path.GetFileName(fileName);
}
entryName = entryName.Replace(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
// 判断并添加目录
String dir = Path.GetDirectoryName(entryName);
if (!String.IsNullOrEmpty(dir))
{
if (!dir.EndsWith(DirSeparator))
{
dir += DirSeparator;
}
if (!Entries.ContainsKey(dir))
{
var zde = new ZipEntry();
zde.FileName = dir;
Entries.Add(dir, zde);
}
}
var entry = ZipEntry.Create(fileName, entryName, stored);
Entries.Add(entry.FileName, entry);
return(entry);
}
