private void GrabObject(GameObject grabbableObject)
{
m_hasGrabbed = true;
m_grabbedObject = grabbableObject;
m_grabbedObject.GetComponent <Tool>().GetGrabbed(transform);
m_toolObject = m_grabbedObject.GetComponent <IUsable>();
}
private void ReleaseObject()
{
m_hasGrabbed = false;
m_toolObject = null;
m_grabbedObject.GetComponent <Tool>().GetReleased();
m_grabbedObject = null;
}
private void Start()
{
iUsable = triggerableObject.GetComponent <IUsable>();
Assert.IsNotNull(enemies, "None enemies specified, please wire correctly");
enemyCount = enemies.Count;
}
private void ObjectTakenAction(GameObject obj, PlayerComponent playerComponent, IUsable usable)
{
string typeName = usable.GetType().Name;
AudioClip clip = null;
if (typeName == nameof(BottleComponent))
{
clip = bottleSound;
}
else if (typeName == nameof(PukeComponent))
{
clip = pukeSound;
}
else if (typeName == nameof(NPCComponent))
{
clip = npcTakeSound;
}
if (clip == null)
{
return;
}
_audioSrc.clip = clip;
_audioSrc.Play();
}
private void InteractWithItemObject(ItemObject itemObject)
{
Debug.Assert(itemObject.Item != null);
IUsable usable = itemObject.Item as IUsable;
IPickupable pickupable = itemObject.Item as IPickupable;
IEquipable equipable = itemObject.Item as IEquipable;
IStackable stackable = itemObject.Item as IStackable;
if (usable != null)
{
usable.OnUse(_stats, itemObject);
}
else if (pickupable != null)
{
if (equipable != null && equipable.IsDurable && _equipment.EquipmentTable[equipable.EquipmentType].IsEmpty)
{
equipable.OnEquip(_equipment, _stats);
}
else if (stackable != null)
{
stackable.OnStack(_inventory);
}
else
{
pickupable.OnPutInInventory(_inventory);
}
pickupable.OnRemoveFromGround(itemObject);
}
}
public static IUsable <TResult> Select <T, TResult>(
this IUsable <T> source,
Func <T, TResult> selector)
where TResult : IDisposable
{
return(new SelectDisposableUsable <T, TResult>(source, selector));
}
public void OnTriggerExit2D(Collider2D other)
{
if (other.tag == "Usable")
{
usable = null;
}
}
// Update is called once per frame
void Update()
{
Debug.DrawRay(transform.position, transform.TransformDirection(Vector3.forward) * 100, Color.yellow);
if (Input.GetMouseButtonDown(RMB))
{
Ray ray = PlayerCamera.ScreenPointToRay(Input.mousePosition);
if (Physics.Raycast(ray, out raycastHit, ClickDistance, layerMask))
{
if (raycastHit.transform)
{
//Debug.Log(raycastHit.transform.gameObject);
IUsable Clickable = raycastHit.transform.GetComponent <IUsable>();
//Debug.Log(Clickable);
if (Clickable != null)
{
if (typeof(IInteractionable).IsAssignableFrom(Clickable.GetType()))
{
//Debug.Log("Interactionable");
((IInteractionable)Clickable).PerformInteraction();
}
else
{
//Debug.Log("Usable");
Clickable.PerformAction();
}
}
}
}
}
}
public override void AddItem(IUsable Item)
{
if (Rider != null)
{
Rider.AddItem(Item);
}
}
public SelectUsable(
IUsable <TOuter> source,
Func <TOuter, T> selector)
{
this.source = source;
this.selector = selector;
}
internal void ItemButton(IUsable item, int m)
{
item.Drop();
if (m==0) item.Take();
else if (m==1) item.Use();
else item.Drop();
}
private void Update()
{
RaycastHit hit;
int layerMask = ~(1 << LayerMask.NameToLayer("FirstPass"));
if (Physics.Raycast(Camera.main.transform.position, Camera.main.transform.forward, out hit, maxDistance, layerMask))
{
IUsable usable = hit.collider.GetComponentInParent <IUsable>();
if (usable != null && (usable as Behaviour).enabled)
{
target = usable;
}
else
{
target = null;
}
}
else
{
target = null;
}
if (target != null && Input.GetKeyDown(KeyCode.E) && Time.timeScale != 0.0f)
{
if (target is IPickable)
{
AudioManager.PlaySfx(pickupClip, transform);
}
target.Use(this);
}
Debug.DrawLine(transform.position, transform.position + transform.forward * maxDistance, Color.red);
}
public Command(CmdAction action, CmdDirection direction, IItem item = null, IUsable usable = null)
{
Action = action;
Direction = direction;
Item = item;
Usable = usable;
}
public static bool Prefix(UseButtonManager __instance, IUsable CAKODNGLPDF)
{
if (CAKODNGLPDF == null)
{
return(true);
}
var Console = CAKODNGLPDF.TryCast <Console>();
if (Console == null)
{
return(true);
}
if (!Map.ContainsKey(Console.ConsoleId))
{
return(true);
}
var CustomUsable = Map[Console.ConsoleId];
__instance.currentTarget = CAKODNGLPDF;
__instance.UseButton.sprite = CustomUsable.UseIcon != null
? CustomUsable.UseIcon
: __instance.UseImage;
CooldownHelpers.SetCooldownNormalizedUvs(__instance.UseButton);
__instance.UseButton.material.SetFloat(Globals.PERCENT,
CustomUsable.PercentCooldown);
__instance.UseButton.color = UseButtonManager.EnabledColor;
return(false);
}
private void Pull()
{
hits = Physics.SphereCastAll(owner.position, 1, owner.forward, pullDistance, LayerMask.GetMask("dynamic"));
foreach (RaycastHit h in hits)
{
if (h.rigidbody)
{
float dist = 1 - Mathf.Clamp01(Vector3.Distance(pullTarget, h.transform.position));
// Switch to holding
if (dist > 0.03f)
{
usable = h.rigidbody.GetComponent <IUsable>();
if (Usable())
{
UseHeldObject();
}
else
{
holding = true;
heldRigid = h.rigidbody;
}
return;
}
// Added the forces
h.rigidbody.AddForce((pullTarget - h.point).normalized * 40 * (Mathf.Cos(dist * Mathf.PI * 0.5f)));
h.rigidbody.AddForce((-h.rigidbody.velocity) * Mathf.Sin(dist * Mathf.PI * 0.5f), ForceMode.Impulse);
h.rigidbody.AddForce(Vector3.up * 9.78f * 4);
}
}
}
public void OnTriggerEnter2D(Collider2D other)
{
if (other.tag == "Usable")
{
usable = other.GetComponent <IUsable>();
}
}
public static IUsable <TResult> SelectMany <TOuter, TInner, TResult>(
this IUsable <TOuter> outerUsable,
Func <TOuter, IUsable <TInner> > innerUsableSelector,
Func <TOuter, TInner, TResult> resultSelector)
{
return(new SelectManyUsable <TOuter, TInner, TResult>(
outerUsable, innerUsableSelector, resultSelector));
}
private void Awake()
{
audioSource = GetComponent <AudioSource>();
if (someObject != null)
{
interactableObject = someObject.GetComponent <IUsable>();
}
}
private void AddBlinkAbility(IUsable <BlinkAbility> blink)
{
var blinkAbility = blink.GetUsableAbility();
this.UsableBlinkAbilities.Add(blinkAbility);
this.menu.AbilitySettings.AddBlinkAbility(blinkAbility.Ability);
this.AddEvadableAbilities(blinkAbility);
}
private void AddCounterAbility(IUsable <CounterAbility> counter)
{
var counterAbility = counter.GetUsableAbility();
this.UsableCounterAbilities.Add(counterAbility);
this.menu.AbilitySettings.AddCounterAbility(counterAbility.Ability);
this.AddEvadableAbilities(counterAbility);
}
private void AddDisableAbility(IUsable <DisableAbility> disable)
{
var disableAbility = disable.GetUsableAbility();
this.UsableDisableAbilities.Add(disableAbility);
this.menu.AbilitySettings.AddDisableAbility(disableAbility.Ability);
this.AddEvadableAbilities(disableAbility);
}
private void AddDodgeAbility(IUsable <DodgeAbility> dodge)
{
var dodgeAbility = dodge.GetUsableAbility();
this.UsableDodgeAbilities.Add(dodgeAbility);
this.menu.AbilitySettings.AddDodgeAbility(dodgeAbility.Ability);
this.AddEvadableAbilities(dodgeAbility);
}
void OnTriggerExit(Collider other)
{
IUsable i = other.GetComponent <IUsable>();
if (i == interaction_target)
{
interaction_target = null;
}
}
public SelectManyUsable(
IUsable <TOuter> outerUsable,
Func <TOuter, IUsable <TInner> > innerUsableSelector,
Func <TOuter, TInner, T> resultSelector)
{
this.outerUsable = outerUsable;
this.innerUsableSelector = innerUsableSelector;
this.resultSelector = resultSelector;
}
public virtual void AddItem(IUsable Item)
{
_items.Add(Item);
if (HealthText != null)
{
HealthText.text = _items.Where(item => item is HealingItem).Count().ToString();
}
}
public SelectManyDisposableUsable(
IUsable <TOuter> outerUsable,
Func <TOuter, TInner> innerDisposableSelector,
Func <TOuter, TInner, T> resultSelector)
{
this.source = outerUsable;
this.collectionSelector = innerDisposableSelector;
this.resultSelector = resultSelector;
}
public PlayerDataComponent() : base()
{
actionState = PlayerActionState.Default;
usableObject = null;
speedModifierObject = null;
trashCount = 0;
closeWindows = new HashSet <WindowComponent>();
id = -1;
}
public void Use(IUsable usable)
{
if (usable != null)
{
InUse.Add(usable);
usable.OnUse(HumanId);
usable.IsBusy = true;
}
}
public static IUsable <TResult> Select <T, TResult>(
this IUsable <T> source,
Func <T, TResult> selector,
bool dispose = true)
{
return((dispose && typeof(TResult) is IDisposable)
? (IUsable <TResult>) new SelectCastDisposableUsable <T, TResult>(source, selector)
: (IUsable <TResult>) new SelectUsable <T, TResult>(source, selector));
}
private void OnTriggerExit(Collider other)
{
var findingUsable = other.GetComponent <IUsable>();
if (findingUsable == usable)
{
usable = null;
}
}
public bool IsUsable => !usable.Equals(null); /*usable != null;*/ //TODO: Баг, поле ссылается на удаленный объект
private void OnTriggerEnter(Collider other)
{
var findingUsable = other.GetComponent <IUsable>();
if (findingUsable != null)
{
usable = findingUsable;
}
}
public virtual bool Fight(IUsable pickedItem)
{
if ((pickedItem is ICommercialItem &&
this.hero.BagOfItems.Contains(pickedItem as ICommercialItem)) ||
(pickedItem is Skill &&
(this.hero.ListOfFightingSkills.Contains(pickedItem as ISkill) ||
this.hero.ListOfMentalSkills.Contains(pickedItem as ISkill))))
{
if (this.hero.IsAlive())
{
this.hero.UseItem(pickedItem);
if (!(pickedItem is IEnergizer))
{
int damage = this.AttackPowerModifier(this.hero);
this.creature.DecreaseCurrentEnergy(damage);
}
}
else
{
this.IsHeroWinner = false;
this.hero.ResetCurrentEnergy();
return false;
}
if (this.creature.IsAlive())
{
int damage = this.AttackPowerModifier(this.creature);
this.hero.DecreaseCurrentEnergy(damage);
}
else
{
this.IsHeroWinner = true;
this.hero.ResetCurrentEnergy();
return false;
}
return true;
}
else
{
throw new ApplicationException("Game rule violation! Hero cannot engage items that don't belong to him");
}
}
private void Battle(Bitmap image1, Bitmap image2, Bitmap image3, IUsable attack)
{
this.picEvil.BackgroundImage = image2;
this.pnlFight.Refresh();
Thread.Sleep(200);
this.picEvil.BackgroundImage = image1;
this.pnlFight.Refresh();
Thread.Sleep(500);
this.arena.Fight(attack);
this.picNinja.BackgroundImage = Resources.NinjaFightHit;
this.pnlFight.Refresh();
Thread.Sleep(200);
if (this.ninja.CurrentEnergy < 0)
{
this.prgrsFightNinja.Value = 0;
}
else
{
this.prgrsFightNinja.Value = this.ninja.CurrentEnergy;
}
if (this.evil.CurrentEnergy < 0)
{
this.prgrsFightEvil.Value = 0;
}
else
{
this.prgrsFightEvil.Value = this.evil.CurrentEnergy;
}
if (arena.IsHeroWinner)
{
this.picNinja.BackgroundImage = Resources.NinjaChampion;
this.picEvil.BackgroundImage = image3;
if (fightForJob)
{
this.jobOffice.RewardNinja(ninja, job);
}
else if (isGymFight)
{
this.gym.GiveReward(ninja);
}
else if(isSchoolFight)
{
this.academy.GiveReward(ninja);
}
this.pnlFight.Refresh();
Thread.Sleep(1000);
MessageBox.Show("Congratilations! You Win!");
this.pnlFight.Visible = false;
this.fightForJob = false;
this.isGymFight = false;
this.isSchoolFight = false;
for (int i = 0; i < this.speciaItemsButtons.Length; i++)
{
this.speciaItemsButtons[i].Visible = false;
}
}
else if (this.prgrsFightNinja.Value <= 0)
{
this.picNinja.BackgroundImage = Resources.NinjaFightDead;
this.pnlFight.Refresh();
MessageBox.Show("Looser!");
this.ninja.CurrentEnergy = this.ninja.TotalEnergy;
this.pnlFight.Visible = false;
this.fightForJob = false;
this.isGymFight = false;
this.isSchoolFight = false;
for (int i = 0; i < this.speciaItemsButtons.Length; i++)
{
speciaItemsButtons[i].Visible = false;
}
}
this.picNinja.BackgroundImage = Resources.NinjaFight;
this.pnlFight.Refresh();
Thread.Sleep(200);
}
private void Fight(IUsable attack)
{
if (evil.GetType().Name == "Jedi")
{
this.Battle(Resources.EnemyJedi, Resources.EnemyJediHit, Resources.EnemyJediDead, attack);
}
else if (evil.GetType().Name == "Assassin" || evil.GetType().Name == "Boss")
{
this.Battle(Resources.EnemyGoblin, Resources.EnemyGoblinHitted, Resources.EnemyGoblinDead, attack);
}
else
{
this.Battle(Resources.EnemyRobo, Resources.EnemyRoboHit, Resources.EnemyRoboDead, attack);
}
}
public virtual bool GetItem(IUsable item)
{
if (item is IEnergyExpandable)
{
this.TotalEnergy += (item as IEnergyExpandable).UpgradeTotalEnergy;
this.ResetCurrentEnergy();
return true;
}
else if (item is ICommercialItem && this.BagOfItems.Count < BagOfItemCapacity)
{
this.BagOfItems.Add(item as ICommercialItem);
this.BagOfItems = this.BagOfItems
.OrderBy(it => it.GetType().Name)
.ThenBy(it => it.Price)
.ToList();
return true;
}
else if (item is ISkill)
{
var newAttack = item as ISkill;
if (newAttack.AttackType == PowerEnum.ForcePower)
{
this.ListOfFightingSkills.Add(newAttack);
return true;
}
else if (newAttack.AttackType == PowerEnum.MentalPower)
{
this.ListOfMentalSkills.Add(newAttack);
return true;
}
}
return false;
}
public virtual void UseItem(IUsable item)
{
if (item is ICommercialItem)
{
if (item is IEnergizer)
{
this.IncreaseCurrentEnergy((item as IEnergizer).HealingPoints);
}
this.BagOfItems.Remove(item as ICommercialItem);
}
this.engagedItem = item;
}
