// Token: 0x0600020D RID: 525 RVA: 0x0001011C File Offset: 0x0000E31C
private void OnUnitAdded(Unit9 unit)
{
try
{
if (unit.IsLaneCreep && unit.Team != this.ownerTeam)
{
if (!unit.BaseUnit.IsSpawned && unit.BaseUnit.IsAlive)
{
LanePosition lane = this.lanePaths.GetCreepLane(unit);
if (lane != LanePosition.Unknown)
{
CreepWave creepWave = this.creepWaves.SingleOrDefault((CreepWave x) => !x.IsSpawned && x.Lane == lane);
if (creepWave == null)
{
this.creepWaves.Add(creepWave = new CreepWave(lane, this.lanePaths.GetLanePath(lane)));
}
creepWave.Creeps.Add(unit);
}
}
}
}
catch (Exception exception)
{
Logger.Error(exception, null);
}
}
private CharacterBattle GetNextCharacterBattle(LanePosition lanePosition, bool moveUp, bool isPlayerTeam)
{
List <CharacterBattle> characterBattleList = GetAliveTeamCharacterBattleList(isPlayerTeam);
if (characterBattleList.Count == 0)
{
return(null);
}
CharacterBattle characterBattle = null;
do
{
// Get next lane position
lanePosition = GetNextLanePosition(lanePosition, moveUp);
// Find character at that position
characterBattle = GetCharacterBattleAt(lanePosition, isPlayerTeam);
if (characterBattle != null && characterBattle.IsDead())
{
characterBattle = null; // Ignore dead
}
} while (characterBattle == null);
return(characterBattle);
}
private void GetObstacleFromPool(LanePosition lanePosition, ObstacleType obstacleType)
{
GameObject obstacle = ObstaclePoolController.Instance.RequestObstacle(obstacleType);
obstacle.GetComponent <Obstacle>().SetSpeed(speedAmountToAdd);
obstacle.transform.position = laneSpawners[(int)lanePosition].transform.position;
}
public float GetActiveTreeDistance(NetInfo prefab, LanePosition position)
{
var segmentData = SegmentDataManager.Instance.GetActiveOptions(prefab);
var result = 0f;
if (segmentData != null && segmentData.Features.IsFlagSet(SegmentData.FeatureFlags.RepeatDistances))
{
switch (position)
{
case LanePosition.Left:
result = segmentData.RepeatDistances.x;
break;
case LanePosition.Middle:
result = segmentData.RepeatDistances.y;
break;
case LanePosition.Right:
result = segmentData.RepeatDistances.z;
break;
default:
throw new ArgumentOutOfRangeException(nameof(position));
}
}
return(result > 0f ? result : GetDefaultTreeDistance(prefab, position));
}
private void CanceledLaneSwitch()
{
if (directionBetweenLanes == ChangingDirection.Left)
{
if (lane == LanePosition.Left)
{
lane = LanePosition.Mid;
}
else
{
lane = LanePosition.Right;
}
}
else
{
if (lane == LanePosition.Right)
{
lane = LanePosition.Mid;
}
else
{
lane = LanePosition.Left;
}
}
}
private void MoveRight()
{
if (inMove)
{
return;
}
if (lane == LanePosition.Right)
{
return;
}
if (lane == LanePosition.Mid)
{
lane = LanePosition.Right;
}
else
{
lane = LanePosition.Mid;
}
directionBetweenLanes = ChangingDirection.Right;
aimPositionX += distanceBetweenLanes;
StartMovement();
animator.SetBool(leftMoveAnimation, true);
lastAnimation = leftMoveAnimation;
}
public float GetActiveTreeDistance(NetInfo prefab, LanePosition position)
{
var segmentData = SegmentDataManager.Instance.GetActiveOptions(prefab);
var result = 0f;
if (segmentData != null && segmentData.Features.IsFlagSet(SegmentData.FeatureFlags.RepeatDistances))
{
switch (position)
{
case LanePosition.Left:
result = segmentData.RepeatDistances.x;
break;
case LanePosition.Middle:
result = segmentData.RepeatDistances.y;
break;
case LanePosition.Right:
result = segmentData.RepeatDistances.z;
break;
default:
throw new ArgumentOutOfRangeException(nameof(position));
}
}
return result > 0f ? result : GetDefaultTreeDistance(prefab, position);
}
public static LanePosition GetNextLanePosition(LanePosition lanePosition, bool moveUp)
{
if (moveUp)
{
switch (lanePosition)
{
default:
case LanePosition.Middle: return(LanePosition.Up);
case LanePosition.Up: return(LanePosition.Top);
case LanePosition.Top: return(LanePosition.Bottom);
case LanePosition.Bottom: return(LanePosition.Down);
case LanePosition.Down: return(LanePosition.Middle);
}
}
else
{
switch (lanePosition)
{
default:
case LanePosition.Middle: return(LanePosition.Down);
case LanePosition.Down: return(LanePosition.Bottom);
case LanePosition.Bottom: return(LanePosition.Top);
case LanePosition.Top: return(LanePosition.Up);
case LanePosition.Up: return(LanePosition.Middle);
}
}
}
// Token: 0x060001EE RID: 494 RVA: 0x0000F954 File Offset: 0x0000DB54
public CreepWave(LanePosition lane, Vector3[] path)
{
this.Lane = lane;
this.Path = path;
this.pathLength = this.Path.Length;
this.endPosition = path[this.pathLength - 1];
this.predictedPosition = path[0];
}
private void InitNoteMesh(int noteTextureId, LanePosition position, float verticalOffset)
{
float uvStart = (float)noteTextureId / NoteTextureCount;
float uvEnd = (float)(noteTextureId + 1) / NoteTextureCount;
var noteMesh = Instantiate(NoteMeshPrefab); //new generic note mesh
noteMesh.transform.parent = transform; //parent to us
noteMesh.transform.localPosition = new Vector3(position.Center, 0, verticalOffset); //offset from us
noteMesh.GetComponent <NoteMeshSetup>().Init(position.Width, uvStart, uvEnd); //generate mesh
}
private CharacterBattle GetCharacterBattleAt(LanePosition lanePosition, bool isPlayerTeam)
{
foreach (CharacterBattle characterBattle in characterBattleList)
{
if (characterBattle.IsPlayerTeam() == isPlayerTeam && characterBattle.GetLanePosition() == lanePosition)
{
return(characterBattle);
}
}
return(null);
}
public static bool IsCorrectSide(this LanePosition position, float lanePosition)
{
switch (position)
{
case LanePosition.Left: return(lanePosition < 0f);
case LanePosition.Middle: return(Mathf.Approximately(lanePosition, 0f));
case LanePosition.Right: return(lanePosition > 0f);
default: throw new ArgumentOutOfRangeException(nameof(position), position, null);
}
}
public static SegmentData.FeatureFlags ToTreeFeatureFlag(this LanePosition position)
{
switch (position)
{
case LanePosition.Left: return(SegmentData.FeatureFlags.TreeLeft);
case LanePosition.Middle: return(SegmentData.FeatureFlags.TreeMiddle);
case LanePosition.Right: return(SegmentData.FeatureFlags.TreeRight);
default: throw new ArgumentOutOfRangeException(nameof(position), position, null);
}
}
public static string GetDescription(this LanePosition position)
{
switch (position)
{
case LanePosition.Left: return("Left");
case LanePosition.Middle: return("Middle");
case LanePosition.Right: return("Right");
default: throw new ArgumentOutOfRangeException(nameof(position), position, null);
}
}
public void Start(CameraFollow cameraFollow)
{
this.cameraFollow = cameraFollow;
cameraFollow.Setup(() => Vector3.zero, () => 50f, true, true);
cameraFollow.SetCameraMoveSpeed(10f);
cameraFollow.SetCameraZoomSpeed(10f);
ResetCamera();
// Set up Battle Scene
foreach (Character character in GameData.characterList)
{
if (character.isInPlayerTeam)
{
LanePosition lanePosition;
switch (character.type)
{
default:
case Character.Type.Player:
lanePosition = LanePosition.Middle;
break;
case Character.Type.Tank:
lanePosition = LanePosition.Down;
break;
case Character.Type.Healer:
lanePosition = LanePosition.Up;
break;
}
SpawnCharacter(character.type, lanePosition, true, character.stats);
}
}
GameData.EnemyEncounter enemyEncounter = BattleHandler.enemyEncounter;
for (int i = 0; i < enemyEncounter.enemyBattleArray.Length; i++)
{
GameData.EnemyEncounter.EnemyBattle enemyBattle = enemyEncounter.enemyBattleArray[i];
SpawnCharacter(enemyBattle.characterType, enemyBattle.lanePosition, false,
new Character(enemyBattle.characterType).stats);
}
SetActiveCharacterBattle(GetAliveTeamCharacterBattleList(true)[0]);
SetSelectedTargetCharacterBattle(GetAliveTeamCharacterBattleList(false)[0]);
lastPlayerActiveLanePosition = GetAliveTeamCharacterBattleList(true)[0].GetLanePosition();
lastEnemyActiveLanePosition =
GetNextLanePosition(GetAliveTeamCharacterBattleList(false)[0].GetLanePosition(), true);
state = State.WaitingForPlayer;
}
public void SetTree(NetInfo prefab, LanePosition position, TreeInfo tree)
{
var newSegmentData = new SegmentData(SegmentDataManager.Instance.GetActiveOptions(prefab));
if (tree != GetDefaultTree(prefab, position))
{
newSegmentData.SetPrefabFeature(position.ToTreeFeatureFlag(), tree);
}
else
{
newSegmentData.UnsetFeature(position.ToTreeFeatureFlag());
}
SegmentDataManager.Instance.SetActiveOptions(prefab, newSegmentData);
}
public static float GetLaneDelay(LanePosition lane, Team team)
{
switch (lane)
{
case LanePosition.Easy:
return(team == Team.Radiant ? 0.3f : 0.5f);
case LanePosition.Middle:
return(team == Team.Radiant ? 0.5f : 0.4f);
case LanePosition.Hard:
return(team == Team.Radiant ? 0.1f : 0.7f);
default:
return(0);
}
}
public static Vector3 GetPosition(LanePosition lanePosition, bool isPlayerTeam)
{
float playerTeamMultiplier = isPlayerTeam ? -1f : 1f;
switch (lanePosition)
{
default:
case LanePosition.Middle: return(new Vector3(playerTeamMultiplier * 50f, 0));
case LanePosition.Up: return(new Vector3(playerTeamMultiplier * 60f, +20));
case LanePosition.Down: return(new Vector3(playerTeamMultiplier * 60f, -20));
case LanePosition.Top: return(new Vector3(playerTeamMultiplier * 70f, +35));
case LanePosition.Bottom: return(new Vector3(playerTeamMultiplier * 70f, -35));
}
}
public TreeInfo GetActiveTree(NetInfo prefab, LanePosition position)
{
var segmentData = SegmentDataManager.Instance.GetActiveOptions(prefab);
if (segmentData == null || !segmentData.Features.IsFlagSet(position.ToTreeFeatureFlag()))
{
return GetDefaultTree(prefab, position);
}
else
{
switch (position)
{
case LanePosition.Left: return segmentData.TreeLeftPrefab;
case LanePosition.Middle: return segmentData.TreeMiddlePrefab;
case LanePosition.Right: return segmentData.TreeRightPrefab;
default: throw new ArgumentOutOfRangeException(nameof(position));
}
}
}
private static void ProcessChannelNotes(Match match, int barOffset, BpmGraph barToBeat, BpmGraph bpmGraph,
Dictionary <int, List <PartialData> > channelData)
{
int barNum = ParseMmm(match.Groups[1]) + barOffset;
int lane = ParseXY(match.Groups[2]);
int channel = ParseXY(match.Groups[3]);
ProcessNotes(match.Groups[4], (barOff, type, width) =>
{
double beat = barToBeat.BeatAt(barNum + barOff);
var time = bpmGraph.FromBeat(beat);
var pos = new LanePosition(lane * 2, width * 2);
if (!channelData.ContainsKey(channel))
{
channelData.Add(channel, new List <PartialData>());
}
channelData[channel].Add(new PartialData(type, pos, time));
});
}
public TreeInfo GetActiveTree(NetInfo prefab, LanePosition position)
{
var segmentData = SegmentDataManager.Instance.GetActiveOptions(prefab);
if (segmentData == null || !segmentData.Features.IsFlagSet(position.ToTreeFeatureFlag()))
{
return(GetDefaultTree(prefab, position));
}
else
{
switch (position)
{
case LanePosition.Left: return(segmentData.TreeLeftPrefab);
case LanePosition.Middle: return(segmentData.TreeMiddlePrefab);
case LanePosition.Right: return(segmentData.TreeRightPrefab);
default: throw new ArgumentOutOfRangeException(nameof(position));
}
}
}
public bool HasTrees(NetInfo prefab, LanePosition position)
{
if (prefab.m_lanes == null)
{
return(false);
}
foreach (var lane in prefab.m_lanes)
{
if (lane?.m_laneProps?.m_props != null && position.IsCorrectSide(lane.m_position))
{
foreach (var laneProp in lane.m_laneProps.m_props)
{
if (laneProp?.m_finalTree != null && _availableStreetLights.Contains(laneProp.m_finalProp))
{
return(true);
}
}
}
}
return(false);
}
public float GetDefaultTreeDistance(NetInfo prefab, LanePosition position)
{
if (prefab.m_lanes == null)
{
return(-1f);
}
foreach (var lane in prefab.m_lanes)
{
if (lane?.m_laneProps?.m_props != null && position.IsCorrectSide(lane.m_position))
{
foreach (var laneProp in lane.m_laneProps.m_props)
{
if (laneProp?.m_finalTree != null)
{
return(laneProp.m_repeatDistance);
}
}
}
}
return(-1f);
}
public TreeInfo GetDefaultTree(NetInfo prefab, LanePosition position)
{
if (prefab.m_lanes == null)
{
return(null);
}
foreach (var lane in prefab.m_lanes)
{
if (lane?.m_laneProps?.m_props != null && position.IsCorrectSide(lane.m_position))
{
foreach (var laneProp in lane.m_laneProps.m_props)
{
if (laneProp?.m_finalTree != null)
{
return(laneProp.m_finalTree);
}
}
}
}
return(null);
}
public void SetTreeDistance(NetInfo prefab, LanePosition position, float val)
{
var newSegmentData = new SegmentData(SegmentDataManager.Instance.GetActiveOptions(prefab));
var distanceVector = newSegmentData.RepeatDistances;
var value = Mathf.Abs(val - GetDefaultTreeDistance(prefab, position)) > .01f ? val : 0f;
switch (position)
{
case LanePosition.Left:
distanceVector.x = value;
break;
case LanePosition.Middle:
distanceVector.y = value;
break;
case LanePosition.Right:
distanceVector.z = value;
break;
default:
throw new ArgumentOutOfRangeException(nameof(position));
}
if (distanceVector != Vector4.zero)
{
newSegmentData.SetStructFeature(SegmentData.FeatureFlags.RepeatDistances, distanceVector);
}
else
{
newSegmentData.UnsetFeature(SegmentData.FeatureFlags.RepeatDistances);
}
SegmentDataManager.Instance.SetActiveOptions(prefab, newSegmentData);
}
public void SetTreeDistance(NetInfo prefab, LanePosition position, float val)
{
var newSegmentData = new SegmentData(SegmentDataManager.Instance.GetActiveOptions(prefab));
var distanceVector = newSegmentData.RepeatDistances;
var value = Mathf.Abs(val - GetDefaultTreeDistance(prefab, position)) > .01f ? val : 0f;
switch (position)
{
case LanePosition.Left:
distanceVector.x = value;
break;
case LanePosition.Middle:
distanceVector.y = value;
break;
case LanePosition.Right:
distanceVector.z = value;
break;
default:
throw new ArgumentOutOfRangeException(nameof(position));
}
if (distanceVector != Vector4.zero)
{
newSegmentData.SetStructFeature(SegmentData.FeatureFlags.RepeatDistances, distanceVector);
}
else
{
newSegmentData.UnsetFeature(SegmentData.FeatureFlags.RepeatDistances);
}
SegmentDataManager.Instance.SetActiveOptions(prefab, newSegmentData);
}
public static float GetDefaultRepeatDistance(NetInfo prefab, LanePosition position)
{
return(NetUtils.GetMatchingLaneProp(prefab, laneProp => laneProp.m_finalTree != null, position)?.m_repeatDistance ?? 20f);
}
public TreePanelController(LanePosition position)
{
Position = position;
}
public bool HasTrees(NetInfo prefab, LanePosition position)
{
if (prefab.m_lanes == null) return false;
foreach (var lane in prefab.m_lanes)
if (lane?.m_laneProps?.m_props != null && position.IsCorrectSide(lane.m_position))
foreach (var laneProp in lane.m_laneProps.m_props)
{
if (laneProp?.m_finalTree != null && _availableStreetLights.Contains(laneProp.m_finalProp)) return true;
}
return false;
}
public TreeInfo GetDefaultTree(NetInfo prefab, LanePosition position)
{
if (prefab.m_lanes == null) return null;
foreach (var lane in prefab.m_lanes)
if (lane?.m_laneProps?.m_props != null && position.IsCorrectSide(lane.m_position))
foreach (var laneProp in lane.m_laneProps.m_props)
{
if (laneProp?.m_finalTree != null) return laneProp.m_finalTree;
}
return null;
}
public float GetDefaultTreeDistance(NetInfo prefab, LanePosition position)
{
if (prefab.m_lanes == null) return -1f;
foreach (var lane in prefab.m_lanes)
if (lane?.m_laneProps?.m_props != null && position.IsCorrectSide(lane.m_position))
foreach (var laneProp in lane.m_laneProps.m_props)
{
if (laneProp?.m_finalTree != null) return laneProp.m_repeatDistance;
}
return -1f;
}
public Vector3[] GetLanePath(LanePosition lane)
{
return(this.Lanes[lane]);
}
public AirArrow(NoteTime time, LanePosition position, bool isUp, int arrowShift) : base(time, position)
{
IsUp = isUp;
ArrowShift = arrowShift;
}
public static TreeInfo GetDefaultTree(NetInfo prefab, LanePosition position)
{
return(NetUtils.GetMatchingLaneProp(prefab, laneProp => laneProp.m_finalTree != null, position)?.m_finalTree);
}
public TreeModifier(LanePosition position, TreeInfo tree = null, float repeatDistance = 20) : base(NetworkSkinModifierType.Tree)
{
Position = position;
Tree = tree;
RepeatDistance = repeatDistance;
}
public HeldNote(NoteTime time, LanePosition position, SlidePoint[] slidePoints) : base(time, position)
{
SlidePoints = slidePoints;
}
public void SetTree(NetInfo prefab, LanePosition position, TreeInfo tree)
{
var newSegmentData = new SegmentData(SegmentDataManager.Instance.GetActiveOptions(prefab));
if (tree != GetDefaultTree(prefab, position))
{
newSegmentData.SetPrefabFeature(position.ToTreeFeatureFlag(), tree);
}
else
{
newSegmentData.UnsetFeature(position.ToTreeFeatureFlag());
}
SegmentDataManager.Instance.SetActiveOptions(prefab, newSegmentData);
}
