public MainWindow()
{
InitializeComponent();
pg = ttt;
ss.Add("A");
ss.Add("B");
ss.Add("C");
EObjectType e = (EObjectType)Enum.Parse(typeof(EObjectType), "1");
timer.Interval = TimeSpan.FromMilliseconds(10);
timer.Tick += TickTest;
TextBox tb = new TextBox()
{
IsEnabled = true
}; tb.KeyDown += sendtest;
bb.DictionaryValues.Add(new Tuple <string, object, Control>("Text", "data", tb));
bb.DictionaryValues.Add(new Tuple <string, object, Control>("ComboBox", new List <String>()
{
"one", "two", "three"
}, new ComboBox()));
bb.DictionaryValues.Add(new Tuple <string, object, Control>("CheckBox", true, new CheckBox()));
//bb.DictionaryValues.Add(new Tuple<string, object, Control>("Custom", null, new DropDownCustomColorPicker.CustomColorPicker()));
}
public static bool Prefix(PlayerControlGizmo __instance, EObjectType tarType, int tarId)
{
if (__instance.mouseOverTargetType == tarType && __instance.mouseOverTargetId == tarId)
{
return(true);
}
if (tarId == 0 || tarType != EObjectType.Entity)
{
return(true);
}
PlanetFactory factory = __instance.player.factory;
EntityData entityData = factory.entityPool[tarId];
if (entityData.id == 0)
{
return(true);
}
ItemProto itemProto = LDB.items.Select(entityData.protoId);
if (itemProto.ModelCount > 1)
{
__instance.mouseOverTargetType = tarType;
__instance.mouseOverTargetId = tarId;
if (__instance.mouseOverTargetGizmo != null)
{
__instance.mouseOverTargetGizmo.Close();
__instance.mouseOverTargetGizmo = null;
}
if (__instance.mouseOverBuildingGizmo != null)
{
__instance.mouseOverBuildingGizmo.Close();
__instance.mouseOverBuildingGizmo = null;
}
if (__instance.mouseOverMinerGizmo != null)
{
__instance.mouseOverMinerGizmo.Close();
__instance.mouseOverMinerGizmo = null;
}
ModelProto proto = LDB.models.modelArray[entityData.modelIndex];
__instance.mouseOverBuildingGizmo = BoxGizmo.Create(entityData.pos, entityData.rot, proto.prefabDesc.selectCenter, proto.prefabDesc.selectSize);
__instance.mouseOverBuildingGizmo.multiplier = 1f;
__instance.mouseOverBuildingGizmo.alphaMultiplier = proto.prefabDesc.selectAlpha;
__instance.mouseOverBuildingGizmo.fadeInScale = 1.3f;
__instance.mouseOverBuildingGizmo.fadeInTime = 0.05f;
__instance.mouseOverBuildingGizmo.fadeInFalloff = 0.5f;
__instance.mouseOverBuildingGizmo.fadeOutScale = 1.3f;
__instance.mouseOverBuildingGizmo.fadeOutTime = 0.05f;
__instance.mouseOverBuildingGizmo.fadeOutFalloff = 0.5f;
__instance.mouseOverBuildingGizmo.color = Color.white;
__instance.mouseOverBuildingGizmo.Open();
return(false);
}
return(true);
}
static public List <ZDObject> HitAtObject(ZDObject Target, EObjectType Type)
{
if (Recorder.ContainsKey(Target))
{
List <ZDObject> Result = new List <ZDObject>();
ZDObjectRecord TargetRecord = Recorder[Target];
(uint, uint)Origin = TargetRecord.Location;
ZDObject Caller = TargetRecord.Owner;
(int, int)OffsetLoc;
foreach (var region in Caller.Regions)
{
OffsetLoc = ((int)Origin.Item1 + region.Key.x, (int)Origin.Item2 + region.Key.y);
if (IsValidMapLoc(OffsetLoc.Item1, OffsetLoc.Item2))
{
List <ZDObject> GetList = RecordGrid[OffsetLoc.Item1, OffsetLoc.Item2].GetTypeList(Type);
if (GetList != null)
{
Result.AddRange(GetList);
}
}
}
if (Result.Count != 0)
{
return(Result);
}
else
{
return(null);
}
}
return(null);
}
public static void SetMouseOverTarget(PlayerControlGizmo __instance, EObjectType tarType, int tarId)
{
if (Instance != null)
{
if (Instance._cursorTextObj == null)
{
Instance._cursorTextObj = GameObject.Find("build-cursor-text")?.GetComponentInChildren <Text>();
}
if (tarId != 0 && tarType == EObjectType.Entity)
{
PlanetFactory factory = GameMain.mainPlayer.factory;
if (factory != null)
{
var storageId = factory.entityPool[tarId].storageId;
var stationId = factory.entityPool[tarId].stationId;
if (storageId > 0)
{
Instance._cursorText = $"{"存储箱ID".Translate()}: {factory.index}.{storageId}";
}
else if (stationId > 0)
{
Instance._cursorText = $"{"物流站ID".Translate()}: S{factory.index}.{stationId}";
}
}
}
else
{
Instance._cursorText = null;
}
}
}
public override void OnDeserialize(byte[] buffer, int index)
{
// object id
uint objectId;
Serializer.DeserializeData(buffer, ref index, out objectId);
GameObjectId = objectId;
// object type
EObjectType type = (EObjectType)((int)buffer[index]);
index++;
bool isLocalPlayer = false;
Serializer.DeserializeData(buffer, ref index, out isLocalPlayer);
IsLocalPlayer = isLocalPlayer;
// player linked id
uint playerId = 0;
Serializer.DeserializeData(buffer, ref index, out playerId);
PlayerLinked = playerId;
// Deserialize components
byte componentsNumber = buffer[index];
index++;
for (int i = 0; i < componentsNumber; i++)
{
ISerializableComponent tmpComponent = GameComponentFactory.DeserializeComponent(buffer, ref index);
Components.Add(tmpComponent);
}
}
/// <summary>
/// 指定对象
/// </summary>
/// <param name="p_Name">1单项工程 2单位工程</param>
/// <returns></returns>
private bool isExist(string p_Name, EObjectType p_Type)
{
//1.判断对象在当前的DataSource中是否存在
//int type = p_Type == EObjectType.UnitProject ? 2 : p_Type == EObjectType.Engineering ? 1 : 0;
// return this.projectTrees1.bindingSource1.Cast<_Directory>().Count(info => info.NodeName == p_Name && info.Deep == type) > 0 ? true : false;
return(false);
}
private bool IfTypeHero(EObjectType eOT)
{
if ((Int32)EObjectType.HeroBegin < (Int32)eOT && (Int32)eOT < (Int32)EObjectType.NPCBegin)
{
return(true);
}
return(false);
}
public GameObjectCreateArgs(uint gameObjectId, EObjectType type, bool isLocalPlayer, List <ISerializableComponent> componentsInfos, uint playerLinkedId)
{
GameObjectId = gameObjectId;
Type = type;
IsLocalPlayer = isLocalPlayer;
ComponentsInfos = componentsInfos;
PlayerLinkedId = playerLinkedId;
}
public static Boolean IfTypeHero(EObjectType eOT)
{
if ((Int32)EObjectType.eObjectType_HeroBegin < (Int32)eOT && (Int32)eOT < (Int32)EObjectType.eObjectType_HeroBegin + (Int32)EConstEnum.eObjLevel1Inter)
{
return(true);
}
return(false);
}
static public List <ZDObject> HitAtUnit(int x, int y, EObjectType Type)
{
(uint, uint)MapLoc = UnitToMap(x, y);
if (MapLoc.Item1 < 0 || MapLoc.Item2 < 0 ||
!(MapLoc.Item1 < ZDGameRule.MAP_WIDTH_UNIT && MapLoc.Item2 < ZDGameRule.MAP_HEIGHT_UNIT))
{
return(null);
}
return(RecordGrid[MapLoc.Item1, MapLoc.Item2].GetTypeList(Type));
}
static public List <ZDObject> HitAt(int x, int y, ZDObject Caller, EObjectType Type)
{
(uint, uint)MapLoc = Recorder[Caller].Location;
x += (int)MapLoc.Item1;
y += (int)MapLoc.Item2;
if (x < 0 || y < 0 || !(x < ZDGameRule.MAP_WIDTH_UNIT && y < ZDGameRule.MAP_HEIGHT_UNIT))
{
return(null);
}
return(RecordGrid[x, y].GetTypeList(Type));
}
public MainWindow()
{
InitializeComponent();
pg = ttt;
ss.Add("A");
ss.Add("B");
ss.Add("C");
EObjectType e = (EObjectType)Enum.Parse(typeof(EObjectType), "1");
}
protected InteractiveObject(Int32 p_staticID, EObjectType p_objectType, Int32 p_spawnerID) : base(p_staticID, p_objectType, p_spawnerID)
{
m_originalPosition = new Position(-1, -1);
m_commands = new List <SpawnCommand>();
m_interactions = new List <BaseInteraction>();
m_questObjectives = new List <SpawnQuestObjective>();
m_trapEffectSpawnerIDs = new List <Int32>();
m_stateMachine = new StateMachine <EState>();
m_stateMachine.AddState(new State <EState>(EState.IDLE));
m_stateMachine.AddState(new State <EState>(EState.RUNNING));
m_stateMachine.AddState(new State <EState>(EState.AFTER_RUNNING));
m_stateMachine.AddState(new State <EState>(EState.FINISHED));
m_stateMachine.ChangeState(EState.IDLE);
}
internal static string TypeString(EObjectType aType)
{
switch (aType)
{
case EObjectType.Blob:
return ("blob");
case EObjectType.Commit:
return ("commit");
case EObjectType.Tree:
return ("tree");
case EObjectType.Tag:
return ("tag");
default:
throw (new GitException("Unknown object type"));
}
}
public static IGameObjectPrototype GetPrototype(EObjectType objectType)
{
if (gameObjects == null)
{
Initialize();
}
if (gameObjects.ContainsKey(objectType))
{
return(gameObjects[objectType]);
}
else
{
Console.WriteLine("Object of type required doesn't exists in the factory");
return(null);
}
}
private bool IsPreservedType(EObjectType Type)
{
switch (Type)
{
case EObjectType.ACollect:
break;
case EObjectType.ADamage:
break;
case EObjectType.Character:
break;
default:
return(false);
}
return(true);
}
protected GridSlot GetMoveTarget(List <GridSlot> p_movePath)
{
Grid grid = LegacyLogic.Instance.MapLoader.Grid;
EObjectType type = (Brain.Data.AITargets != EAITarget.Monster) ? EObjectType.PARTY : EObjectType.MONSTER;
List <GridSlot> list = new List <GridSlot>();
IEnumerable <GridSlot> enumerable = grid.SlotIteratorAround(Controller.Position, Brain.Data.AIRange);
foreach (GridSlot gridSlot in enumerable)
{
if (gridSlot.CountEntityTypes(type) > 0)
{
list.Add(gridSlot);
}
}
if (list.Count > 1)
{
list.Sort(delegate(GridSlot a, GridSlot b)
{
Int32 num = Position.DistanceSquared(Controller.Position, a.Position).CompareTo(Position.DistanceSquared(Controller.Position, b.Position));
if (num == 0)
{
return(b.CountEntityTypes(type).CompareTo(a.CountEntityTypes(type)));
}
return(num);
});
}
if (list.Count > 0)
{
foreach (GridSlot gridSlot2 in list)
{
p_movePath.Clear();
if (grid.CalculateMovablePath(Controller, gridSlot2.Position, p_movePath) <= Brain.Data.AIRange)
{
if (p_movePath.Count > 0)
{
p_movePath.RemoveAt(0);
}
return(gridSlot2);
}
}
}
p_movePath.Clear();
return(null);
}
/*
* /// <summary>
* ///【公共属性】获取配置信息对象
* /// </summary>
* public virtual _ObjMetaanalysis ObjMetaanalysis
* {
* get
* {
* return this.Parent.DataObject.Get("通用汇总分析") as _ObjMetaanalysis;
* }
* set
* {
* this.Parent.DataObject.Set("通用汇总分析", value);
* }
* }*/
/// <summary>
/// 当前业务对象中是否存指定名称的业务对象(默认查找当前对象的字典中的所有对象包括:单项工程,单位工程)
/// </summary>
/// <param name="p_Name">名称</param>
/// <param name="p_TypeName">类型名称0,1,2可多选</param>
/// <returns>是否存在</returns>
public virtual bool IsExist(string p_Code, EObjectType p_ObjectType)
{
foreach (_COBJECTS item in this.Parent.StrustObject.ObjectList.Values)
{
if (p_ObjectType == EObjectType.Engineering)
{
if (item.Property.Basis.CODE == p_Code)
{
return(true);
}
}
if (p_ObjectType == EObjectType.UnitProject)
{
if (item.Property.IsExist(p_Code, p_ObjectType))
{
return(true);
}
}
}
return(false);
}
public static bool OnPlayerInspecteeChange(UIGame __instance, EObjectType objType, int objId)
{
if (Instance != null)
{
if (Instance._inspectingStorage)
{
if (objType == EObjectType.Entity)
{
// Trying to inspect another object
if (objId != 0)
{
var factory = GameMain.mainPlayer.factory;
var storageId = factory?.entityPool[objId].storageId;
var stationId = factory?.entityPool[objId].stationId;
// The other object is another storage
if (storageId > 0)
{
Instance.CloseStorage();
return(true);
}
if (stationId > 0)
{
Instance.CloseStation();
return(true);
}
}
else // PlayerAction_Inspect.InspectNothing() e.g., in space
{
// Prevent storage ID set to 0, which closes the window.
return(false);
}
}
}
}
return(true);
}
/// <summary>
/// Extract from RaycastLogic::GameTick
/// Use to filter buidling
/// </summary>
public static void Select(RaycastLogic __instance, BuildingFilter filter)
{
int activeColHashCount = Traverse.Create((object)__instance).Field("activeColHashCount").GetValue <int>();
int[] activeColHashes = Traverse.Create((object)__instance).Field("activeColHashes").GetValue <int[]>();
ColliderContainer[] colChunks = Traverse.Create((object)__instance).Field("colChunks").GetValue <ColliderContainer[]>();
if (!__instance.doCast || GameMain.localPlanet != __instance.planet || (VFInput.inFullscreenGUI || !Application.isFocused))
{
return;
}
for (int i = 0; i < activeColHashCount; i++)
{
int activeColHash = activeColHashes[i];
ColliderData[] colliderPool = colChunks[activeColHash].colliderPool;
for (int j = 1; j < colChunks[activeColHash].cursor; j++)
{
if (colliderPool[j].idType != 0)
{
EObjectType objType = colliderPool[j].objType;
bool typeFlag = objType == EObjectType.Vein || objType == EObjectType.Vegetable;
if (!typeFlag || !__instance.ignoreVegeAndVein)
{
if ((colliderPool[j].usage == EColliderUsage.Build || typeFlag) &&
colliderPool[j].shape == EColliderShape.Box)
{
//Send to filter
filter(colliderPool[j]);
}
}
}
}
}
}
public BaseObject(Int32 p_staticID, EObjectType p_type, Int32 p_spawnerID)
{
m_type = p_type;
InitBaseObject(p_staticID, p_spawnerID);
}
public static MapObjectReader GetObjectReader(EObjectType objectType)
{
MapObjectReader readerObject = null;
switch (objectType)
{
case EObjectType.EVENT:
return(new CGEventReader());
case EObjectType.HERO:
case EObjectType.RANDOM_HERO:
case EObjectType.PRISON:
return(new CGHeroReader());
case EObjectType.MONSTER: //Monster
case EObjectType.RANDOM_MONSTER:
case EObjectType.RANDOM_MONSTER_L1:
case EObjectType.RANDOM_MONSTER_L2:
case EObjectType.RANDOM_MONSTER_L3:
case EObjectType.RANDOM_MONSTER_L4:
case EObjectType.RANDOM_MONSTER_L5:
case EObjectType.RANDOM_MONSTER_L6:
case EObjectType.RANDOM_MONSTER_L7:
return(new CGCreatureReader());
case EObjectType.OCEAN_BOTTLE:
case EObjectType.SIGN:
return(new CGSignBottleReader());
case EObjectType.SEER_HUT:
return(new CGSeerHutReader());
case EObjectType.WITCH_HUT:
return(new CGWitchHutReader());
case EObjectType.SCHOLAR:
return(new CGScholarReader());
case EObjectType.GARRISON:
case EObjectType.GARRISON2:
return(new CGGarrisonReader());
case EObjectType.ARTIFACT:
case EObjectType.RANDOM_ART:
case EObjectType.RANDOM_TREASURE_ART:
case EObjectType.RANDOM_MINOR_ART:
case EObjectType.RANDOM_MAJOR_ART:
case EObjectType.RANDOM_RELIC_ART:
case EObjectType.SPELL_SCROLL:
return(new CGArtifactReader());
case EObjectType.RANDOM_RESOURCE:
case EObjectType.RESOURCE:
return(new CGResourceReader());
case EObjectType.RANDOM_TOWN:
case EObjectType.TOWN:
return(new CGTownReader());
case EObjectType.MINE:
case EObjectType.ABANDONED_MINE:
return(new CGMineReader());
case EObjectType.CREATURE_GENERATOR1:
case EObjectType.CREATURE_GENERATOR2:
case EObjectType.CREATURE_GENERATOR3:
case EObjectType.CREATURE_GENERATOR4:
return(new CGDwellingSimpleReader());
case EObjectType.SHRINE_OF_MAGIC_GESTURE:
case EObjectType.SHRINE_OF_MAGIC_INCANTATION:
case EObjectType.SHRINE_OF_MAGIC_THOUGHT:
return(new CGShrineReader());
case EObjectType.PANDORAS_BOX:
return(new CGPandoraBoxReader());
case EObjectType.GRAIL:
return(new CGGrailReader());
case EObjectType.RANDOM_DWELLING:
case EObjectType.RANDOM_DWELLING_FACTION:
case EObjectType.RANDOM_DWELLING_LVL:
return(new CGDwellingReader());
case EObjectType.QUEST_GUARD:
return(new CGQuestGuardReader());
case EObjectType.SHIPYARD:
return(new CGShipyardReader());
case EObjectType.HERO_PLACEHOLDER:
return(new CGHeroPlaceholderReader());
case EObjectType.BORDERGUARD:
return(new CGBorderGuardReader());
case EObjectType.BORDER_GATE:
return(new CGBorderGateReader());
case EObjectType.PYRAMID:
return(new CGPyramidReader());
case EObjectType.LIGHTHOUSE:
return(new CGLightHouseReader());
default:
break;
}
return(readerObject);
}
public void Load(SaveGameData p_data)
{
m_name = p_data.Get <String>("Name", null);
Int32 num = p_data.Get <Int32>("ObjectCount", 0);
for (Int32 i = 0; i < num; i++)
{
SaveGameData saveGameData = p_data.Get <SaveGameData>("InteractiveObject" + i, null);
if (saveGameData != null)
{
try
{
Int32 p_staticID = saveGameData.Get <Int32>("StaticID", 0);
Int32 p_spawnID = saveGameData.Get <Int32>("SpawnerID", 0);
EObjectType p_type = saveGameData.Get <EObjectType>("ObjectType", EObjectType.NONE);
InteractiveObject interactiveObject = (InteractiveObject)EntityFactory.Create(p_type, p_staticID, p_spawnID);
interactiveObject.Load(saveGameData);
m_objects.Add(interactiveObject);
}
catch (Exception p_message)
{
LegacyLogger.LogError(p_message);
}
}
}
Int32 num2 = p_data.Get <Int32>("MonsterCount", 0);
for (Int32 j = 0; j < num2; j++)
{
SaveGameData saveGameData2 = p_data.Get <SaveGameData>("Monster" + j, null);
if (saveGameData2 != null)
{
try
{
Monster monster = new Monster();
monster.Load(saveGameData2);
m_monster.Add(monster);
}
catch (Exception p_message2)
{
LegacyLogger.LogError(p_message2);
}
}
}
SaveGameData saveGameData3 = p_data.Get <SaveGameData>("InvalidSpawns", null);
if (saveGameData3 != null)
{
List <Int32> collection = SaveGame.CreateArrayFromData <Int32>(saveGameData3);
m_invalidSpawns.AddRange(collection);
}
SaveGameData saveGameData4 = p_data.Get <SaveGameData>("TerrainMatrix", null);
if (saveGameData4 != null)
{
m_terrainDataHeight = saveGameData4.Get <Int32>("MatrixHeight", 0);
m_terrainDataWidth = saveGameData4.Get <Int32>("MatrixWidth", 0);
m_terrainData = new TerrainTypeData[m_terrainDataWidth * m_terrainDataHeight];
for (Int32 k = 0; k < m_terrainDataHeight; k++)
{
for (Int32 l = 0; l < m_terrainDataWidth; l++)
{
SaveGameData saveGameData5 = saveGameData4.Get <SaveGameData>(String.Concat(new Object[]
{
"terrain_",
l,
"_",
k
}), null);
if (saveGameData5 != null)
{
TerrainTypeData terrainTypeData = default(TerrainTypeData);
terrainTypeData.Load(saveGameData5);
m_terrainData[k * m_terrainDataWidth + l] = terrainTypeData;
}
}
}
}
}
internal Object(EObjectType aType, byte[] aContents)
{
iType = aType;
iContents = aContents;
}
internal static byte TypeByte(EObjectType aType)
{
return ((byte)aType);
}
internal string WriteObject(byte[] aContent, EObjectType aType)
{
byte zero = 0;
byte space = (byte)' ';
byte[] type = Object.TypeBytes(aType);
byte[] length = ASCIIEncoding.ASCII.GetBytes(aContent.Length.ToString());
byte[] obj = new byte[type.Length + length.Length + aContent.Length + 2];
Array.Copy(type, 0, obj, 0, type.Length);
obj[type.Length] = space;
Array.Copy(length, 0, obj, type.Length + 1, length.Length);
obj[type.Length + length.Length + 1] = zero;
Array.Copy(aContent, 0, obj, type.Length + length.Length + 2, aContent.Length);
string id = Hash.String(iHash.Compute(obj));
DirectoryInfo folder = iFolderObjects.CreateSubdirectory(id.Substring(0, 2));
String path = Path.Combine(folder.FullName, id.Substring(2));
if (File.Exists(path))
{
return (id);
}
var file = new FileStream(path, FileMode.CreateNew, FileAccess.Write);
DeflaterOutputStream deflater = new DeflaterOutputStream(file);
using (var writer = new BinaryWriter(deflater))
{
writer.Write(obj);
deflater.Finish();
}
return (id);
}
public static BaseObject Create(EObjectType p_type, Int32 p_staticID, Int32 p_spawnID)
{
switch (p_type)
{
case EObjectType.MONSTER:
return(new Monster(p_staticID, p_spawnID));
case EObjectType.SIGN:
return(new Sign(p_staticID, p_spawnID));
case EObjectType.DOOR:
return(new Door(p_staticID, p_spawnID));
case EObjectType.ENTRANCE:
return(new Entrance(p_staticID, p_spawnID));
case EObjectType.TELEPORTER:
return(new Teleporter(p_staticID, p_spawnID));
case EObjectType.LEVER:
return(new Lever(p_staticID, p_spawnID));
case EObjectType.BUTTON:
return(new Button(p_staticID, p_spawnID));
case EObjectType.SENSOR:
return(new Sensor(p_staticID, p_spawnID));
case EObjectType.CONTAINER:
return(new Container(p_staticID, p_spawnID));
case EObjectType.NPC_CONTAINER:
return(new NpcContainer(p_staticID, p_spawnID));
case EObjectType.TRAP:
return(new Trap(p_staticID, p_spawnID));
case EObjectType.CONDITIONAL_TRIGGER:
return(new ConditionalTrigger(p_staticID, p_spawnID));
case EObjectType.CUTSCENE:
return(new Cutscene(p_spawnID));
case EObjectType.TRAP_EFFECT_CONTAINER:
return(new TrapEffectContainer(p_staticID, p_spawnID));
case EObjectType.SUMMON:
return(new Summon(p_staticID, p_spawnID));
case EObjectType.PRESSURE_PLATE:
return(new PressurePlate(p_staticID, p_spawnID));
case EObjectType.PREFAB_CONTAINER:
return(new PrefabContainer(p_staticID, p_spawnID));
case EObjectType.COUNTING_OBJECT:
return(new CounterObject(p_staticID, p_spawnID));
case EObjectType.PLATFORM:
return(new Platform(p_staticID, p_spawnID));
case EObjectType.PLACEHOLDER:
return(new PlaceHolder(p_staticID, p_spawnID));
case EObjectType.COMMAND_CONTAINER:
return(new CommandContainer(p_staticID, p_spawnID));
case EObjectType.BARREL:
return(new Barrel(p_staticID, p_spawnID));
case EObjectType.RECHARGING_OBJECT:
return(new RechargingObject(p_staticID, p_spawnID));
case EObjectType.SHRINE:
return(new Shrine(p_staticID, p_spawnID));
}
throw new NotImplementedException(String.Concat(new Object[]
{
"Create unknown, ObjectType: ",
p_type,
"; StaticID: ",
p_staticID,
"; SpawnID: ",
p_spawnID
}));
}
protected Button(Int32 p_staticID, EObjectType p_objectType, Int32 p_spawnerID)
: base(p_staticID, p_objectType, p_spawnerID)
{
m_State = EInteractiveObjectState.BUTTON_UP;
}
public MovingEntity(Int32 p_staticID, EObjectType p_type, Int32 p_spawnerID) : base(p_staticID, p_type, p_spawnerID)
{
}
internal static byte[] TypeBytes(EObjectType aType)
{
return (ASCIIEncoding.ASCII.GetBytes(TypeString(aType)));
}
internal Tag(Repository aRepository, string aId, byte[] aBytes)
{
iRepository = aRepository;
iId = aId;
string id = null;
string type = null;
string tag = ASCIIEncoding.ASCII.GetString(aBytes);
string[] lines = tag.Split(new char[] { '\n' });
int offset = 1;
foreach (string line in lines)
{
if (line.Length == 0)
{
break;
}
offset += line.Length + 1;
int keyEnd = line.IndexOf(' ');
CorruptIf(keyEnd < 0);
string key = line.Substring(0, keyEnd);
string value = line.Substring(keyEnd + 1);
switch (key)
{
case "object":
id = value;
break;
case "type":
type = value;
break;
case "tag":
iName = value;
break;
case "tagger":
iTagger = PersonTime.Create(value);
break;
default:
CorruptIf(true);
break;
}
}
iDescription = tag.Substring(offset);
CorruptIf(iName == null);
CorruptIf(iTagger == null);
CorruptIf(id == null);
CorruptIf(type == null);
switch (type)
{
case "commit":
iType = EObjectType.Commit;
break;
case "blob":
iType = EObjectType.Blob;
break;
case "tree":
iType = EObjectType.Tree;
break;
case "tag":
iType = EObjectType.Tag;
break;
default:
CorruptIf(true);
break;
}
}
public IndoorSceneBase(Int32 p_staticID, EObjectType p_objectType, Int32 p_spawnerID) : base(p_staticID, p_objectType, p_spawnerID)
{
}
static public List <ZDObject> HitAtUnit(Vector2 UnitLoc, EObjectType Type)
{
return(HitAtUnit((int)UnitLoc.x, (int)UnitLoc.y, Type));
}
static public List <ZDObject> HitAt(Vector2 input, ZDObject Caller, EObjectType Type)
{
return(HitAt((int)input.x, (int)input.y, Caller, Type));
}
// This function is based on PlayerAction_Mine.GameTick
public void DroneGameTick()
{
double powerFactor = 0.01666666753590107;
PlanetFactory factory = this.player.factory;
if (factory == null)
{
// This has only been seen briefly when the Render Distance mod is transitioning to or from a planet view.
return;
}
double miningEnergyCost = this.player.mecha.miningPower * powerFactor;
double energyAvailable;
float fractionOfEnergyAvailable;
this.player.mecha.QueryEnergy(miningEnergyCost, out energyAvailable, out fractionOfEnergyAvailable);
int miningTime = (int)(this.player.mecha.miningSpeed * configSpeedScaleFactor * fractionOfEnergyAvailable * 10000f + 0.49f);
VegeData vegeData = factory.GetVegeData(this.miningId);
this.miningProtoId = (int)vegeData.protoId;
VegeProto vegeProto = LDB.veges.Select((int)vegeData.protoId);
if (vegeProto != null)
{
this.miningTick += miningTime;
this.player.mecha.coreEnergy -= energyAvailable;
this.player.mecha.MarkEnergyChange(5, -miningEnergyCost);
this.percent = Mathf.Clamp01((float)((double)this.miningTick / (double)(vegeProto.MiningTime * 10000)));
if (this.miningTick >= vegeProto.MiningTime * 10000)
{
System.Random random = new System.Random(vegeData.id + ((this.player.planetData.seed & 16383) << 14));
bool inventoryOverflowFlag = false;
int popupQueueIndex = 0;
for (int itemIdx = 0; itemIdx < vegeProto.MiningItem.Length; itemIdx++)
{
float randomMiningChance = (float)random.NextDouble();
if (randomMiningChance < vegeProto.MiningChance[itemIdx])
{
int minedItem = vegeProto.MiningItem[itemIdx];
int minedItemCount = (int)((float)vegeProto.MiningCount[itemIdx] * (vegeData.scl.y * vegeData.scl.y) + 0.5f);
if (minedItemCount > 0 && LDB.items.Select(minedItem) != null)
{
int inventoryOverflowCount = this.player.package.AddItemStacked(minedItem, minedItemCount);
if (inventoryOverflowCount != 0)
{
UIItemup.Up(minedItem, inventoryOverflowCount);
UIRealtimeTip.PopupItemGet(minedItem, inventoryOverflowCount, vegeData.pos + vegeData.pos.normalized, popupQueueIndex++);
}
else // Unable to fit all items
{
inventoryOverflowFlag = true;
}
}
}
}
VFEffectEmitter.Emit(vegeProto.MiningEffect, vegeData.pos, vegeData.rot);
VFAudio.Create(vegeProto.MiningAudio, null, vegeData.pos, true);
factory.RemoveVegeWithComponents(vegeData.id);
GameMain.gameScenario.NotifyOnVegetableMined((int)vegeData.protoId);
this.miningType = EObjectType.Entity; // This change will cause the mission to be completed.
this.miningId = 0;
if (inventoryOverflowFlag)
{
//Logger.LogInfo("Inventory overflow detected.");
}
this.miningTick = 0;
}
}
else
{
//Logger.LogInfo("null vegeProto. Icarus likely removed clearing target.");
this.miningType = EObjectType.Entity; // This change will cause the mission to be completed.
this.miningId = 0;
this.miningTick = 0;
this.percent = 0f;
factory.RemoveVegeWithComponents(vegeData.id);
}
}
