public Bullet SpawnProjectileForDeath(Vector3 spawnWorldLocation, SmartEntity attacker, ProjectileTypeVO deathProjectileType, uint deathProjectileDelay, int deathProjectileDistance, int deathProjectileDamage, out bool useRotation, ref int rotateDegrees)
{
useRotation = false;
TransformComponent transformComp = attacker.TransformComp;
int num = transformComp.CenterGridX();
int num2 = transformComp.CenterGridZ();
if (spawnWorldLocation.y < 0f)
{
spawnWorldLocation = new Vector3(Units.BoardToWorldX(num), 0f, Units.BoardToWorldZ(num2));
}
Vector3 vector = spawnWorldLocation;
if (deathProjectileDistance > 0)
{
this.ChooseTargetLocationForDeathProjectile(attacker, deathProjectileDistance, ref num, ref num2, out rotateDegrees);
useRotation = true;
Vector3 point = Vector3.right * (float)deathProjectileDistance;
vector += Quaternion.Euler(0f, (float)rotateDegrees, 0f) * point;
}
HealthFragment healthFrag = new HealthFragment(attacker, HealthType.Damaging, deathProjectileDamage);
TeamType teamType = attacker.TeamComp.TeamType;
Bullet bullet = new Bullet();
bullet.InitWithTargetPositionAndTravelTime(deathProjectileDelay, spawnWorldLocation, num, num2, teamType, attacker, healthFrag, deathProjectileType, null, FactionType.Invalid);
bullet.SetTargetWorldLocation(vector);
bullet.FlashTarget = (deathProjectileType.ApplyBuffs == null || deathProjectileType.ApplyBuffs.Length == 0);
this.SpawnProjectileInternal(bullet, true, false);
return(bullet);
}
public override void Execute()
{
base.Execute();
Entity entity = null;
NodeList <BuildingNode> nodeList = Service.Get <EntityController>().GetNodeList <BuildingNode>();
for (BuildingNode buildingNode = nodeList.Head; buildingNode != null; buildingNode = buildingNode.Next)
{
if (buildingNode.BuildingComp.BuildingType.BuildingID.Equals(this.prepareArgs[0], 5))
{
entity = buildingNode.Entity;
this.buildingFound = true;
break;
}
}
if (entity != null)
{
this.width = Units.GridToBoardX(entity.Get <BuildingComponent>().BuildingType.SizeX);
this.depth = Units.GridToBoardZ(entity.Get <BuildingComponent>().BuildingType.SizeY);
this.boardX = entity.Get <BoardItemComponent>().BoardItem.BoardX + this.width / 2;
this.boardZ = entity.Get <BoardItemComponent>().BoardItem.BoardZ + this.depth / 2;
}
if (this.buildingFound)
{
Service.Get <BuildingController>().HighlightBuilding(entity);
Service.Get <UXController>().MiscElementsManager.HighlightRegion((float)this.boardX, (float)this.boardZ, this.width, this.depth);
Vector3 zero = Vector3.zero;
zero.x = Units.BoardToWorldX(this.boardX);
zero.z = Units.BoardToWorldZ(this.boardZ);
Service.Get <WorldInitializer>().View.PanToLocation(zero);
Service.Get <UserInputInhibitor>().AllowOnly(entity);
}
this.parent.ChildComplete(this);
}
public void UpdateNewEntityView(SmartEntity entity)
{
GameObjectViewComponent gameObjectViewComp = entity.GameObjectViewComp;
TransformComponent transformComp = entity.TransformComp;
if (gameObjectViewComp == null || transformComp == null)
{
Service.Get <StaRTSLogger>().WarnFormat("Entity is not ready for rendering. view: {0}, transform: {1}, entity: {2}", new object[]
{
(gameObjectViewComp == null) ? "null" : gameObjectViewComp.ToString(),
(transformComp == null) ? "null" : transformComp.ToString(),
entity.ID
});
return;
}
gameObjectViewComp.MainTransform.position = new Vector3(Units.BoardToWorldX(transformComp.CenterX()), gameObjectViewComp.MainTransform.position.y, Units.BoardToWorldZ(transformComp.CenterZ()));
if (entity.TroopComp != null || entity.DroidComp != null)
{
this.RotateGameObject(entity, 0f, 0f, 0f);
float speed = Service.Get <BattlePlaybackController>().CurrentPlaybackScale;
this.UpdateAnimationSpeed(gameObjectViewComp, speed);
this.UpdateAnimationState(gameObjectViewComp, entity.StateComp);
return;
}
if (entity.TrapComp != null)
{
gameObjectViewComp.MainGameObject.SetActive(true);
Service.Get <TrapController>().SetTrapState(entity.TrapComp, entity.TrapComp.CurrentState);
Service.Get <TrapViewController>().UpdateTrapVisibility(entity);
gameObjectViewComp.Rotate(transformComp.Rotation);
return;
}
gameObjectViewComp.Rotate(transformComp.Rotation);
gameObjectViewComp.MainGameObject.SetActive(true);
}
public void ExecuteTrap(TrapComponent comp, int boardX, int boardZ)
{
TrapEventType eventType = comp.Type.EventType;
if (eventType != TrapEventType.SpecialAttack)
{
if (eventType != TrapEventType.Turret)
{
return;
}
this.SwapTrapToTurret((SmartEntity)comp.Entity);
this.SetTrapState(comp, TrapState.Active);
}
else
{
Vector3 zero = Vector3.zero;
zero.x = Units.BoardToWorldX(boardX);
zero.z = Units.BoardToWorldX(boardZ);
SpecialAttackTypeVO specialAttackTypeVO = Service.Get <IDataController>().Get <SpecialAttackTypeVO>(comp.Type.ShipTED.SpecialAttackName);
Service.Get <SpecialAttackController>().DeploySpecialAttack(specialAttackTypeVO, TeamType.Defender, zero);
if (comp.Type.DisarmConditions == "EventSuccess")
{
this.SetTrapState(comp, TrapState.Active);
this.SetTrapState(comp, TrapState.Spent);
}
if (!specialAttackTypeVO.IsDropship)
{
Service.Get <ViewTimerManager>().CreateViewTimer((specialAttackTypeVO.AnimationDelay + specialAttackTypeVO.HitDelay) * 0.001f, false, new TimerDelegate(this.OnStarshipStrike), comp.Entity);
return;
}
}
}
public void OnStartPurchaseBuilding(SmartEntity buildingEntity, bool stampable)
{
this.EnsureLoweredLiftedBuilding();
this.buildingSelector.EnsureDeselectSelectedBuilding();
this.ResetOnPress(Vector2.zero, Vector3.zero);
this.buildingSelector.SelectBuilding(buildingEntity, Vector3.zero);
this.LiftSelectedBuilding(this.buildingSelector.SelectedBuilding, false);
int cx = 0;
int cz = 0;
Service.CameraManager.MainCamera.GetLookatBoardCell(out cx, out cz);
int boardX;
int num;
this.buildingController.FindStartingLocation(buildingEntity, out boardX, out num, cx, cz, stampable);
float x;
float z;
EditBaseController.BuildingBoardToWorld(buildingEntity, boardX, num, out x, out z);
Vector3 vector = new Vector3(x, 0f, z);
this.MoveLiftedBuilding(buildingEntity, vector);
UXController uXController = Service.UXController;
uXController.MiscElementsManager.ShowConfirmGroup(buildingEntity, new MiscConfirmDelegate(this.OnConfirmPurchase));
uXController.HUD.ToggleExitEditModeButton(false);
vector.x = Units.BoardToWorldX(boardX);
vector.z = Units.BoardToWorldX(num);
this.worldView.PanToLocation(vector);
this.LowerLiftedBuilding(DropKind.JustDrop, false, true, true, false);
}
private void MoveLiftedBuilding(Entity building, Vector3 worldGroundPosition, bool isPartOfSelection)
{
Entity selectedBuilding = this.buildingSelector.SelectedBuilding;
TransformComponent transformComponent = building.Get <TransformComponent>();
TransformComponent transformComponent2 = selectedBuilding.Get <TransformComponent>();
float num = (float)transformComponent2.X - (float)transformComponent.BoardWidth / 2f + (float)transformComponent2.BoardWidth / 2f;
float num2 = (float)transformComponent2.Z - (float)transformComponent.BoardDepth / 2f + (float)transformComponent2.BoardDepth / 2f;
float num3 = (float)transformComponent.X;
float num4 = (float)transformComponent.Z;
float num5 = Units.BoardToWorldX(num3 - num);
float num6 = Units.BoardToWorldZ(num4 - num2);
Vector3 grabPoint = this.buildingSelector.GrabPoint;
float num7 = worldGroundPosition.x - grabPoint.x + num5;
float num8 = worldGroundPosition.z - grabPoint.z + num6;
float num9;
float num10;
EditBaseController.BuildingBoardToWorld(building, 0, 0, out num9, out num10);
float num11 = num7 - num9;
float num12 = num8 - num10;
Units.SnapWorldToGridX(ref num11);
Units.SnapWorldToGridZ(ref num12);
int num13 = Units.WorldToBoardX(num11);
int num14 = Units.WorldToBoardZ(num12);
transformComponent.X = num13;
transformComponent.Z = num14;
int num15 = -2147483648;
if (this.prevBoardAnchorX.ContainsKey(building))
{
num15 = this.prevBoardAnchorX[building];
}
int num16 = -2147483648;
if (this.prevBoardAnchorZ.ContainsKey(building))
{
num16 = this.prevBoardAnchorZ[building];
}
if (num13 != num15 || num14 != num16)
{
this.canOccupy = this.EntireSelectionIsPlaceable();
Service.UXController.MiscElementsManager.EnableConfirmGroupAcceptButton(this.canOccupy);
FootprintMoveData cookie = new FootprintMoveData(building, num11, num12, this.canOccupy);
Service.EventManager.SendEvent(EventId.UserMovedLiftedBuilding, cookie);
}
GameObjectViewComponent gameObjectViewComponent = building.Get <GameObjectViewComponent>();
if (gameObjectViewComponent != null)
{
gameObjectViewComponent.SetXYZ(num7, 3f, num8);
}
if (this.canOccupy && !isPartOfSelection)
{
this.prevValidBoardAnchorX[building] = num13;
this.prevValidBoardAnchorZ[building] = num14;
}
}
private void GenerateEffectRadius(uint maxRange, uint minRange)
{
float num = (15f - minRange) / 15f;
num = Mathf.Max(num, 0.1f);
CircleMeshUtils.AddCircleMesh(this.effectRadius, Units.BoardToWorldX(minRange), Units.BoardToWorldX(maxRange - minRange), num);
this.GenerateEffectMaterial();
}
private void AddLoweredFootprint(SmartEntity building)
{
TransformComponent transformComp = building.TransformComp;
Vector3 vector = new Vector3(Units.BoardToWorldX(transformComp.X), 0f, Units.BoardToWorldZ(transformComp.Z));
SizeComponent sizeComp = building.SizeComp;
this.loweredFootprint.AddTiles(vector.x, vector.z, sizeComp.Width, sizeComp.Depth, building.WallComp != null);
}
public static void GrantInstantBuildingUpgrade(RewardVO reward, CurrentPlayer cp)
{
for (int i = 0; i < reward.BuildingInstantUpgrades.Length; i++)
{
string[] array = reward.BuildingInstantUpgrades[i].Split(new char[]
{
':'
});
int num = Convert.ToInt32(array[1], CultureInfo.InvariantCulture);
string text = array[0];
BuildingTypeVO buildingTypeVO = Service.Get <IDataController>().Get <BuildingTypeVO>(text);
if (buildingTypeVO == null)
{
Service.Get <StaRTSLogger>().WarnFormat("buildingUiD {0} does not exist", new object[]
{
text
});
}
else
{
BuildingUpgradeCatalog buildingUpgradeCatalog = Service.Get <BuildingUpgradeCatalog>();
ISupportController supportController = Service.Get <ISupportController>();
NodeList <BuildingNode> nodeList = Service.Get <EntityController>().GetNodeList <BuildingNode>();
for (BuildingNode buildingNode = nodeList.Head; buildingNode != null; buildingNode = buildingNode.Next)
{
BuildingTypeVO buildingType = buildingNode.BuildingComp.BuildingType;
if (buildingType.Lvl < num && buildingType.Type == buildingTypeVO.Type && buildingType.Type != BuildingType.Clearable)
{
BuildingTypeVO byLevel = buildingUpgradeCatalog.GetByLevel(buildingType.UpgradeGroup, num);
if (byLevel != null && byLevel.PlayerFacing)
{
if (!string.IsNullOrEmpty(buildingTypeVO.LinkedUnit))
{
if (ContractUtils.IsChampionRepairing(buildingNode.Entity))
{
supportController.FinishCurrentContract(buildingNode.Entity, true);
}
if (cp.Inventory.Champion.GetItemAmount(buildingTypeVO.LinkedUnit) == 0)
{
cp.OnChampionRepaired(buildingTypeVO.LinkedUnit);
}
}
supportController.StartBuildingUpgrade(byLevel, buildingNode.Entity, true);
int boardX = buildingNode.Entity.Get <BoardItemComponent>().BoardItem.BoardX;
int boardZ = buildingNode.Entity.Get <BoardItemComponent>().BoardItem.BoardZ;
float x;
float z;
EditBaseController.BuildingBoardToWorld(buildingNode.Entity, boardX, boardZ, out x, out z);
Vector3 worldLocation = new Vector3(x, 0f, z);
worldLocation.x = Units.BoardToWorldX(boardX);
worldLocation.z = Units.BoardToWorldX(boardZ);
Service.Get <WorldInitializer>().View.PanToLocation(worldLocation);
}
}
}
}
}
}
private void SpawnTransport(ContractEventData contractData)
{
if (!this.CountTransportRequest(contractData))
{
return;
}
Entity entity = contractData.Entity;
BuildingTypeVO buildingVO = contractData.BuildingVO;
string uid;
if (buildingVO.Faction == FactionType.Empire)
{
uid = this.TRANSPORT_SHIP_EMPIRE;
}
else
{
if (buildingVO.Faction != FactionType.Rebel)
{
return;
}
uid = this.TRANSPORT_SHIP_REBEL;
}
TransportTypeVO transportType = Service.StaticDataController.Get <TransportTypeVO>(uid);
Entity entity2 = this.FindIdleTransport(transportType);
if (entity2 == null)
{
return;
}
Entity entity3 = this.FindIdleStarport(contractData);
if (entity3 == null)
{
return;
}
TransformComponent transformComponent = entity.Get <TransformComponent>();
Vector3 vector = new Vector3(Units.BoardToWorldX(transformComponent.CenterX()), 0f, Units.BoardToWorldZ(transformComponent.CenterZ()));
GameObject vehicleLocator = entity.Get <GameObjectViewComponent>().VehicleLocator;
if (vehicleLocator != null)
{
this.factoryOffset = new Vector3(0f, vehicleLocator.transform.position.y + TransportController.FACTORY_WALL_HEIGHT, 0f);
}
else
{
this.factoryOffset = new Vector3(0f, TransportController.FACTORY_WALL_HEIGHT, 0f);
}
vector += this.factoryOffset;
transformComponent = entity3.Get <TransformComponent>();
Vector3 vector2 = new Vector3(Units.BoardToWorldX(transformComponent.CenterX()), 0f, Units.BoardToWorldZ(transformComponent.CenterZ()));
vector2 += TransportController.DOCK_OFFSET;
TransportComponent transportComponent = entity2.Get <TransportComponent>();
this.BuildSpline(transportComponent.Spline, TransportController.SPAWN_POSITION, vector, vector2, entity3, contractData);
entity2.Get <StateComponent>().CurState = EntityState.Moving;
}
private void SetGridQuadVertices(int x, int z, int index, Vector3[] vertices)
{
float num = Units.BoardToWorldX(x);
float num2 = Units.BoardToWorldZ(z);
float maxX = num + 3f;
float maxZ = num2 + 3f;
UnityUtils.SetQuadVertices(num, num2, maxX, maxZ, index, vertices);
}
public bool UnstashBuilding(SmartEntity buildingEntity, Position pos, bool stampable, bool panToBuilding, bool playLoweredSound)
{
this.EnsureLoweredLiftedBuilding();
this.buildingSelector.EnsureDeselectSelectedBuilding();
this.ResetOnPress(Vector2.zero, Vector3.zero);
this.buildingSelector.SelectBuilding(buildingEntity, Vector3.zero);
this.LiftSelectedBuilding(this.buildingSelector.SelectedBuilding, false);
int x;
int z;
if (pos == null)
{
int cx = 0;
int cz = 0;
Service.CameraManager.MainCamera.GetLookatBoardCell(out cx, out cz);
this.buildingController.FindStartingLocation(buildingEntity, out x, out z, cx, cz, stampable);
UXController uXController = Service.UXController;
if (stampable)
{
uXController.MiscElementsManager.ShowConfirmGroup(buildingEntity, new MiscConfirmDelegate(this.OnConfirmUnstashStamp));
}
else
{
this.buildingController.DisableUnstashStampingState();
}
}
else
{
x = pos.X;
z = pos.Z;
}
float x2;
float z2;
EditBaseController.BuildingBoardToWorld(buildingEntity, x, z, out x2, out z2);
Vector3 vector = new Vector3(x2, 0f, z2);
this.MoveLiftedBuilding(buildingEntity, vector);
if (panToBuilding)
{
vector.x = Units.BoardToWorldX(x);
vector.z = Units.BoardToWorldX(z);
this.worldView.PanToLocation(vector);
}
BoardCell boardCell = Service.WorldController.AddBuildingToBoard(buildingEntity, x, z, true);
if (boardCell != null)
{
this.LowerLiftedBuilding(DropKind.JustDrop, true, true, playLoweredSound, false);
}
else
{
this.lifted = false;
this.moved = false;
}
return(boardCell != null);
}
public override void Execute()
{
base.Execute();
Vector3 zero = Vector3.zero;
zero.x = Units.BoardToWorldX(this.boardX);
zero.z = Units.BoardToWorldZ(this.boardZ);
Service.WorldInitializer.View.PanToLocation(zero);
this.parent.ChildComplete(this);
}
private void SetDefaultTargetWorldLocation(float targetWorldY)
{
float num = 0f;
if (this.Target == null)
{
num = 1f;
}
this.SetTargetWorldLocation(new Vector3(Units.BoardToWorldX(this.TargetBoardX) + num, targetWorldY, Units.BoardToWorldZ(this.TargetBoardZ) + num));
}
private void LiftSelectedBuilding(SmartEntity buildingInSelection, bool sendLiftedEvent, bool clearPreviousAnchorPos)
{
this.lifted = true;
if (buildingInSelection == this.buildingSelector.SelectedBuilding)
{
Service.UXController.HUD.ShowContextButtons(buildingInSelection);
}
Vector3 grabPoint = this.buildingSelector.GrabPoint;
BoardItemComponent boardItemComponent = buildingInSelection.Get <BoardItemComponent>();
if (boardItemComponent.BoardItem.Filter == CollisionFilters.BUILDING)
{
boardItemComponent.BoardItem.Filter = CollisionFilters.BUILDING_GHOST;
}
else if (boardItemComponent.BoardItem.Filter == CollisionFilters.TRAP)
{
boardItemComponent.BoardItem.Filter = CollisionFilters.TRAP_GHOST;
}
else if (boardItemComponent.BoardItem.Filter == CollisionFilters.WALL)
{
boardItemComponent.BoardItem.Filter = CollisionFilters.WALL_GHOST;
}
else if (boardItemComponent.BoardItem.Filter == CollisionFilters.BLOCKER)
{
boardItemComponent.BoardItem.Filter = CollisionFilters.BLOCKER_GHOST;
}
else if (boardItemComponent.BoardItem.Filter == CollisionFilters.PLATFORM)
{
boardItemComponent.BoardItem.Filter = CollisionFilters.PLATFORM_GHOST;
}
this.canOccupy = true;
if (clearPreviousAnchorPos)
{
this.ClearPreviousAnchors();
}
TransformComponent transformComp = this.buildingSelector.SelectedBuilding.TransformComp;
Vector3 worldGroundPosition = new Vector3(Units.BoardToWorldX(transformComp.X), 0f, Units.BoardToWorldZ(transformComp.Z));
if (sendLiftedEvent)
{
Service.EventManager.SendEvent(EventId.UserLiftedBuilding, buildingInSelection);
Service.EventManager.SendEvent(EventId.UserLiftedBuildingAudio, buildingInSelection);
}
float num;
float num2;
EditBaseController.BuildingBoardToWorld(this.buildingSelector.SelectedBuilding, 0, 0, out num, out num2);
worldGroundPosition.x += num + grabPoint.x;
worldGroundPosition.z += num2 + grabPoint.z;
this.MoveLiftedBuilding(buildingInSelection, worldGroundPosition);
Service.EntityViewManager.SetCollider(buildingInSelection, false);
this.buildingSelector.ApplySelectedEffect(buildingInSelection);
Service.BuildingTooltipController.HideBuildingTooltip(buildingInSelection);
}
private void SpecialAttackDeployedActionCallback(uint id, object cookie)
{
SpecialAttackDeployedAction specialAttackDeployedAction = cookie as SpecialAttackDeployedAction;
IDataController dataController = Service.Get <IDataController>();
SpecialAttackTypeVO specialAttackTypeVO = dataController.Get <SpecialAttackTypeVO>(specialAttackDeployedAction.SpecialAttackId);
Vector3 vector = new Vector3(Units.BoardToWorldX(specialAttackDeployedAction.BoardX), 0f, Units.BoardToWorldZ(specialAttackDeployedAction.BoardZ));
Service.Get <SpecialAttackController>().DeploySpecialAttack(specialAttackTypeVO, specialAttackDeployedAction.TeamType, vector);
IntPosition boardPosition = Units.WorldToBoardIntPosition(vector);
this.battleController.OnSpecialAttackDeployed(specialAttackTypeVO.Uid, specialAttackDeployedAction.TeamType, boardPosition);
}
public static void BuildingBoardToWorld(Entity building, int boardX, int boardZ, out float worldX, out float worldZ)
{
SizeComponent sizeComp = ((SmartEntity)building).SizeComp;
BuildingComponent buildingComp = ((SmartEntity)building).BuildingComp;
int num = 0;
if (buildingComp.BuildingType.Type != BuildingType.Blocker && sizeComp.Width > 1 && sizeComp.Depth > 1)
{
num = 1;
}
worldX = Units.BoardToWorldX((float)boardX + (float)(sizeComp.Width - num) * 0.5f);
worldZ = Units.BoardToWorldZ((float)boardZ + (float)(sizeComp.Depth - num) * 0.5f);
}
public void SetWorldTarget(float boardX, float boardZ, float width, float depth)
{
if (this.View == null)
{
return;
}
this.View.name = this.name;
this.ViewTransform.position = new Vector3(Units.BoardToWorldX(boardX), 0.09f, Units.BoardToWorldZ(boardZ));
this.reticleScale = 1.4f * Mathf.Max(Units.BoardToWorldX(width), Units.BoardToWorldZ(depth));
this.ViewTransform.localScale = new Vector3(3f * this.reticleScale, 3f * this.reticleScale, 3f * this.reticleScale);
this.ViewTransform.localEulerAngles = Vector3.zero;
this.View.SetActive(true);
this.StartLockon();
}
private void SetColliderHelper(GameObject gameObject, SizeComponent size, bool flat)
{
BoxCollider component = gameObject.GetComponent <BoxCollider>();
if (component == null)
{
return;
}
float y = gameObject.transform.position.y;
float num = Units.BoardToWorldX(size.Depth);
float num2 = Units.BoardToWorldX(size.Width);
float num3 = (!flat) ? ((num + num2) * 0.5f + y) : 0.25f;
component.size = new Vector3(num, num3, num2);
component.center = new Vector3(0f, num3 * 0.5f - y, 0f);
}
public void StashBuilding(SmartEntity buildingEntity, bool allowRevert)
{
BuildingComponent buildingComponent = buildingEntity.Get <BuildingComponent>();
if (buildingComponent.BuildingType.Type == BuildingType.Clearable)
{
Service.Logger.Warn("BLT: Can't stash clearable: " + buildingComponent.BuildingTO.Key + ":" + buildingComponent.BuildingTO.Uid);
return;
}
string uid = buildingComponent.BuildingTO.Uid;
if (this.stashedBuildingMap == null)
{
this.stashedBuildingMap = new Dictionary <string, List <SmartEntity> >();
}
if (!this.stashedBuildingMap.ContainsKey(uid))
{
this.stashedBuildingMap.Add(uid, new List <SmartEntity>());
}
List <SmartEntity> list = this.stashedBuildingMap[uid];
if (!list.Contains(buildingEntity))
{
list.Add(buildingEntity);
}
GameObjectViewComponent gameObjectViewComp = buildingEntity.GameObjectViewComp;
if (gameObjectViewComp != null)
{
TransformComponent transformComp = buildingEntity.TransformComp;
gameObjectViewComp.SetXYZ(Units.BoardToWorldX(transformComp.CenterX()), -1000f, Units.BoardToWorldZ(transformComp.CenterZ()));
}
if (buildingEntity.HealthViewComp != null)
{
HealthViewComponent healthViewComponent = buildingEntity.Get <HealthViewComponent>();
healthViewComponent.TeardownElements();
}
Service.EventManager.SendEvent(EventId.UserStashedBuilding, buildingEntity);
Service.BoardController.RemoveEntity(buildingEntity, true);
Service.EventManager.SendEvent(EventId.EntityDestroyed, buildingEntity.ID);
Service.EventManager.SendEvent(EventId.BuildingMovedOnBoard, buildingEntity);
Service.BuildingController.DisableUnstashStampingState();
if (allowRevert)
{
this.ShouldRevertMap = true;
}
}
public void RotateSelectedBuildings(Entity building)
{
this.AutoLiftSelectedBuilding();
float num = Mathf.Sin(-1.57079637f);
float num2 = Mathf.Cos(-1.57079637f);
Vector3 grabPoint = this.buildingSelector.GrabPoint;
float num3;
float num4;
EditBaseController.BuildingBoardToWorld(building, 0, 0, out num3, out num4);
TransformComponent transformComponent = building.Get <TransformComponent>();
float num5 = (float)transformComponent.X;
float num6 = (float)transformComponent.Z;
Vector3 worldGroundPosition = new Vector3(Units.BoardToWorldX(num5), 0f, Units.BoardToWorldX(num6));
worldGroundPosition.x += num3 + grabPoint.x;
worldGroundPosition.z += num4 + grabPoint.z;
int count = this.buildingSelector.AdditionalSelectedBuildings.Count;
this.MoveLiftedBuilding(building, worldGroundPosition, count > 0);
for (int i = 0; i < count; i++)
{
Entity entity = this.buildingSelector.AdditionalSelectedBuildings[i];
TransformComponent transformComponent2 = entity.Get <TransformComponent>();
float num7 = (float)transformComponent2.X + (float)transformComponent2.BoardWidth / 2f - (float)transformComponent.BoardWidth / 2f;
float num8 = (float)transformComponent2.Z + (float)transformComponent2.BoardDepth / 2f - (float)transformComponent.BoardWidth / 2f;
float num9 = num7 - num5;
float num10 = num8 - num6;
float num11 = num5 + (num9 * num2 - num10 * num);
float num12 = num6 + (num9 * num + num10 * num2);
Vector3 worldGroundPosition2 = new Vector3(Units.BoardToWorldX(num11 - num9), 0f, Units.BoardToWorldZ(num12 - num10));
worldGroundPosition2.x += num3 + grabPoint.x;
worldGroundPosition2.z += num4 + grabPoint.z;
this.MoveLiftedBuilding(entity, worldGroundPosition2, true);
}
this.canOccupy = this.EntireSelectionIsPlaceable();
if (this.canOccupy)
{
this.UpdatePrevValidBoardAnchors();
this.LowerLiftedBuilding(DropKind.JustDrop, true, true, true, true);
}
else
{
this.UpdateWallConnectorsInSelection(true);
}
}
public bool GetRayShieldIntersection(Vector3 rayPos, Vector3 targetPos, ShieldGeneratorComponent shield, out Vector3 intersectionWorldPoint)
{
SmartEntity smartEntity = shield.Entity as SmartEntity;
if (smartEntity == null)
{
intersectionWorldPoint = Vector3.zero;
return(false);
}
TransformComponent transformComp = smartEntity.TransformComp;
Vector3 ellipseOrigin = new Vector3(Units.BoardToWorldX(transformComp.CenterX()), 1.25f, Units.BoardToWorldZ(transformComp.CenterZ()));
float num = 3f * (float)shield.CurrentRadius;
Vector3 ellipseRadius = new Vector3(num, num, num);
Vector3 rayDir = targetPos - rayPos;
targetPos.Normalize();
return(UnityUtils.GetRayEllipsoidIntersection(rayPos, rayDir, ellipseOrigin, ellipseRadius, out intersectionWorldPoint));
}
private void LoadAsset(GameObject parentObject, Transform locator, BuildingTypeVO buildingVO, AssetManager assetManager)
{
Transform transform = parentObject.transform;
transform.parent = locator;
transform.localPosition = Vector3.zero;
transform.localRotation = Quaternion.identity;
transform.localScale = Vector3.one;
BoxCollider boxCollider = parentObject.AddComponent <BoxCollider>();
float x = Units.BoardToWorldZ(buildingVO.SizeY);
float num = Units.BoardToWorldX(buildingVO.SizeX);
boxCollider.size = new Vector3(x, num, num);
AssetHandle item = AssetHandle.Invalid;
assetManager.Load(ref item, buildingVO.AssetName, new AssetSuccessDelegate(this.OnAssetLoaded), null, transform);
this.assetHandles.Add(item);
}
public void AdvanceNextTurn()
{
float num = 0f;
float num2 = 0f;
this.GetTroopClusterOffset(ref num, ref num2);
float num3 = Units.BoardToWorldX((float)this.PathComponent.CurrentPath.TroopWidth / 2f);
GameObjectViewComponent gameObjectViewComponent = this.PathComponent.Entity.Get <GameObjectViewComponent>();
if (gameObjectViewComponent == null)
{
TransformComponent transformComponent = this.PathComponent.Entity.Get <TransformComponent>();
this.StartPos = new Vector3(Units.BoardToWorldX(transformComponent.CenterX()), 0f, Units.BoardToWorldZ(transformComponent.CenterZ()));
}
else
{
this.StartPos = gameObjectViewComponent.MainTransform.position;
}
this.StartPos -= new Vector3(num3 + num, 0f, num3 + num2);
if (this.nextTurnIndex < this.PathComponent.CurrentPath.TurnCount - 1)
{
this.nextTurnIndex++;
this.TimeOnPathSegment = 0f;
this.TimeToTarget = (float)(this.PathComponent.CurrentPath.GetTurnDistance(this.nextTurnIndex) * this.PathComponent.TimePerBoardCellMs) * 1E-06f;
if (this.TimeToTarget == 0f)
{
this.Speed = 0f;
}
else
{
BoardCell <Entity> turn = this.PathComponent.CurrentPath.GetTurn(this.nextTurnIndex - 1);
BoardCell <Entity> turn2 = this.PathComponent.CurrentPath.GetTurn(this.nextTurnIndex);
float num4 = Units.BoardToWorldX(turn2.X - turn.X) + num;
float num5 = Units.BoardToWorldZ(turn2.Z - turn.Z) + num2;
this.Speed = Mathf.Sqrt(num4 * num4 + num5 * num5) / this.TimeToTarget;
}
TransformComponent transformComponent2 = this.PathComponent.Entity.Get <TransformComponent>();
if (transformComponent2 != null)
{
transformComponent2.RotationVelocity = 0f;
}
}
}
public RegionHighlight(UXElement highlight, float boardX, float boardZ, int width, int depth)
{
this.buttonHighlight = highlight;
this.buttonHighlight.Parent = Service.UXController.WorldAnchor;
UnityUtils.SetLayerRecursively(highlight.Root, 8);
this.buttonHighlight.UXCamera = Service.CameraManager.UXCamera;
float num = (float)depth / 2f;
float num2 = (float)width / 2f;
this.top = new Vector3(Units.BoardToWorldX(boardX - num2), 0f, Units.BoardToWorldZ(boardZ - num));
this.bottom = new Vector3(Units.BoardToWorldX(boardX + num2), 0f, Units.BoardToWorldZ(boardZ + num));
this.left = new Vector3(Units.BoardToWorldX(boardX - num2), 0f, Units.BoardToWorldZ(boardZ + num));
this.right = new Vector3(Units.BoardToWorldX(boardX + num2), 0f, Units.BoardToWorldZ(boardZ - num));
this.center = (this.left + this.right) / 2f;
this.cam = Service.CameraManager.MainCamera;
this.age = 0f;
this.UpdateHighlightPosition(0f);
Service.ViewTimeEngine.RegisterFrameTimeObserver(this);
this.buttonHighlight.Visible = true;
}
public override void Execute()
{
base.Execute();
Vector3 zero = Vector3.zero;
zero.x = Units.BoardToWorldX(this.boardX);
zero.z = Units.BoardToWorldX(this.boardZ);
IDataController dataController = Service.Get <IDataController>();
SpecialAttackTypeVO specialAttackTypeVO = dataController.Get <SpecialAttackTypeVO>(this.prepareArgs[0]);
SpecialAttack specialAttack = Service.Get <SpecialAttackController>().DeploySpecialAttack(specialAttackTypeVO, TeamType.Attacker, zero);
if (specialAttack != null)
{
List <IAssetVO> assets = new List <IAssetVO>();
ProjectileUtils.AddProjectileAssets(specialAttackTypeVO.ProjectileType, assets, dataController);
Service.Get <ProjectileViewManager>().LoadProjectileAssetsAndCreatePools(assets);
Service.Get <EventManager>().SendEvent(EventId.SpecialAttackDeployed, specialAttack);
}
this.parent.ChildComplete(this);
}
public EatResponse OnEvent(EventId id, object cookie)
{
if (id != EventId.BuildingQuickStashed)
{
if (id != EventId.UserLoweredBuilding)
{
if (id == EventId.BuildingViewReady)
{
EntityViewParams entityViewParams = (EntityViewParams)cookie;
if (this.IsBuildingStashed(entityViewParams.Entity))
{
GameObjectViewComponent gameObjectViewComp = entityViewParams.Entity.GameObjectViewComp;
TransformComponent transformComp = entityViewParams.Entity.TransformComp;
gameObjectViewComp.SetXYZ(Units.BoardToWorldX(transformComp.CenterX()), -1000f, Units.BoardToWorldZ(transformComp.CenterZ()));
}
}
}
else
{
Entity entity = (Entity)cookie;
if (entity != null)
{
Building buildingTO = entity.Get <BuildingComponent>().BuildingTO;
Position position = this.lastSavedMap.GetPosition(buildingTO.Key);
if ((position != null && this.HasBuildingMoved(buildingTO, position)) || (Service.GameStateMachine.CurrentState is WarBaseEditorState && position == null))
{
this.ShouldRevertMap = true;
}
}
}
}
else if (this.IsQuickStashModeEnabled)
{
SmartEntity smartEntity = (SmartEntity)cookie;
this.StashBuilding(smartEntity);
string uid = smartEntity.BuildingComp.BuildingTO.Uid;
Service.BuildingController.EnsureDeselectSelectedBuilding();
Service.UXController.HUD.BaseLayoutToolView.RefreshStashedBuildingCount(uid);
}
return(EatResponse.NotEaten);
}
private void ImpactAreaWithSplash(Bullet bullet)
{
int targetBoardX = bullet.TargetBoardX;
int targetBoardZ = bullet.TargetBoardZ;
int splashRadius = bullet.SplashVO.SplashRadius;
BoardCellDynamicArray cellsInSquare = Service.BoardController.Board.GetCellsInSquare(splashRadius, targetBoardX, targetBoardZ);
Dictionary <Entity, bool> dictionary = new Dictionary <Entity, bool>();
Vector3 targetWorldLocation = bullet.TargetWorldLocation;
for (int i = 0; i < cellsInSquare.Length; i++)
{
BoardCell boardCell = cellsInSquare.Array[i];
int chessboardDistance = BoardUtils.GetChessboardDistance(boardCell.X, boardCell.Z, targetBoardX, targetBoardZ);
int splashDamagePercent = bullet.SplashVO.GetSplashDamagePercent(chessboardDistance);
if (splashDamagePercent != 0)
{
ShieldGeneratorComponent activeShieldAffectingBoardPos = Service.ShieldController.GetActiveShieldAffectingBoardPos(boardCell.X, boardCell.Z);
if (activeShieldAffectingBoardPos != null && !bullet.ProjectileType.PassThroughShield && activeShieldAffectingBoardPos.Entity.Get <TeamComponent>().TeamType != bullet.OwnerTeam)
{
TransformComponent transformComponent = activeShieldAffectingBoardPos.Entity.Get <TransformComponent>();
Vector3 targetPos = new Vector3(Units.BoardToWorldX(transformComponent.CenterX()), transformComponent.CenterX(), Units.BoardToWorldZ(transformComponent.CenterZ()));
Vector3 zero = Vector3.zero;
if (Service.ShieldController.GetRayShieldIntersection(targetWorldLocation, targetPos, activeShieldAffectingBoardPos, out zero))
{
bullet.SetTargetWorldLocation(zero);
}
this.ImpactTargetFromSplashDamage((SmartEntity)activeShieldAffectingBoardPos.ShieldBorderEntity, bullet, splashDamagePercent, ref dictionary);
}
else if (boardCell.Children != null)
{
LinkedListNode <BoardItem> next;
for (LinkedListNode <BoardItem> linkedListNode = boardCell.Children.First; linkedListNode != null; linkedListNode = next)
{
next = linkedListNode.Next;
this.ImpactTargetFromSplashDamage((SmartEntity)linkedListNode.Value.Data, bullet, splashDamagePercent, ref dictionary);
}
}
}
}
}
private void DeployGroupAfterDelay(uint id, object cookie)
{
this.timers.Remove(id);
DefenseTroopGroup defenseTroopGroup = (DefenseTroopGroup)cookie;
TroopTypeVO troop = this.sdc.Get <TroopTypeVO>(defenseTroopGroup.TroopUid);
for (int i = 0; i < defenseTroopGroup.Quantity; i++)
{
this.DeployTroopGroup(i, troop, defenseTroopGroup);
}
if (this.waves[this.currentWaveIndex].Troops.Count == 0 && this.timers.Count == 0)
{
this.EndCurrentWave();
}
if (Service.CurrentPlayer.CampaignProgress.FueInProgress)
{
int boardX = 0;
int boardZ = 0;
DefensiveBattleController.GetBoardEdge(defenseTroopGroup.Direction, defenseTroopGroup.Range, out boardX, out boardZ);
this.AddCameraEvent(Units.BoardToWorldX(boardX), Units.BoardToWorldZ(boardZ), DefensiveCameraEventType.TroopSpawned);
}
}
public Vector3 MoveGameObject(GameObjectViewComponent view, PathView pathView, int troopWidth)
{
BoardCell <Entity> nextTurn = pathView.GetNextTurn();
if (nextTurn != null && pathView.TimeToTarget > 0f)
{
float num = 0f;
float num2 = 0f;
pathView.GetTroopClusterOffset(ref num, ref num2);
float num3 = Mathf.Min(pathView.TimeOnPathSegment / pathView.TimeToTarget, 1f);
Vector3 startPos = pathView.StartPos;
float num4 = (Units.BoardToWorldX(nextTurn.X) - startPos.x) * num3 + startPos.x + num;
float num5 = (Units.BoardToWorldX(nextTurn.Z) - startPos.z) * num3 + startPos.z + num2;
num4 += Units.BoardToWorldX((float)troopWidth / 2f);
num5 += Units.BoardToWorldX((float)troopWidth / 2f);
Transform mainTransform = view.MainTransform;
Vector3 result = new Vector3(num4 - mainTransform.position.x, 0f, num5 - mainTransform.position.z);
view.SetXYZ(num4, mainTransform.position.y, num5);
return(result);
}
return(Vector3.zero);
}
