/// <summary> /// Clamps this <see cref="WorldCoordinate"/> between two other <see cref="WorldCoordinate"/> values. /// </summary> /// <param name="lower">The lower bound to clamp between.</param> /// <param name="upper">The upper bound to clamp between.</param> /// <returns>A new <see cref="WorldCoordinate"/>, clamped within the given bounds.</returns> public WorldCoordinate Clamp(WorldCoordinate lower, WorldCoordinate upper) { return((this < lower) ? lower : (this > upper) ? upper : this); }
private void GeneratePopulation(bool fresh) { Debug.Log(string.Concat(new object[] { "Generate population for : ", this.world.region.name, " FRESH: ", fresh })); if (this.world.game.setupValues.proceedLineages > 0) { for (int i = 0; i < this.spawners.Count; i++) { if (this.spawners[i] is World.Lineage) { for (int j = 0; j < this.world.game.setupValues.proceedLineages; j++) { (this.spawners[i] as World.Lineage).ChanceToProgress(this.world); } } } } //----------------------------------------Error start for (int k = 0; k < this.spawners.Count; k++) { if (this.spawners[k] is World.SimpleSpawner) { World.SimpleSpawner simpleSpawner = this.spawners[k] as World.SimpleSpawner; int num; if (fresh || StaticWorld.GetCreatureTemplate(simpleSpawner.creatureType).quantified || !StaticWorld.GetCreatureTemplate(simpleSpawner.creatureType).saveCreature) { num = simpleSpawner.amount; } else { num = this.HowManyOfThisCritterShouldRespawn(simpleSpawner.SpawnerID, simpleSpawner.amount); } if (num > 0) { AbstractRoom abstractRoom = this.world.GetAbstractRoom(simpleSpawner.den); if (abstractRoom != null && simpleSpawner.den.abstractNode >= 0 && simpleSpawner.den.abstractNode < abstractRoom.nodes.Length && (abstractRoom.nodes[simpleSpawner.den.abstractNode].type == AbstractRoomNode.Type.Den || abstractRoom.nodes[simpleSpawner.den.abstractNode].type == AbstractRoomNode.Type.GarbageHoles)) { if (StaticWorld.GetCreatureTemplate(simpleSpawner.creatureType).quantified) { abstractRoom.AddQuantifiedCreature(simpleSpawner.den.abstractNode, simpleSpawner.creatureType, simpleSpawner.amount); } else { for (int l = 0; l < num; l++) { abstractRoom.MoveEntityToDen(new AbstractCreature(this.world, StaticWorld.GetCreatureTemplate(simpleSpawner.creatureType), null, simpleSpawner.den, this.world.game.GetNewID(simpleSpawner.SpawnerID)) { spawnData = simpleSpawner.spawnDataString }); } } } } } else if (this.spawners[k] is World.Lineage) { World.Lineage lineage = this.spawners[k] as World.Lineage; bool flag = fresh || this.ShouldThisCritterRespawn(lineage.SpawnerID); if (flag) { AbstractRoom abstractRoom2 = this.world.GetAbstractRoom(lineage.den); CreatureTemplate.Type?type = lineage.CurrentType((this.game.session as StoryGameSession).saveState); if (type == null) { lineage.ChanceToProgress(this.world); } else if (abstractRoom2 != null && lineage.den.abstractNode >= 0 && lineage.den.abstractNode < abstractRoom2.nodes.Length && (abstractRoom2.nodes[lineage.den.abstractNode].type == AbstractRoomNode.Type.Den || abstractRoom2.nodes[lineage.den.abstractNode].type == AbstractRoomNode.Type.GarbageHoles)) { abstractRoom2.MoveEntityToDen(new AbstractCreature(this.world, StaticWorld.GetCreatureTemplate(type.Value), null, lineage.den, this.world.game.GetNewID(lineage.SpawnerID)) { spawnData = lineage.CurrentSpawnData((this.game.session as StoryGameSession).saveState) }); } if (type == null) { (this.game.session as StoryGameSession).saveState.respawnCreatures.Add(lineage.SpawnerID); Debug.Log("add NONE creature to respawns for lineage " + lineage.SpawnerID); } } } } //--------------------Error end if (this.playerCharacter != 2 && !(this.game.session as StoryGameSession).saveState.guideOverseerDead && !(this.game.session as StoryGameSession).saveState.miscWorldSaveData.playerGuideState.angryWithPlayer && UnityEngine.Random.value < this.world.region.regionParams.playerGuideOverseerSpawnChance) { WorldCoordinate worldCoordinate = new WorldCoordinate(this.world.offScreenDen.index, -1, -1, 0); if (this.world.region.name == "SU") { worldCoordinate = new WorldCoordinate(this.world.GetAbstractRoom("SU_C04").index, 137, 17, 0); } AbstractCreature abstractCreature = new AbstractCreature(this.world, StaticWorld.GetCreatureTemplate(CreatureTemplate.Type.Overseer), null, worldCoordinate, new EntityID(-1, 5)); if (this.world.GetAbstractRoom(worldCoordinate).offScreenDen) { this.world.GetAbstractRoom(worldCoordinate).entitiesInDens.Add(abstractCreature); } else { this.world.GetAbstractRoom(worldCoordinate).AddEntity(abstractCreature); } (abstractCreature.abstractAI as OverseerAbstractAI).SetAsPlayerGuide(); } if (this.world.region.name == "UW" || UnityEngine.Random.value < this.world.region.regionParams.overseersSpawnChance * Mathf.InverseLerp(2f, 21f, (float)((this.game.session as StoryGameSession).saveState.cycleNumber + ((this.game.StoryCharacter != 2) ? 0 : 17)))) { int num2 = UnityEngine.Random.Range(this.world.region.regionParams.overseersMin, this.world.region.regionParams.overseersMax); for (int m = 0; m < num2; m++) { this.world.offScreenDen.entitiesInDens.Add(new AbstractCreature(this.world, StaticWorld.GetCreatureTemplate(CreatureTemplate.Type.Overseer), null, new WorldCoordinate(this.world.offScreenDen.index, -1, -1, 0), this.game.GetNewID())); } } }
public WarpCommandPacket() { Player = String.Empty; Coordinates = new WorldCoordinate(); }
public extern void orig_ctor(World world, patch_CreatureTemplate creatureTemplate, patch_Creature realizedCreature, WorldCoordinate pos, EntityID ID);
public void ctor(World world, patch_CreatureTemplate creatureTemplate, patch_Creature realizedCreature, WorldCoordinate pos, EntityID ID) { orig_ctor(world, creatureTemplate, realizedCreature, pos, ID); CreatureTemplate.Type type = creatureTemplate.TopAncestor().type; if (creatureTemplate.AI) { type = creatureTemplate.type; switch (type) { case CreatureTemplate.Type.Scavenger: abstractAI = new ScavengerAbstractAI(world, this); goto IL_2F4; case CreatureTemplate.Type.Overseer: abstractAI = new OverseerAbstractAI(world, this); goto IL_2F4; default: switch (type) { case CreatureTemplate.Type.Vulture: break; default: if (type != CreatureTemplate.Type.MirosBird) { abstractAI = new AbstractCreatureAI(world, this); goto IL_2F4; } abstractAI = new MirosBirdAbstractAI(world, this); goto IL_2F4; case CreatureTemplate.Type.CicadaA: case CreatureTemplate.Type.CicadaB: abstractAI = new CicadaAbstractAI(world, this); goto IL_2F4; case CreatureTemplate.Type.BigEel: abstractAI = new BigEelAbstractAI(world, this); goto IL_2F4; case CreatureTemplate.Type.Deer: abstractAI = new DeerAbstractAI(world, this); goto IL_2F4; case (CreatureTemplate.Type)patch_CreatureTemplate.Type.WalkerBeast: abstractAI = new WalkerBeastAbstractAI(world, this); goto IL_2F4; } break; case CreatureTemplate.Type.SmallNeedleWorm: case CreatureTemplate.Type.BigNeedleWorm: abstractAI = new NeedleWormAbstractAI(world, this); goto IL_2F4; case CreatureTemplate.Type.DropBug: abstractAI = new DropBugAbstractAI(world, this); goto IL_2F4; case CreatureTemplate.Type.KingVulture: break; } abstractAI = new VultureAbstractAI(world, this); } IL_2F4: if (pos.abstractNode > -1 && pos.abstractNode < Room.nodes.Length && Room.nodes[pos.abstractNode].type == AbstractRoomNode.Type.Den && !pos.TileDefined) { if (Room.offScreenDen) { remainInDenCounter = 1; } else { remainInDenCounter = UnityEngine.Random.Range(100, 1000); } if (abstractAI != null) { abstractAI.denPosition = new WorldCoordinate?(pos); } spawnDen = pos; } if (creatureTemplate.type == CreatureTemplate.Type.TentaclePlant || creatureTemplate.type == CreatureTemplate.Type.PoleMimic) { remainInDenCounter = 0; } }
public patch_AbstractCreature(World world, CreatureTemplate creatureTemplate, Creature realizedCreature, WorldCoordinate pos, EntityID ID) : base(world, creatureTemplate, realizedCreature, pos, ID) { }
public void WriteWorldCoordinate(WorldCoordinate coordinate) { coordinate.WriteTo(this); }
public extern void OriginalConstructor(World world, AbstractObjectType type, PhysicalObject realizedObject, WorldCoordinate pos, EntityID ID);
public void ctor_AbstractPhysicalObject(World world, AbstractObjectType type, PhysicalObject realizedObject, WorldCoordinate pos, EntityID ID) { OriginalConstructor(world, type, realizedObject, pos, ID); if (ID.number != -1 && ID.number != 5 && ID.number != 0 && this.ID.number != 1 && this.ID.number != 2 && this.ID.number == 3) { while ((this.ID.number >= -1 && this.ID.number <= 15000)) { this.ID.number = UnityEngine.Random.Range(int.MinValue, int.MaxValue); } } if (ID.number == 0) { playerdist = UnityEngine.Random.Range(int.MinValue, int.MaxValue); } if (MonklandSteamManager.isInGame) { owner = NetworkGameManager.playerID; } }
public MovementConnection FollowPath(WorldCoordinate originPos, bool actuallyFollowingThisPath) { int num = int.MinValue; PathCost costToGoal = new PathCost(0f, PathCost.Legality.Unallowed); WorldCoordinate dest = originPos; if (!originPos.TileDefined && !originPos.NodeDefined) { return(null); } WorldCoordinate worldCoordinate = RestrictedOriginPos(originPos); if (actuallyFollowingThisPath && debugDrawer != null) { debugDrawer.Blink(worldCoordinate); } AItile aitile = realizedRoom.aimap.getAItile(worldCoordinate.x, worldCoordinate.y); PathFinder.PathingCell pathingCell = PathingCellAtWorldCoordinate(worldCoordinate); if (pathingCell != null) { if (!pathingCell.reachable || !pathingCell.possibleToGetBackFrom) { OutOfElement(worldCoordinate); } MovementConnection movementConnection = null; PathCost b = new PathCost(0f, PathCost.Legality.Unallowed); int num2 = -acceptablePathAge; PathCost.Legality legality = PathCost.Legality.Unallowed; int num3 = -acceptablePathAge; float num4 = float.MaxValue; int num5 = 0; for (; ;) { MovementConnection movementConnection2 = ConnectionAtCoordinate(true, worldCoordinate, num5); num5++; if (movementConnection2 == null) { break; } if (movementConnection2.type == MovementConnection.MovementType.Standard && movementConnection2.StartTile.FloatDist(movementConnection2.DestTile) > 1f) { //Debug.Log("WTF " + movementConnection2); } if (!movementConnection2.destinationCoord.TileDefined || Custom.InsideRect(movementConnection2.DestTile, coveredArea)) { PathFinder.PathingCell pathingCell2 = PathingCellAtWorldCoordinate(movementConnection2.destinationCoord); PathCost pathCost = CheckConnectionCost(pathingCell, pathingCell2, movementConnection2, true); if (!pathingCell2.possibleToGetBackFrom && !walkPastPointOfNoReturn) { pathCost.legality = PathCost.Legality.Unallowed; } PathCost pathCost2 = pathingCell2.costToGoal + pathCost; if (movementConnection2.destinationCoord.TileDefined && destination.TileDefined && movementConnection2.destinationCoord.Tile == destination.Tile) { pathCost2.resistance = 0f; } else if (realizedRoom.IsPositionInsideBoundries(creature.pos.Tile) && ConnectionAlreadyFollowedSeveralTimes(movementConnection2)) { pathCost += new PathCost(0f, PathCost.Legality.Unwanted); } if (movementConnection2.type == MovementConnection.MovementType.OutsideRoom && !(AI as WalkerBeastAI).AllowMovementBetweenRooms) { pathCost += new PathCost(0f, PathCost.Legality.Unallowed); } if (Input.GetKey("u") && actuallyFollowingThisPath) { Debug.Log(" "); Debug.Log(movementConnection2.startCoord); CDebug.Log(movementConnection2.type.ToString(), movementConnection2.destinationCoord); Debug.Log(string.Concat(new object[] { "conn: ", pathCost.legality.ToString(), " ", pathCost.resistance })); Debug.Log(string.Concat(new object[] { "costToGoal: ", pathingCell2.costToGoal.legality.ToString(), " ", pathingCell2.costToGoal.resistance })); Debug.Log(string.Concat(new object[] { "totCost: ", pathCost2.legality.ToString(), " ", pathCost2.resistance })); Debug.Log("generation: " + pathingCell2.generation); if (!pathingCell2.possibleToGetBackFrom && !walkPastPointOfNoReturn) { Debug.Log("PONOR"); } } if (pathingCell2.generation > num3) { num3 = pathingCell2.generation; num4 = pathCost2.resistance; } else if (pathingCell2.generation == num3 && pathCost2.resistance < num4) { num4 = pathCost2.resistance; } if (pathCost.legality < legality) { movementConnection = movementConnection2; legality = pathCost.legality; num2 = pathingCell2.generation; b = pathCost2; } else if (pathCost.legality == legality) { if (pathingCell2.generation > num2) { movementConnection = movementConnection2; legality = pathCost.legality; num2 = pathingCell2.generation; b = pathCost2; } else if (pathingCell2.generation == num2 && pathCost2 <= b) { movementConnection = movementConnection2; legality = pathCost.legality; num2 = pathingCell2.generation; b = pathCost2; } } } } if (Input.GetKey("u") && actuallyFollowingThisPath) { Debug.Log(worldCoordinate); CDebug.Log("chosen move: ", movementConnection); } if (legality <= PathCost.Legality.Unwanted) { if (actuallyFollowingThisPath) { if (movementConnection != null && movementConnection.type == MovementConnection.MovementType.ShortCut && realizedRoom.shortcutData(movementConnection.StartTile).shortCutType == ShortcutData.Type.RoomExit) { LeavingRoom(); } creatureFollowingGeneration = num2; } if (!actuallyFollowingThisPath || movementConnection == null || movementConnection.type != MovementConnection.MovementType.OutsideRoom || movementConnection.destinationCoord.TileDefined || walkerBeast.shortcutDelay >= 1) { return(movementConnection); } int num6 = 30; if (!Custom.InsideRect(originPos.Tile, new IntRect(-num6, -num6, realizedRoom.TileWidth + num6, realizedRoom.TileHeight + num6))) { foreach (WorldCoordinate worldCoordinate2 in world.sideAccessNodes) { PathFinder.PathingCell pathingCell3 = PathingCellAtWorldCoordinate(worldCoordinate2); if (pathingCell3.generation > num) { num = pathingCell3.generation; costToGoal = pathingCell3.costToGoal; dest = worldCoordinate2; } else if (pathingCell3.generation == num && pathingCell3.costToGoal < costToGoal) { costToGoal = pathingCell3.costToGoal; dest = worldCoordinate2; } if (worldCoordinate2.CompareDisregardingTile(destination)) { dest = worldCoordinate2; break; } } if (!dest.CompareDisregardingTile(movementConnection.destinationCoord)) { walkerBeast.AccessSideSpace(movementConnection.destinationCoord, dest); if (dest.room != creaturePos.room) { LeavingRoom(); } } return(null); } IntVector2 intVector = new IntVector2(0, 1); if (movementConnection.startCoord.x == 0) { intVector = new IntVector2(-1, 0); } else if (movementConnection.startCoord.x == realizedRoom.TileWidth - 1) { intVector = new IntVector2(1, 0); } else if (movementConnection.startCoord.y == 0) { intVector = new IntVector2(0, -1); } return(new MovementConnection(MovementConnection.MovementType.Standard, originPos, new WorldCoordinate(originPos.room, originPos.x + intVector.x * 10, originPos.y + intVector.y * 10, originPos.abstractNode), 1)); } } return(null); }
public patch_AbstractPhysicalObject(World world, AbstractObjectType type, PhysicalObject realizedObject, WorldCoordinate pos, EntityID ID) : base(world, type, realizedObject, pos, ID) { }
public override void DestinationHasChanged(WorldCoordinate oldDestination, WorldCoordinate newDestination) { }
public void API_Move() { var newPos = new WorldCoordinate(room.name, localPoint + IntPoint.DirectionToIntPoint(direction)); position = newPos; }
// Token: 0x06001E6C RID: 7788 RVA: 0x001B2720 File Offset: 0x001B0920 public override void Update() { this.focusCreature = null; base.Update(); if (this.getAwayCounter > 0) { this.getAwayCounter--; } AIModule aimodule = base.utilityComparer.HighestUtilityModule(); this.currentUtility = base.utilityComparer.HighestUtility(); if (aimodule != null) { if (aimodule is ThreatTracker) { this.behavior = SeaDrakeAI.Behavior.Flee; } else if (aimodule is RainTracker) { this.behavior = SeaDrakeAI.Behavior.EscapeRain; } else if (aimodule is PreyTracker) { if (this.creature.realizedCreature != null && preyTracker.MostAttractivePrey.representedCreature.realizedCreature != null && !this.creature.realizedCreature.room.PointSubmerged(preyTracker.MostAttractivePrey.representedCreature.realizedCreature.mainBodyChunk.pos)) { this.behavior = SeaDrakeAI.Behavior.Idle; } this.behavior = SeaDrakeAI.Behavior.Hunt; } else if (aimodule is NoiseTracker) { this.behavior = SeaDrakeAI.Behavior.ExamineSound; } else if (aimodule is StuckTracker) { this.behavior = SeaDrakeAI.Behavior.GetUnstuck; } } if (this.currentUtility < 0.1f) { this.behavior = SeaDrakeAI.Behavior.Idle; } if (this.behavior != SeaDrakeAI.Behavior.Flee && this.fish.grasps[0] != null) { this.behavior = SeaDrakeAI.Behavior.ReturnPrey; } switch (this.behavior) { case SeaDrakeAI.Behavior.Idle: if (this.exploreCoordinate != null) { this.creature.abstractAI.SetDestination(this.exploreCoordinate.Value); if (Custom.ManhattanDistance(this.creature.pos, this.exploreCoordinate.Value) < 5 || (UnityEngine.Random.value < 0.0125f && base.pathFinder.DoneMappingAccessibility && this.fish.room.aimap.TileAccessibleToCreature(this.creature.pos.x, this.creature.pos.y, this.creature.creatureTemplate) && !base.pathFinder.CoordinateReachableAndGetbackable(this.exploreCoordinate.Value))) { this.exploreCoordinate = null; } } else if (Custom.ManhattanDistance(this.creature.pos, base.pathFinder.GetDestination) < 5 || !base.pathFinder.CoordinateReachableAndGetbackable(base.pathFinder.GetDestination)) { WorldCoordinate worldCoordinate = this.fish.room.GetWorldCoordinate(Custom.RestrictInRect(this.fish.mainBodyChunk.pos, new FloatRect(0f, 0f, this.fish.room.PixelWidth, this.fish.room.PixelHeight)) + Custom.RNV() * 200f); if (this.fish.room.IsPositionInsideBoundries(worldCoordinate.Tile) && base.pathFinder.CoordinateReachableAndGetbackable(worldCoordinate) && this.fish.room.VisualContact(this.creature.pos.Tile, worldCoordinate.Tile)) { this.creature.abstractAI.SetDestination(worldCoordinate); } } if (UnityEngine.Random.value < 1f / ((this.exploreCoordinate == null) ? 80f : 1600f)) { WorldCoordinate worldCoordinate2 = new WorldCoordinate(this.fish.room.abstractRoom.index, UnityEngine.Random.Range(0, this.fish.room.TileWidth), UnityEngine.Random.Range(0, this.fish.room.TileHeight), -1); if (this.fish.room.aimap.TileAccessibleToCreature(worldCoordinate2.Tile, this.creature.creatureTemplate) && base.pathFinder.CoordinateReachableAndGetbackable(worldCoordinate2)) { this.exploreCoordinate = new WorldCoordinate?(worldCoordinate2); } } if (Custom.DistLess(this.creature.pos, base.pathFinder.GetDestination, 20f) && this.fish.room.VisualContact(this.creature.pos, base.pathFinder.GetDestination)) { this.floatGoalPos = new Vector2?(this.fish.room.MiddleOfTile(base.pathFinder.GetDestination)); } else { this.floatGoalPos = null; } break; case SeaDrakeAI.Behavior.Flee: { WorldCoordinate destination = base.threatTracker.FleeTo(this.creature.pos, 3, 30, this.currentUtility > 0.3f); if (base.threatTracker.mostThreateningCreature != null) { this.focusCreature = base.threatTracker.mostThreateningCreature; } this.creature.abstractAI.SetDestination(destination); this.floatGoalPos = null; break; } case SeaDrakeAI.Behavior.Hunt: this.attackCounter--; this.focusCreature = base.preyTracker.MostAttractivePrey; if (this.focusCreature.VisualContact) { this.floatGoalPos = new Vector2?(this.focusCreature.representedCreature.realizedCreature.mainBodyChunk.pos); } else { this.creature.abstractAI.SetDestination(this.focusCreature.BestGuessForPosition()); } if (this.focusCreature.VisualContact && this.focusCreature.representedCreature.realizedCreature.collisionLayer != this.fish.collisionLayer && Custom.DistLess(this.focusCreature.representedCreature.realizedCreature.mainBodyChunk.pos, this.fish.bodyChunks[2].pos, this.fish.bodyChunks[2].rad + this.focusCreature.representedCreature.realizedCreature.mainBodyChunk.rad)) { this.fish.Collide(this.focusCreature.representedCreature.realizedCreature, 2, 0); } break; case SeaDrakeAI.Behavior.ExamineSound: if (this.fish != null) { this.floatGoalPos = new Vector2?(this.fish.room.MiddleOfTile(this.noiseTracker.ExaminePos)); } else { this.creature.abstractAI.SetDestination(base.noiseTracker.ExaminePos); } break; case SeaDrakeAI.Behavior.EscapeRain: if (base.denFinder.GetDenPosition() != null) { this.creature.abstractAI.SetDestination(base.denFinder.GetDenPosition().Value); } this.floatGoalPos = null; break; case SeaDrakeAI.Behavior.ReturnPrey: if (base.denFinder.GetDenPosition() != null) { this.creature.abstractAI.SetDestination(base.denFinder.GetDenPosition().Value); } this.floatGoalPos = null; break; case SeaDrakeAI.Behavior.GoToFood: this.creature.abstractAI.SetDestination(this.fish.room.GetWorldCoordinate(this.goToFood.firstChunk.pos)); break; case SeaDrakeAI.Behavior.GetUnstuck: this.creature.abstractAI.SetDestination(base.stuckTracker.getUnstuckPosCalculator.unstuckGoalPosition); if (UnityEngine.Random.value < Custom.LerpMap(base.stuckTracker.Utility(), 0.9f, 1f, 0f, 0.1f) && this.fish.room.GetTile(this.fish.mainBodyChunk.pos).AnyWater&& this.fish.enteringShortCut == null && base.stuckTracker.stuckCloseToShortcutModule.foundShortCut != null) { this.fish.enteringShortCut = base.stuckTracker.stuckCloseToShortcutModule.foundShortCut; base.stuckTracker.Reset(); } break; } }
/// <summary> /// Used to split the tile in 11x11 real world coordinates matrix, starting from south west to north east. /// The latitude step between two points is Math.Abs(Math.Abs(northEast.Lat) - Math.Abs(southWest.Lat))/(tileWidth - 1). /// </summary> /// <param name="i">The index of the processed vertex</param> /// <param name="tileWidth">The edge size, in vertices number.</param> /// <param name="distanceBetweenPoints">Delta latitude between two vertices</param> /// <param name="precLat">Latitude of precedent vertex</param> /// <returns>The latitude for the processed vertex</returns> private double GetLatFromSouthWest(double i, double tileWidth, double distanceBetweenPoints, WorldCoordinate precLat) { return(precLat.Lat + (distanceBetweenPoints * Math.Floor(i / tileWidth))); }
public AbstractDestruction(World world, WorldCoordinate pos, Vector2 realPos, float rad, EntityID ID, bool affectTerrain = true) : base(world, pos, ID) { this.realPos = realPos; this.rad = (int)rad; this.affectTerrain = affectTerrain; }
/// <summary> /// Used to split the tile in 11x11 real world coordinates matrix, starting from south west to north east. /// The longitude step between two points is Math.Abs(Math.Abs(northEast.Lon) - Math.Abs(southWest.Lon)) / (tileWidth - 1). /// </summary> /// <param name="i">The index of the processed vertex</param> /// <param name="tileWidth">The edge size, in vertices number.</param> /// <param name="distanceBetweenPoints">Delta latitude between two vertices</param> /// <param name="precLng">Longitude of precedent vertex</param> /// <returns>The longitude for the processed vertex</returns> private double GetLngFromSouthWest(double i, double tileWidth, double distanceBetweenPoints, WorldCoordinate precLng) { return(precLng.Lon + (distanceBetweenPoints * (i % tileWidth))); }
void OnPositionChanged(WorldCoordinate pPrevPos, WorldCoordinate pNewPos) { UpdateMovingDoorPosition(); }
private void SpawnEntity(SandboxEditor.PlacedIconData placedIconData) { IconSymbol.IconSymbolData data = placedIconData.data; WorldCoordinate pos = new WorldCoordinate(0, -1, -1, -1); pos.x = Mathf.RoundToInt(placedIconData.pos.x / 20f); pos.y = Mathf.RoundToInt(placedIconData.pos.y / 20f); EntityID entityID = (!base.GameTypeSetup.saveCreatures) ? this.game.GetNewID() : placedIconData.ID; if (data.itemType == AbstractPhysicalObject.AbstractObjectType.Creature) { AbstractCreature abstractCreature = null; if (base.GameTypeSetup.saveCreatures) { for (int i = 0; i < this.arenaSitting.creatures.Count; i++) { if (this.arenaSitting.creatures[i].creatureTemplate.type == data.critType && this.arenaSitting.creatures[i].ID == entityID) { abstractCreature = this.arenaSitting.creatures[i]; this.arenaSitting.creatures.RemoveAt(i); for (int j = 0; j < 2; j++) { abstractCreature.state.CycleTick(); } string creatureString = SaveState.AbstractCreatureToString(abstractCreature); abstractCreature = SaveState.AbstractCreatureFromString(this.game.world, creatureString, false); abstractCreature.pos = pos; break; } } } if (abstractCreature == null) { abstractCreature = new AbstractCreature(this.game.world, StaticWorld.GetCreatureTemplate(data.critType), null, pos, entityID); } CreatureTemplate.Type critType = data.critType; switch (critType) { case CreatureTemplate.Type.TentaclePlant: case CreatureTemplate.Type.PoleMimic: abstractCreature.pos.x = -1; abstractCreature.pos.y = -1; abstractCreature.pos.abstractNode = data.intData; this.game.world.GetAbstractRoom(0).entitiesInDens.Add(abstractCreature); break; default: switch (critType) { case CreatureTemplate.Type.Fly: case CreatureTemplate.Type.Leech: case CreatureTemplate.Type.SeaLeech: for (int k = 0; k < 5; k++) { this.game.world.GetAbstractRoom(0).AddEntity(new AbstractCreature(this.game.world, StaticWorld.GetCreatureTemplate(data.critType), null, pos, entityID)); } break; default: if (critType == CreatureTemplate.Type.Slugcat) { if (this.playerSpawnDens == null) { this.playerSpawnDens = new List <int>(); } this.playerSpawnDens.Add(data.intData); } if (critType != CreatureTemplate.Type.Spider) { this.game.world.GetAbstractRoom(0).AddEntity(abstractCreature); } break; } break; case CreatureTemplate.Type.Centipede: { float num = 0f; if (data.intData == 2) { num = Mathf.Lerp(0.265f, 0.55f, Mathf.Pow(Custom.ClampedRandomVariation(0.5f, 0.5f, 0.7f), 1.2f)); } else if (data.intData == 3) { num = Mathf.Lerp(0.7f, 1f, Mathf.Pow(UnityEngine.Random.value, 0.6f)); } abstractCreature.spawnData = "{" + num.ToString() + "}"; this.game.world.GetAbstractRoom(0).AddEntity(abstractCreature); break; } } } else { AbstractPhysicalObject.AbstractObjectType itemType = data.itemType; if (itemType != AbstractPhysicalObject.AbstractObjectType.Spear) { if (itemType != AbstractPhysicalObject.AbstractObjectType.WaterNut) { if (itemType != AbstractPhysicalObject.AbstractObjectType.SporePlant) { if (itemType != AbstractPhysicalObject.AbstractObjectType.BubbleGrass) { if (AbstractConsumable.IsTypeConsumable(data.itemType)) { this.game.world.GetAbstractRoom(0).AddEntity(new AbstractConsumable(this.game.world, data.itemType, null, pos, entityID, -1, -1, null)); } else { this.game.world.GetAbstractRoom(0).AddEntity(new AbstractPhysicalObject(this.game.world, data.itemType, null, pos, entityID)); } } else { this.game.world.GetAbstractRoom(0).AddEntity(new BubbleGrass.AbstractBubbleGrass(this.game.world, null, pos, entityID, 1f, -1, -1, null)); } } else { this.game.world.GetAbstractRoom(0).AddEntity(new SporePlant.AbstractSporePlant(this.game.world, null, pos, entityID, -1, -1, null, false, true)); } } else { this.game.world.GetAbstractRoom(0).AddEntity(new WaterNut.AbstractWaterNut(this.game.world, null, pos, entityID, -1, -1, null, false)); } } else { this.game.world.GetAbstractRoom(0).AddEntity(new AbstractSpear(this.game.world, null, pos, entityID, data.intData == 1)); } } }
public WorldCoordinate ReadWorldCoordinate() { return(WorldCoordinate.FromStream(this)); }