public Test()
{
EquipmentInventory i = new EquipmentInventory();
Items.Equipment item = new Items.Equipment("armor_1", "test", EquipSlot.ARMOR);
i.Add(item); // success
}
public virtual IEnumerator ReloadEnum(EquipmentInventory myWeaponManager)
{
// do nothing
yield return(null);
while (counter <= reloadTime && counter > 0)
{
counter -= Time.deltaTime;
//Debug.Log("reloading" + counter);
if (Input.GetButtonDown("Fire1"))
{
counter = 0;
StopCoroutine(ReloadEnum(null));
}
else if (counter <= 0)
{
//throws out all ammo in the gun
if (ammoMax > myWeaponManager.AmmoBackpack[(int)myAmmoType])
{
ammo = myWeaponManager.AmmoBackpack[(int)myAmmoType];
myWeaponManager.AmmoBackpack[(int)myAmmoType] = 0;
}
else
{
myWeaponManager.AmmoBackpack[(int)myAmmoType] -= ammoMax;
ammo = ammoMax;
}
Debug.Log("RELOADED");
}
yield return(null);
}
}
public void equipment_selected(TMP_Dropdown d)
{
selecting = true;
string e = d.captionText.text;
EquipmentInventory ei = TurnPhaser.I.active_disc.equipment_inventory;
// Undo the selection, the same equipment cannot be worn more than once,
// and only one of a type can be worn at once.
if (ei.has_equipped(e) || ei.get_equipment_amount(e) > 1)
{
if (ei.equipment_slots[dropdowns[d]].full)
{
string name = ei.equipment_slots[dropdowns[d]].equipment.name;
d.value = d.options.FindIndex(option => option.text == name);
}
else
{
d.value = d.options.FindIndex(option => option.text == "Empty");
}
return;
}
// Unequip existing worn item.
if (ei.equipment_slots[dropdowns[d]].full)
{
ei.unequip(dropdowns[d]);
}
hide_equipment_descriptionP();
ei.equip(e, dropdowns[d]);
}
public void load_discipline(Discipline disc)
{
EquipmentInventory ei = disc.equipment_inventory;
unlock_slots(ei);
fill_dropdowns(ei);
}
public virtual IEnumerator FireEnum(GameObject myWeapon, Camera myCamera, EquipmentInventory myInventory)
{
if (ammo > 0)
{
counter = rateOfFire;
RaycastHit hit;
if (Physics.Raycast(myWeapon.transform.position, myWeapon.transform.forward, out hit, range))
{
// damage target or create decal or whatever.
Debug.Log(hit.transform.name);
}
BulletTrail = ObjectPoolingManager.Instance.GetObject("bullet");
BulletTrail.SetActive(true);
BulletTrail.GetComponent <MusselEffect>().SetPositions(myWeapon.transform.position, hit.point);
ammo--;
ApplyRecoil(myWeapon);
//ApplyRecoil(myCamera.gameObject);
}
else
{
Debug.Log("weapon empty");
Reload(myInventory);
//Click empty
}
yield return(null);
while (counter <= rateOfFire && counter > 0)
{
counter -= Time.deltaTime;
//Debug.Log("weapon not ready: "+counter.ToString());
yield return(null);
}
}
public Inventory()
{
this.keys = 0;
this.gold = 0;
this.potions = 0;
this.equipmentInventory = new EquipmentInventory();
this.EquipmentInventory = equipmentInventory.AsReadOnly();
}
public void fill_dropdowns(EquipmentInventory ei)
{
foreach (TMP_Dropdown d in dropdowns.Keys)
{
fill_dropdown(d, ei);
select_equipped(ei);
}
}
public void load_equipment_description(EquipmentInventory ei, string e)
{
if (!ei.has_equipped(e))
{
return;
}
descriptionP.SetActive(true);
descriptionT.text = ei.equipment[e][0].description;
}
public void unequipItem(EquipItem eitem)
{
EquipmentInventory einv = _getEquipmentInventory();
if (!einv)
{
Debug.LogError("Unit has invalid EquipmentInventory");
}
einv.unequipItem(eitem);
}
public Player()
{
Type |= ObjectTypes.Player;
inventory = new PlayerInventory(this, (UpdateFields.PLAYER_FARSIGHT - UpdateFields.PLAYER_FIELD_INV_SLOT_HEAD) / 2);
_equipment = new EquipmentInventory(this);
_backPack = new BackPackInventory(this);
_bank = new BankInventory(this);
_bankBags = new BankBagsInventory(this);
_keyRing = new KeyRingInventory(this);
}
void Awake()
{
if (instance != null)
{
Debug.LogWarning("More than one instance of Inventory found!");
return;
}
instance = this;
}
void Start()
{
binventory = inventory.instance;
jEquipmentInventory = EquipmentInventory.instance;
binventory.onItemChangedCallback += UpdateUI;
jEquipmentInventory.onItemChangedCallback += UpdateUI;
slots = itemsParent.GetComponentsInChildren <InventorySlot>();
gearslots = gearParent.GetComponentsInChildren <EquipmentInventorySlot>();
jinventoryUI.SetActive(false);
}
private void Start()
{
_player = GetComponent <Player>();
_playerAbilitySystem = GetComponent <AbilitiesSystem>();
_equipmentInventory = new EquipmentInventory();
_playerInventory = GetComponent <Player>().Inventory;
equipmentInventoryUI.SetPlayer(GetComponent <Player>());
equipmentInventoryUI.SetInventory(_equipmentInventory);
_basePlayerMoveSpeed = GetComponent <NavMeshAgent>().speed;
}
public override void Fire(GameObject myWeapon, Camera myCamera, EquipmentInventory myWeaponManager)
{
if (notCounter <= 0)
{
StartCoroutine(FireEnum(myWeapon, myCamera, myWeaponManager));
}
else
{
Debug.Log("weapon Not Ready");
}
}
//-------------------------------------------------------------------------------------------------
// private methods
//-------------------------------------------------------------------------------------------------
private EquipmentInventory _getEquipmentInventory()
{
EquipmentInventory einv = mInventory as EquipmentInventory;
if (!einv)
{
Debug.LogError("Unit does not have an equippment inventory.");
return(null);
}
return(einv);
}
private void OnTriggerEnter(Collider other)
{
EquipmentInventory player = other.gameObject.GetComponent <EquipmentInventory>();
//StateManager playerA = collision.gameObject.GetComponent<StateManager>();
if (player != null)
{
player.AddAmmoToBackpack((int)myAmmoType, ammoValue);
Destroy(gameObject);
}
}
void Start()
{
myRigidBody = GetComponent <Rigidbody>();
myCamera = GetComponentInChildren <Camera>();
myMovement = GetComponent <MovementScript>();
myMenu = GetComponent <Interactable>();
SetPlayerState(PlayerState.Falling);
SetPlayerStance(PlayerStance.Standing);
myMovement.SetRunForce(myMovement.RunForce);
myInventoryManager = GetComponent <ItemWheel>();
myInventory = GetComponent <EquipmentInventory>();
}
public List <EquipItem> getAvailableEquipItems()
{
List <EquipItem> alist = new List <EquipItem>();
EquipmentInventory einv = _getEquipmentInventory();
if (!einv)
{
return(alist);
}
alist = einv.getAvailableEquipItems();
return(alist);
}
public List <EquipItem> getEquippedItems()
{
List <EquipItem> elist = new List <EquipItem>();
EquipmentInventory einv = _getEquipmentInventory();
if (!einv)
{
return(elist);
}
elist = einv.getEquippedItems();
return(elist);
}
private void select_equipped(EquipmentInventory ei)
{
foreach (TMP_Dropdown d in dropdowns.Keys)
{
EquipmentSlot es = ei.equipment_slots[dropdowns[d]];
if (!es.full)
{
continue;
}
d.captionText.text = es.equipment.name;
}
}
public override void dropInventory()
{
//drop the units inventory on the ground
//To Do: Implement Items that are visible on the map
//Currently I'm just deleting them
EquipmentInventory einv = _getEquipmentInventory();
if (!einv)
{
return;
}
einv.wipe();
}
public void unlock_slots(EquipmentInventory ei)
{
if (ei == null)
{
return;
}
int highest_unlocked_slot = ei.get_highest_unlocked_slot();
foreach (TMP_Dropdown d in dropdowns.Keys)
{
activate_equipment_slot(d, dropdowns[d] <= highest_unlocked_slot);
}
}
public void load_equipment_description(string e)
{
if (e == "Empty")
{
return;
}
EquipmentInventory ei = TurnPhaser.I.active_disc.equipment_inventory;
if (!ei.has(e))
{
return;
}
descriptionP.SetActive(true);
descriptionT.text = ei.equipment[e][0].description;
}
private void show_equipment_boosts()
{
if (unit.is_enemy)
{
return;
}
EquipmentInventory ei = Controller.I.get_disc(get_punit().owner_ID).equipment_inventory;
hpT.color = ei.get_stat_boost_amount(unit.get_ID(), Unit.HEALTH) > 0 ?
equipment_text_color : Color.white;
defT.color = ei.get_stat_boost_amount(unit.get_ID(), Unit.DEFENSE) > 0 ?
equipment_text_color : Color.white;
attT.color = ei.get_stat_boost_amount(unit.get_ID(), Unit.ATTACK) > 0 ?
equipment_text_color : Color.white;
}
public override IEnumerator FireEnum(GameObject myWeapon, Camera myCamera, EquipmentInventory myWeaponManager)
{
if (ammo > 0)
{
notCounter = rateOfFire;
RaycastHit hit;
for (int i = 0; i < pellets; i++)
{
Vector3 forwardVector = Vector3.forward;
float deviation = Random.Range(0f, maxDeviation);
float angle = Random.Range(0f, 360f);
forwardVector = Quaternion.AngleAxis(deviation, Vector3.up) * forwardVector;
forwardVector = Quaternion.AngleAxis(angle, Vector3.forward) * forwardVector;
forwardVector = myWeapon.transform.rotation * forwardVector;
if (Physics.Raycast(myWeapon.transform.position, forwardVector, out hit, range))
{
Debug.DrawRay(myWeapon.transform.position, forwardVector * hit.distance, Color.yellow);
// damage target or create decal or whatever.
Debug.Log(hit.transform.name);
}
//create a bullet trails pool which can be pulled from for any weapon?
BulletTrail = ObjectPoolingManager.Instance.GetObject("bullet");
BulletTrail.SetActive(true);
BulletTrail.GetComponent <MusselEffect>().SetPositions(myWeapon.transform.position, hit.point);
}
ammo--;
ApplyRecoil(myWeapon);
//ApplyRecoil(myCamera.gameObject);
}
else
{
Debug.Log("weapon empty");
Reload(myWeaponManager);
//Click empty
}
yield return(null);
while (notCounter <= rateOfFire && notCounter > 0)
{
notCounter -= Time.deltaTime;
//Debug.Log("weapon not ready: "+counter.ToString());
yield return(null);
}
}
private void fill_dropdown(TMP_Dropdown dropdown, EquipmentInventory ei)
{
clear_dropdown_options(dropdown);
List <TMP_Dropdown.OptionData> options = new List <TMP_Dropdown.OptionData>();
foreach (string e in ei.equipment.Keys)
{
if (ei.equipment[e].Count > 1)
{
options.Add(new TMP_Dropdown.OptionData(ei.equipment[e].Count.ToString() + " " + ei.equipment[e][0].name));
}
else
{
options.Add(new TMP_Dropdown.OptionData(ei.equipment[e][0].name));
}
}
dropdown.AddOptions(options);
}
public async Task <bool> Handle(AddEquipmentInventoryCommand request, CancellationToken cancellationToken)
{
EquipmentInventory _equipmentInventory = new EquipmentInventory
{
Quantity = request.MyEquipmentsInventoryVM.Quantity,
EncodingDate = DateTime.Now,
ItemPrice = request.MyEquipmentsInventoryVM.ItemPrice,
Remarks = request.MyEquipmentsInventoryVM.Remarks,
InventoryManagerID = request.MyEquipmentsInventoryVM.UserID,
EquipmentID = request.MyEquipmentsInventoryVM.EquipmentDetailsID,
DeliveryID = request.MyEquipmentsInventoryVM.DeliveryDetailsID,
CreatedOn = DateTime.Now
};
dbContext.EquipmentInventories.Add(_equipmentInventory);
await dbContext.SaveChangesAsync();
return(true);
}
//Reload
public virtual void Reload(EquipmentInventory myInventory)
{
if (counter <= 0)
{
if (myInventory.AmmoBackpack[(int)myAmmoType] > 0)
{
counter = reloadTime;
Debug.Log("reloading");
StartCoroutine(ReloadEnum(myInventory));
}
else
{
Debug.Log(" NO AMMO");
}
}
//Debug.Log("reloading");
//ammo in gun is lost, new ammo added from backpack
//ammoBackpack = ammoBackpack - (ammo + ammoMax);
//ammo = ammoMax;
}
public void Run()
{
equipmentInventory = EquipmentInventory.Instance;
}
public async Task Load(AtlasPlayer player)
{
API.DoScreenFadeOut(0);
Atlas.DiscordRichPresence.Status = player.Character.Fullname;
Atlas.DiscordRichPresence.Commit();
var transition = new LoadTransition();
if (!player.Character.MarkedAsRegistered)
{
API.StopPlayerSwitch();
}
var character = player.Character;
var position = !character.MarkedAsRegistered
? CharacterExtensions.RegistrationPosition
: character.Metadata.LastPosition ?? CharacterExtensions.DefaultPosition;
if (position == character.Metadata.LastPosition)
{
position.Y += 1f;
}
character.Revive(position);
try
{
var ped = Cache.Entity.Id;
var health = character.Health;
if (health > API.GetEntityMaxHealth(ped))
{
health = API.GetEntityMaxHealth(ped);
}
API.SetEntityHealth(ped, health);
API.SetPedArmour(ped, character.Shield);
}
catch (Exception)
{
// Dunno
}
var inventories = InventoryManager.GetModule();
var required = new InventoryContainer[]
{
new EquipmentInventory(new InventoryContainerBase
{
Seed = "equipment_inventory",
Name = "Utrustning",
SlotAmount = 5
}),
new PocketsInventory(new InventoryContainerBase
{
Seed = "pockets_inventory",
Name = "Fickor",
SlotAmount = 20
}),
new ProximityInventory(new InventoryContainerBase
{
Seed = "proximity_inventory",
Name = "Omgivning",
SlotAmount = 20
})
};
foreach (var entry in required)
{
if (character.Metadata.Inventories.All(self => self.Seed != entry.Seed))
{
inventories.RegisterContainer(entry);
character.Metadata.Inventories.Add(entry);
entry.CallRegistration();
}
else
{
var created = entry;
switch (entry.Seed.ToUpper())
{
case "EQUIPMENT_INVENTORY":
created = new EquipmentInventory(
character.Metadata.Inventories.FirstOrDefault(
self => self.Seed == "equipment_inventory"));
break;
case "POCKETS_INVENTORY":
created = new PocketsInventory(
character.Metadata.Inventories.FirstOrDefault(
self => self.Seed == "pockets_inventory"));
break;
case "PROXIMITY_INVENTORY":
created = new ProximityInventory(
character.Metadata.Inventories.FirstOrDefault(
self => self.Seed == "proximity_inventory"));
created.Slots = new InventoryItem[created.SlotAmount];
break;
default:
Logger.Info($"[Inventory] Could not find default required inventory {entry.Seed}");
break;
}
inventories.RegisterContainer(created);
created.CallRegistration();
}
}
inventories.Registry.ForEach(self => self.RefreshItemClassifications());
await player.Character.Load();
Session.Join(player.Character.MarkedAsRegistered ? 1 : 100 + API.GetPlayerServerId(API.PlayerId()));
await SafeTeleport.Teleport(player.Entity.Id, position);
if (player.Character.MarkedAsRegistered)
{
await transition.Wait();
API.DoScreenFadeIn(5000);
await transition.Down(player);
}
else
{
await player.Character.PostLoad();
}
if (API.IsScreenFadedOut() && !API.IsScreenFadingOut())
{
API.DoScreenFadeIn(5000);
}
player.EnableHud();
}
