public void AddContent(ServerInventoryItem item)
{
if (!content.ContainsKey(item.Object.Id))
{
content.TryAdd(item.Object.Id, item);
}
}
public bool AddItem(IInventoryObject obj, int count)
{
if (obj != null && count > 0)
{
ServerInventoryItem servItem = new ServerInventoryItem(obj, count);
if (HasSpaceForItems(servItem))
{
if (items.ContainsKey(servItem.Object.Id))
{
ServerInventoryItem existingItem = null;
if (items.TryGetValue(servItem.Object.Id, out existingItem))
{
existingItem.Add(count);
return(true);
}
}
else
{
items.TryAdd(servItem.Object.Id, servItem);
return(true);
}
}
}
return(false);
}
private ServerInventoryItem GiveOreReward(MmoActor player, ContractOreDataReward oreReward)
{
int playerLevel = player.GetComponent <CharacterObject>().level;
OreData data = null;
foreach (var ore in player.resource.Materials.Ores)
{
if (ore.Id.Contains(playerLevel.ToString()))
{
data = ore;
break;
}
}
if (data != null)
{
MaterialObject materialObj = new MaterialObject(data.Id);
int count = Rand.Int(oreReward.minCount, oreReward.maxCount);
if (count > 0)
{
ServerInventoryItem item = new ServerInventoryItem(materialObj, count);
return(item);
}
}
return(null);
}
public void AddToStationInventory(ServerInventoryItem item, bool sendUpdateEvent = true)
{
Station.StationInventory.Add(item.Object, item.Count);
if (sendUpdateEvent)
{
EventOnStationHoldUpdated();
}
}
public bool TryGetObject(string playerID, string inventoryObjectID, out ServerInventoryItem obj) {
CheckAndFillPlayer(playerID);
obj = null;
ConcurrentDictionary<string, ServerInventoryItem> filteredObjects = null;
if(m_Content.TryGetValue(playerID, out filteredObjects)) {
if(filteredObjects.TryGetValue(inventoryObjectID, out obj)) {
return true;
}
}
return false;
}
public int SlotsForItem(ServerInventoryItem it)
{
if (items.ContainsKey(it.Object.Id))
{
return(0);
}
else
{
return(1);
}
}
public bool TryRemoveActorObjectids(string playerID, List<string> inventoryObjectIDs) {
CheckAndFillPlayer(playerID);
ConcurrentDictionary<string, ServerInventoryItem> filtered = null;
bool result = true;
if(m_Content.TryGetValue(playerID, out filtered)) {
foreach(var id in inventoryObjectIDs ) {
ServerInventoryItem removed = null;
result = result && filtered.TryRemove(id, out removed);
}
}
return result;
}
public RPCErrorCode Check(MmoActor player, ServerInventoryItem item)
{
switch (item.Object.Id)
{
case "analyzer001":
//return CheckAnaluzer001(player);
return(RPCErrorCode.Ok);
default:
return(RPCErrorCode.InvalidObjectType);
}
}
public bool TryGetObject(string actorId, string objectId, out ServerInventoryItem resultObject)
{
resultObject = null;
ConcurrentDictionary <string, ServerInventoryItem> filteredObjects = null;
if (content.TryGetValue(actorId, out filteredObjects))
{
if (filteredObjects.TryGetValue(objectId, out resultObject))
{
return(true);
}
}
return(false);
}
public void OnWasKilled()
{
s_Log.InfoFormat("MiningStation.OnWasKilled() call with = {0} damagers".Color(LogColor.orange), m_damagers.Count);
if (currentCount > 0 && m_damagers.Count > 0)
{
NebulaElementObject nebObject = new NebulaElementObject(nebulaElementID, nebulaElementID);
ServerInventoryItem serverInventoryItem = new ServerInventoryItem(nebObject, currentCount);
List <ServerInventoryItem> itemsPerDamager = new List <ServerInventoryItem> {
serverInventoryItem
};
var chest = ObjectCreate.Chest(nebulaObject.world as MmoWorld, transform.position, 4 * 60,
m_damagers, itemsPerDamager);
chest.AddToWorld();
}
}
private ServerInventoryItem GenerateItemOnDictionary(DropItem dropItem) {
if(dropItem != null ) {
switch(dropItem.itemType ) {
case InventoryObjectType.quest_item: {
QuestObjectDropItem questDropItem = dropItem as QuestObjectDropItem;
if (questDropItem != null) {
QuestItemObject questItemObject = new QuestItemObject(dropItem.itemId, questDropItem.quest);
ServerInventoryItem serverInventoryItem = new ServerInventoryItem(questItemObject, questDropItem.count);
return serverInventoryItem;
}
}
break;
default:
return null;
}
}
return null;
}
public bool TryRemoveActorObjectids(string actorId, List <string> ids)
{
ConcurrentDictionary <string, ServerInventoryItem> filtered = null;
bool result = true;
if (content.TryGetValue(actorId, out filtered))
{
foreach (var id in ids)
{
ServerInventoryItem removed = null;
result = result && filtered.TryRemove(id, out removed);
}
if (filtered.Count == 0)
{
ConcurrentDictionary <string, ServerInventoryItem> removedList = null;
content.TryRemove(actorId, out removedList);
}
}
return(result);
}
public void EventOnInventoryItemAdded(string containerId, byte containerType, List <IInventoryObject> addedObjects)
{
//GetInventory().TryGetItem()
List <Hashtable> items = new List <Hashtable>();
foreach (var addedObj in addedObjects)
{
ServerInventoryItem resultItem = null;
if (this.Inventory.TryGetItem(addedObj.Type, addedObj.Id, out resultItem))
{
items.Add(resultItem.GetInfo());
}
}
Hashtable eventData = new Hashtable();
eventData.Add((int)SPC.Target, containerId);
eventData.Add((int)SPC.TargetType, containerType);
eventData.Add((int)SPC.Items, items.ToArray());
var eventInstance = new ItemGeneric {
ItemId = Avatar.Id,
ItemType = Avatar.Type,
CustomEventCode = (byte)CustomEventCode.InventoryItemsAdded,
EventData = eventData,
GameReferenceId = nebulaObject.Id,
CharacterId = mCharacter.characterId
};
var eData = new EventData((byte)EventCode.ItemGeneric, eventInstance);
SendParameters sendParameters = new SendParameters {
Unreliable = true, ChannelId = Settings.ItemEventChannel
};
((IMmoItem)Avatar).ReceiveEvent(eData, sendParameters);
}
public Hashtable TransformPetSchemeToPet(string schemeId)
{
var inventory = player.Station.StationInventory;
var petManager = player.GetComponent <PetManager>();
var playerRaceable = player.GetComponent <RaceableObject>();
if (false == inventory.HasItem(InventoryObjectType.pet_scheme, schemeId))
{
return(CreateResponse(RPCErrorCode.ItemNotFound));
}
ServerInventoryItem schemeItem = null;
if (false == inventory.TryGetItem(InventoryObjectType.pet_scheme, schemeId, out schemeItem))
{
return(CreateResponse(RPCErrorCode.ErrorOfGettingInventoryItem));
}
PetSchemeObject petSchemeObject = schemeItem.Object as PetSchemeObject;
if (false == petManager.hasFreeSpace)
{
return(CreateResponse(RPCErrorCode.LowPetAngarSpace));
}
string model = player.resource.petParameters.defaultModels[(Race)playerRaceable.race];
if (string.IsNullOrEmpty(model))
{
return(CreateResponse(RPCErrorCode.ResourceDataError));
}
PetDropper.PetDropSettings settings = new PetDropper.PetDropSettings();
settings.OffGenerateColor();
settings.SetColor(petSchemeObject.petColor);
settings.OffGenerateModel();
settings.SetModel(model);
settings.OnGeneratePassiveSkill();
settings.OnGenerateActiveSkills();
settings.OnGenerateDamageType();
settings.OnSetMastery();
settings.SetMastery(0);
settings.OffGenerateRace();
settings.SetRace((Race)playerRaceable.race);
PetDropper dropper = new PetDropper();
PetInfo petInfo = dropper.Drop(player.resource.petParameters, settings, player.resource.petSkills, player.resource.petPassiveBonuses);
inventory.Remove(InventoryObjectType.pet_scheme, schemeId, 1);
if (false == petManager.AddPet(petInfo))
{
return(CreateResponse(RPCErrorCode.ErrorOfAddingPetToCollection));
}
var allowedCount = player.resource.petParameters.GetPlayerPetCount(player.GetComponent <PlayerCharacterObject>().level);
if (petManager.countOfActivePets < allowedCount)
{
bool success = petManager.ActivatePet(petInfo.id);
if (success)
{
player.GetComponent <MmoMessageComponent>().ReceivePetsUpdate();
}
}
player.EventOnStationHoldUpdated();
Hashtable hash = CreateResponse(RPCErrorCode.Ok);
hash.Add((int)SPC.Pet, petInfo.GetInfo(player.resource));
var achievments = player.GetComponent <AchievmentComponent>();
achievments.SetVariable("max_pet_color", (int)petInfo.color);
return(hash);
}
private void RewardItemImpl(InventoryItemQuestReward reward)
{
ServerInventoryItem targetItem = null;
switch (reward.ObjectType)
{
case InventoryObjectType.Material: {
MaterialItemQuestReward materialReward = reward as MaterialItemQuestReward;
if (materialReward != null)
{
MaterialObject material = new MaterialObject(materialReward.OreId);
targetItem = new ServerInventoryItem(material, materialReward.Count);
}
}
break;
case InventoryObjectType.Scheme: {
SchemeItemQuestReward schemeReward = reward as SchemeItemQuestReward;
if (schemeReward != null)
{
SchemeObject scheme = new SchemeObject(new SchemeObject.SchemeInitData(
id: Guid.NewGuid().ToString(),
name: string.Empty,
level: PlayerLevel,
workshop: PlayerWorkshop,
templateModuleId: resource.ModuleTemplates.Module(PlayerWorkshop, schemeReward.Slot).Id,
color: schemeReward.Color,
craftingMaterials: new Dictionary <string, int>(),
inSetID: string.Empty
));
targetItem = new ServerInventoryItem(scheme, schemeReward.Count);
}
}
break;
case InventoryObjectType.Weapon: {
WeaponItemQuestReward weaponReward = reward as WeaponItemQuestReward;
if (weaponReward != null)
{
WeaponDropper.WeaponDropParams weaponDropParams = new WeaponDropper.WeaponDropParams(
resource: resource,
level: PlayerLevel,
workshop: PlayerWorkshop,
damageType: WeaponDamageType.damage,
difficulty: Difficulty.none
);
ColorInfo colorInfo = resource.ColorRes.Color(ColoredObjectType.Weapon, weaponReward.Color);
DropManager dropManager = DropManager.Get(resource);
WeaponDropper weaponDropper = dropManager.GetWeaponDropper(dropParams: weaponDropParams);
WeaponObject weapon = weaponDropper.DropWeapon(colorInfo);
targetItem = new ServerInventoryItem(weapon, weaponReward.Count);
}
}
break;
}
if (targetItem != null)
{
GetComponent <MmoActor>()?.AddToStationInventory(item: targetItem, sendUpdateEvent: true);
}
}
public bool TryGetObject(string playerID, string inventoryObjectID, out ServerInventoryItem item)
{
return(content.TryGetValue(inventoryObjectID, out item));
}
public Hashtable EquipModule(string moduleId, WorkhouseStation station)
{
var character = GetComponent <CharacterObject>();
var player = GetComponent <MmoActor>();
ServerInventoryItem obj = null;
if (!station.StationInventory.TryGetItem(InventoryObjectType.Module, moduleId, out obj))
{
return(new Hashtable {
{ (int)SPC.ReturnCode, (int)RPCErrorCode.ObjectNotFound }
});
}
if (!(obj.Object is ShipModule))
{
return(new Hashtable {
{ (int)SPC.ReturnCode, (int)RPCErrorCode.InvalidObjectType }
});
}
ShipModule module = obj.Object as ShipModule;
if (module.Workshop != (Workshop)character.workshop)
{
return(new Hashtable {
{ (int)SPC.ReturnCode, (int)RPCErrorCode.InvalidObjectWorkshop },
{ (int)SPC.Data, (byte)module.Workshop }
});
}
ShipModel model = shipModel;
int willBeHoldCount = model.HoldCountWhenInstalledThatModule(module);
int usedInventoryCount = player.Inventory.SlotsUsed;
if (willBeHoldCount < usedInventoryCount)
{
return(new Hashtable {
{ (int)SPC.ReturnCode, (int)RPCErrorCode.LowInventorySpace },
{ (int)SPC.Data, (usedInventoryCount - willBeHoldCount) }
});
}
station.StationInventory.Remove(InventoryObjectType.Module, moduleId, 1);
ShipModule prevModule = null;
this.SetModule(module, out prevModule);
player.Inventory.ChangeMaxSlots(holdCapacity);
if (prevModule == null)
{
return(new Hashtable
{
{ (int)SPC.ReturnCode, (int)RPCErrorCode.Ok }
});
}
if (!station.StationInventory.Add(prevModule, 1))
{
return(new Hashtable {
{ (int)SPC.ReturnCode, (int)RPCErrorCode.FailAddToStation }
});
}
if (player != null)
{
player.EventOnStationHoldUpdated();
player.EventOnInventoryUpdated();
player.GetComponent <MmoMessageComponent>().ReceiveUpdateCombatStats();
}
return(new Hashtable
{
{ (int)SPC.ReturnCode, (int)RPCErrorCode.Ok }
});
}
