protected virtual void Awake()
{
movingObject = gameObject;
movingEntity = GetComponent <MovingEntity>();
motor = GetComponent <Motor>();
tickManager = new TickManager();
}
protected override void Volatile_OnHeartBeat(EventArgs args)
{
if (SpellMenu["wardjump"].Cast <KeyBind>().CurrentValue&& TickManager.NoLag(2))
{
WardJump();
}
}
private async Task HandleCommand(SocketMessage messageParam)
{
if (!(messageParam is SocketUserMessage message))
{
return;
}
if (SettingsManager.GetBool("config", "moduleIRC"))
{
var module = TickManager.GetModule <IRCModule>();
module?.SendMessage(message.Channel.Id, message.Author.Id, message.Author.Username, message.Content);
}
if (SettingsManager.GetBool("config", "moduleTelegram"))
{
TickManager.GetModule <TelegramModule>()?.SendMessage(message.Channel.Id, message.Author.Id, message.Author.Username, message.Content);
}
int argPos = 0;
if (!(message.HasCharPrefix(SettingsManager.Get("config", "botDiscordCommandPrefix")[0], ref argPos) || message.HasMentionPrefix
(Client.CurrentUser, ref argPos)))
{
return;
}
var context = new CommandContext(Client, message);
await Commands.ExecuteAsync(context, argPos);
}
private static void Harass()
{
var target = TargetManager.Target(Q, DamageType.Magical);
if (SpellMenu["qth"].Cast <CheckBox>().CurrentValue&&
!SpellMenu["dontgrab" + target.ChampionName.ToLower()].Cast <CheckBox>().CurrentValue&&
Player.Distance(target) > Player.GetAutoAttackRange())
{
CastManager.Cast.Line.SingleTargetHero(Q, DamageType.Magical);
}
if (SpellMenu["eth"].Cast <CheckBox>().CurrentValue&& E.IsReady() && TickManager.NoLag(3))
{
var enemy = EntityManager.Heroes.Enemies.FirstOrDefault(e => Player.Distance(e) < 300);
if (enemy != null)
{
Orbwalker.DisableMovement = true;
Orbwalker.DisableAttacking = true;
E.Cast();
EloBuddy.Player.IssueOrder(GameObjectOrder.AttackUnit, enemy);
Orbwalker.DisableMovement = false;
Orbwalker.DisableAttacking = false;
}
}
}
public CombatManager(TickManager tickManager, CharactersManager charactersManager)
{
this.tickManager = tickManager;
this.charactersManager = charactersManager;
tickManager.OnTick += TickManager_OnTick;
}
private static void Harass()
{
var target = TargetManager.Target(_q, DamageType.Magical);
if (!_q.IsReady() || !TickManager.NoLag(1) || !SpellMenu["qth"].Cast <CheckBox>().CurrentValue ||
target == null || !target.IsValidTarget(_q.Range))
{
return;
}
if (SpellMenu["qthcc"].Cast <CheckBox>().CurrentValue&& !_avoidSpam)
{
var targetcc = target.Buffs.Where(b => b.IsKnockup || b.IsRoot || b.IsStunOrSuppressed).ToList();
if (!targetcc.Any())
{
return;
}
var longest = (int)targetcc.Max(cc => cc.EndTime);
Core.DelayAction(() => StackCC_Part2(target), longest - (int)Game.Time);
_avoidSpam = true;
}
else
{
_q.Cast();
}
}
static void Postfix(TickManager __instance)
{
if (GameComponent.NextEventTick > 0 && __instance.TicksGame >= GameComponent.NextEventTick)
{
GameComponent.DecideAndDoEvent();
}
}
private static void Harass()
{
var qtarget = TargetManager.Target(Q, DamageType.Magical);
if (!Q.IsReady() || !TickManager.NoLag(1) || !SpellMenu["qth"].Cast <CheckBox>().CurrentValue ||
qtarget == null || !qtarget.IsValidTarget(Q.Range))
{
return;
}
if (SpellMenu["qth"].Cast <CheckBox>().CurrentValue&& !_avoidSpam)
{
_avoidSpam = true;
}
{
Q.Cast(qtarget);
}
var etarget = TargetManager.Target(E, DamageType.Magical);
if (!E.IsReady() || !TickManager.NoLag(3) || !SpellMenu["eth"].Cast <CheckBox>().CurrentValue)
{
return;
}
{
if (etarget != null)
{
E.Cast();
}
}
}
static bool Prefix(TickManager __instance, ref float __result)
{
if (Multiplayer.Client == null)
{
return(true);
}
if (__instance.CurTimeSpeed == TimeSpeed.Paused)
{
__result = 0;
}
else if (__instance.slower.ForcedNormalSpeed)
{
__result = 1;
}
else if (__instance.CurTimeSpeed == TimeSpeed.Fast)
{
__result = 3;
}
else if (__instance.CurTimeSpeed == TimeSpeed.Superfast)
{
__result = 6;
}
else
{
__result = 1;
}
return(false);
}
public override void CreateRenderer()
{
TickFunction WindowTick = new TickFunction
{
TickFunc = UpdateInput,
TickPriority = TickFunction.HighPriority,
CanTick = true,
};
IEngine.Instance.GameThreadTickManager.AddTick(WindowTick);
RenderStartFunc.TickFunc = RenderStart;
TickManager.AddTick(RenderStartFunc);
PreRenderFunc.TickFunc = PreRender;
TickManager.AddTick(PreRenderFunc);
SortRendererFunc.TickFunc = SortRenderer;
TickManager.AddTick(SortRendererFunc);
DoRenderFunc.TickFunc = RenderAll;
TickManager.AddTick(DoRenderFunc);
RenderEndFunc.TickFunc = RenderEnd;
TickManager.AddTick(RenderEndFunc);
SDL.SDL_SetHint(SDL.SDL_HINT_WINDOWS_DISABLE_THREAD_NAMING, "1");
SDL.SDL_Init(SDL.SDL_INIT_EVERYTHING);
}
private async Task HandleCommand(SocketMessage messageParam)
{
await AsyncHelper.RedirectToThreadPool();
if (!(messageParam is SocketUserMessage message))
{
return;
}
if (SettingsManager.Settings.Config.ModuleIRC)
{
var module = TickManager.GetModule <IRCModule>();
module?.SendMessage(message.Channel.Id, message.Author.Id, message.Author.Username, message.Content);
}
if (SettingsManager.Settings.Config.ModuleTelegram)
{
var name = APIHelper.DiscordAPI.GetGuild().GetUser(message.Author.Id)?.Nickname ?? message.Author.Username;
TickManager.GetModule <TelegramModule>()?.SendMessage(message.Channel.Id, message.Author.Id, name, message.Content);
}
int argPos = 0;
if (!(message.HasCharPrefix(SettingsManager.Settings.Config.BotDiscordCommandPrefix[0], ref argPos) || message.HasMentionPrefix
(Client.CurrentUser, ref argPos)))
{
return;
}
var context = new CommandContext(Client, message);
await Commands.ExecuteAsync(context, argPos, null);
}
static void Postfix(Rect timerRect)
{
long until_unpause = SafePause.MillisecondsUntilCanUnpause();
TickManager mgr = Find.TickManager;
if (SafePause.speed_this_tick == TimeSpeed.Paused &&
mgr.CurTimeSpeed != TimeSpeed.Paused)
{
if (until_unpause != 0)
{
mgr.CurTimeSpeed = TimeSpeed.Paused;
}
SafePause.last_unpause_input = Stopwatch.StartNew();
}
if (until_unpause != 0 && mgr.CurTimeSpeed == TimeSpeed.Paused)
{
Vector2 line_start = timerRect.position;
line_start.x += TimeControls.TimeButSize.x;
line_start.y += TimeControls.TimeButSize.y / 2f;
float total_width = TimeControls.TimeButSize.x * 3;
Widgets.DrawLineHorizontal(line_start.x, line_start.y, total_width);
float timeout_ratio = 1f - ((float)until_unpause / (float)SafePauseSettings.max_timeout);
GUI.DrawTexture(new Rect(line_start.x, line_start.y, total_width * timeout_ratio, 1f), TimeoutTex);
}
}
static void Postfix(TickManager __instance)
{
if (__instance.Paused)
{
SafePause.last_pause = Stopwatch.StartNew();
}
}
protected override void updateTransform(float positionAvg, float rotationAvg)
{
if (_cameraTransform == null || followObject == null)
{
return;
}
lookAtPosition = getLookatPosition();
newPosition = getPosition();
if (_shakeOffset != Vector3.zero)
{
this._cameraTransform.position = newPosition + _shakeOffset;
}
else
{
newPosition = Vector3.Lerp(this._cameraTransform.position, newPosition, positionAvg);
rotation = Quaternion.LookRotation(lookAtPosition, Vector3.up);
this._cameraTransform.position = newPosition;
this._cameraTransform.rotation = Quaternion.Lerp(this._cameraTransform.rotation, rotation, rotationAvg);
}
TickManager.LateCameraUpdate();
}
protected virtual void LateUpdate()
{
if (this._cameraTransform == null)
{
return;
}
if (!this.followObject || this.isCameraFocusing)
{
TickManager.LateCameraUpdate();
return;
}
if (this._isNeedResetDistance)
{
float deltaSlepTime = Time.time - this._startResetSlepTime;
if (deltaSlepTime > this.resetTime)
{
deltaSlepTime = this.resetTime;
this._isNeedResetDistance = false;
}
this.distance = Mathf.Lerp(this.distance, this.toDistance, deltaSlepTime / this.resetTime);
}
float t = Time.fixedDeltaTime;
this.updateTransform(positionAvgSpeed * t, rotationAvgSpeed * t);
}
private static void CastSpellLogic(bool useQ = false, bool useW = false, bool useE = false,
Obj_AI_Base target = null)
{
if (useQ)
{
var enemy = TargetSelector.GetTarget(Q.Range, DamageType.Magical);
if (enemy != null && enemy.IsValidTarget(Q.Range))
{
Q.Cast();
}
}
if (useW)
{
if (SpellMenu["wtc"].Cast <CheckBox>().CurrentValue&& Player.CountEnemiesInRange(700) >= 2)
{
W.Cast();
}
}
if (useE && E.IsReady() && TickManager.NoLag(3))
{
var enemy = TargetSelector.GetTarget(E.Range, DamageType.Mixed);
if (enemy != null && enemy.IsValidTarget(E.Range))
{
E.Cast(enemy);
}
}
}
private void Update()
{
matrix.Set(coordinates, this);
if (TickManager.GetTickComplete())
{
if (isTouchingPlayer && summon == null)
{
SoundEffectsManager.Play("Snap");
Instantiate(go);
fiesta.material = second;
isTouchingPlayer = false;
}
}
if (summon)
{
target = new Vector3(0, -0.09f, 0);
}
else if (fiesta.material = second)
{
fiesta.material = first;
target = Vector3.zero;
}
else
{
target = Vector3.zero;
}
model.transform.localPosition = Vector3.SmoothDamp(model.transform.localPosition, target, ref velocity, 0.05f);
}
public void stop()
{
mPlaying = false;
currentFrame = 0;
TickManager.remove(advanceTime);
}
private void JungleClear()
{
var camp = EntityManager.MinionsAndMonsters.Monsters.Where(m => Player.Distance(m) < E.Range * 1.2);
Obj_AI_Minion target = null;
foreach (var monster in camp)
{
if (target == null)
{
target = monster;
}
else if (monster.MinionLevel > target.MinionLevel)
{
target = monster;
}
}
if (target == null)
{
return;
}
if (E.IsReady() && SpellMenu["etj"].Cast <CheckBox>().CurrentValue&& TickManager.NoLag(3))
{
E.Cast(target);
}
if (Q.IsReady() && SpellMenu["qtj"].Cast <CheckBox>().CurrentValue&& TickManager.NoLag(3))
{
Q.Cast();
}
}
public static bool DoSingleTick(TickManager __instance)
{
//RimThreaded.currentInstance = __instance;
if (!DebugSettings.fastEcology)
{
__instance.ticksGameInt++;
}
else
{
__instance.ticksGameInt += 2000;
}
Shader.SetGlobalFloat(ShaderPropertyIDs.GameSeconds, __instance.TicksGame.TicksToSeconds());
RimThreaded.MainThreadWaitLoop(__instance);
if (DebugViewSettings.logHourlyScreenshot && Find.TickManager.TicksGame >= __instance.lastAutoScreenshot + 2500)
{
ScreenshotTaker.QueueSilentScreenshot();
__instance.lastAutoScreenshot = Find.TickManager.TicksGame / 2500 * 2500;
}
Debug.developerConsoleVisible = false;
return(false);
}
public override async Task Run(object prm)
{
if (IsRunning)
{
return;
}
if (Settings.Config.ModuleAuthWeb && TickManager.GetModule <WebAuthModule>().IsEntityInitFailed)
{
return;
}
IsRunning = true;
var manual = (bool?)prm ?? false;
try
{
if (Settings.WebAuthModule.AuthCheckUnregisteredDiscordUsers)
{
await CheckDiscordUsers(manual);
}
await CheckDBUsers(manual);
}
finally
{
IsRunning = false;
}
}
internal GridSystem(int width, int height, int id, City parentCity, TickManager tickMan, Vector3 worldGridPosition)
{
Id = id;
ParentCity = parentCity;
Width = width;
Height = height;
_tickManager = tickMan;
Tiles = new GridTile[Width][];
//Initialize Tiles array with empty tiles:
for (int x = 0; x < Width; x++)
{
Tiles[x] = new GridTile[Height];
for (int y = 0; y < Height; y++)
{
Tiles[x][y] = new GridTile(new Vector2Int(x, y), this);
}
}
Residents = new List <Resident>();
_gridResources = new Dictionary <Type, List <ResourceData> >();
WorldGrid = CreateWorldGrid(worldGridPosition);
}
public override void SpawnSetup(Map map, bool respawningAfterLoad)
{
base.SpawnSetup(map, respawningAfterLoad);
tickMan = Find.TickManager;
powerComp = GetComp <CompPowerTrader>();
LongEventHandler.ExecuteWhenFinished(GetGraphicArray);
}
private static void AutoCast()
{
if (SpellMenu["user"].Cast <CheckBox>().CurrentValue&&
Player.CountEnemiesInRange(_w.Range) >= SpellMenu["ramount"].Cast <Slider>().CurrentValue &&
(Player.Health / Player.MaxHealth) * 100 >= SpellMenu["rhealth"].Cast <Slider>().CurrentValue&&
TickManager.NoLag(4))
{
_r.Cast();
}
if (SpellMenu["autoe"].Cast <CheckBox>().CurrentValue&&
Player.HealthPercent <SpellMenu["minhp"].Cast <Slider>().CurrentValue &&
Player.ManaPercent> SpellMenu["minmana"].Cast <Slider>().CurrentValue&&
Orbwalker.ActiveModesFlags != Orbwalker.ActiveModes.Combo && !Player.IsRecalling() &&
!InFountain(Player) && TickManager.NoLag(3))
{
_e.Cast();
}
if (SpellMenu["awq"].Cast <CheckBox>().CurrentValue&& _w.IsReady() && _q.IsReady())
{
var enemies = EntityManager.Heroes.Enemies;
var target = enemies.OrderByDescending(QHits).First();
if (QHits(target) > SpellMenu["awqa"].Cast <Slider>().CurrentValue&& target.IsValidTarget(_w.Range * (float)0.95) &&
Player.Mana > (ManaManager.GetMana(SpellSlot.Q) + ManaManager.GetMana(SpellSlot.W)) &&
TickManager.NoLag(2))
{
_w.Cast(target);
}
}
}
private static void Harass()
{
if (SpellMenu["qth"].Cast <CheckBox>().CurrentValue)
{
if (SpellMenu["qstun"].Cast <CheckBox>().CurrentValue)
{
var target = TargetManager.Target(Q, DamageType.Magical);
if (target.HasBuff("brandablaze"))
{
CastManager.Cast.Line.SingleTargetHero(Q, DamageType.Magical);
}
}
else
{
CastManager.Cast.Line.SingleTargetHero(Q, DamageType.Magical);
}
}
if (SpellMenu["wth"].Cast <CheckBox>().CurrentValue)
{
CastManager.Cast.Circle.Optimized(W, DamageType.Magical);
}
if (SpellMenu["eth"].Cast <CheckBox>().CurrentValue&& TickManager.NoLag(3))
{
var target = TargetManager.Target(E, DamageType.Magical);
if (target.IsValidTarget())
{
E.Cast(target);
}
}
}
// Update is called once per frame
protected override void Update()
{
if (renderSupport == null)
{
return;
}
bool isResize = false;
if (_stage.stageWidth != Screen.width)
{
_stage.stageWidth = Screen.width;
isResize = true;
}
if (_stage.stageHeight != Screen.height)
{
_stage.stageHeight = Screen.height;
isResize = true;
}
if (isResize)
{
ResizeMananger.getInstance().resize(Screen.width, Screen.height);
}
updateInput();
//float deltaTime = 1.0f/60;
//UnityEngine.Time.DeltaTime;
TickManager.getInstance().tick();
renderSupport.nextFrame();
_stage.render(renderSupport, 1.0f);
renderSupport.finishQuadBatch();
}
private static void JungleClear()
{
if (SpellMenu["qtj"].Cast <CheckBox>().CurrentValue&& TickManager.NoLag(1))
{
if (
EntityManager.MinionsAndMonsters.Monsters.Any(
m => m.Distance(Player) < Q.Range && m.HasBuff("brandablaze")))
{
Q.Cast(EntityManager.MinionsAndMonsters.Monsters.Where(
m =>
m.Distance(Player) < Q.Range && m.HasBuff("brandablaze") &&
Q.GetPrediction(m).HitChance > HitChance.High).OrderByDescending(m => m.MinionLevel).First());
}
}
if (SpellMenu["wtj"].Cast <CheckBox>().CurrentValue&& TickManager.NoLag(2))
{
if (EntityManager.MinionsAndMonsters.Monsters.Any(
m => m.Distance(Player) < W.Range + W.Radius))
{
var pos = MinionManager.GetBestCircularFarmLocation(EntityManager.MinionsAndMonsters.Monsters.Where(
m => m.Distance(Player) < W.Range).Select(m => m.Position.To2D()).ToList(), W.Radius, W.Range);
W.Cast(pos.Position.To3D());
}
}
if (SpellMenu["etj"].Cast <CheckBox>().CurrentValue&& TickManager.NoLag(3))
{
if (EntityManager.MinionsAndMonsters.Monsters.Any(
m => m.Distance(Player) < E.Range))
{
E.Cast(EntityManager.MinionsAndMonsters.Monsters.Where(
m =>
m.Distance(Player) < E.Range).OrderByDescending(m => m.MinionLevel).First());
}
}
}
public override void Tick()
{
if (mobSummoned)
{
TickManager.Recalculate();
mobSummoned = false;
}
}
private static void Flee()
{
Orbwalker.MoveTo(Game.CursorPos);
if (TickManager.NoLag(2) && W.IsReady())
{
W.Cast(Player);
}
}
public static TickManager getInstance()
{
if (ins == null)
{
ins = new TickManager();
}
return(ins);
}
protected virtual void Awake()
{
movingObject = gameObject;
movingEntity = GetComponent<MovingEntity>();
motor = GetComponent<Motor>();
tickManager = new TickManager();
}
protected virtual void Awake()
{
tickManager = (TickManager)FindObjectOfType(typeof(TickManager));
tickManager.lateTick += new Action(LateFixedUpdate);
startTime = Time.time;
gameObject.AddComponent<AudioSource>();
audio.clip = Resources.Load<AudioClip>("sound/ground_impact");
audio.maxDistance = 100000;
audio.rolloffMode = AudioRolloffMode.Linear;
audio.volume = 1f;
state = GameState.Instance;
style = new GUIStyle();
style.normal.textColor = Color.red;
style.fontSize = 16;
LoadInfo();
}
