void Awake()
{
Dialog = GameObject.Find("GUI").GetComponent <DialogBoxHandler>();
nurse = transform.FindChild("NPC_nurse").GetComponent <NPCHandler>();
screenSprite = transform.FindChild("PokeCenterScreen").FindChild("Screen_SpriteLight").GetComponent <SpriteRenderer>();
screenLight = transform.FindChild("PokeCenterScreen").FindChild("Screen_Light").GetComponent <Light>();
Transform healMachine = transform.FindChild("healMachine").transform;
for (int i = 0; i < 6; i++)
{
pokeBalls[i] = healMachine.FindChild("Ball" + i).GetComponent <SpriteRenderer>();
}
PokemonCenterAudio = transform.GetComponent <AudioSource>();
}
void CheckCollision(Collision coll)
{
if (coll.gameObject.tag == "Ally")
{
NPCHandler npcHandler = coll.gameObject.GetComponent <NPCHandler>();
if (npcHandler.mode == NPCMode.ALLY && isSeenByCamera && mode != NPCMode.ALLY) //ensures it is visible and hit by an ally, and is not an ally
{
ConvertToAlly();
AddPoint();
}
}
else if (coll.gameObject.tag == "Player" && mode != NPCMode.ALLY) //ensures it is hit by player and is not an ally previously
{
ConvertToAlly();
AddPoint();
}
}
public void BuyBackItem(Character chr, Item item)
{
var inv = chr.Inventory;
var newSlotId = inv.FindFreeSlot(item, item.Amount, false);
var err = newSlotId.Container.CheckAdd(newSlotId.Slot, item, item.Amount);
if (err == InventoryError.OK)
{
var amount = item.Amount;
inv.CheckUniqueness(item, ref amount, ref err, true);
if (err == InventoryError.OK && amount != item.Amount)
{
err = InventoryError.CANT_CARRY_MORE_OF_THIS;
}
else
{
if (newSlotId.Slot != BaseInventory.INVALID_SLOT)
{
var price = ((uint)item.Amount * item.Template.SellPrice);
if (chr.Money < price)
{
NPCHandler.SendBuyError(chr.Client, NPC, (ItemId)item.EntryId, BuyItemError.NotEnoughMoney);
return;
}
else
{
item.Remove(false);
newSlotId.Container.AddUnchecked(newSlotId.Slot, item, true);
chr.Money -= price;
NPCHandler.SendBuyItem(chr.Client, NPC, item.Template.ItemId, amount);
return;
}
}
else
{
err = InventoryError.INVENTORY_FULL;
}
}
}
ItemHandler.SendInventoryError(chr.Client, err);
}
// Update is called once per frame
void Update()
{
var multipler = 1f;
if (colHandler.underwater())
{
multipler = waterMultiplier;
}
if (Input.GetKeyDown(KeyCode.UpArrow))
{
rb.velocity = Vector3.up * JumpSpeed * multipler;
}
else if (Input.GetKey(KeyCode.DownArrow))
{
if (rb.velocity.y - DuckSpeed > maxFallSpeed)
{
rb.velocity -= Vector3.up * DuckSpeed * multipler;
}
}
if (colHandler.underwater())
{
rb.velocity = Vector3.up * Mathf.Min(rb.velocity.y, maxWaterVerticalSpeed);
rb.velocity = Vector3.up * Mathf.Max(rb.velocity.y, minWaterVerticalSpeed);
}
if (Input.GetKeyDown(KeyCode.F))
{
if (inInteraction || colHandler.canAccessNPC())
{
if (!inInteraction)
{
currNPC = colHandler.currNPC();
}
inInteraction = currNPC.interact();
}
}
}
/// <summary>
/// Also sends a message to the Character, if not valid
/// </summary>
internal bool CheckVendorInteraction(Character chr)
{
if (chr.Map != m_Map ||
!IsInRadiusSq(chr, NPCMgr.DefaultInteractionDistanceSq) ||
!chr.CanSee(this))
{
NPCHandler.SendNPCError(chr, this, VendorInventoryError.TooFarAway);
return(false);
}
if (!IsAlive)
{
NPCHandler.SendNPCError(chr, this, VendorInventoryError.VendorDead);
return(false);
}
if (chr.IsAlive == IsSpiritHealer)
{
NPCHandler.SendNPCError(chr, this, VendorInventoryError.YouDead);
return(false);
}
if (!chr.CanInteract || !CanInteract)
{
return(false);
}
var reputation = chr.Reputations.GetOrCreate(Faction.ReputationIndex);
if (reputation != null && !reputation.CanInteract)
{
NPCHandler.SendNPCError(chr, this, VendorInventoryError.BadRep);
return(false);
}
return(true);
}
void SpawnNPC(LevelData levelData)
{
int maxAllies = master.saveHandler.GetAllies();
int maxNonCon = master.controls.NPCCount - maxAllies;
Debug.Log(maxNonCon + " max");
int allyCount = 0;
int nonConCount = 0;
if (levelData.isTutorial)
{
maxAllies = 0; maxNonCon = 5;
}
while (allyCount < maxAllies || nonConCount < maxNonCon) //keep looping until all allies and noncons are in places
{
foreach (LevelData.NPCSpawn npcSpawn in levelData.npcSpawn)
{
foreach (Transform child in levelData.transform)
{
if (child.name.Contains(npcSpawn.keyTerm))
{
NPCHandler.NPCMode npcMode = npcSpawn.mode;
if (npcMode == NPCHandler.NPCMode.NONCON)
{
// Debug.Log("checking: " + nonConCount + " .... " + maxNonCon);
}
if (npcMode == NPCHandler.NPCMode.ALLY && allyCount < maxAllies ||
npcMode == NPCHandler.NPCMode.NONCON && nonConCount < maxNonCon)
{
GameObject npc = Instantiate(npcSpawn.NPCPrefab, child);
npc.transform.parent = levelData.transform;
npc.name = "NPC [" + npcSpawn.keyTerm.Replace("Spawn", "") + "]";
NPCHandler npcHandler = npc.GetComponent <NPCHandler>();
npcHandler.master = master;
npcHandler.SetMode(npcSpawn.mode);
MoveMotor motor = npc.GetComponent <MoveMotor>();
motor.master = master;
if (npcMode == NPCHandler.NPCMode.ALLY)
{
allyCount++;
// Debug.Log("add ally111");
}
else if (npcMode == NPCHandler.NPCMode.NONCON)
{
nonConCount++;
}
}
}
}
}
}
foreach (LevelData.NPCSpawn npcSpawn in levelData.npcSpawn)
{
foreach (Transform child in levelData.transform)
{
if (child.name.Contains(npcSpawn.keyTerm))
{
Destroy(child.gameObject);
}
}
}
}
private IEnumerator runEvent(CustomEventTree[] treesArray, int index)
{
CustomEventDetails currentEvent = treesArray[eventTreeIndex].events[index];
CustomEventDetails nextEvent = null;
if (index + 1 < treesArray[eventTreeIndex].events.Length)
{
//if not the last event
nextEvent = treesArray[eventTreeIndex].events[index + 1];
}
NPCHandler targetNPC = null;
CustomEventDetails.CustomEventType ty = currentEvent.eventType;
Debug.Log("Run event. Type: " + ty.ToString());
switch (ty)
{
case (CustomEventDetails.CustomEventType.Wait):
yield return(new WaitForSeconds(currentEvent.float0));
break;
case (CustomEventDetails.CustomEventType.Walk):
if (currentEvent.object0.GetComponent <NPCHandler>() != null)
{
targetNPC = currentEvent.object0.GetComponent <NPCHandler>();
int initialDirection = targetNPC.direction;
targetNPC.direction = (int)currentEvent.dir;
for (int i = 0; i < currentEvent.int0; i++)
{
targetNPC.direction = (int)currentEvent.dir;
Vector3 forwardsVector = targetNPC.getForwardsVector(true);
if (currentEvent.bool0)
{
//if direction locked in
targetNPC.direction = initialDirection;
}
while (forwardsVector == new Vector3(0, 0, 0))
{
targetNPC.direction = (int)currentEvent.dir;
forwardsVector = targetNPC.getForwardsVector(true);
if (currentEvent.bool0)
{
//if direction locked in
targetNPC.direction = initialDirection;
}
yield return(new WaitForSeconds(0.1f));
}
targetNPC.setOverrideBusy(true);
yield return(StartCoroutine(targetNPC.move(forwardsVector, currentEvent.float0)));
targetNPC.setOverrideBusy(false);
}
targetNPC.setFrameStill();
} //Move the player if set to player
if (currentEvent.object0 == PlayerMovement.player.gameObject)
{
int initialDirection = PlayerMovement.player.direction;
PlayerMovement.player.speed = (currentEvent.float0 > 0)
? PlayerMovement.player.walkSpeed / currentEvent.float0
: PlayerMovement.player.walkSpeed;
for (int i = 0; i < currentEvent.int0; i++)
{
PlayerMovement.player.updateDirection((int)currentEvent.dir);
Vector3 forwardsVector = PlayerMovement.player.getForwardVector();
if (currentEvent.bool0)
{
//if direction locked in
PlayerMovement.player.updateDirection(initialDirection);
}
PlayerMovement.player.setOverrideAnimPause(true);
yield return
(StartCoroutine(PlayerMovement.player.move(forwardsVector, false, currentEvent.bool0)));
PlayerMovement.player.setOverrideAnimPause(false);
}
PlayerMovement.player.speed = PlayerMovement.player.walkSpeed;
}
break;
case (CustomEventDetails.CustomEventType.TurnTo):
int direction;
float xDistance;
float zDistance;
if (currentEvent.object0.GetComponent <NPCHandler>() != null)
{
targetNPC = currentEvent.object0.GetComponent <NPCHandler>();
}
if (targetNPC != null)
{
if (currentEvent.object1 != null)
{
//calculate target objects's position relative to this objects's and set direction accordingly.
xDistance = targetNPC.hitBox.position.x - currentEvent.object1.transform.position.x;
zDistance = targetNPC.hitBox.position.z - currentEvent.object1.transform.position.z;
if (xDistance >= Mathf.Abs(zDistance))
{
//Mathf.Abs() converts zDistance to a positive always.
direction = 3;
} //this allows for better accuracy when checking orientation.
else if (xDistance <= Mathf.Abs(zDistance) * -1)
{
direction = 1;
}
else if (zDistance >= Mathf.Abs(xDistance))
{
direction = 2;
}
else
{
direction = 0;
}
targetNPC.setDirection(direction);
}
if (currentEvent.int0 != 0)
{
direction = targetNPC.direction + currentEvent.int0;
while (direction > 3)
{
direction -= 4;
}
while (direction < 0)
{
direction += 4;
}
targetNPC.setDirection(direction);
}
}
break;
case (CustomEventDetails.CustomEventType.Dialog):
for (int i = 0; i < currentEvent.strings.Length; i++)
{
Dialog.drawDialogBox();
yield return(StartCoroutine(Dialog.drawText(currentEvent.strings[i])));
if (i < currentEvent.strings.Length - 1)
{
while (!Input.GetButtonDown("Select") && !Input.GetButtonDown("Back"))
{
yield return(null);
}
}
}
if (nextEvent != null)
{
if (nextEvent.eventType != CustomEventDetails.CustomEventType.Choice)
{
while (!Input.GetButtonDown("Select") && !Input.GetButtonDown("Back"))
{
yield return(null);
}
if (!EventRequiresDialogBox(nextEvent.eventType))
{
Dialog.undrawDialogBox();
} // do not undraw the box if the next event needs it
}
}
else
{
while (!Input.GetButtonDown("Select") && !Input.GetButtonDown("Back"))
{
yield return(null);
}
Dialog.undrawDialogBox();
}
break;
case (CustomEventDetails.CustomEventType.Choice):
if (currentEvent.strings.Length > 1)
{
Dialog.drawChoiceBox(currentEvent.strings);
yield return(StartCoroutine(Dialog.choiceNavigate(currentEvent.strings)));
}
else
{
Dialog.drawChoiceBox();
yield return(StartCoroutine(Dialog.choiceNavigate()));
}
int chosenIndex = Dialog.chosenIndex;
chosenIndex = currentEvent.ints.Length - 1 - chosenIndex; //flip it to reflect the original input
Dialog.undrawChoiceBox();
Dialog.undrawDialogBox();
if (chosenIndex < currentEvent.ints.Length)
{
//only change tree if index is valid
if (currentEvent.ints[chosenIndex] != eventTreeIndex &&
currentEvent.ints[chosenIndex] < treesArray.Length)
{
JumpToTree(currentEvent.ints[chosenIndex]);
}
}
break;
case CustomEventDetails.CustomEventType.Sound:
SfxHandler.Play(currentEvent.sound);
break;
case CustomEventDetails.CustomEventType.ReceiveItem:
//Play Good for TM, Average for Item
AudioClip itemGetMFX = (currentEvent.bool0)
? Resources.Load <AudioClip>("Audio/mfx/GetGood")
: Resources.Load <AudioClip>("Audio/mfx/GetDecent");
BgmHandler.main.PlayMFX(itemGetMFX);
string firstLetter = currentEvent.string0.Substring(0, 1).ToLowerInvariant();
Dialog.drawDialogBox();
if (currentEvent.bool0)
{
Dialog.StartCoroutine(Dialog.drawText(
SaveData.currentSave.playerName + " received TM" +
ItemDatabase.getItem(currentEvent.string0).getTMNo() + ": " + currentEvent.string0 + "!"));
}
else
{
if (currentEvent.int0 > 1)
{
Dialog.StartCoroutine(Dialog.drawText(
SaveData.currentSave.playerName + " received " + currentEvent.string0 + "s!"));
}
else if (firstLetter == "a" || firstLetter == "e" || firstLetter == "i" || firstLetter == "o" ||
firstLetter == "u")
{
Dialog.StartCoroutine(Dialog.drawText(
SaveData.currentSave.playerName + " received an " + currentEvent.string0 + "!"));
}
else
{
Dialog.StartCoroutine(Dialog.drawText(
SaveData.currentSave.playerName + " received a " + currentEvent.string0 + "!"));
}
}
yield return(new WaitForSeconds(itemGetMFX.length));
bool itemAdd = SaveData.currentSave.Bag.addItem(currentEvent.string0, currentEvent.int0);
Dialog.drawDialogBox();
if (itemAdd)
{
if (currentEvent.bool0)
{
yield return
(Dialog.StartCoroutine(Dialog.drawTextSilent(
SaveData.currentSave.playerName + " put the TM" +
ItemDatabase.getItem(currentEvent.string0).getTMNo() + " \\away into the bag.")));
}
else
{
if (currentEvent.int0 > 1)
{
yield return
(Dialog.StartCoroutine(Dialog.drawTextSilent(
SaveData.currentSave.playerName + " put the " + currentEvent.string0 +
"s \\away into the bag.")));
}
else
{
yield return
(Dialog.StartCoroutine(Dialog.drawTextSilent(
SaveData.currentSave.playerName + " put the " + currentEvent.string0 +
" \\away into the bag.")));
}
}
while (!Input.GetButtonDown("Select") && !Input.GetButtonDown("Back"))
{
yield return(null);
}
}
else
{
yield return(Dialog.StartCoroutine(Dialog.drawTextSilent("But there was no room...")));
while (!Input.GetButtonDown("Select") && !Input.GetButtonDown("Back"))
{
yield return(null);
}
}
Dialog.undrawDialogBox();
break;
case CustomEventDetails.CustomEventType.ReceivePokemon:
if (SaveData.currentSave.PC.hasSpace(0))
{
//Play Great for Pokemon
AudioClip pokeGetMFX = Resources.Load <AudioClip>("Audio/mfx/GetGreat");
PokemonData pkd = PokemonDatabase.getPokemon(currentEvent.ints[0]);
string pkName = pkd.getName();
Pokemon.Gender pkGender = Pokemon.Gender.CALCULATE;
if (pkd.getMaleRatio() == -1)
{
pkGender = Pokemon.Gender.NONE;
}
else if (pkd.getMaleRatio() == 0)
{
pkGender = Pokemon.Gender.FEMALE;
}
else if (pkd.getMaleRatio() == 100)
{
pkGender = Pokemon.Gender.MALE;
}
else
{
//if not a set gender
if (currentEvent.ints[2] == 0)
{
pkGender = Pokemon.Gender.MALE;
}
else if (currentEvent.ints[2] == 1)
{
pkGender = Pokemon.Gender.FEMALE;
}
}
Dialog.drawDialogBox();
yield return
(Dialog.StartCoroutine(Dialog.drawText(
SaveData.currentSave.playerName + " received the " + pkName + "!")));
BgmHandler.main.PlayMFX(pokeGetMFX);
yield return(new WaitForSeconds(pokeGetMFX.length));
string nickname = currentEvent.strings[0];
if (currentEvent.strings[1].Length == 0)
{
//If no OT set, allow nicknaming of Pokemon
Dialog.drawDialogBox();
yield return
(StartCoroutine(
Dialog.drawTextSilent("Would you like to give a nickname to \nthe " + pkName +
" you received?")));
Dialog.drawChoiceBox();
yield return(StartCoroutine(Dialog.choiceNavigate()));
int nicknameCI = Dialog.chosenIndex;
Dialog.undrawDialogBox();
Dialog.undrawChoiceBox();
if (nicknameCI == 1)
{
//give nickname
//SfxHandler.Play(selectClip);
yield return(StartCoroutine(ScreenFade.main.Fade(false, 0.4f)));
Scene.main.Typing.gameObject.SetActive(true);
StartCoroutine(Scene.main.Typing.control(10, "", pkGender,
Pokemon.GetIconsFromID_(currentEvent.ints[0], currentEvent.bool0)));
while (Scene.main.Typing.gameObject.activeSelf)
{
yield return(null);
}
if (Scene.main.Typing.typedString.Length > 0)
{
nickname = Scene.main.Typing.typedString;
}
yield return(StartCoroutine(ScreenFade.main.Fade(true, 0.4f)));
}
}
if (!EventRequiresDialogBox(nextEvent.eventType))
{
Dialog.undrawDialogBox();
}
int[] IVs = new int[]
{
Random.Range(0, 32), Random.Range(0, 32), Random.Range(0, 32),
Random.Range(0, 32), Random.Range(0, 32), Random.Range(0, 32)
};
if (currentEvent.bool1)
{
//if using Custom IVs
IVs[0] = currentEvent.ints[5];
IVs[1] = currentEvent.ints[6];
IVs[2] = currentEvent.ints[7];
IVs[3] = currentEvent.ints[8];
IVs[4] = currentEvent.ints[9];
IVs[5] = currentEvent.ints[10];
}
string pkNature = (currentEvent.ints[3] == 0)
? NatureDatabase.getRandomNature().getName()
: NatureDatabase.getNature(currentEvent.ints[3] - 1).getName();
string[] pkMoveset = pkd.GenerateMoveset(currentEvent.ints[1]);
for (int i = 0; i < 4; i++)
{
if (currentEvent.strings[4 + i].Length > 0)
{
pkMoveset[i] = currentEvent.strings[4 + i];
}
}
Debug.Log(pkMoveset[0] + ", " + pkMoveset[1] + ", " + pkMoveset[2] + ", " + pkMoveset[3]);
Pokemon pk = new Pokemon(currentEvent.ints[0], nickname, pkGender, currentEvent.ints[1],
currentEvent.bool0, currentEvent.strings[2], currentEvent.strings[3],
currentEvent.strings[1], IVs[0], IVs[1], IVs[2], IVs[3], IVs[4], IVs[5], 0, 0, 0, 0, 0, 0,
pkNature, currentEvent.ints[4],
pkMoveset, new int[4]);
SaveData.currentSave.PC.addPokemon(pk);
}
else
{
//jump to new tree
JumpToTree(currentEvent.int0);
}
break;
case (CustomEventDetails.CustomEventType.SetActive):
if (currentEvent.bool0)
{
currentEvent.object0.SetActive(true);
}
else
{
if (currentEvent.object0 == this.gameObject)
{
deactivateOnFinish = true;
}
else if (currentEvent.object0 != PlayerMovement.player.gameObject)
{
//important to never deactivate the player
currentEvent.object0.SetActive(false);
}
}
break;
case CustomEventDetails.CustomEventType.SetCVariable:
SaveData.currentSave.setCVariable(currentEvent.string0, currentEvent.float0);
break;
case (CustomEventDetails.CustomEventType.LogicCheck):
bool passedCheck = false;
CustomEventDetails.Logic lo = currentEvent.logic;
switch (lo)
{
case CustomEventDetails.Logic.CVariableEquals:
if (currentEvent.float0 == SaveData.currentSave.getCVariable(currentEvent.string0))
{
passedCheck = true;
}
break;
case CustomEventDetails.Logic.CVariableGreaterThan:
if (SaveData.currentSave.getCVariable(currentEvent.string0) > currentEvent.float0)
{
passedCheck = true;
}
break;
case CustomEventDetails.Logic.CVariableLessThan:
if (SaveData.currentSave.getCVariable(currentEvent.string0) < currentEvent.float0)
{
passedCheck = true;
}
break;
case CustomEventDetails.Logic.GymBadgeNoOwned:
if (Mathf.FloorToInt(currentEvent.float0) < SaveData.currentSave.gymsBeaten.Length &&
Mathf.FloorToInt(currentEvent.float0) >= 0)
{
//ensure input number is valid
if (SaveData.currentSave.gymsBeaten[Mathf.FloorToInt(currentEvent.float0)])
{
passedCheck = true;
}
}
break;
case CustomEventDetails.Logic.GymBadgesEarned:
int badgeCount = 0;
for (int bi = 0; bi < SaveData.currentSave.gymsBeaten.Length; bi++)
{
if (SaveData.currentSave.gymsBeaten[bi])
{
badgeCount += 1;
}
}
if (badgeCount >= currentEvent.float0)
{
passedCheck = true;
}
break;
case CustomEventDetails.Logic.PokemonIDIsInParty:
for (int pi = 0; pi < 6; pi++)
{
if (SaveData.currentSave.PC.boxes[0][pi] != null)
{
if (SaveData.currentSave.PC.boxes[0][pi].getID() ==
Mathf.FloorToInt(currentEvent.float0))
{
passedCheck = true;
pi = 6;
}
}
}
break;
case CustomEventDetails.Logic.SpaceInParty:
if (currentEvent.bool0)
{
if (!SaveData.currentSave.PC.hasSpace(0))
{
passedCheck = true;
}
}
else
{
if (SaveData.currentSave.PC.hasSpace(0))
{
passedCheck = true;
}
}
break;
}
if (passedCheck)
{
int newTreeIndex = currentEvent.int0;
if (newTreeIndex != eventTreeIndex && //only change tree if index is valid
newTreeIndex < treesArray.Length)
{
JumpToTree(newTreeIndex);
}
}
break;
case CustomEventDetails.CustomEventType.TrainerBattle:
//custom cutouts not yet implemented
StartCoroutine(ScreenFade.main.FadeCutout(false, ScreenFade.slowedSpeed, null));
//Automatic LoopStart usage not yet implemented
Scene.main.Battle.gameObject.SetActive(true);
Trainer trainer = currentEvent.object0.GetComponent <Trainer>();
if (trainer.battleBGM != null)
{
Debug.Log(trainer.battleBGM.name);
BgmHandler.main.PlayOverlay(trainer.battleBGM, trainer.samplesLoopStart);
}
else
{
BgmHandler.main.PlayOverlay(Scene.main.Battle.defaultTrainerBGM,
Scene.main.Battle.defaultTrainerBGMLoopStart);
}
Scene.main.Battle.gameObject.SetActive(false);
yield return(new WaitForSeconds(1.6f));
Scene.main.Battle.gameObject.SetActive(true);
StartCoroutine(Scene.main.Battle.control(true, trainer, currentEvent.bool0));
while (Scene.main.Battle.gameObject.activeSelf)
{
yield return(null);
}
//yield return new WaitForSeconds(sceneTransition.FadeIn(0.4f));
yield return(StartCoroutine(ScreenFade.main.Fade(true, 0.4f)));
if (currentEvent.bool0)
{
if (Scene.main.Battle.victor == 1)
{
int newTreeIndex = currentEvent.int0;
if (newTreeIndex != eventTreeIndex && //only change tree if index is valid
newTreeIndex < treesArray.Length)
{
JumpToTree(newTreeIndex);
}
}
}
break;
}
}
public ActionFirstEvent()
{
_event = new Handler(onActionFirst);
_npcEvent = new NPCHandler(onActionFirstNPC);
}
/// <summary>
/// Tries to sell the given Item of the given Character
/// </summary>
/// <param name="chr">The seller.</param>
/// <param name="item">May be null (will result into error message for chr)</param>
/// <param name="amount">The amount of Item to sell.</param>
public void SellItem(Character chr, Item item, int amount)
{
if (!CheckVendorInteraction(chr))
{
return;
}
var error = SellItemError.Success;
if (!CanPlayerSellItem(chr, item, ref error))
{
NPCHandler.SendSellError(chr.Client, NPC.EntityId, item.EntityId, error);
return;
}
if (amount <= 0 || amount > item.Amount)
{
amount = item.Amount;
}
var money = (uint)(amount * item.Template.SellPrice);
var maxDur = item.MaxDurability;
if (maxDur != 0)
{
money = (money * (uint)item.Durability) / (uint)maxDur;
}
chr.Money += money;
var invError = InventoryError.OK;
if (amount < item.Amount)
{
// split the stack
// create a new stack of items with the number sold
var newBuyBackItem = item.CreateNew(amount);
// subtract the sold items from the original stack
// if item.Amount reaches 0, the item is destroyed
item.Amount -= amount;
// Move the new stack to the buyback partial inventory
invError = chr.Inventory.BuyBack.AddBuyBackItem(newBuyBackItem, true);
}
else if (item.Slot != (int)InventorySlot.Invalid)
{
// Move the item from the Player's inventory to the buyback inventory
invError = chr.Inventory.BuyBack.AddBuyBackItem(item, false);
}
if (invError != InventoryError.OK)
{
ItemHandler.SendInventoryError(chr.Client, invError);
return;
}
chr.Achievements.CheckPossibleAchievementUpdates(AchievementCriteriaType.MoneyFromVendors, money);
NPCHandler.SendSellError(chr.Client, NPC.EntityId, item.EntityId, error);
}
public void BuyItem(Character chr, uint itemEntryId, BaseInventory bag, int amount, int slot)
{
if (!CheckVendorInteraction(chr))
{
return;
}
var item = GetVendorItem(itemEntryId);
if (item == null)
{
return;
}
amount = Math.Max(amount, 1);
if (item.BuyStackSize > 0)
{
amount = amount * item.BuyStackSize;
}
uint price;
var buyErr = CanPlayerBuyItem(chr, item, amount, out price);
if (buyErr != BuyItemError.Ok)
{
NPCHandler.SendBuyError(chr, NPC, item.Template.ItemId, buyErr);
return;
}
BaseInventory inv = chr.Inventory;
InventoryError err;
if (inv.IsValidSlot(slot))
{
err = inv.TryAdd(item.Template, ref amount, slot);
}
else
{
// count will be set to the actual amount of items that found space in the inventory
// if not all could be added, err contains the reason why
err = inv.TryAdd(item.Template, ref amount);
}
if (err != InventoryError.OK)
{
ItemHandler.SendInventoryError(chr.Client, null, null, err);
}
if (amount <= 0)
{
// Nothing was purchased
// Should usually never happen, but just to make sure
ItemHandler.SendInventoryError(chr.Client, null, null, InventoryError.INVENTORY_FULL);
return;
}
chr.Money -= (price * (uint)amount); // we already checked that our money is sufficient
if (item.ExtendedCostEntry != null)
{
var exCost = item.ExtendedCostEntry;
chr.HonorPoints -= exCost.HonorCost;
chr.ArenaPoints -= exCost.ArenaPointCost;
foreach (var reqItem in exCost.RequiredItems)
{
if (reqItem.Id == ItemId.None)
{
break;
}
if (!chr.Inventory.RemoveByItemId(reqItem.Id, reqItem.Cost, false))
{
// should not happen
LogManager.GetCurrentClassLogger().Warn("Unable to remove required item \"{0}\" from player \"{1}\" when purchasing item: {2}",
reqItem.Template, chr, item.Template);
}
}
}
// manage stock
int remainingAmount;
if (item.RemainingStockAmount != UnlimitedSupply)
{
// The vendor had a limited supply of this item, update the chr.Client with the new inventory
remainingAmount = item.RemainingStockAmount - amount;
//NPCHandler.SendVendorInventoryList(chr.Client, NPC.EntityId, ConstructVendorItemList(chr));
}
else
{
remainingAmount = UnlimitedSupply;
}
// send packet
NPCHandler.SendBuyItem(chr.Client, NPC, item.Template.ItemId, amount, remainingAmount);
}
public DialogueEvent()
{
_event = new Handler(onDialogue);
_npcEvent = new NPCHandler(onDialogueNPC);
_rivalEvent = new RivalHandler(onDialogueRival);
}
