static bool OnToggle(UnityModManager.ModEntry modEntry, bool value)
{
if (enabled == value)
{
return(true);
}
enabled = value;
if (enabled)
{
harmonyInstance = HarmonyInstance.Create(modEntry.Info.Id);
harmonyInstance.PatchAll(Assembly.GetExecutingAssembly());
ModMenu.Instance.gameObject.AddComponent <XLShredRespawnNearBail>();
RespawnData respawnData = PlayerController.Instance.respawn.gameObject.AddComponent <RespawnData>();
respawnData.RespawnComponent = PlayerController.Instance.respawn;
XLShredDataRegistry.SetData("kiwi.XLShredRespawnNearBail", "isRespawnNearBailActive", settings.respawnNearBail);
}
else
{
harmonyInstance.UnpatchAll(harmonyInstance.Id);
UnityEngine.Object.Destroy(ModMenu.Instance.gameObject.GetComponent <XLShredRespawnNearBail>());
UnityEngine.Object.Destroy(PlayerController.Instance.respawn.gameObject.GetComponent <RespawnData>());
XLShredDataRegistry.SetData("kiwi.XLShredRespawnNearBail", "isRespawnNearBailActive", false);
}
return(true);
}
public static RespawnData Clone(RespawnData given)
{
return(new RespawnData()
{
respawnPosition = given.respawnPosition,
sceneName = given.sceneName
});
}
// Start is called before the first frame update
void Awake()
{
respawnState = new StateSetter(this, null, null, null, StateSetter.SetStrength.Strong);
RespawnData newMajor = new RespawnData()
{
sceneName = SceneManager.GetActiveScene().name,
respawnPosition = Player.instance.transform.position
};
MajorRespawnData = newMajor;
}
private static void Respawn(RespawnData respawnData)
{
// REMOVE FROM RESPAWN LIST
respawnQueue.Remove(respawnData);
// RESPAWN OBJECT
GameObject obj = GameObject.Instantiate(respawnData.objectToSpawn, respawnData.respawnTransform.position, respawnData.respawnTransform.rotation);
SetRespawnParameters(respawnData);
// ADD TO INSTANTIATED LIST
instantiatedObjectsList.Add(obj);
}
public RespawnBehaviour(ShipTeam[] teams, Transform[] points, float[] distancies, float time)
{
respawn = new RespawnData[teams.Length];
for (int i = 0; i < teams.Length; i++)
{
respawn[i] = new RespawnData()
{
team = teams[i], point = points[i], distanceToCenter = distancies[i]
}
}
;
this.time = time;
}
static void Prefix(Respawn __instance, ref bool ____init)
{
RespawnData respawnData = PlayerController.Instance.respawn.GetExtensionComponent();
if (!____init && PlayerController.Instance.boardController.AllDown)
{
respawnData.SetSpawnPos();
____init = true;
}
if (Main.enabled && Main.settings.respawnNearBail && !__instance.respawning && !__instance.puppetMaster.isBlending && Time.time - respawnData.lastTmpSave > 0.5f && PlayerController.Instance.IsGrounded() && !__instance.bail.bailed && Time.timeScale != 0f)
{
respawnData.lastTmpSave = Time.time;
respawnData.SetTmpSpawnPos();
}
}
public static void QueueRespawn(RespawnData respawnData)
{
// ADD TO RESPAWN QUEUE
respawnQueue.Add(respawnData);
// SET TIMER
Timer timer = new Timer();
timer.Interval = respawnData.secondsToSpawn * 1000;
timer.Enabled = true;
timer.Elapsed += (object source, ElapsedEventArgs e) => Respawn(respawnData);
// DESTROY INSTANTIATED OBJECT
instantiatedObjectsList.Remove(respawnData.objectToDestroy);
GameObject.Destroy(respawnData.objectToDestroy);
}
static bool Load(UnityModManager.ModEntry modEntry)
{
settings = Settings.Load <Settings>(modEntry);
var harmony = HarmonyInstance.Create(modEntry.Info.Id);
harmony.PatchAll(Assembly.GetExecutingAssembly());
modEntry.OnSaveGUI = OnSaveGUI;
modEntry.OnToggle = OnToggle;
ModMenu.Instance.gameObject.AddComponent <XLShredRespawnNearBail>();
RespawnData respawnData = PlayerController.Instance.respawn.gameObject.AddComponent <RespawnData>();
respawnData.RespawnComponent = PlayerController.Instance.respawn;
return(true);
}
IEnumerator Respawn(RespawnData areaCode)
{
playerRespawn?.Invoke(); //So things know that the player is respawning.
Player.instance.DisableHitboxAndVisuals();
Player.instance.SetLivingEntityState(respawnState, false);
Player.instance.InputAndPhysicsCleanUp();
Player.instance.entityRB2D.bodyType = RigidbodyType2D.Kinematic;
yield return(new WaitForSeconds(1));
UIManager.instance.ToggleFade();
yield return(new WaitForSeconds(UIManager.instance.fadeTime));
Scene activeScene = SceneManager.GetActiveScene();
if (!activeScene.name.Equals(areaCode.sceneName))
{
SceneManager.LoadScene(areaCode.sceneName);
yield return(new WaitUntil(() => activeScene.isLoaded));
}
Player.instance.transform.position = areaCode.respawnPosition;
if (areaCode == miniRespawnData)
{
Player.instance.healthControl.ProcInvincibility();
}
if (areaCode == majorRespawnData)
{
miniRespawnData = RespawnData.Clone(areaCode);
Player.instance.healthControl.CurrentHealth = Player.instance.healthControl.MaxHealth;
}
yield return(new WaitForSeconds(1));
Player.instance.EnableHitboxAndVisuals();
UIManager.instance.ToggleFade();
Player.instance.entityRB2D.bodyType = RigidbodyType2D.Dynamic;
Player.instance.OriginalStateSet();
}
public void OnBotDestroyed(int botId)
{
Bot bot = GetBotFromBotId(botId);
var d = new RespawnData();
d.botId = bot.ID;
d.deathTime = Time.time;
this.respawnList.Add(d);
if (GetEnemyTeamFromBotId(botId).flag.Stolen&& GetEnemyTeamFromBotId(botId).flag.Carrier == botId)
{
DropFlag(botId);
}
bot.Disable();
// if(bot_infos.ID == flag_carriers[0])
// {
// flag_carriers[0] = -1;
// }
// if(bot_infos.ID == flag_carriers[1])
// {
// flag_carriers[1] = -1;
// }
//
// bot_infos.is_dead = true;
// bot_infos.BroadcastMessage("OnDeath", SendMessageOptions.DontRequireReceiver);
//
// RespawnData rd = new RespawnData();
// rd.timer = respawn_delay;
// rd.bot = bot_infos;
// rd.invincibility_left = respawn_invincibility_time;
// rd.respawned = false;
// to_respawn.Add(rd);
//
// // give some invincibility by changing object's tag
// rd.bot.gameObject.tag = "Untagged";
// bot_infos.Disable();
}
public void MainMenu()
{
GameManager.Instance.Playing(true);
RespawnData.Reset();
SceneManager.LoadScene("MainMenu");
}
private static void SetRespawnParameters(RespawnData respawnData)
{
// SET RESPAWN PARAMETERS
}
// public GameObject tutorialPanel;
public void Play()
{
GameManager.Instance.Playing(true);
RespawnData.Reset();
SceneManager.LoadScene("Chapter1");
}
void Update()
{
// CHECK PLAYERS TO RESPAWN
int k = 0;
while (k < to_respawn.Count)
{
RespawnData dat = to_respawn[k];
dat.timer -= Time.deltaTime;
to_respawn[k] = dat;
if (dat.timer < 0)
{
Respawn(dat.bot);
to_respawn.RemoveAt(k);
}
else
{
k++;
}
}
// FLAG INTERACTIONS FOR RED TEAM
for (int i = 0; i < teams[0].bots.Length; i++)
{
if (!teams[0].bots[i].gameObject.activeSelf)
{
continue;
}
Collider c = teams[0].bots[i].GetComponent <Collider>();
// Got enemy flag
if (c.bounds.Intersects(teams[0].enemy_flag.bounds))
{
// check if no one already carries this flag
if (flag_carriers[1] == -1)
{
is_flag_home[1] = false;
flag_carriers[1] = teams[0].bots[i].ID;
}
}
else if (c.bounds.Intersects(teams[0].team_flag.bounds)) // get back team flag
{
// check if flag is not home AND no enemy is carrying it
if (!is_flag_home[0] && flag_carriers[0] == -1)
{
// bring back flag to base
teams[0].team_flag.transform.position = teams[0].team_base.transform.position;
is_flag_home[0] = true;
}
}
}
// FLAG INTERACTIONS FOR BLUE TEAM
for (int i = 0; i < teams[1].bots.Length; i++)
{
if (!teams[1].bots[i].gameObject.activeSelf)
{
continue;
}
Collider c = teams[1].bots[i].GetComponent <Collider>();
// Got master flag
if (c.bounds.Intersects(teams[1].enemy_flag.bounds))
{
// check if no one already carries this flag
if (flag_carriers[0] == -1)
{
is_flag_home[0] = false;
flag_carriers[0] = teams[1].bots[i].ID;
}
}
else if (c.bounds.Intersects(teams[1].team_flag.bounds))
{
// check if flag is not home AND no bot from team red is carrying it
if (!is_flag_home[1] && flag_carriers[1] == -1)
{
// bring back flag to base
teams[1].team_flag.transform.position = teams[1].team_base.position;
is_flag_home[1] = true;
}
}
}
// FLAG MOVEMENT
if (flag_carriers[1] != -1)
{
teams[0].enemy_flag.transform.position = GetBotFromID(flag_carriers[1]).transform.position;
}
if (flag_carriers[0] != -1)
{
teams[0].team_flag.transform.position = GetBotFromID(flag_carriers[0]).transform.position;
}
if (teams[0].team_flag.bounds.Intersects(teams[0].enemy_flag.bounds))
{
if (is_flag_home[0])
{
// red scores
score[0]++;
is_flag_home[1] = true;
is_flag_home[0] = true;
teams[0].enemy_flag.transform.position = teams[0].enemy_base.position;
flag_carriers[1] = -1;
flag_carriers[0] = -1;
teams[0].SendMessageToTeam("OnScored");
}
else if (is_flag_home[1])
{
// blue scores
score[1]++;
is_flag_home[1] = true;
is_flag_home[0] = true;
teams[1].enemy_flag.transform.position = teams[1].enemy_base.position;
flag_carriers[1] = -1;
flag_carriers[0] = -1;
teams[1].SendMessageToTeam("OnScored");
}
}
text_score_team_red.text = score[0].ToString();
text_score_team_blue.text = score[1].ToString();
}
private void CreateMonster()
{
if (this.mgInfo == null)
{
return;
}
this.index = 0;
int num = 0;
for (int i = 0; i < 6; i++)
{
if (i >= this.mgInfo.RespawnID.Count || this.mgInfo.RespawnID[i] == 0)
{
break;
}
MGRespawnInfo info = Globals.Instance.AttDB.MGRespawnDict.GetInfo(this.mgInfo.RespawnID[i]);
if (info == null)
{
break;
}
if (this.respawnActors[this.maxWave] == null)
{
this.respawnActors[this.maxWave] = new List<RespawnData>();
}
int num2 = UtilFunc.RangeRandom(0, 100) % 3;
this.way[i] = num2;
if (i <= 0)
{
num = 1;
}
else
{
if (this.way[i - 1] == num2)
{
num++;
}
else
{
num = 1;
}
if (num >= 3)
{
num2 = (num2 + 1) % 3;
this.way[i] = num2;
num = 1;
}
}
this.timer += this.mgInfo.Delay[i];
for (int j = 0; j < info.InfoID.Count; j++)
{
if (info.InfoID[j] != 0)
{
int num3 = info.PosIndex[i];
if (num3 > 5)
{
global::Debug.LogErrorFormat("MGRespawnInfo InfoID count = {0} > {1}", new object[]
{
j,
5
});
break;
}
if (this.respawnPoints[num2, num3] == null)
{
global::Debug.LogError(new object[]
{
string.Format("respawnPoints error, wayIndex = {0}, posIndex = {1}", num2, num3)
});
break;
}
RespawnData respawnData = new RespawnData();
if (respawnData == null)
{
global::Debug.LogError(new object[]
{
"Allocate RespawnData error"
});
break;
}
respawnData.Actor = this.actorMgr.CreateMonster(info.InfoID[j], this.respawnPoints[num2, num3].Position, this.respawnPoints[num2, num3].Rotation, new Vector3(info.Scale[j], info.Scale[j], info.Scale[j]), 10000);
if (respawnData.Actor != null)
{
respawnData.Actor.AiCtrler.FindEnemyDistance = 3.40282347E+38f;
respawnData.Actor.AiCtrler.SetInitTarget(this.gearActor);
respawnData.Actor.gameObject.SetActive(false);
respawnData.DelayTime = info.Delay[j];
this.respawnActors[this.maxWave].Add(respawnData);
}
}
}
this.maxWave++;
}
this.index = 0;
}
public void RestartLevel()
{
GameManager.Instance.Playing(true);
RespawnData.Reset();
SceneManager.LoadScene(SceneManager.GetActiveScene().name);
}
private void CreateMonster()
{
int startID = this.GetStartID();
for (int i = 0; i < 5; i++)
{
TrialRespawnInfo info = Globals.Instance.AttDB.TrialRespawnDict.GetInfo(startID + i);
if (info == null)
{
if (this.respawnActors[i] != null)
{
this.respawnActors[i].Clear();
}
break;
}
if (this.respawnActors[i] == null)
{
this.respawnActors[i] = new List<RespawnData>();
}
this.respawnActors[i].Clear();
for (int j = 0; j < info.InfoID.Count; j++)
{
if (j >= 15)
{
global::Debug.LogError(new object[]
{
string.Format("TrialRespawnInfo InfoID count = {0} >= {1}", j, 15)
});
break;
}
if (info.InfoID[j] != 0)
{
if (this.respawnPoints[j] == null)
{
global::Debug.LogError(new object[]
{
string.Format("respawnPoints error, index = {0}", j)
});
break;
}
RespawnData respawnData = new RespawnData();
if (respawnData == null)
{
global::Debug.LogError(new object[]
{
"Allocate RespawnData error"
});
break;
}
respawnData.Actor = this.actorMgr.CreateMonster(info.InfoID[j], this.respawnPoints[j].Position, this.respawnPoints[j].Rotation, new Vector3(info.Scale[j], info.Scale[j], info.Scale[j]), 10000);
if (respawnData.Actor != null)
{
respawnData.Actor.AiCtrler.FindEnemyDistance = 3.40282347E+38f;
respawnData.Actor.gameObject.SetActive(false);
respawnData.DelayTime = info.Delay[j];
this.respawnActors[i].Add(respawnData);
}
}
}
}
}
