public static bool AddToTradingPost(int mo_id, int amount, int camp_id)
{
using (var db = new MinionWarsEntities())
{
MinionOwnership mo = db.MinionOwnership.Find(mo_id);
if (mo.available < amount)
{
return(false);
}
else
{
Trading trade = new Trading();
trade.camp_id = camp_id;
trade.owner_id = mo.owner_id;
trade.amount = amount;
trade.minion_id = mo.minion_id;
mo.group_count -= amount;
mo.available -= amount;
db.Trading.Add(trade);
db.MinionOwnership.Attach(mo);
db.Entry(mo).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
}
}
return(true);
}
private void CharacterBody_OnInventoryChanged(On.RoR2.CharacterBody.orig_OnInventoryChanged orig, CharacterBody self)
{
// This hook runs on Client and on Server
orig(self);
CharacterMaster master = self.master;
if (!master)
{
return;
}
MinionOwnership minionOwnership = master.minionOwnership;
if (!minionOwnership || minionOwnership.ownerMaster || FilterMinions(master))
{
return;
}
OptionMasterTracker masterTracker = master.GetOrAddComponent <OptionMasterTracker>();
int newCount = GetCount(self);
int oldCount = masterTracker.optionItemCount;
int diff = newCount - oldCount;
if (diff != 0)
{
masterTracker.optionItemCount = newCount;
Log.Message($"OnInventoryChanged: Master: {master.name}, OldCount: {oldCount}, NewCount: {newCount}, Difference: {diff}");
if (diff > 0)
{
LoopAllMinions(master, minion => OptionMasterTracker.SpawnOptions(minion, oldCount, newCount));
}
else
{
LoopAllMinions(master, minion => OptionMasterTracker.DestroyOptions(minion, oldCount, newCount));
}
}
}
public static bool BuildMinions(int ob_id, int user_id, int amount)
{
using (var db = new MinionWarsEntities())
{
OffensiveBuilding ob = db.OffensiveBuilding.Find(ob_id);
List <MinionOwnership> mol = db.MinionOwnership.Where(x => x.owner_id == user_id && x.minion_id == ob.minion_id).ToList();
if (mol.Count > 0)
{
bool check = CostManager.ApplyMinionCosts(user_id, amount);
if (check)
{
MinionOwnership mo = mol.First();
mo.group_count += amount;
mo.available += amount;
}
else
{
return(false);
}
}
}
return(true);
}
public static bool RemoveMinions(int a_id)
{
using (var db = new MinionWarsEntities())
{
BattlegroupAssignment ba = db.BattlegroupAssignment.Find(a_id);
if (ba != null)
{
MinionOwnership mo = null;
Battlegroup bg = db.Battlegroup.Find(ba.battlegroup_id);
mo = db.MinionOwnership.Where(x => x.minion_id == ba.minion_id && x.owner_id == bg.owner_id).First();
mo.available += ba.group_count;
db.BattlegroupAssignment.Remove(ba);
db.MinionOwnership.Attach(mo);
db.Entry(mo).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
return(true);
}
else
{
return(false);
}
}
}
public static void AwardMinions(int user_id, int minion_id, int amount)
{
using (var db = new MinionWarsEntities())
{
MinionOwnership mo = null;
List <MinionOwnership> list = db.MinionOwnership.Where(x => x.owner_id == user_id && x.minion_id == minion_id).ToList();
if (list.Count > 0)
{
mo = list.First();
mo.group_count += amount;
mo.available += amount;
db.MinionOwnership.Attach(mo);
db.Entry(mo).State = System.Data.Entity.EntityState.Modified;
}
else
{
mo = new MinionOwnership();
mo.group_count = 10;
mo.available = 10;
mo.owner_id = user_id;
mo.minion_id = minion_id;
db.MinionOwnership.Add(mo);
}
db.SaveChanges();
}
}
public static string ProcessAddition(int?o_id, int?amount, int?line, int?bg_id, string name)
{
if (amount == null)
{
return("amount is null");
}
else if (line == null)
{
return("line is null");
}
else if (o_id == null)
{
return("ownership is null");
}
else if (bg_id == null && (name == null || name == ""))
{
return("bg error");
}
else
{
Battlegroup bg = null;
MinionOwnership mo = null;
using (var db = new MinionWarsEntities())
{
mo = db.MinionOwnership.Find(o_id);
if (mo.available < amount)
{
return("Too much minions");
}
else
{
if (name != null && name != "")
{
bg = BattlegroupManager.ConstructBattlegroup(mo.owner_id, 2, name);
db.Battlegroup.Add(bg);
}
else if (bg_id != null)
{
bg = db.Battlegroup.Find(bg_id.Value);
}
mo.available -= amount;
db.MinionOwnership.Attach(mo);
db.Entry(mo).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
}
}
if (bg != null && mo != null)
{
BattlegroupManager.AddMinions(mo.minion_id, amount.Value, line.Value, bg);
}
}
return("ok");
}
private void CheckMinions(MinionOwnership minion)
{
if (base.isUserAlive && base.meetsBodyRequirement)
{
if (minion != null)
{
MinionOwnership.MinionGroup group = minion.group;
if (group != null)
{
CharacterMaster playerMaster = base.localUser.cachedMasterController.master;
if (playerMaster != null)
{
if (group.ownerId == playerMaster.netId)
{
MinionOwnership[] minionArray = group.members;
if (minionArray != null)
{
int validDrones = 0;
foreach (MinionOwnership tempMinion in minionArray)
{
if (tempMinion != null)
{
List <string> nameList = new List <string>();
foreach (string tempName in validDroneNames)
{
nameList.Add(tempName + "Master(Clone)");
}
string droneName = tempMinion.name;
if (nameList.Contains(droneName))
{
validDrones += 1;
}
}
}
if (validDrones >= 8)
{
base.Grant();
}
}
}
}
}
}
}
}
public CharacterMaster SummonDrone(CharacterBody attackerBody)
{
var transform = attackerBody.transform;
// Spawn drone above player position
Vector3 position = transform.position + Vector3.up * 3f;
Util.PlaySound("Play_drone_repair", attackerBody.gameObject);
CharacterMaster characterMaster = SummonMaster(
Resources.Load <GameObject>("Prefabs/CharacterMasters/DroneBackupMaster"), position, transform.rotation, attackerBody);
if (characterMaster)
{
MinionOwnership ownership = characterMaster.GetComponent <MinionOwnership>();
int stageCount = SacrificeRemix.GetStageCount();
int minStage = stageCount - 1;
int maxStage = stageCount + 2;
int minBaseStats = stageCount - 1;
int maxBaseStats = stageCount * 2;
int randomItemCount = Random.Range(minStage, maxStage);
int lifeTimerOffset = Random.Range(minStage, maxStage);
// Attach to player
if (ownership)
{
ownership.SetOwner(attackerBody.master);
}
// Random items
if (randomItemCount > 0)
{
characterMaster.inventory.GiveRandomItems(randomItemCount);
}
// Base stats
characterMaster.inventory.GiveItem(ItemIndex.BoostDamage, Random.Range(minBaseStats, maxBaseStats));
characterMaster.inventory.GiveItem(ItemIndex.BoostHp, Random.Range(minBaseStats, maxBaseStats));
// Drone lifetime
characterMaster.gameObject.AddComponent <MasterSuicideOnTimer>().lifeTimer = 30f + lifeTimerOffset;
}
return(characterMaster);
}
private IEnumerator GetTurretMasterStuff()
{
yield return(new WaitForSeconds(3f));
int i = 0;
Debug.Log(i++);
turretBody = transform.parent.GetComponent <CharacterBody>();
Debug.Log(i++);
turretMaster = turretBody.master;
Debug.Log(i++);
turretOwnership = turretMaster.minionOwnership;
Debug.Log(i++);
ownerMaster = turretOwnership.ownerMaster;
Debug.Log(i++);
prepared = true;
Debug.Log(i++);
}
public static void GenerateNewUserOwnership(int id)
{
for (int i = 0; i < 3; i++)
{
using (var db = new MinionWarsEntities())
{
Minion minion = MinionGenotype.generateRandomMinion();
MinionOwnership mo = new MinionOwnership();
mo.owner_id = id;
mo.group_count = 10;
mo.minion_id = minion.id;
mo.available = 10;
db.MinionOwnership.Add(mo);
db.SaveChanges();
}
}
}
// Token: 0x0600292F RID: 10543 RVA: 0x000AD948 File Offset: 0x000ABB48
private void OnMinionGroupChangedGlobal(MinionOwnership minion)
{
int num = EngiArmyAchievement.requirement;
MinionOwnership.MinionGroup group = minion.group;
if (num <= ((group != null) ? group.memberCount : 0))
{
CharacterMaster master = base.localUser.cachedMasterController.master;
if (!master)
{
return;
}
NetworkInstanceId netId = master.netId;
if (minion.group.ownerId == netId)
{
base.Grant();
}
}
}
private static void SetMemberTarget(MinionOwnership member, GameObject targetGameObject)
{
if (!member)
{
return;
}
BaseAI component = member.GetComponent <BaseAI>();
if (!component)
{
return;
}
if (component.currentEnemy == null)
{
return;
}
if (targetGameObject)
{
component.currentEnemy.gameObject = targetGameObject;
}
}
/// <summary>
/// Loops through the minions and fellow minions, then applies processing for each through an action.
/// </summary>
/// <param name="ownerOrMinion">Master of the minions or a fellow minion</param>
/// <param name="logic">Code to apply for each minion</param>
public static void LoopMinions(this CharacterMaster ownerOrMinion, Action <CharacterMaster> logic)
{
MinionOwnership thisMinionOwnership = ownerOrMinion.minionOwnership;
if (!thisMinionOwnership)
{
return;
}
MinionOwnership[] minionOwnerships = Object.FindObjectsOfType <MinionOwnership>();
foreach (MinionOwnership minionOwnership in minionOwnerships)
{
if (minionOwnership && minionOwnership.ownerMaster)
{
bool ownerCondition = !thisMinionOwnership.ownerMaster && minionOwnership.ownerMaster == ownerOrMinion;
bool minionCondition = thisMinionOwnership.ownerMaster && minionOwnership.ownerMaster == thisMinionOwnership.ownerMaster;
if (ownerCondition || minionCondition)
{
CharacterMaster minion = minionOwnership.GetComponent <CharacterMaster>();
logic(minion);
}
}
}
}
private void CharacterBody_onBodyStartGlobal(CharacterBody obj)
{
CharacterMaster botMaster = obj.master;
if (!botMaster)
{
return;
}
MinionOwnership minionOwnership = botMaster.minionOwnership;
if (!minionOwnership)
{
return;
}
if (IsDroneSupported(botMaster))
{
CharacterMaster ownerMaster = botMaster.minionOwnership.ownerMaster;
if (ownerMaster)
{
BotStatTracker tracker = BotStatTracker.GetOrAddComponent(botMaster, ownerMaster, obj, ownerMaster.GetBody());
tracker.UpdateTrackerBoosts();
}
}
}
public void Awake()
{
ReadConfig();
SetupArtifact();
On.RoR2.CharacterMaster.OnBodyDeath += (orig, master, body) =>
{
bool couldrespawn = false;
if (master.inventory.GetItemCount(RoR2Content.Items.ExtraLife) > 0)
{
couldrespawn = true;
}
orig(master, body);
if (!couldrespawn)
{
DropStolenInventory(body);
}
};
On.RoR2.CharacterBody.Start += (orig, body) =>
{
UpdateThiefBuff(body);
orig(body);
};
//Enemy Item Pickup Related Hooks
On.RoR2.GenericPickupController.BodyHasPickupPermission += (orig, body) =>
{
if (body.masterObject)
{
if (body.inventory)
{
if (RunArtifactManager.instance.IsArtifactEnabled(Grief.artifactIndex) && EnemyCanPickup.Value)
{
MinionOwnership minionowner = body.master.minionOwnership;
if (!minionowner || !minionowner.ownerMaster)
{
return(true);
}
}
else if (body.masterObject.GetComponent <PlayerCharacterMasterController>())
{
TeamComponent component = body.GetComponent <TeamComponent>();
if (component && component.teamIndex == TeamIndex.Player)
{
return(true);
}
}
}
}
return(false);
};
On.RoR2.GenericPickupController.AttemptGrant += (orig, gpc, body) =>
{
orig(gpc, body);
if (RunArtifactManager.instance.IsArtifactEnabled(Grief.artifactIndex) && EnemyCanPickup.Value)
{
TeamComponent component = body.GetComponent <TeamComponent>();
if (component && component.teamIndex != TeamIndex.Player)
{
Inventory inventory = body.inventory;
if (inventory)
{
PickupDef pickupDef = PickupCatalog.GetPickupDef(gpc.pickupIndex);
if (pickupDef.itemIndex != ItemIndex.None)
{
gpc.gameObject.SetActive(false);
inventory.GiveItem(pickupDef.itemIndex, 1);
Chat.AddPickupMessage(body, ((pickupDef != null) ? pickupDef.nameToken : null) ?? PickupCatalog.invalidPickupToken, (pickupDef != null) ? pickupDef.baseColor : Color.black, 1);
if (body)
{
Util.PlaySound("Play_UI_item_pickup", body.gameObject);
}
AddToStolenInventory(body, body.master.gameObject, pickupDef.itemIndex, 1);
UnityEngine.Object.Destroy(gpc.gameObject);
}
}
}
}
};
//Setup Grief from Damage Report
On.RoR2.CharacterBody.OnTakeDamageServer += (orig, charbody, damageReport) =>
{
orig(charbody, damageReport);
if (RunArtifactManager.instance.IsArtifactEnabled(Grief.artifactIndex))
{
if (charbody.master)
{
CharacterMaster master = charbody.master;
if (master.playerCharacterMasterController)
{
SetupGriefFromDamageReport(master, damageReport);
}
}
}
};
}
