public IEnumerator Load(World.Data world)
{
ActionProgressBar.UpdateProgress("Loading Map Prefabs", 0f);
yield return(null);
yield return(null);
Stopwatch sw = Stopwatch.StartNew();
for (int i = 0; i < world.prefabData.Count; i++)
{
if (sw.Elapsed.TotalSeconds > 1f || i == 0 || i == world.prefabData.Count - 1)
{
ActionProgressBar.UpdateProgress("Loading Map Prefabs", (float)world.prefabData.Count / (float)i);
yield return(null);
yield return(null);
sw.Reset();
}
ProtoBuf.PrefabData prefabData = world.prefabData[i];
CreatePrefab(StringPool.Get(prefabData.id), prefabData.category, prefabData.position, prefabData.rotation, prefabData.scale);
}
sw.Stop();
}
private void ScaleDealtDamage(HitInfo hitInfo)
{
string bodypart = StringPool.Get(hitInfo.HitBone) ?? string.Empty;
var ammoMod = 1.0f;
var heldWeapon = hitInfo?.Weapon?.GetItem()?.GetHeldEntity()?.GetComponent <BaseProjectile>() ?? null;
var ammoName = heldWeapon?.primaryMagazine?.ammoType?.shortname ?? string.Empty;
if (weaponData.Weapons.ContainsKey(ammoName))
{
ammoMod = weaponData.Weapons[ammoName].GlobalModifier;
}
string weapon = hitInfo?.Weapon?.GetItem()?.info?.shortname ?? string.Empty;
if (string.IsNullOrEmpty(weapon))
{
return;
}
if (InList(weapon, bodypart))
{
var globalMod = weaponData.Weapons[weapon].GlobalModifier;
var individualMod = weaponData.Weapons[weapon].IndividualParts[bodypart];
var totalMod = (globalMod + individualMod + ammoMod) - 2;
if (totalMod != 1.0f)
{
hitInfo.damageTypes.ScaleAll(totalMod);
}
}
else if (ammoMod != 1.0f)
{
hitInfo.damageTypes.ScaleAll(ammoMod);
}
}
public SkillState(Dictionary <string, AbstractStoragePool> poolByName, StringPool strings, StringType stringType,
Annotation annotationType, List <AbstractStoragePool> types, FileInputStream @in, Mode mode) : base(strings, @in.Path, mode, types, poolByName, stringType, annotationType)
{
try {
AbstractStoragePool p = null;
poolByName.TryGetValue("testenum", out p);
TestEnumsField = (null == p) ? (P0)Parser.newPool("testenum", null, types) : (P0)p;
poolByName.TryGetValue("testenum:default", out p);
Testenum_defaultsField = (null == p) ? (P1)Parser.newPool("testenum:default", TestEnumsField, types) : (P1)p;
poolByName.TryGetValue("testenum:second", out p);
Testenum_secondsField = (null == p) ? (P2)Parser.newPool("testenum:second", TestEnumsField, types) : (P2)p;
poolByName.TryGetValue("testenum:third", out p);
Testenum_thirdsField = (null == p) ? (P3)Parser.newPool("testenum:third", TestEnumsField, types) : (P3)p;
poolByName.TryGetValue("testenum:last", out p);
Testenum_lastsField = (null == p) ? (P4)Parser.newPool("testenum:last", TestEnumsField, types) : (P4)p;
} catch (System.InvalidCastException e) {
throw new ParseException(@in, -1, e,
"A super type does not match the specification; see cause for details.");
}
foreach (AbstractStoragePool t in types)
{
poolByName[t.Name] = t;
}
finalizePools(@in);
@in.close();
}
/// <summary>
/// Make sure string is added to pool
/// </summary>
internal static void Prepare(StringPool pool, string value, int resourceId = -1)
{
if (value != null)
{
pool.Add(value, resourceId);
}
}
private void OnPlayerInit(BasePlayer player)
{
if (player.HasPlayerFlag(BasePlayer.PlayerFlags.ReceivingSnapshot))
{
timer.Once(2, () => OnPlayerInit(player));
return;
}
PetData info;
if (!npcSaveList.TryGetValue(player.userID, out info) || !info.NeedToSpawn)
{
return;
}
Puts("Loading pet...");
BaseEntity pet = InstantiateEntity(StringPool.Get(info.prefabID), new Vector3(info.x, info.y, info.z), new Quaternion());
if (pet == null)
{
return;
}
NPCController controller = player.gameObject.AddComponent <NPCController>();
pet.enableSaving = false;
pet.Spawn();
controller.npcAi = pet.gameObject.AddComponent <NpcAI>();
controller.npcAi.owner = controller;
controller.npcAi.inventory.Load(ProtoBuf.ItemContainer.Deserialize(info.inventory));
info.NeedToSpawn = false;
}
public static void print_prefabs(Arg arg)
{
PrefabPoolCollection pool = GameManager.server.pool;
if (pool.storage.Count == 0)
{
arg.ReplyWith("Prefab pool is empty.");
return;
}
string @string = arg.GetString(0, string.Empty);
TextTable textTable = new TextTable();
textTable.AddColumn("id");
textTable.AddColumn("name");
textTable.AddColumn("count");
foreach (KeyValuePair <uint, PrefabPool> item in pool.storage)
{
string text = item.Key.ToString();
string text2 = StringPool.Get(item.Key);
string text3 = item.Value.Count.ToString();
if (string.IsNullOrEmpty(@string) || text2.Contains(@string, CompareOptions.IgnoreCase))
{
textTable.AddRow(text, Path.GetFileNameWithoutExtension(text2), text3);
}
}
arg.ReplyWith(textTable.ToString());
}
public override void Hurt(HitInfo info)
{
bool flag = false;
if ((double)info.damageTypes.Total() >= (double)this.health)
{
this.health = 1000000f;
this.myAI.CriticalDamage();
flag = true;
}
base.Hurt(info);
if (flag)
{
return;
}
foreach (BaseHelicopter.weakspot weakspot in this.weakspots)
{
foreach (string bonename in weakspot.bonenames)
{
if ((int)info.HitBone == (int)StringPool.Get(bonename))
{
weakspot.Hurt(info.damageTypes.Total(), info);
this.myAI.WeakspotDamaged(weakspot, info);
}
}
}
}
public void SpawnVisual(BasePlayer player)
{
if (_visualEntity != null || !Configuration.ShowOnBack)
{
return;
}
BaseEntity entity = GameManager.server.CreateEntity(BackpackPrefab, new Vector3(0, -0.1f, 0), Quaternion.Euler(-5, -90, 180));
DroppedItemContainer container = entity as DroppedItemContainer;
container.inventory = new ItemContainer();
container.inventory.ServerInitialize(null, 0);
container.inventory.GiveUID();
container.inventory.entityOwner = container;
container.inventory.SetFlag(ItemContainer.Flag.NoItemInput, true);
container.CancelInvoke(container.RemoveMe);
var visualBackpack = entity.gameObject.AddComponent <VisualBackpack>();
visualBackpack.Backpack = this;
entity.limitNetworking = true;
entity.SetParent(player, StringPool.Get(BackBone));
entity.SetFlag(BaseEntity.Flags.Locked, true);
entity.Spawn();
entity.name = "backpack";
_visualEntity = entity;
}
private void Init()
{
lang.RegisterMessages(new Dictionary <string, string>
{
{ "NotEnoughItems", "Not enough {0}! You need {1} but you only have {2}" },
{ "NotAllowed", "<color=red>You are not allowed to use that command!</color>" },
{ "UnknownGrade", "<color=red>Unknown grade!</color>" },
{ "UnknownCategory", "<color=red>Unknown category!</color>" },
{ "NotLookingAt", "<color=red>You are not looking at a building block!</color>" },
{ "FinishedUp", "Finished upgrading!" },
{ "FinishedDown", "Finished downgrading!" },
{ "AlreadyRunning", "Already running, please wait!" },
{ "AnotherProcess", "Another process already running, please try again in a few seconds!" }
}, this);
configData = Config.ReadObject <ConfigData>();
foreach (var category in configData.Categories)
{
var data = new HashSet <uint>();
foreach (var prefab in category.Value)
{
var prefabId = StringPool.Get(prefab);
if (prefabId <= 0)
{
continue;
}
data.Add(prefabId);
}
categories.Add(category.Key, data);
}
}
public void Load(WorldSerialization blob)
{
var terrainSize = new Vector3(blob.world.size, 1000, blob.world.size);
var terrainPosition = 0.5f * terrainSize;
Terrain land = GameObject.FindGameObjectWithTag("Land").GetComponent <Terrain>();
Terrain water = GameObject.FindGameObjectWithTag("Water").GetComponent <Terrain>();
WorldConverter.MapInfo terrains = WorldConverter.worldToTerrain(blob);
land.terrainData.heightmapResolution = terrains.resolution;
land.terrainData.size = terrains.size;
water.terrainData.heightmapResolution = terrains.resolution;
water.terrainData.size = terrains.size;
land.terrainData.SetHeights(0, 0, terrains.land.heights);
water.terrainData.SetHeights(0, 0, terrains.water.heights);
land.terrainData.alphamapResolution = terrains.resolution;
land.terrainData.size = terrains.size;
land.terrainData.splatPrototypes = getTextures();
land.terrainData.SetAlphamaps(0, 0, terrains.splatMap);
GameObject defaultObj = Resources.Load <GameObject>("Prefabs/DefaultPrefab");
for (int i = 0; i < terrains.prefabData.Length; i++)
{
Vector3 pos = new Vector3(terrains.prefabData[i].position.x, terrains.prefabData[i].position.y, terrains.prefabData[i].position.z);
Vector3 scale = new Vector3(terrains.prefabData[i].scale.x, terrains.prefabData[i].scale.y, terrains.prefabData[i].scale.z);
Quaternion rotation = Quaternion.Euler(new Vector3(terrains.prefabData[i].rotation.x, terrains.prefabData[i].rotation.y, terrains.prefabData[i].rotation.z));
GameObject g = FileSystem.Load <GameObject>(StringPool.Get((blob.world.prefabs[i].id)));
GameObject newObject = Instantiate(g, pos + terrainPosition, rotation);
newObject.transform.localScale = scale;
PrefabDataHolder pdh = newObject.GetComponent <PrefabDataHolder>();
if (pdh == null)
{
newObject.AddComponent <PrefabDataHolder>();
}
pdh.prefabData = terrains.prefabData[i];
}
GameObject pathObj = Resources.Load <GameObject>("Paths/Path");
for (int i = 0; i < terrains.pathData.Length; i++)
{
Vector3 averageLocation = Vector3.zero;
for (int j = 0; j < terrains.pathData[i].nodes.Length; j++)
{
averageLocation += terrains.pathData[i].nodes[j];
}
averageLocation /= terrains.pathData[i].nodes.Length;
GameObject newObject = Instantiate(pathObj, averageLocation + terrainPosition, Quaternion.identity);
newObject.GetComponent <PathDataHolder>().pathData = terrains.pathData[i];
newObject.GetComponent <PathDataHolder>().offset = terrainPosition;
}
}
void OnPlayerInit(BasePlayer player)
{
if (player.HasPlayerFlag(BasePlayer.PlayerFlags.ReceivingSnapshot))
{
timer.Once(2, () => OnPlayerInit(player));
return;
}
PetInfo info;
if (!SaveNpcList.TryGetValue(player.userID, out info) || !info.NeedToSpawn)
{
return;
}
Puts("Loading pet...");
var pet = GameManager.server.CreateEntity(StringPool.Get(info.prefabID), new Vector3(info.x, info.y, info.z));
if (pet == null)
{
return;
}
var comp = player.gameObject.AddComponent <NpcControl>();
pet.Spawn();
comp.npc = pet.gameObject.AddComponent <NpcAI>();
comp.npc.owner = comp;
comp.npc.inventory.Load(ProtoBuf.ItemContainer.Deserialize(info.inventory));
info.NeedToSpawn = false;
}
/// <summary>
/// Make sure string is added to pool
/// </summary>
internal static void Prepare(StringPool pool, string value, int resourceId = -1)
{
if (value != null)
{
pool.Add(value, resourceId);
}
}
void Init()
{
LoadData();
turretPrefabId = StringPool.Get(turretPrefab);
permission.RegisterPermission("turretconfig.infiniteammo", this);
bulletDamage = GetConfig("bulletDamage", 10f);
bulletSpeed = GetConfig("bulletSpeed", 10f);
ammoType = GetConfig("ammoType", "ammo.rifle");
adminOverride = GetConfig("adminOverride", true);
animalOverride = GetConfig("animalOverride", false);
sleepOverride = GetConfig("sleepOverride", false);
animals = GetConfig <List <object> >("animals", GetPassiveAnimals());
useGlobalDamageModifier = GetConfig("useGlobalDamageModifier", false);
globalDamageModifier = GetConfig("globalDamageModifier", 1f);
health = GetConfig("health", 750f);
aimCone = GetConfig("aimCone", 5f);
sightRange = GetConfig("sightRange", 30f);
infiniteAmmo = GetConfig("infiniteAmmo", false);
LoadTurrets();
}
public HurtEvent(HitInfo info)
{
_info = info;
string bonename = StringPool.Get(info.HitBone);
HitBone = bonename == ""?"unknown":bonename;
}
/**
* read String pool, for apk binary xml file and resource table.
*/
public static async Task <StringPool> readStringPool(ByteBuffer buffer, StringPoolHeader stringPoolHeader)
{
long beginPos = buffer.position();
long[] offsets = new long[(int)stringPoolHeader.getStringCount()];
// read strings offset
if (stringPoolHeader.getStringCount() > 0)
{
for (int idx = 0; idx < stringPoolHeader.getStringCount(); idx++)
{
offsets[idx] = Buffers.readUInt(buffer);
}
}
// read flag
// the string index is sorted by the string values if true
bool sorted = (stringPoolHeader.getFlags() & StringPoolHeader.SORTED_FLAG) != 0;
// string use utf-8 format if true, otherwise utf-16
bool utf8 = (stringPoolHeader.getFlags() & StringPoolHeader.UTF8_FLAG) != 0;
// read strings. the head and metas have 28 bytes
long stringPos = beginPos + stringPoolHeader.getStringsStart() - stringPoolHeader.getHeaderSize();
buffer.position((int)stringPos);
StringPoolEntry[] entries = new StringPoolEntry[offsets.Length];
for (int i = 0; i < offsets.Length; i++)
{
entries[i] = new StringPoolEntry(i, stringPos + offsets[i]);
}
string lastStr = null;
long lastOffset = -1;
StringPool stringPool = new StringPool((int)stringPoolHeader.getStringCount());
foreach (StringPoolEntry entry in entries)
{
if (entry.getOffset() == lastOffset)
{
stringPool.set(entry.getIdx(), lastStr);
continue;
}
buffer.position((int)entry.getOffset());
lastOffset = entry.getOffset();
string str = await ParseUtils.readString(buffer, utf8);
lastStr = str;
stringPool.set(entry.getIdx(), str);
}
// read styles
if (stringPoolHeader.getStyleCount() > 0)
{
// now we just skip it
}
buffer.position((int)(beginPos + stringPoolHeader.getBodySize()));
return(stringPool);
}
internal string GetClass()
{
using (var temp = StringPool.Borrow())
{
var sb = temp.Item;
sb.Append("m-portlet");
if (this.Border)
{
sb.Append(" m-portlet--bordered");
}
if (this.Semi)
{
sb.Append(" m-portlet--bordered-semi");
}
if (this.Rounded)
{
sb.Append(" m-portlet--rounded");
}
if (!this.Air)
{
sb.Append(" m-portlet--unair");
}
if (this.SmallHead)
{
sb.Append(" m-portlet--head-sm");
}
if (!string.IsNullOrEmpty(this.BgColor))
{
sb.AppendFormat(" m--bg-{0}", this.BgColor);
}
return(sb.ToString());
}
}
internal unsafe Wrapper(EngineFuncs engineFuncs, GlobalVars.Internal *pGlobals)
: base(new EngineShared(engineFuncs))
{
Log.Message("Initializing wrapper");
EntityDictionary = new EntityDictionary(engineFuncs);
//Make sure this knows how to convert edicts
EntVars.EntityDictionary = EntityDictionary;
EngineFuncs = engineFuncs;
Globals = new GlobalVars(pGlobals, EntityDictionary);
EntityDictionary.SetGlobals(Globals);
StringPool = new StringPool(Globals);
EngineString.StringPool = StringPool;
//Create interface implementations
EngineServer = new EngineServer(EngineFuncs, StringPool, EntityDictionary, Globals, FileSystem);
CVar = new CVar.CVar(EngineFuncs);
}
/**
* Create a new skill file based on argument path and mode.
*
* @throws IOException
* on IO and mode related errors
* @throws SkillException
* on file or specification consistency errors
* @note suppress unused warnings, because sometimes type declarations are
* created, although nobody is using them
*/
public static new SkillFile open(string path, params Mode[] mode)
{
ActualMode actualMode = new ActualMode(mode);
try {
switch (actualMode.open)
{
case Mode.Create:
// initialization order of type information has to match file
// parser
// and can not be done in place
StringPool strings = new StringPool(null);
List <AbstractStoragePool> types = new List <AbstractStoragePool>(1);
StringType stringType = new StringType(strings);
Annotation annotation = new Annotation(types);
return(new SkillState(new Dictionary <string, AbstractStoragePool>(), strings, stringType, annotation,
types, FileInputStream.open(path, false), actualMode.close));
case Mode.Read:
Parser p = new Parser(FileInputStream.open(path, actualMode.close == Mode.ReadOnly));
return(p.read <SkillState>(typeof(SkillState), actualMode.close));
default:
throw new System.InvalidOperationException("should never happen");
}
} catch (SkillException e) {
// rethrow all skill exceptions
throw e;
} catch (Exception e) {
throw new SkillException(e);
}
}
public override void Read(Stream source)
{
uint spriteFileEntriesCount = DataStream.ReadUInt32(source);
uint spriteFileEntriesPosition = DataStream.ReadUInt32(source);
uint spriteEntriesCount = DataStream.ReadUInt32(source);
uint spriteEntriesPosition = DataStream.ReadUInt32(source);
source.Seek(spriteFileEntriesPosition, SeekOrigin.Begin);
for (int i = 0; i < spriteFileEntriesCount; i++)
{
var entry = new SpriteFileEntry();
entry.Id = DataStream.ReadUInt32(source);
entry.Name = StringPool.Read(source);
entry.FileName = StringPool.Read(source);
entry.Index = DataStream.ReadUInt32(source);
fileEntries.Add(entry);
}
source.Seek(spriteEntriesPosition, SeekOrigin.Begin);
for (int i = 0; i < spriteEntriesCount; i++)
{
var entry = new SpriteEntry();
entry.Id = DataStream.ReadUInt32(source);
entry.Name = StringPool.Read(source);
entry.Index = DataStream.ReadUInt16(source);
entry.GroupId = DataStream.ReadUInt16(source);
entries.Add(entry);
}
}
private GameObject Instantiate(string strPrefab, Vector3 pos, Quaternion rot)
{
if (!strPrefab.IsLower())
{
Debug.LogWarning("Converting prefab name to lowercase: " + strPrefab);
strPrefab = strPrefab.ToLower();
}
GameObject gameObject = FindPrefab(strPrefab);
if (!gameObject)
{
Debug.LogError("Couldn't find prefab \"" + strPrefab + "\"");
return(null);
}
GameObject gameObject2 = pool.Pop(StringPool.Get(strPrefab), pos, rot);
if (gameObject2 == null)
{
gameObject2 = Facepunch.Instantiate.GameObject(gameObject, pos, rot);
gameObject2.name = strPrefab;
}
else
{
gameObject2.transform.localScale = gameObject.transform.localScale;
}
if (!Clientside && Serverside && gameObject2.transform.parent == null)
{
SceneManager.MoveGameObjectToScene(gameObject2, Rust.Server.EntityScene);
}
return(gameObject2);
}
public static void export_prefabs(ConsoleSystem.Arg arg)
{
PrefabPoolCollection prefabPoolCollection = GameManager.server.pool;
if (prefabPoolCollection.storage.Count == 0)
{
arg.ReplyWith("Prefab pool is empty.");
return;
}
string str = arg.GetString(0, string.Empty);
StringBuilder stringBuilder = new StringBuilder();
foreach (KeyValuePair <uint, PrefabPool> keyValuePair in prefabPoolCollection.storage)
{
string str1 = keyValuePair.Key.ToString();
string str2 = StringPool.Get(keyValuePair.Key);
string str3 = keyValuePair.Value.Count.ToString();
if (!string.IsNullOrEmpty(str) && !str2.Contains(str, CompareOptions.IgnoreCase))
{
continue;
}
stringBuilder.AppendLine(string.Format("{0},{1},{2}", str1, Path.GetFileNameWithoutExtension(str2), str3));
}
File.WriteAllText("prefabs.csv", stringBuilder.ToString());
}
static Debugger()
{
for (int i = 24; i < 70; i++)
{
StringPool.PreAlloc(i, 2);
}
}
public virtual void PreProcess(IPrefabProcessor preProcess, GameObject rootObj, string name, bool serverside, bool clientside, bool bundling)
{
if (bundling)
{
return;
}
this.fullName = name;
this.hierachyName = base.transform.GetRecursiveName("");
this.prefabID = StringPool.Get(name);
this.instanceID = base.GetInstanceID();
this.worldPosition = base.transform.position;
this.worldRotation = base.transform.rotation;
this.worldForward = base.transform.forward;
this.localPosition = base.transform.localPosition;
this.localScale = base.transform.localScale;
this.localRotation = base.transform.localRotation;
if (serverside)
{
this.prefabAttribute = PrefabAttribute.server;
this.gameManager = GameManager.server;
this.isServer = true;
}
this.AttributeSetup(rootObj, name, serverside, clientside, bundling);
if (serverside)
{
PrefabAttribute.server.Add(this.prefabID, this);
}
preProcess.RemoveComponent(this);
preProcess.NominateForDeletion(base.gameObject);
}
public override void ServerCommand(Item item, string command, BasePlayer player)
{
if (item.GetOwnerPlayer() != player)
{
bool flag = false;
foreach (ItemContainer container in player.inventory.loot.containers)
{
if (item.GetRootContainer() == container)
{
flag = true;
break;
}
}
if (!flag)
{
return;
}
}
if (!(command == "study") || !item.IsBlueprint())
{
return;
}
ItemDefinition blueprintTargetDef = item.blueprintTargetDef;
ItemBlueprint blueprint = blueprintTargetDef.Blueprint;
bool flag2 = player.blueprints.IsUnlocked(blueprintTargetDef);
if (flag2 && blueprint != null && blueprint.additionalUnlocks != null && blueprint.additionalUnlocks.Count > 0)
{
foreach (ItemDefinition additionalUnlock in blueprint.additionalUnlocks)
{
if (!player.blueprints.IsUnlocked(additionalUnlock))
{
flag2 = false;
}
}
}
if (flag2 || Interface.CallHook("OnPlayerStudyBlueprint", player, item) != null)
{
return;
}
Item item2 = item;
if (item.amount > 1)
{
item2 = item.SplitItem(1);
}
item2.UseItem();
player.blueprints.Unlock(blueprintTargetDef);
if (blueprint != null && blueprint.additionalUnlocks != null && blueprint.additionalUnlocks.Count > 0)
{
foreach (ItemDefinition additionalUnlock2 in blueprint.additionalUnlocks)
{
player.blueprints.Unlock(additionalUnlock2);
}
}
if (studyEffect.isValid)
{
Effect.server.Run(studyEffect.resourcePath, player, StringPool.Get("head"), Vector3.zero, Vector3.zero);
}
}
private GameObject Instantiate(string strPrefab, Vector3 pos, Quaternion rot)
{
if (!strPrefab.IsLower())
{
Debug.LogWarning(string.Concat("Converting prefab name to lowercase: ", strPrefab));
strPrefab = strPrefab.ToLower();
}
GameObject gameObject = this.FindPrefab(strPrefab);
if (!gameObject)
{
Debug.LogError(string.Concat("Couldn't find prefab \"", strPrefab, "\""));
return(null);
}
GameObject gameObject1 = this.pool.Pop(StringPool.Get(strPrefab), pos, rot);
if (gameObject1 != null)
{
gameObject1.transform.localScale = gameObject.transform.localScale;
}
else
{
gameObject1 = Instantiate.GameObject(gameObject, pos, rot);
gameObject1.name = strPrefab;
}
if (!this.Clientside && this.Serverside && gameObject1.transform.parent == null)
{
SceneManager.MoveGameObjectToScene(gameObject1, Rust.Server.EntityScene);
}
return(gameObject1);
}
public static string rpclog(Arg arg)
{
if (!rpclog_enabled)
{
return("RPC log is not enabled.");
}
List <Tuple <uint, ulong> > list = new List <Tuple <uint, ulong> >();
foreach (KeyValuePair <uint, TimeAverageValue> item in SingletonComponent <ServerMgr> .Instance.rpcHistory.dict)
{
list.Add(new Tuple <uint, ulong>(item.Key, item.Value.Calculate()));
}
TextTable textTable = new TextTable();
textTable.AddColumn("id");
textTable.AddColumn("name");
textTable.AddColumn("calls");
foreach (Tuple <uint, ulong> item2 in list.OrderByDescending((Tuple <uint, ulong> entry) => entry.Item2))
{
if (item2.Item2 == 0L)
{
break;
}
string text = item2.Item1.ToString();
string text2 = StringPool.Get(item2.Item1);
string text3 = item2.Item2.ToString();
textTable.AddRow(text, text2, text3);
}
return(textTable.ToString());
}
public static void print_prefabs(ConsoleSystem.Arg arg)
{
PrefabPoolCollection prefabPoolCollection = GameManager.server.pool;
if (prefabPoolCollection.storage.Count == 0)
{
arg.ReplyWith("Prefab pool is empty.");
return;
}
string str = arg.GetString(0, string.Empty);
TextTable textTable = new TextTable();
textTable.AddColumn("id");
textTable.AddColumn("name");
textTable.AddColumn("count");
foreach (KeyValuePair <uint, PrefabPool> keyValuePair in prefabPoolCollection.storage)
{
string str1 = keyValuePair.Key.ToString();
string str2 = StringPool.Get(keyValuePair.Key);
string str3 = keyValuePair.Value.Count.ToString();
if (!string.IsNullOrEmpty(str) && !str2.Contains(str, CompareOptions.IgnoreCase))
{
continue;
}
textTable.AddRow(new string[] { str1, Path.GetFileNameWithoutExtension(str2), str3 });
}
arg.ReplyWith(textTable.ToString());
}
void OnEntityTakeDamage(BaseCombatEntity entity, HitInfo hitInfo)
{
try
{
if (entity is BasePlayer && hitInfo.Initiator is BasePlayer)
{
if (entity as BasePlayer == null || hitInfo == null)
{
return;
}
string bodypart = StringPool.Get(hitInfo.HitBone);
if (bodypart == null || bodypart == "")
{
return;
}
string weapon = hitInfo.Weapon.GetItem().info.shortname;
if (weapon == null || weapon == "")
{
return;
}
if (InList(weapon, bodypart))
{
float modifier = configData.Weapons[weapon][bodypart];
hitInfo.damageTypes.ScaleAll(modifier);
}
}
}
catch (NullReferenceException ex)
{
}
}
public void Awake()
{
FileSystem.iface = new FileSystem_AssetBundles(@"C:\Program Files (x86)\Steam\steamapps\common\RustStaging\Bundles\Bundles");
Transform prefabsParent = GameObject.FindGameObjectWithTag("Prefabs").transform;
foreach (PrefabDataHolder pdh in GameObject.FindObjectsOfType <PrefabDataHolder>())
{
if (!pdh.spawnOnPlay)
{
continue;
}
Debug.Log(StringPool.Get((pdh.prefabData.id)));
GameObject g = FileSystem.Load <GameObject>(StringPool.Get((pdh.prefabData.id)));
GameObject newObject = spawnPrefab(g, pdh.prefabData, prefabsParent);
PrefabDataHolder prefabData = newObject.GetComponent <PrefabDataHolder>();
if (prefabData == null)
{
prefabData = newObject.AddComponent <PrefabDataHolder>();
}
prefabData.prefabData = pdh.prefabData;
Destroy(pdh.gameObject);
}
}
string formatBodyPartName(HitInfo hitInfo)
{
string bodypart = "Unknown";
bodypart = StringPool.Get(Convert.ToUInt32(hitInfo?.HitBone)) ?? "Unknown";
if ((bool)string.IsNullOrEmpty(bodypart))
{
bodypart = "Unknown";
}
for (int i = 0; i < 10; i++)
{
bodypart = bodypart.Replace(i.ToString(), "");
}
bodypart = bodypart.Replace(".prefab", "");
bodypart = bodypart.Replace("L", "");
bodypart = bodypart.Replace("R", "");
bodypart = bodypart.Replace("_", "");
bodypart = bodypart.Replace(".", "");
bodypart = bodypart.Replace("right", "");
bodypart = bodypart.Replace("left", "");
bodypart = bodypart.Replace("tranform", "");
bodypart = bodypart.Replace("lowerjaweff", "jaw");
bodypart = bodypart.Replace("rarmpolevector", "arm");
bodypart = bodypart.Replace("connection", "");
bodypart = bodypart.Replace("uppertight", "tight");
bodypart = bodypart.Replace("fatjiggle", "");
bodypart = bodypart.Replace("fatend", "");
bodypart = bodypart.Replace("seff", "");
bodypart = bodypart.Replace("Unknown", "Bleed to death");
bodypart = bodypart.ToUpper();
return(bodypart);
}
void Init()
{
LoadData();
autoTurretPrefabId = StringPool.Get(autoTurretPrefab);
flameTurretPrefabId = StringPool.Get(flameTurretPrefab);
permission.RegisterPermission("turretconfig.infiniteammo", this);
adminOverride = GetConfig("Settings", "adminOverride", true);
animalOverride = GetConfig("Settings", "animalOverride", false);
sleepOverride = GetConfig("Settings", "sleepOverride", false);
animals = GetConfig("Settings", "animals", GetPassiveAnimals());
infiniteAmmo = GetConfig("Settings", "infiniteAmmo", false);
useGlobalDamageModifier = GetConfig("Settings", "useGlobalDamageModifier", false);
globalDamageModifier = GetConfig("Settings", "globalDamageModifier", 1f);
defaultBulletModifier = GetConfig("Auto", "defaultBulletModifier", 1f);
defaultAutoHealth = GetConfig("Auto", "defaultAutoHealth", 1000f);
defaultAimCone = GetConfig("Auto", "defaultAimCone", 5f);
defaultSightRange = GetConfig("Auto", "defaultSightRange", 30f);
defaultBulletSpeed = GetConfig("Auto", "defaultBulletSpeed", 10f);
defaultAmmoType = GetConfig("Auto", "defaultAmmoType", "ammo.rifle");
bulletModifiers = GetConfig("Auto", "bulletModifiers", GetDefaultBulletModifiers());
bulletSpeeds = GetConfig("Auto", "bulletSpeeds", GetDefaultBulletSpeeds());
ammoTypes = GetConfig("Auto", "ammoTypes", GetDefaultAmmoTypes());
sightRanges = GetConfig("Auto", "sightRanges", GetDefaultSightRanges());
autoHealths = GetConfig("Auto", "autoHealths", GetDefaultAutoHealths());
aimCones = GetConfig("Auto", "aimCones", GetDefaultAimCones());
defaultArc = GetConfig("Flame", "defaultArc", 45f);
defaultTriggerDuration = GetConfig("Flame", "defaultTriggerDuration", 5f);
defaultFlameRange = GetConfig("Flame", "defaultFlameRange", 7f);
defaultFlameRadius = GetConfig("Flame", "defaultFlameRadius", 4f);
defaultFuelPerSec = GetConfig("Flame", "defaultFuelPerSec", 1f);
defaultFlameHealth = GetConfig("Flame", "defaultFlameHealth", 300f);
arcs = GetConfig("Flame", "arcs", GetDefaultArcs());
triggerDurations = GetConfig("Flame", "triggerDurations", GetDefaultTriggerDurations());
flameRanges = GetConfig("Flame", "flameRanges", GetDefaultFlameRanges());
flameRadiuses = GetConfig("Flame", "flameRadiuses", GetDefaultFlameRadiuses());
fuelPerSecs = GetConfig("Flame", "fuelPerSecs", GetDefaultFuelPerSecs());
flameHealths = GetConfig("Flame", "flameHealths", GetDefaultFlameHealths());
LoadPermissions(bulletModifiers);
LoadPermissions(bulletSpeeds);
LoadPermissions(ammoTypes);
LoadPermissions(sightRanges);
LoadPermissions(autoHealths);
LoadPermissions(aimCones);
LoadPermissions(arcs);
LoadPermissions(triggerDurations);
LoadPermissions(flameRanges);
LoadPermissions(flameRadiuses);
LoadPermissions(fuelPerSecs);
LoadPermissions(flameHealths);
}
/// <summary>
/// Create a tree for the given document
/// </summary>
public XmlTree(XDocument doc)
: base(ChunkTypes.RES_XML_TYPE)
{
strings = new StringPool();
resourceMap = new ResourceMap();
CreateNodes(doc.Root);
}
/// <summary>
/// Write out string pool with encrypt.
/// </summary>
/// <param name="stringPool">String pool.</param>
/// <param name="writer">Binary data writer.</param>
/// <returns>Size of bytes written out.</returns>
public static uint Write(StringPool stringPool, DataWriter writer)
{
Helper.ThrowIfNull(stringPool);
Helper.ThrowIfNull(writer);
byte[] encryptedStringPool = new byte[stringPool.Length];
Microsoft.Tts.ServiceProvider.HTSVoiceDataEncrypt.EncryptStringPool(
stringPool.ToArray(), encryptedStringPool);
return writer.Write(encryptedStringPool);
}
/// <summary>
/// Creation ctor
/// </summary>
internal Package(Table table, int id, string name)
: base(ChunkTypes.RES_TABLE_PACKAGE_TYPE)
{
this.table = table;
this.id = id;
this.name = name;
keyStrings = new StringPool();
typeStrings = new StringPool();
}
/// <summary>
/// Default ctor
/// </summary>
internal Table(ResReader reader)
: base(reader, ChunkTypes.RES_TABLE_TYPE)
{
var packageCount = reader.ReadInt32();
strings = new StringPool(reader);
for (var i = 0; i < packageCount; i++)
{
packages.Add(new Package(this, reader));
}
}
public void LoadAndCreateTest()
{
var xml = new XmlTree(new MemoryStream(TestResource.AndroidManifest));
var pool = xml.StringPool;
var stream = new MemoryStream();
var writer = new ResWriter(stream);
pool.Write(writer);
stream.Position = 0;
var pool2 = new StringPool(new ResReader(stream));
Assert.AreEqual(pool.Count, pool2.Count);
}
/// <summary>
/// Default ctor
/// </summary>
internal Package(Table table, ResReader reader)
: base(reader, ChunkTypes.RES_TABLE_PACKAGE_TYPE)
{
this.table = table;
id = reader.ReadInt32();
name = reader.ReadFixedLenghtUnicodeString(128);
var typeStringsOffset = reader.ReadInt32();
var lastPublicType = reader.ReadInt32();
var keyStringsOffset = reader.ReadInt32();
var lastPublicKey = reader.ReadInt32();
// Record offset
var dataOffset = reader.Position;
// Data
typeStrings = new StringPool(reader);
keyStrings = new StringPool(reader);
TypeSpec currentTypeSpec = null;
while (reader.Position - dataOffset < DataSize)
{
var chunkType = reader.PeekChunkType();
if (chunkType == ChunkTypes.RES_TABLE_TYPE_SPEC_TYPE)
{
currentTypeSpec = Read(reader, () => new TypeSpec(this, reader));
typeSpecs.Add(currentTypeSpec);
}
else if (chunkType == ChunkTypes.RES_TABLE_TYPE_TYPE)
{
if (currentTypeSpec == null)
{
throw new IOException("Invalid chunk sequence: content read before typeSpec.");
}
var parent = currentTypeSpec;
var type = Read(reader, () => new Type(parent, reader));
currentTypeSpec.Add(type);
}
else
{
throw new IOException("Unexpected chunk type (" + chunkType + ").");
}
}
}
/// <summary>
/// Reading ctor
/// </summary>
public XmlTree(ResReader reader)
: base(reader, ChunkTypes.RES_XML_TYPE)
{
strings = new StringPool(reader);
resourceMap = new ResourceMap(reader);
while (true)
{
var tag = reader.PeekChunkType();
Node node;
switch (tag)
{
case ChunkTypes.RES_XML_START_NAMESPACE_TYPE:
node = new StartNamespace(reader, this);
break;
case ChunkTypes.RES_XML_START_ELEMENT_TYPE:
node = new StartElement(reader, this);
break;
case ChunkTypes.RES_XML_CDATA_TYPE:
node = new CData(reader, this);
break;
case ChunkTypes.RES_XML_END_ELEMENT_TYPE:
node = new EndElement(reader, this);
break;
case ChunkTypes.RES_XML_END_NAMESPACE_TYPE:
node = new EndNamespace(reader, this);
break;
default:
throw new IOException(string.Format("Unexpected tag: 0x{0:X}", (int)tag));
}
nodes.Add(node);
if (tag == ChunkTypes.RES_XML_END_NAMESPACE_TYPE)
break;
}
}
/// <summary>
/// Compile Chinese tone data table into binary file.
/// </summary>
/// <param name="chineseToneDataFile">Path of Chinese tone data file.</param>
/// <param name="outputStream">Output Stream.</param>
/// <returns>ErrorSet.</returns>
public static ErrorSet Compile(string chineseToneDataFile, Stream outputStream)
{
if (string.IsNullOrEmpty(chineseToneDataFile))
{
throw new ArgumentNullException("chineseToneDataFile");
}
if (outputStream == null)
{
throw new ArgumentNullException("outputStream");
}
ErrorSet errorSet = new ErrorSet();
if (!File.Exists(chineseToneDataFile))
{
errorSet.Add(ChineseToneCompilerError.DataFileNotFound, chineseToneDataFile);
}
else
{
BinaryWriter outputBinaryWriter = new BinaryWriter(outputStream, Encoding.Unicode);
List<string> fileLines = new List<string>(Helper.FileLines(chineseToneDataFile, Encoding.Unicode));
List<string> wordListAABB = new List<string>();
List<string> wordListAAB = new List<string>();
int nTableIdx = -1;
// Load words from raw data file to a word list
for (int i = 0; i < fileLines.Count; ++i)
{
string fileLine = fileLines[i];
if (fileLine.Contains("[ABAB]"))
{
nTableIdx = 0;
continue;
}
else if (fileLine.Contains("[AAB]"))
{
nTableIdx = 1;
continue;
}
if ((nTableIdx == 0 || nTableIdx == 1) && !string.IsNullOrWhiteSpace(fileLines[i]) && !fileLines[i].StartsWith("//"))
{
// Remove comment at the end of line
if (fileLine.Contains("//"))
{
fileLine = fileLine.Remove(fileLines[i].IndexOf("//"));
}
// Clean white spaces among the line
fileLine = fileLine.Trim();
string[] segments = fileLine.Split(
new string[] { PairSeparator }, StringSplitOptions.RemoveEmptyEntries);
if (segments.Length == 2)
{
segments[0] = segments[0].Trim();
segments[1] = segments[1].Trim();
switch (nTableIdx)
{
case 0:
wordListAABB.AddRange(segments);
wordListAABB.Add(string.Empty);
break;
case 1:
wordListAAB.AddRange(segments);
wordListAAB.Add(string.Empty);
break;
default:
break;
}
}
else
{
errorSet.Add(ChineseToneCompilerError.InvalidPatternFormData);
}
}
}
if (errorSet.Count == 0)
{
// used for 4 bytes align.
const int ALIGNCOUNT = 4;
byte[] alignBytes = new byte[]
{
0, 0, 0, 0
};
// Start writing binary to output stream
// Write table count
outputBinaryWriter.Write((uint)2);
// Write word count in each table
outputBinaryWriter.Write((uint)wordListAABB.Count);
outputBinaryWriter.Write((uint)wordListAAB.Count);
List<int> offsetList = new List<int>();
using (StringPool stringPool = new StringPool())
{
// Put the words from word list to string pool
StringPool.WordsToStringPool(wordListAABB, stringPool, offsetList);
// Write the strings from string pool
byte[] stringBuffer = stringPool.ToArray();
int nWordByteSize = sizeof(int) * offsetList.Count;
int nBufferByteSize = stringBuffer.Length;
int nUnAlignSize = stringBuffer.Length % ALIGNCOUNT;
if (nUnAlignSize != 0)
{
nBufferByteSize += ALIGNCOUNT - nUnAlignSize;
}
int nTableByteSize = nWordByteSize + nBufferByteSize;
// Write offset of each table
outputBinaryWriter.Write((uint)nTableByteSize);
// Write offset of each word
offsetList.ForEach(x => outputBinaryWriter.Write((uint)x));
outputBinaryWriter.Write(stringBuffer, 0, stringBuffer.Length);
// Fill 0 to align the memory by 4 bytes
if (stringBuffer.Length % ALIGNCOUNT != 0)
{
outputBinaryWriter.Write(alignBytes, 0, ALIGNCOUNT - (stringBuffer.Length % ALIGNCOUNT));
}
}
offsetList = new List<int>();
using (StringPool stringPool = new StringPool())
{
// Put the words from word list to string pool
StringPool.WordsToStringPool(wordListAAB, stringPool, offsetList);
// Write the strings from string pool
byte[] stringBuffer = stringPool.ToArray();
int nWordByteSize = sizeof(int) * offsetList.Count;
int nBufferByteSize = stringBuffer.Length;
int nUnAlignSize = stringBuffer.Length % ALIGNCOUNT;
if (nUnAlignSize != 0)
{
nBufferByteSize += ALIGNCOUNT - nUnAlignSize;
}
int nTableByteSize = nWordByteSize + nBufferByteSize;
// Write offset of each table
outputBinaryWriter.Write((uint)nTableByteSize);
// Write offset of each word
offsetList.ForEach(x => outputBinaryWriter.Write((uint)x));
outputBinaryWriter.Write(stringBuffer, 0, stringBuffer.Length);
// Fill 0 to align the memory by 4 bytes
if (stringBuffer.Length % ALIGNCOUNT != 0)
{
outputBinaryWriter.Write(alignBytes, 0, ALIGNCOUNT - (stringBuffer.Length % ALIGNCOUNT));
}
}
}
}
return errorSet;
}
/// <summary>
/// Creation ctor
/// </summary>
public Table(string packageName)
: base(ChunkTypes.RES_TABLE_TYPE)
{
strings = new StringPool();
packages.Add(new Package(this, 0x7f, packageName));
}
/// <summary>
/// Save pre-selection forest.
/// </summary>
/// <param name="decisionForest">The forest with each tree corresponding to a unit.</param>
/// <param name="candidateGroups">The candidate group collection.</param>
/// <param name="unitCandidateNameIds">Given candidate idx.</param>
/// <param name="customFeatures">Cusotmized linguistic feature list.</param>
/// <param name="outputPath">The output path.</param>
public void Write(DecisionForest decisionForest,
ICollection<CandidateGroup> candidateGroups,
IDictionary<string, int> unitCandidateNameIds,
HashSet<string> customFeatures,
string outputPath)
{
foreach (Question question in decisionForest.QuestionList)
{
question.Language = _phoneSet.Language;
question.ValueSetToCodeValueSet(_posSet, _phoneSet, customFeatures);
}
FileStream file = new FileStream(outputPath, FileMode.Create);
try
{
using (DataWriter writer = new DataWriter(file))
{
file = null;
uint position = 0;
// Write header section place holder
PreselectionFileHeader header = new PreselectionFileHeader();
position += (uint)header.Write(writer);
HtsFontSerializer serializer = new HtsFontSerializer();
// Write feature, question and prepare string pool
HtsQuestionSet questionSet = new HtsQuestionSet
{
Items = decisionForest.QuestionList,
Header = new HtsQuestionSetHeader { HasQuestionName = false },
CustomFeatures = customFeatures,
};
using (StringPool stringPool = new StringPool())
{
Dictionary<string, uint> questionIndexes = new Dictionary<string, uint>();
header.QuestionOffset = position;
header.QuestionSize = serializer.Write(
questionSet, writer, stringPool, questionIndexes, customFeatures);
position += header.QuestionSize;
// Write leaf referenced data to buffer
IEnumerable<INodeData> dataNodes = GetCandidateNodes(candidateGroups);
using (MemoryStream candidateSetBuffer = new MemoryStream())
{
Dictionary<string, int> namedSetOffset = new Dictionary<string, int>();
int candidateSetSize = HtsFontSerializer.Write(
dataNodes, new DataWriter(candidateSetBuffer), namedSetOffset);
// Write decision forest
Dictionary<string, uint[]> namedOffsets =
namedSetOffset.ToDictionary(p => p.Key, p => new[] { (uint)p.Value });
header.DecisionTreeSectionOffset = position;
header.DecisionTreeSectionSize = (uint)Write(decisionForest, unitCandidateNameIds,
questionIndexes, questionSet, namedOffsets, new DecisionForestSerializer(), writer);
position += header.DecisionTreeSectionSize;
// Write string pool
header.StringPoolOffset = position;
header.StringPoolSize = HtsFontSerializer.Write(stringPool, writer);
position += header.StringPoolSize;
// Write leaf referenced data
header.CandidateSetSectionOffset = position;
header.CandidateSetSectionSize = writer.Write(candidateSetBuffer.ToArray());
position += header.CandidateSetSectionSize;
}
// Write header section place holder
using (PositionRecover recover = new PositionRecover(writer, 0))
{
header.Write(writer);
}
}
}
}
finally
{
if (null != file)
{
file.Dispose();
}
}
}
/// <summary>
/// Save feature set.
/// </summary>
/// <param name="writer">Binary data writer.</param>
/// <param name="stringPool">String pool.</param>
/// <param name="language">Language.</param>
/// <param name="schemaFile">Schema file.</param>
/// <param name="outVarFile">Out var file.</param>
/// <param name="phoneToIdIndexes">Phone id mapping.</param>
/// <returns>Size of bytes written out.</returns>
public uint Write(DataWriter writer, StringPool stringPool,
Language language, string schemaFile, string outVarFile, Dictionary<string, string> phoneToIdIndexes)
{
Helper.ThrowIfNull(writer);
Helper.ThrowIfNull(language);
Helper.ThrowIfNull(phoneToIdIndexes);
Helper.ThrowIfFileNotExist(schemaFile);
Helper.ThrowIfFileNotExist(outVarFile);
uint size = 0;
size += WriteSchema(language, schemaFile, phoneToIdIndexes, writer, stringPool);
size += WriteOutVariance(outVarFile, writer);
Debug.Assert(size % sizeof(uint) == 0, "Data must be 4-byte aligned.");
return size;
}
/// <summary>
/// Save schema (with feature set and it's value group, mean, variance).
/// </summary>
/// <param name="language">The language.</param>
/// <param name="schemaFile">The schema File.</param>
/// <param name="phoneToIdIndexes">Phone To Id Indexes.</param>
/// <param name="writer">Writer.</param>
/// <param name="stringPool">String pool.</param>
/// <returns>Size of bytes written out.</returns>
public uint WriteSchema(Language language, string schemaFile, Dictionary<string, string> phoneToIdIndexes, DataWriter writer, StringPool stringPool)
{
Helper.ThrowIfFileNotExist(schemaFile);
Helper.ThrowIfNull(phoneToIdIndexes);
Helper.ThrowIfNull(writer);
Helper.ThrowIfNull(stringPool);
Helper.ThrowIfNull(language);
uint size = 0;
LexicalAttributeSchema schema = new LexicalAttributeSchema(language);
schema.Load(schemaFile);
List<string> stateFeatureList = new List<string>();
List<string> featureList = new List<string>();
int stateFeatureCount = 0;
for (int i = 0; i < schema.Categories.Count; i++)
{
string name = schema.Categories[i].Name.ToLower();
if (name.IndexOf("state") >= 0)
{
stateFeatureCount++;
if (!stateFeatureList.Contains(name))
{
stateFeatureList.Add(name);
}
}
if (!featureList.Contains(name))
{
featureList.Add(name);
}
}
// write state feature count.
size += writer.Write((uint)stateFeatureList.Count);
size += writer.Write((uint)stateFeatureCount);
// write total feature count.
size += writer.Write((uint)featureList.Count());
Dictionary<string, uint> featureIndex = new Dictionary<string, uint>();
uint index = 0;
foreach (string feature in featureList)
{
size += writer.Write((uint)stringPool.Length);
stringPool.PutString(feature);
featureIndex.Add(feature, index++);
}
// write feature category
size += writer.Write((uint)schema.Categories.Count);
for (int i = 0; i < schema.Categories.Count; i++)
{
string featureName = schema.Categories[i].Name.ToLower();
// feature index
size += writer.Write((uint)featureIndex[featureName]);
// mean
size += writer.Write(schema.Categories[i].Mean);
// invStdDev
size += writer.Write(schema.Categories[i].InvStdDev);
// value count
size += writer.Write((uint)schema.Categories[i].Values.Count);
for (int k = 0; k < schema.Categories[i].Values.Count; k++)
{
string valueName = schema.Categories[i].Values[k].Name.ToLower();
string id = string.Empty;
if (phoneToIdIndexes.ContainsKey(valueName) && featureName.IndexOf("phoneidentity") >= 0)
{
id = phoneToIdIndexes[valueName];
}
else
{
id = valueName;
}
try
{
size += writer.Write(uint.Parse(id));
}
catch (System.FormatException)
{
continue;
}
}
}
Debug.Assert(size % sizeof(uint) == 0, "Data must be 4-byte aligned.");
return size;
}
public static ErrorSet Compile(string rnnModelPath, Stream outputStream, Collection<string> addedFileNames)
{
if (string.IsNullOrEmpty(rnnModelPath))
{
throw new ArgumentNullException("rnnModelPath");
}
if (outputStream == null)
{
throw new ArgumentNullException("outputStream");
}
if (addedFileNames == null)
{
throw new ArgumentNullException("addedFileNames");
}
ErrorSet errorSet = new ErrorSet();
if (!File.Exists(rnnModelPath))
{
errorSet.Add(RNNModelCompilerError.ModelDataNotFound, rnnModelPath);
}
else
{
BinaryWriter bw = new BinaryWriter(outputStream, Encoding.Unicode);
Dictionary<string, float> polyCharactersInfo = null;
List<string> polyphones = null;
List<float> thresholds = null;
// load polyphonic characters that should be enabled in product.
string polyphonicCharFile = Path.Combine(new DirectoryInfo(Path.GetDirectoryName(rnnModelPath)).Parent.FullName, "RNNPolyphoneList.txt");
if (File.Exists(polyphonicCharFile))
{
// If the list file is existed, load it.
polyCharactersInfo = LoadPolyphonicInfo(polyphonicCharFile, errorSet);
}
else
{
errorSet.Add(RNNModelCompilerError.PolyphonicCharFileNotFound, polyphonicCharFile);
}
polyphones = GetPolyphonicChars(polyCharactersInfo);
thresholds = GetPolyphonicThreshold(polyCharactersInfo);
uint polyCharCount = 0;
uint modelOffset = 0;
// write the count of polyphonic characters and polyphonic characters
using (StringPool plycharSp = new StringPool())
{
Collection<int> polycharOffsets = new Collection<int>();
StringPool.WordsToStringPool(polyphones, plycharSp, polycharOffsets);
polyCharCount = (uint)polycharOffsets.Count;
bw.Write(modelOffset);
bw.Write(polyCharCount);
foreach (float threshold in thresholds)
{
bw.Write(threshold);
}
byte[] plycharPool = plycharSp.ToArray();
foreach (int offset in polycharOffsets)
{
bw.Write((uint)offset);
}
bw.Write(plycharPool, 0, plycharPool.Length);
}
modelOffset = (uint)bw.BaseStream.Position;
// write rnn models
using (FileStream fs = new FileStream(rnnModelPath, FileMode.Open, FileAccess.Read))
using (BinaryReader br = new BinaryReader(fs))
{
bw.Write(br.ReadBytes((int)fs.Length));
}
bw.Flush();
bw.Seek(0, SeekOrigin.Begin);
bw.Write(modelOffset);
bw.Flush();
addedFileNames.Add(rnnModelPath);
}
return errorSet;
}
/// <summary>
/// Collect the words in the file and save them into string pool together with
/// The offset list.
/// </summary>
/// <param name="filePath">File path containing words.</param>
/// <param name="stringPool">String pool.</param>
/// <param name="offsets">Offset list.</param>
/// <param name="sort">Whether the word in the string pool are sorted.</param>
/// <param name="errorSet">Error set.</param>
/// <returns>Number of words.</returns>
public static int LoadWordsIntoStringPool(string filePath, StringPool stringPool,
ICollection<int> offsets, bool sort, ErrorSet errorSet)
{
if (string.IsNullOrEmpty(filePath))
{
throw new ArgumentNullException("filePath");
}
if (stringPool == null)
{
throw new ArgumentNullException("stringPool");
}
if (offsets == null)
{
throw new ArgumentNullException("offsets");
}
if (errorSet == null)
{
throw new ArgumentNullException("errorSet");
}
List<string> words = new List<string>();
errorSet.Merge(LoadWordsIntoWordList(filePath, words, sort));
StringPool.WordsToStringPool(words, stringPool, offsets);
return words.Count;
}
public static ErrorSet Compile(string crfModelDir, Stream outputStream,
Collection<string> addedFileNames, Language lang)
{
if (string.IsNullOrEmpty(crfModelDir))
{
throw new ArgumentNullException("crfModelDir");
}
if (outputStream == null)
{
throw new ArgumentNullException("outputStream");
}
if (addedFileNames == null)
{
throw new ArgumentNullException("addedFileNames");
}
ErrorSet errorSet = new ErrorSet();
if (!Directory.Exists(crfModelDir))
{
errorSet.Add(CrfModelCompilerError.DataFolderNotFound, crfModelDir);
}
else
{
BinaryWriter bw = new BinaryWriter(outputStream, Encoding.Unicode);
List<byte[]> crfModels = new List<byte[]>();
List<string> crfTags = new List<string>();
Dictionary<string, string> localizedNameMapping = null;
// if language = zh-cn or ja-jp, we should use their localized name as crf model tag.
if (lang == Language.ZhCN || lang == Language.JaJP)
{
string crfModelNameMappingFile = Path.Combine(new DirectoryInfo(crfModelDir).Parent.FullName, "CRFLocalizedMapping.txt");
if (File.Exists(crfModelNameMappingFile))
{
// If the mapping file is existed, load it.
localizedNameMapping = LocalizeCRFModelName(crfModelNameMappingFile, errorSet);
}
else
{
errorSet.Add(CrfModelCompilerError.MappingFileNotFound, crfModelNameMappingFile);
}
}
string[] crfModelFileNames = Directory.GetFiles(crfModelDir, "*.crf", SearchOption.TopDirectoryOnly);
foreach (string crfModelFileName in crfModelFileNames)
{
if (localizedNameMapping != null)
{
// If mapping is existed, replace the crfTag name.
string crfModelName = Path.GetFileName(crfModelFileName);
if (localizedNameMapping.ContainsKey(crfModelName))
{
crfTags.Add(localizedNameMapping[crfModelName].ToUpper()); // case insensitive
}
}
else
{
crfTags.Add(Path.GetFileNameWithoutExtension(crfModelFileName).ToUpper()); // case insensitive
}
using (FileStream fs = new FileStream(crfModelFileName, FileMode.Open, FileAccess.Read))
using (BinaryReader br = new BinaryReader(fs))
{
crfModels.Add(br.ReadBytes((int)fs.Length));
}
addedFileNames.Add(crfModelFileName);
}
using (StringPool crfModelSp = new StringPool())
{
using (StringPool crfTagSp = new StringPool())
{
Collection<int> crfModelsOffsets = new Collection<int>();
Collection<int> crfTagsOffsets = new Collection<int>();
// Add models to StringPool
foreach (byte[] model in crfModels)
{
crfModelsOffsets.Add(crfModelSp.PutBuffer(model));
}
// Add tags to StringPool
StringPool.WordsToStringPool(crfTags, crfTagSp, crfTagsOffsets);
uint tagOffset = 0;
uint modelOffset = 0;
bw.Write(tagOffset);
bw.Write(modelOffset);
bw.Write((uint)crfTagsOffsets.Count);
for (int i = 0; i < crfModelsOffsets.Count; i++)
{
uint offset = (uint)crfModelsOffsets[i];
if ((offset % 4) != 0)
{
errorSet.Add(CrfModelCompilerError.InvalidCrfModel, crfModelFileNames[i]);
}
bw.Write(offset);
}
foreach (int offset in crfTagsOffsets)
{
bw.Write((uint)offset);
}
modelOffset = (uint)bw.BaseStream.Position;
Debug.Assert((modelOffset % 4) == 0);
byte[] crfModelPool = crfModelSp.ToArray();
bw.Write(crfModelPool, 0, crfModelPool.Length);
tagOffset = (uint)bw.BaseStream.Position;
Debug.Assert((tagOffset % 4) == 0);
byte[] crfTagPool = crfTagSp.ToArray();
bw.Write(crfTagPool, 0, crfTagPool.Length);
bw.Flush();
// Update offset value.
bw.Seek(0, SeekOrigin.Begin);
bw.Write(tagOffset);
bw.Write(modelOffset);
bw.Flush();
}
}
}
return errorSet;
}
private void Dispose(bool disposing)
{
if (disposing)
{
if (_stringPool != null)
{
_stringPool.Dispose();
_disposed = true;
_stringPool = null;
}
}
}
/// <summary>
/// Write the pst data.
/// </summary>
/// <param name="pstFile">The pst file name to be stored.</param>
/// <param name="data">The pst data to be write.</param>
/// <param name="ttsPhoneSet">The tts Phone set.</param>
/// <param name="ttsPosSet">The tts pst set.</param>
public void WritePSTData(string pstFile, PSTData data, TtsPhoneSet ttsPhoneSet, TtsPosSet ttsPosSet)
{
foreach (Question question in data.DecisionForest.QuestionList)
{
question.Language = ttsPhoneSet.Language;
question.ValueSetToCodeValueSet(ttsPosSet, ttsPhoneSet, data.CustomFeatures);
}
FileStream file = new FileStream(pstFile, FileMode.Create);
try
{
using (DataWriter writer = new DataWriter(file))
{
file = null;
uint position = 0;
// Write header section place holder
PreselectionFileHeader header = new PreselectionFileHeader();
position += (uint)header.Write(writer);
HtsFontSerializer serializer = new HtsFontSerializer();
using (StringPool stringPool = new StringPool())
{
Dictionary<string, uint> questionIndexes = new Dictionary<string, uint>();
header.QuestionOffset = position;
header.QuestionSize = serializer.Write(
data.QuestionSet, writer, stringPool, questionIndexes, data.CustomFeatures);
position += header.QuestionSize;
// Write leaf referenced data to buffer
List<CandidateSetData> dataNodes = data.CadidateSets;
int val = data.CadidateSets.Sum(c => c.Candidates.Count);
using (MemoryStream candidateSetBuffer = new MemoryStream())
{
Dictionary<string, int> namedSetOffset = new Dictionary<string, int>();
int candidateSetSize = HtsFontSerializer.Write(
dataNodes, new DataWriter(candidateSetBuffer), namedSetOffset);
// Write decision forest
Dictionary<string, uint[]> namedOffsets =
namedSetOffset.ToDictionary(p => p.Key, p => new[] { (uint)p.Value });
header.DecisionTreeSectionOffset = position;
header.DecisionTreeSectionSize = (uint)Write(data.DecisionForest, data.TreeIndexes,
questionIndexes, data.QuestionSet, namedOffsets, new DecisionForestSerializer(), writer);
position += header.DecisionTreeSectionSize;
// Write string pool
header.StringPoolOffset = position;
header.StringPoolSize = HtsFontSerializer.Write(stringPool, writer);
position += header.StringPoolSize;
// Write leaf referenced data
header.CandidateSetSectionOffset = position;
header.CandidateSetSectionSize = writer.Write(candidateSetBuffer.ToArray());
position += header.CandidateSetSectionSize;
}
// Write header section place holder
using (PositionRecover recover = new PositionRecover(writer, 0))
{
header.Write(writer);
}
}
}
}
finally
{
if (null != file)
{
file.Dispose();
}
}
}
/// <summary>
/// Reading ctor
/// </summary>
internal static string Read(ResReader reader, StringPool pool)
{
var index = reader.ReadInt32();
return (index < 0) ? null : pool[index];
}
/// <summary>
/// Write helper
/// </summary>
internal static void Write(ResWriter writer, StringPool pool, string value, int resourceId = -1)
{
var index = (value == null) ? -1 : pool.Get(value, resourceId);
writer.WriteInt32(index);
}
