protected void Dispose()
{
if (this.Looters == null)
{
return;
}
IList <LooterEntry> looters = this.Looters;
this.Looters = (IList <LooterEntry>)null;
for (int index = 0; index < looters.Count; ++index)
{
LooterEntry looterEntry = looters[index];
Character owner = looterEntry.Owner;
if (owner != null)
{
LootHandler.SendLootReleaseResponse(owner, this);
}
if (looterEntry.Loot == this)
{
looterEntry.Loot = (Loot)null;
}
}
this.OnDispose();
}
/// <summary>
/// Lets the given Character roll for the item at the given index
/// </summary>
/// <param name="index"></param>
/// <param name="type"></param>
public void Roll(Character chr, uint index, LootRollType type)
{
LootItem lootItem = this.Items[index];
if (lootItem.RollProgress == null)
{
return;
}
lootItem.RollProgress.Roll(chr, type);
if (!lootItem.RollProgress.IsRollFinished)
{
return;
}
Character highestParticipant = lootItem.RollProgress.HighestParticipant;
if (highestParticipant != null)
{
LootHandler.SendRollWon(highestParticipant, this, lootItem, lootItem.RollProgress.HighestEntry);
this.HandoutItem(highestParticipant, lootItem, (BaseInventory)null, (int)byte.MaxValue);
}
else
{
this.RemoveItem(lootItem);
}
lootItem.RollProgress.Dispose();
}
/// <summary>
/// Returns whether the given looter may loot the given Item.
/// Make sure the Looter is logged in before calling this Method.
///
/// TODO: Find the right error messages
/// TODO: Only give every MultiLoot item to everyone once! Also check for quest-dependencies etc.
/// </summary>
public InventoryError CheckTakeItemConditions(LooterEntry looter, LootItem item)
{
if (item.Taken)
{
return(InventoryError.ALREADY_LOOTED);
}
if (item.RollProgress != null)
{
return(InventoryError.DONT_OWN_THAT_ITEM);
}
if (!looter.MayLoot(this))
{
return(InventoryError.DontReport);
}
ICollection <LooterEntry> multiLooters = item.MultiLooters;
if (multiLooters != null)
{
if (multiLooters.Contains(looter))
{
return(InventoryError.OK);
}
if (looter.Owner != null)
{
LootHandler.SendLootRemoved(looter.Owner, item.Index);
}
return(InventoryError.DONT_OWN_THAT_ITEM);
}
return(!item.Template.CheckLootConstraints(looter.Owner) || this.Method != LootMethod.FreeForAll &&
(item.Template.Quality > this.Group.LootThreshold && !item.Passed ||
this.Group.MasterLooter != null && this.Group.MasterLooter != looter.Owner.GroupMember)
? InventoryError.DONT_OWN_THAT_ITEM
: InventoryError.OK);
}
/// <summary>
/// Generates loot for Items and GOs.
/// </summary>
/// <param name="lootable">The Object or Unit that is being looted</param>
/// <returns>The object's loot or null if there is nothing to get or the given Character can't access the loot.</returns>
public static ObjectLoot CreateAndSendObjectLoot(ILootable lootable, Character initialLooter,
LootEntryType type, bool heroic)
{
var oldLoot = initialLooter.LooterEntry.Loot;
if (oldLoot != null)
{
oldLoot.ForceDispose();
}
var looters = FindLooters(lootable, initialLooter);
var loot = CreateLoot <ObjectLoot>(lootable, initialLooter, type, heroic, 0); // TODO: pass mapid
if (loot != null)
{
initialLooter.LooterEntry.Loot = loot;
loot.Initialize(initialLooter, looters, 0); // TODO: pass mapid
LootHandler.SendLootResponse(initialLooter, loot);
}
else
{
//lootable.OnFinishedLooting();
// empty Item -> Don't do anything
}
return(loot);
}
private IEnumerator DropLootCoroutine(GridObject gridObject, Vector3 dropLocation, float delayAppear = 1.0f)
{
LootHandler lh = gridObject.gameObject.GetComponent <LootHandler>();
if (lh != null)
{
GameObject lootObjectToDrop = lh.RequestLootDrop(dropLocation, forced: true);
if (lootObjectToDrop != null)
{
MeshRenderer renderer = lootObjectToDrop.GetComponentInChildren <MeshRenderer>();
renderer.enabled = false;
gm.AddObjectToGrid(lootObjectToDrop, gm.WorldToGrid(dropLocation));
gridObjectsInPlay.Add(lootObjectToDrop.GetComponent <Loot>());
Rotator lootRotator = lootObjectToDrop.GetComponent <Rotator>();
lootRotator.enabled = true;
lootRotator.ApplyRotation("Left");
yield return(new WaitForSeconds(delayAppear));
renderer.enabled = true;
}
}
}
protected void Dispose()
{
if (Looters == null)
{
return;
}
var looters = Looters;
Looters = null;
for (var i = 0; i < looters.Count; i++)
{
var looter = looters[i];
var owner = looter.Owner;
if (owner != null)
{
LootHandler.SendLootReleaseResponse(owner, this);
}
if (looter.Loot == this)
{
looter.Loot = null;
}
}
OnDispose();
}
/// <summary>
/// Lets the given Character roll for the item at the given index
/// </summary>
/// <param name="index"></param>
/// <param name="type"></param>
public void Roll(Character chr, uint index, LootRollType type)
{
var item = Items[index];
if (item.RollProgress != null)
{
// item is actually being rolled for
item.RollProgress.Roll(chr, type);
if (item.RollProgress.IsRollFinished)
{
// handout the item, once the Roll finished
var highest = item.RollProgress.HighestParticipant;
if (highest != null)
{
LootHandler.SendRollWon(highest, this, item, item.RollProgress.HighestEntry);
HandoutItem(highest, item, null, BaseInventory.INVALID_SLOT);
}
else
{
// no one online to receive the item (odd) -> Simply remove it
RemoveItem(item);
}
item.RollProgress.Dispose();
}
}
}
/// <summary>
/// Returns whether the given looter may loot the given Item.
/// Make sure the Looter is logged in before calling this Method.
///
/// TODO: Find the right error messages
/// TODO: Only give every MultiLoot item to everyone once! Also check for quest-dependencies etc.
/// </summary>
public InventoryError CheckTakeItemConditions(Asda2LooterEntry looter, Asda2LootItem item)
{
if (item.Taken)
{
return(InventoryError.ALREADY_LOOTED);
}
if (!looter.MayLoot(this))
{
return(InventoryError.DontReport);
}
ICollection <Asda2LooterEntry> multiLooters = item.MultiLooters;
if (multiLooters != null)
{
if (multiLooters.Contains(looter))
{
return(InventoryError.OK);
}
if (looter.Owner != null)
{
LootHandler.SendLootRemoved(looter.Owner, item.Index);
}
return(InventoryError.DONT_OWN_THAT_ITEM);
}
if (!item.Template.CheckLootConstraints(looter.Owner))
{
return(InventoryError.DONT_OWN_THAT_ITEM);
}
int method = (int)this.Method;
return(InventoryError.OK);
}
// Use this for initialization
void Start()
{
if (monsterLoot == null)
{
monsterLoot = gameObject.GetComponent <LootHandler>();
}
}
// Use this for initialization
void Start()
{
if (monsterLoot == null)
{
monsterLoot = gameObject.GetComponent<LootHandler>();
}
}
/// <summary>
/// This gives the money to everyone involved. Will only work the first time its called.
/// Afterwards <c>IsMoneyLooted</c> will be true.
/// </summary>
public void GiveMoney()
{
if (this.m_moneyLooted)
{
return;
}
if (this.Group == null)
{
LooterEntry looterEntry = this.Looters.FirstOrDefault <LooterEntry>();
if (looterEntry != null && looterEntry.Owner != null)
{
this.m_moneyLooted = true;
this.SendMoney(looterEntry.Owner, this.Money);
}
}
else
{
List <Character> characterList = new List <Character>();
if (this.UsesRoundRobin)
{
LooterEntry looterEntry = this.Looters.FirstOrDefault <LooterEntry>();
if (looterEntry != null && looterEntry.Owner != null)
{
characterList.Add(looterEntry.Owner);
if (this.Lootable is WorldObject)
{
WorldObject lootable = (WorldObject)this.Lootable;
}
else
{
Character owner = looterEntry.Owner;
}
}
}
else
{
foreach (LooterEntry looter in (IEnumerable <LooterEntry>) this.Looters)
{
if (looter.m_owner != null)
{
characterList.Add(looter.m_owner);
}
}
}
if (characterList.Count > 0)
{
this.m_moneyLooted = true;
uint amount = this.Money / (uint)characterList.Count;
foreach (Character character in characterList)
{
this.SendMoney(character, amount);
LootHandler.SendMoneyNotify(character, amount);
}
}
}
this.CheckFinished();
}
public DungeonHandlers(FormState state)
{
_ah = new ActionHandler();
_lh = new LootHandler();
_d = (state.DungeonType == Enemies.DungeonType.FINAL) ?
new Dungeon(state.Player.GetLevel(), state.DungeonType, state.Random) :
new Dungeon(state.dungeonTiers[state.DungeonType], state.DungeonType, state.Random);
}
/// <summary>
/// Lets the given Character roll
/// </summary>
/// <param name="chr"></param>
/// <param name="type"></param>
public void Roll(Character chr, LootRollType type)
{
if (m_RemainingParticipants.Remove(chr.LooterEntry))
{
var roll = Utility.Random(1, LootMgr.HighestRoll);
m_rolls[new LootRollEntry(roll, type)] = chr.LooterEntry;
LootHandler.SendRoll(chr, m_loot, m_lootItem, roll, type);
}
}
public static void StartTheServer()
{
try
{
Console.ForegroundColor = ConsoleColor.Green;
zoneServer.Monsters = new List <NonPlayerCharacterClass>();
zoneServer.Vendors = new List <VendingMachine>();
zoneServer.Doors = new List <Doors>();
using (SqlWrapper sqltester = new SqlWrapper())
{
if (sqltester.SQLCheck() != SqlWrapper.DBCheckCodes.DBC_ok)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Database setup not correct");
Console.WriteLine("Error: #" + sqltester.lasterrorcode + " - " + sqltester.lasterrormessage);
Console.WriteLine("Please press Enter to exit.");
Console.ReadLine();
Process.GetCurrentProcess().Kill();
}
sqltester.CheckDBs();
}
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Loaded {0} items", ItemHandler.CacheAllItems());
Console.WriteLine("Loaded {0} nanos", NanoHandler.CacheAllNanos());
Console.WriteLine("Loaded {0} spawns", NonPlayerCharacterHandler.CacheAllFromDB());
Console.WriteLine("Loaded {0} vendors", VendorHandler.CacheAllFromDB());
Console.WriteLine("Loaded {0} teleports", DoorHandler.CacheAllFromDB());
Console.WriteLine("Loaded {0} statels", Statels.CacheAllStatels());
LootHandler.CacheAllFromDB();
Tradeskill.CacheItemNames();
csc.AddScriptMembers();
csc.CallMethod("Init", null);
ThreadMgr.Start();
zoneServer.Start();
Console.ResetColor();
}
catch (MySqlException e)
{
Console.WriteLine("MySql Error. Server Cannot Start");
Console.WriteLine("Exception: " + e.Message);
string current = DateTime.Now.ToString("HH:mm:ss");
StreamWriter logfile = File.AppendText("ZoneEngineLog.txt");
logfile.WriteLine(current + " " + e.Source + " MySql Error. Server Cannot Start");
logfile.WriteLine(current + " " + e.Source + " Exception: " + e.Message);
logfile.Close();
zoneServer.Stop();
ThreadMgr.Stop();
Process.GetCurrentProcess().Kill();
}
}
public override void ActivateEffect(GameObject activator, float value, Collision2D coll, Collider2D other)
{
if (lootHandler == null)
{
lootHandler = gameObject.GetComponent<LootHandler>();
}
if (lootHandler != null)
{
lootHandler.DropLoot();
}
}
/// <summary>
/// Adds all initial Looters of nearby Characters who may loot this Loot.
/// When all of the initial Looters gave up the Loot, the Loot becomes free for all.
/// </summary>
public void Initialize(Character chr, IList <LooterEntry> looters, MapId mapid)
{
Looters = looters;
if (IsGroupLoot)
{
var groupMember = chr.GroupMember;
if (groupMember != null)
{
Group = groupMember.Group;
Method = Group.LootMethod;
Threshold = Group.LootThreshold;
var decision = Method == LootMethod.MasterLoot ? LootDecision.Master : LootDecision.Rolling;
IList <LooterEntry> nearbyLooters = null;
// TODO: masterlooter
foreach (var item in Items)
{
if (item.Template.Flags.HasFlag(ItemFlags.MultiLoot) ||
item.Template.Quality >= Threshold)
{
if (UsesRoundRobin)
{
nearbyLooters = new List <LooterEntry>();
Group.GetNearbyLooters(Lootable, chr, nearbyLooters);
}
else
{
nearbyLooters = Looters;
}
}
if (item.Template.Flags.HasFlag(ItemFlags.MultiLoot))
{
item.AddMultiLooters(nearbyLooters);
}
else if (item.Template.Quality >= Threshold)
{
item.Decision = decision;
if (decision == LootDecision.Rolling)
{
item.RollProgress = new LootRollProgress(this, item, nearbyLooters);
LootHandler.SendStartRoll(this, item, nearbyLooters, mapid);
}
}
}
return;
}
}
Method = LootMethod.FreeForAll;
}
/// <summary>
/// Marks the given Item as taken and removes it from the list of available Items
/// </summary>
/// <param name="lootItem"></param>
public void RemoveItem(LootItem lootItem)
{
lootItem.Taken = true;
++this.m_takenCount;
foreach (LooterEntry looter in (IEnumerable <LooterEntry>) this.Looters)
{
if (looter.Owner != null)
{
LootHandler.SendLootRemoved(looter.Owner, lootItem.Index);
}
}
this.CheckFinished();
}
/// <summary>
/// Marks the given Item as taken and removes it from the list of available Items
/// </summary>
/// <param name="lootItem"></param>
public void RemoveItem(LootItem lootItem)
{
lootItem.Taken = true;
++m_takenCount;
foreach (LooterEntry looter in Looters)
{
if (looter.Owner != null)
{
LootHandler.SendLootRemoved(looter.Owner, lootItem.Index);
}
}
CheckFinished();
}
/// <summary>
/// Returns whether the given looter may loot the given Item.
/// Make sure the Looter is logged in before calling this Method.
///
/// TODO: Find the right error messages
/// TODO: Only give every MultiLoot item to everyone once! Also check for quest-dependencies etc.
/// </summary>
public InventoryError CheckTakeItemConditions(LooterEntry looter, LootItem item)
{
if (item.Taken)
{
return(InventoryError.ALREADY_LOOTED);
}
if (item.RollProgress != null)
{
// TODO: Still being rolled for
return(InventoryError.DONT_OWN_THAT_ITEM);
}
if (!looter.MayLoot(this))
{
return(InventoryError.DontReport);
}
var multiLooters = item.MultiLooters;
if (multiLooters != null)
{
if (!multiLooters.Contains(looter))
{
if (looter.Owner != null)
{
// make sure, Item cannot be seen by client anymore
LootHandler.SendLootRemoved(looter.Owner, item.Index);
}
return(InventoryError.DONT_OWN_THAT_ITEM);
}
return(InventoryError.OK);
}
if (!item.Template.CheckLootConstraints(looter.Owner))
{
return(InventoryError.DONT_OWN_THAT_ITEM);
}
if (Method != LootMethod.FreeForAll)
{
// definitely Group-Loot
if ((item.Template.Quality > Group.LootThreshold && !item.Passed) ||
(Group.MasterLooter != null &&
Group.MasterLooter != looter.Owner.GroupMember))
{
return(InventoryError.DONT_OWN_THAT_ITEM);
}
}
return(InventoryError.OK);
}
/// <summary>
/// Marks the given Item as taken and removes it from the list of available Items
/// </summary>
/// <param name="lootItem"></param>
public void RemoveItem(LootItem lootItem)
{
lootItem.Taken = true;
m_takenCount++;
// TODO: Have correct collection of all observing Characters
foreach (var looter in Looters)
{
if (looter.Owner != null)
{
LootHandler.SendLootRemoved(looter.Owner, lootItem.Index);
}
}
CheckFinished();
}
public bool OnInteraction(GameObject player)
{
if (!FlagHelper.IsSet(flags, ItemFlags.INTERACTABLE))
{
return(false);
}
if (FlagHelper.IsSet(flags, ItemFlags.LOOTABLE))
{
OnLootStart(player);
LootHandler.OnLoot(this.gameObject, player);
OnLootEnd(player);
}
return(true);
}
internal void FinalizeStep(QuestStep p_step)
{
LootHandler lootHandler = new LootHandler(p_step);
lootHandler.DistributeRewards(null);
LegacyLogic.Instance.EventManager.InvokeEvent(this, EEventType.QUESTLOG_CHANGED, new QuestChangedEventArgs(QuestChangedEventArgs.Type.COMPLETED_QUEST, p_step));
if (p_step.StaticData.FollowupStep > 0)
{
ActivateQuest(p_step.StaticData.FollowupStep);
LegacyLogic.Instance.CharacterBarkHandler.RandomPartyMemberBark(EBarks.IMPLICIT_QUEST_END);
}
else
{
LegacyLogic.Instance.CharacterBarkHandler.RandomPartyMemberBark(EBarks.FINAL_QUEST);
}
LegacyLogic.Instance.TrackingManager.TrackQuestStepCompleted(p_step.StaticData.StaticID);
}
public override bool Use(Character user)
{
if (m_go.Entry.IsConsumable)
{
m_go.State = GameObjectState.Disabled;
}
if (m_go.Loot != null)
{
LootHandler.SendLootResponse(user, m_go.Loot);
}
else
{
LootMgr.CreateAndSendObjectLoot(m_go, user, LootEntryType.GameObject, user.Map.IsHeroic);
}
return(true);
}
/// <summary>
/// Releases the current loot and (maybe) makes it available to everyone else.
/// </summary>
public void Release()
{
if (m_loot == null)
{
return;
}
if (m_owner != null)
{
LootHandler.SendLootReleaseResponse(m_owner, m_loot);
}
m_loot.RemoveLooter(this);
if (m_loot.Looters.Count == 0)
{
m_loot.IsReleased = true;
}
Loot = null;
}
void spawnLoot()
{
Vector3 position = this.gameObject.transform.position;
float enemyMeshSizeX = this.gameObject.GetComponent <MeshFilter> ().mesh.bounds.size.x;
float deltaX = size / (enemyMeshSizeX * this.gameObject.transform.localScale.x);
position.x = position.x - (enemyMeshSizeX);
float randomRange = deltaX;
for (int i = 0; i < size; i++)
{
// Random position for the loot defined by these
float current1 = (Random.Range(-1 * randomRange, randomRange));
float current2 = (Random.Range(-1 * randomRange, randomRange));
// Getting random loot from our loot handler
GameObject loot = LootHandler.getRandomLoot(shipClass);
// Spawning loot on the screen at position altered by random value
Instantiate(loot, position + new Vector3(current1, current2, 0), Quaternion.identity);
}
}
/// <summary>
/// Requires loot to already be generated
/// </summary>
/// <param name="lootable"></param>
public void TryLoot(ILootable lootable)
{
Release(); // make sure that the Character is not still looting something else
var loot = lootable.Loot;
if (loot == null)
{
LootHandler.SendLootFail(m_owner, lootable);
// TODO: Kneel and unkneel?
}
else if (MayLoot(loot))
{
// we are either already a looter or become a new one
m_owner.CancelAllActions();
Loot = loot;
LootHandler.SendLootResponse(m_owner, loot);
}
else
{
LootHandler.SendLootFail(m_owner, lootable);
}
}
public JsonResult GetConfig()
{
return(Json(LootHandler.GetConfig()));
}
public ContentResult SetConfig([FromBody] ConfigWrapper config)
{
LootHandler.SetConfig(config);
return(Content("config was set."));
}
/// <summary>
/// This gives the money to everyone involved. Will only work the first time its called.
/// Afterwards <c>IsMoneyLooted</c> will be true.
/// </summary>
public void GiveMoney()
{
if (!m_moneyLooted)
{
if (Group == null)
{
// we only have a single looter
var looter = Looters.FirstOrDefault();
if (looter != null && looter.Owner != null)
{
m_moneyLooted = true;
SendMoney(looter.Owner, Money);
}
}
else
{
var looters = new List <Character>();
if (UsesRoundRobin)
{
// we only added the RoundRobin member, so we have to find everyone in the radius for the money now
var looter = Looters.FirstOrDefault();
if (looter != null && looter.Owner != null)
{
looters.Add(looter.Owner);
WorldObject center;
if (Lootable is WorldObject)
{
center = (WorldObject)Lootable;
}
else
{
center = looter.Owner;
}
GroupMember otherMember;
var chrs = center.GetObjectsInRadius(LootMgr.LootRadius, ObjectTypes.Player, false, 0);
foreach (Character chr in chrs)
{
if (chr.IsAlive && (chr == looter.Owner ||
((otherMember = chr.GroupMember) != null && otherMember.Group == Group)))
{
looters.Add(chr);
}
}
}
}
else
{
foreach (var looter in Looters)
{
if (looter.m_owner != null)
{
looters.Add(looter.m_owner);
}
}
}
if (looters.Count > 0)
{
m_moneyLooted = true;
var amount = Money / (uint)looters.Count;
foreach (var looter in looters)
{
SendMoney(looter, amount);
LootHandler.SendMoneyNotify(looter, amount);
}
}
}
CheckFinished();
}
}
/// <summary>
/// Gives the receiver the money and informs everyone else
/// </summary>
/// <param name="receiver"></param>
/// <param name="amount"></param>
protected void SendMoney(Character receiver, uint amount)
{
receiver.AddMoney(amount);
LootHandler.SendClearMoney(this);
}
/// <summary>
/// This gives the money to everyone involved. Will only work the first time its called.
/// Afterwards <c>IsMoneyLooted</c> will be true.
/// </summary>
public void GiveMoney()
{
if (!m_moneyLooted)
{
if (Group == null)
{
// we only have a single looter
var looter = Looters.FirstOrDefault();
if (looter != null && looter.Owner != null)
{
m_moneyLooted = true;
SendMoney(looter.Owner, Money);
}
}
else
{
var looters = new List <Character>();
if (UsesRoundRobin)
{
// we only added the RoundRobin member, so we have to find everyone in the radius for the money now
var looter = Looters.FirstOrDefault();
if (looter != null && looter.Owner != null)
{
looters.Add(looter.Owner);
WorldObject center;
if (Lootable is WorldObject)
{
center = (WorldObject)Lootable;
}
else
{
center = looter.Owner;
}
}
}
else
{
foreach (var looter in Looters)
{
if (looter.m_owner != null)
{
looters.Add(looter.m_owner);
}
}
}
if (looters.Count > 0)
{
m_moneyLooted = true;
var amount = Money / (uint)looters.Count;
foreach (var looter in looters)
{
SendMoney(looter, amount);
LootHandler.SendMoneyNotify(looter, amount);
}
}
}
CheckFinished();
}
}
void Start()
{
m_KeysContainer = GameObject.Find("Keys&Gates&Plates");
m_CoinsContainer = GameObject.Find("CoinsContainer");
m_LootHandler = FindObjectOfType <LootHandler>();
}
