/// <summary>
/// Ebben van a ko papir ollos cucc, 1hez ad 1tol levon
/// </summary>
/// <param name="randomMission"></param>
public override void VisitRandomMission(RandomMission randomMission)
{
var missionLevel = _missionInProgress.MissionLevel;
var rawGrindLevel = _missionDataCache.LookUpGrindAmount(missionLevel);
var diffmult = randomMission.DifficultyMultiplier;
var standingValue = 1 / (diffmult * rawGrindLevel);
standingValue *= _missionInProgress.GetParticipantBonusModifier();
// 0 -> 0.0 10 - > 1.0
// 6 -> 0.6 --> 0.5*0.6 => positive x 30%
//Implementation: Add reputation for all factions equally -- No factional bias!
IEnumerable <long> allianceEids = DefaultCorporationDataCache.GetMegaCorporationEids();
List <MissionStandingChange> standingChangeForSyndicatification = new List <MissionStandingChange>();
foreach (long id in allianceEids)
{
standingChangeForSyndicatification.Add(new MissionStandingChange(id, standingValue));
}
_standingChanges = standingChangeForSyndicatification.ToArray();
}
public List <StandingInfo> GetStandingForCharacter(Character character)
{
var allianceEids = DefaultCorporationDataCache.GetMegaCorporationEids().ToArray();
var qs = "select * from standings where [source] in (" + allianceEids.ArrayToString() + ") and [target]=@characterEid";
return(Db.Query().CommandText(qs).SetParameter("@characterEid", character.Eid).Execute().Select(CreateStandingInfoFromRecord).ToList());
}
public void HandleRequest(IRequest request)
{
using (var scope = Db.CreateTransaction())
{
var character = request.Session.Character;
var corporationeid = character.CorporationEid;
DefaultCorporationDataCache.IsCorporationDefault(corporationeid).ThrowIfTrue(ErrorCodes.CharacterMustBeInPrivateCorporation);
var role = Corporation.GetRoleFromSql(character);
role.IsAnyRole(CorporationRole.CEO, CorporationRole.DeputyCEO, CorporationRole.HRManager, CorporationRole.PRManager).ThrowIfFalse(ErrorCodes.InsufficientPrivileges);
//do the work
_corporationManager.DeleteYellowPages(corporationeid);
var entry = _corporationManager.GetYellowPages(corporationeid);
var result = new Dictionary <string, object> {
{ k.data, entry }
};
Message.Builder.FromRequest(request).WithData(result).Send();
CorporationData.RemoveFromCache(corporationeid);
scope.Complete();
}
}
public void Visit(CorporateHangar hangar)
{
Visit((Container)hangar);
if (_error != ErrorCodes.NoError)
{
return;
}
if (hangar.IsLeaseExpired && _access != ContainerAccess.LogList)
{
_error = ErrorCodes.CorporationHangarLeaseExpired;
return;
}
if (!(_access == ContainerAccess.LogList || _access == ContainerAccess.LogClear || _access == ContainerAccess.LogStart ||
_access == ContainerAccess.List || _access == ContainerAccess.LogStop))
{
_error = CheckDockedState(hangar);
if (_error != ErrorCodes.NoError)
{
return;
}
}
//is the owner of this container is the corporation the character is a member of?
var corpEid = _character.CorporationEid;
if (DefaultCorporationDataCache.IsCorporationDefault(corpEid))
{
_error = ErrorCodes.CharacterMustBeInPrivateCorporation;
return;
}
if (!Corporation.Exists(corpEid))
{
Logger.Error("a character found with a non-existing corporationEID. characterID:" + _character + " corpEID:" + corpEid);
_error = ErrorCodes.InsufficientPrivileges; //no such corporation
return;
}
if (hangar.Owner != corpEid)
{
_error = ErrorCodes.InsufficientPrivileges;
return;
}
//if his corporation owns this container
//check role
var memberRole = Corporation.GetRoleFromSql(_character);
if (!hangar.HasAccess(memberRole, _access))
{
_error = ErrorCodes.InsufficientPrivileges;
}
}
public void HandleRequest(IRequest request)
{
var character = request.Session.Character;
var itemDefinition = request.Data.GetOrDefault <int>(k.definition);
//training character => no markets in range
if (character.IsInTraining())
{
var trainingResult = new Dictionary <string, object>
{
{ k.definition, itemDefinition },
};
Message.Builder.FromRequest(request).WithData(trainingResult).Send();
return;
}
long?corporationEid = character.CorporationEid;
if (DefaultCorporationDataCache.IsCorporationDefault((long)corporationEid))
{
corporationEid = null;
}
var trainingMarketEid = _marketHandler.GetTrainingMarketEid();
//raw select by definition
//exclude training market
//include corp orders if character in private corp
//include normal orders (non corp)
var orders = _marketOrderRepository.GetAllByDefinition(itemDefinition).Where(r => r.marketEID != trainingMarketEid && (r.forMembersOf == corporationEid || r.forMembersOf == null)).ToArray();
//ez szabalyozza le, hogy nem latszanak a pbs marketek
//itt lehet ugyeskedni
//filtered markets
//var orders = repo.GetByMarketEids(MarketHandler.GetAllDefaultMarketsEids(), itemDefinition, request.character.CorporationEid).ToArray();
var orderDict = new Dictionary <string, object>(orders.Length);
var counter = 0;
foreach (var oneOrder in orders.Select(order => order.ToDictionary()))
{
orderDict.Add("m" + counter++, oneOrder);
}
var result = new Dictionary <string, object>
{
{ k.definition, itemDefinition },
{ k.orders, orderDict }
};
Message.Builder.FromRequest(request).WithData(result).Send();
}
public static IDictionary <string, object> GetStandingForDefaultCorporations(this IStandingHandler standingHandler, Character character)
{
return(DefaultCorporationDataCache.GetAllDefaultCorporationEid().ToDictionary("s", corporationEID =>
{
var standing = standingHandler.GetStanding(corporationEID, character.Eid);
var entry = new Dictionary <string, object>
{
{ k.eid, corporationEID },
{ k.standing, standing }
};
return entry;
}));
}
public static IDictionary <string, object> GetStandingForDefaultAlliances(this IStandingHandler standingHandler, Character character)
{
return(DefaultCorporationDataCache.GetMegaCorporationEids().ToDictionary("s", allianceEID =>
{
var standing = standingHandler.GetStanding(allianceEID, character.Eid);
var entry = new Dictionary <string, object>()
{
{ k.eid, allianceEID },
{ k.standing, standing },
};
return entry;
}));
}
public void HandleRequest(IRequest request)
{
var character = request.Session.Character;
var corporationeid = character.CorporationEid;
DefaultCorporationDataCache.IsCorporationDefault(corporationeid).ThrowIfTrue(ErrorCodes.CharacterMustBeInPrivateCorporation);
var entry = _corporationManager.GetYellowPages(corporationeid);
var result = new Dictionary <string, object> {
{ k.data, entry }
};
Message.Builder.FromRequest(request).WithData(result).Send();
}
public void HandleRequest(IRequest request)
{
using (var scope = Db.CreateTransaction())
{
var standing = request.Data.GetOrDefault <double>(k.standing).Clamp(-10, 10);
var character = request.Session.Character;
foreach (var allienceEid in DefaultCorporationDataCache.GetMegaCorporationEids())
{
_standingHandler.SetStanding(allienceEid, character.Eid, standing);
}
Message.Builder.FromRequest(request).WithOk().Send();
scope.Complete();
}
}
private bool HasAccess(long playersCorporationEid)
{
if (playersCorporationEid == Owner)
{
//own corporation -> ok
return(true);
}
if (DefaultCorporationDataCache.IsCorporationDefault(playersCorporationEid))
{
//only private corporation members
return(false);
}
var standingValue = _standingHandler.GetStanding(Owner, playersCorporationEid);
//match standing level
return(standingValue > StandingLimit);
}
public void HandleRequest(IRequest request)
{
var offsetInDays = request.Data.GetOrDefault <int>(k.offset);
var zoneId = request.Data.GetOrDefault <int>(k.zoneID);
var corporationEid = request.Session.Character.CorporationEid;
DefaultCorporationDataCache.IsCorporationDefault(corporationEid).ThrowIfTrue(ErrorCodes.CharacterMustBeInPrivateCorporation);
var role = Corporation.GetRoleFromSql(request.Session.Character);
role.IsAnyRole(CorporationRole.CEO, CorporationRole.DeputyCEO, CorporationRole.viewPBS).ThrowIfFalse(ErrorCodes.InsufficientPrivileges);
var history = PBSHelper.GetPBSLog(offsetInDays, corporationEid, zoneId);
Message.Builder.FromRequest(request).WithData(new Dictionary <string, object> {
{ k.history, history }
}).WrapToResult().Send();
}
protected double GetStandingOfOwnerToCharacter(Character character)
{
var facilityOwner = Owner;
if (facilityOwner > 0)
{
if (DefaultCorporationDataCache.IsAllianceDefault(facilityOwner))
{
//simply the player vs the alliance
return(StandingHandler.GetStanding(facilityOwner, character.Eid));
//return StandingHandler.Instance.GetIndustrialDefaultCorporationStandingByAlliance(character.Eid, facilityOwner);
}
return(StandingHandler.GetStandingServerEntityToPlayerHierarchy(facilityOwner, character));
}
Logger.Error("no owner defined for production facility:" + this);
return(0.0);
}
public void HandleRequest(IRequest request)
{
var daysBack = request.Data.GetOrDefault <int>(k.offset);
var character = request.Session.Character;
var corporationEid = character.CorporationEid;
if (DefaultCorporationDataCache.IsCorporationDefault(corporationEid))
{
Message.Builder.FromRequest(request).WithOk().Send();
return;
}
var sapActivityDict = IntrusionHelper.GetMySitesLog(daysBack, corporationEid);
Message.Builder.FromRequest(request)
.WithData(new Dictionary <string, object> {
{ "intrusionPublicLog", sapActivityDict },
})
.Send();
}
public void HandleRequest(IRequest request)
{
var character = request.Session.Character;
var corporationEid = character.CorporationEid;
if (DefaultCorporationDataCache.IsCorporationDefault(corporationEid))
{
Message.Builder.FromRequest(request).WithOk().Send();
return;
}
var totalDict = Outpost.GetOwnershipPrivateInfo(corporationEid);
var result = new Dictionary <string, object>
{
{ k.info, totalDict }
};
Message.Builder.FromRequest(request).WithData(result).Send();
}
public void HandleRequest(IRequest request)
{
var character = request.Session.Character;
var corporationEid = character.CorporationEid;
DefaultCorporationDataCache.IsCorporationDefault(corporationEid).ThrowIfTrue(ErrorCodes.CharacterMustBeInPrivateCorporation);
var result = new Dictionary <string, object>();
var standingsData = _standingHandler.GetStandingsList(corporationEid);
if (standingsData != null)
{
result.Add(k.standing, standingsData);
result.Add(k.corporationEID, corporationEid);
Message.Builder.SetCommand(Commands.StandingList).WithData(result).ToClient(request.Session).Send();
}
else
{
Message.Builder.FromRequest(request).WithEmpty().Send();
}
}
/// <summary>
/// Ebben van a ko papir ollos cucc, 1hez ad 1tol levon
/// </summary>
/// <param name="randomMission"></param>
public override void VisitRandomMission(RandomMission randomMission)
{
var missionLevel = _missionInProgress.MissionLevel;
var rawGrindLevel = _missionDataCache.LookUpGrindAmount(missionLevel);
var diffmult = randomMission.DifficultyMultiplier;
var standingValue = 1 / (diffmult * rawGrindLevel);
// 0 -> 0.0 10 - > 1.0
// 6 -> 0.6 --> 0.5*0.6 => positive x 30%
var f = _missionInProgress.MissionLevel.Clamp(0, 9) / 9.0;
var negativeValue = -1 * (standingValue / 2) * f; //20% extension can reduce it to 10%
var positiveAllianceEid = _missionLocation.Agent.OwnerAlliance.Eid;
var opposingAllianceEid = DefaultCorporationDataCache.SelectOpposingAlliance(positiveAllianceEid);
_standingChanges = new[] { new MissionStandingChange(positiveAllianceEid, standingValue), new MissionStandingChange(opposingAllianceEid, negativeValue) };
}
/// <summary>
/// map category to issuerAlliance's proper corp ww, ii , ss etc....
/// </summary>
/// <param name="missionCategory"></param>
/// <param name="issuerCorporationEid"></param>
/// <param name="issuerAllianceEid"></param>
public void GetIssuerCorporationByCategory(MissionCategory missionCategory, out long issuerCorporationEid, out long issuerAllianceEid)
{
issuerAllianceEid = Agent.OwnerAlliance.Eid;
var corpNamePostFix = MissionDataCache.GetCorporationPostFixByMissionCategory(missionCategory);
var corporationEid =
DefaultCorporationDataCache.GetPureCorporationFromAllianceByPostFix(issuerAllianceEid, corpNamePostFix);
issuerCorporationEid = corporationEid;
#if DEBUG
if (MissionResolveTester.isTestMode)
{
return;
}
var allianceName = DefaultCorporationDataCache.GetAllianceName(issuerAllianceEid);
var corporationName = DefaultCorporationDataCache.GetCorporationName(issuerCorporationEid);
Logger.Info(missionCategory + " " + allianceName + " mapped to " + corporationName);
#endif
}
public void HandleRequest(IZoneRequest request)
{
using (var scope = Db.CreateTransaction())
{
var siteEid = request.Data.GetOrDefault <long>(k.siteEID);
var standingLimit = request.Data.GetOrDefault <double?>(k.standing);
var character = request.Session.Character;
var outpost = request.Zone.GetUnit(siteEid).ThrowIfNotType <Outpost>(ErrorCodes.IntrusionSiteNotFound);
var siteInfo = outpost.GetIntrusionSiteInfo();
if (siteInfo.DefenseStandingLimit == standingLimit)
{
//nothing to do => exit
Message.Builder.FromRequest(request).WithOk().Send();
return;
}
var corporationEid = character.CorporationEid;
//only owner corp controls
siteInfo.Owner.ThrowIfNotEqual(corporationEid, ErrorCodes.AccessDenied);
DefaultCorporationDataCache.IsCorporationDefault(corporationEid).ThrowIfTrue(ErrorCodes.PrivateCorporationAllowedOnly);
var role = Corporation.GetRoleFromSql(character);
role.IsAnyRole(CorporationRole.CEO, CorporationRole.DeputyCEO, CorporationRole.Accountant).ThrowIfFalse(ErrorCodes.InsufficientPrivileges);
siteInfo.Stability.ThrowIfLess(Outpost.DefenseNodesStabilityLimit, ErrorCodes.StabilityTooLow);
outpost.SetDefenseStandingLimit(standingLimit);
scope.Complete();
}
}
public void HandleRequest(IRequest request)
{
var character = request.Session.Character;
var corporationEid = character.CorporationEid;
DefaultCorporationDataCache.IsCorporationDefault(corporationEid).ThrowIfTrue(ErrorCodes.CharacterMustBeInPrivateCorporation);
var standingData = _standingHandler.GetReputationFor(corporationEid).ToDictionary("d", info =>
{
return(new Dictionary <string, object>
{
{ k.sourceEID, info.sourceEID },
{ k.standing, info.standing }
});
});
var result = new Dictionary <string, object>
{
{ k.targetEID, corporationEid },
{ k.standing, standingData }
};
Message.Builder.FromRequest(request).WithData(result).WrapToResult().Send();
}
protected override Unit CreateDeployableItem(IZone zone, Position spawnPosition, Player player)
{
var corporationEid = player.CorporationEid;
DefaultCorporationDataCache.IsCorporationDefault(corporationEid).ThrowIfTrue(ErrorCodes.CharacterMustBeInPrivateCorporation);
var pbsEgg = (PBSEgg)base.CreateDeployableItem(zone, spawnPosition, player);
//let the egg check the conditions by type
pbsEgg.CheckDefinitionRelatedConditionsOrThrow(zone, spawnPosition, corporationEid);
var pbsObjectDefinition = PBSHelper.GetPBSObjectDefinitionFromCapsule(ED);
var pbsEd = EntityDefault.Get(pbsObjectDefinition);
//check zone for conditions
PBSHelper.CheckZoneForDeployment(zone, spawnPosition, pbsEd).ThrowIfError();
//pass owner
pbsEgg.DeployerPlayer = player;
//all conditions match return the egg and continue placing it to the zone
return(pbsEgg);
}
public void HandleRequest(IRequest request)
{
using (var scope = Db.CreateTransaction())
{
var character = request.Session.Character;
var primaryactivity = request.Data.GetOrDefault(k.primaryActivity, -1);
var primaryzone = request.Data.GetOrDefault(k.zoneID, -1);
var primarybase = request.Data.GetOrDefault(k.baseEID, (long)-1);
var orientation = request.Data.GetOrDefault(k.orientation, -1);
var lookingfor = request.Data.GetOrDefault(k.lookingFor, -1);
var preferredfaction = request.Data.GetOrDefault(k.preferredFaction, -1);
var providesinsurance = request.Data.GetOrDefault(k.providesInsurance, -1);
var timezone = request.Data.GetOrDefault(k.timeZone, -1);
var requiredactivity = request.Data.GetOrDefault(k.requiredActivity, -1);
var communication = request.Data.GetOrDefault(k.communication, -1);
var services = request.Data.GetOrDefault(k.services, -1);
var updateList = new List <string>();
var insertDict = new Dictionary <string, object>();
var corporationeid = character.CorporationEid;
DefaultCorporationDataCache.IsCorporationDefault(corporationeid).ThrowIfTrue(ErrorCodes.CharacterMustBeInPrivateCorporation);
var role = Corporation.GetRoleFromSql(character);
role.IsAnyRole(CorporationRole.CEO, CorporationRole.DeputyCEO, CorporationRole.HRManager, CorporationRole.PRManager).ThrowIfFalse(ErrorCodes.InsufficientPrivileges);
var update = false;
var query = Db.Query();
var id = query.CommandText("select id from yellowpages where corporationeid=@corporationeid")
.SetParameter("@corporationeid", corporationeid)
.ExecuteScalar <int>();
if (id > 0)
{
update = true;
}
insertDict.Add("corporationeid", corporationeid);
if (primaryactivity >= 0)
{
insertDict.Add("primaryactivity", primaryactivity);
updateList.Add("primaryactivity=@primaryactivity ");
query.SetParameter("@primaryactivity", primaryactivity);
}
if (primaryzone >= 0)
{
_zoneManager.ContainsZone(primaryzone).ThrowIfFalse(ErrorCodes.ZoneNotFound);
insertDict.Add("zoneID", primaryzone);
updateList.Add("zoneID = @primaryzone ");
query.SetParameter("@primaryzone", primaryzone);
}
//set explicitely on the client
if (request.Data.ContainsKey(k.zoneID) && primaryzone == -1)
{
updateList.Add("zoneID = NULL ");
}
//na ezert nem lehet pbs base-t a yellow pagesbe beallitani
if (primarybase > 0)
{
var dockingBase = _dockingBaseHelper.GetDockingBase(primarybase);
insertDict.Add("baseEID", dockingBase.Eid);
updateList.Add("baseEID = @primarybase ");
query.SetParameter("@primarybase", primarybase);
}
if (request.Data.ContainsKey(k.baseEID) && primarybase == -1)
{
updateList.Add("baseEID = NULL ");
}
if (orientation >= 0)
{
insertDict.Add("orientation", orientation);
updateList.Add("orientation=@orientation ");
query.SetParameter("@orientation", orientation);
}
if (lookingfor >= 0)
{
insertDict.Add("lookingfor", lookingfor);
updateList.Add("lookingfor=@lookingfor ");
query.SetParameter("@lookingfor", lookingfor);
}
if (preferredfaction >= 0)
{
insertDict.Add("preferredfaction", preferredfaction);
updateList.Add("preferredfaction = @preferredfaction ");
query.SetParameter("@preferredfaction", preferredfaction);
}
if (request.Data.ContainsKey(k.preferredFaction) && preferredfaction == -1)
{
updateList.Add("preferredfaction = NULL ");
}
if (providesinsurance >= 0)
{
insertDict.Add("providesinsurance", providesinsurance);
updateList.Add("providesinsurance=@providesinsurance ");
query.SetParameter("@providesinsurance", providesinsurance);
}
if (timezone >= 0)
{
insertDict.Add("timezone", timezone);
updateList.Add("timezone=@timezone ");
query.SetParameter("@timezone", timezone);
}
if (requiredactivity >= 0)
{
insertDict.Add("requiredactivity", requiredactivity);
updateList.Add("requiredactivity=@requiredactivity ");
query.SetParameter("@requiredactivity", requiredactivity);
}
if (communication >= 0)
{
insertDict.Add("communication", communication);
updateList.Add("communication=@communication ");
query.SetParameter("@communication", communication);
}
if (services >= 0)
{
insertDict.Add("services", services);
updateList.Add("services=@services");
query.SetParameter("@services", services);
}
updateList.Count.ThrowIfEqual(0, ErrorCodes.NothingDefined);
string cmdStr;
if (update)
{
cmdStr = "update yellowpages set " + updateList.ArrayToString() + " where id=@id";
query.CommandText(cmdStr).SetParameter("@id", id);
}
else
{
cmdStr = insertDict.ToInsertString("yellowpages", "nothing");
query.CommandText(cmdStr);
}
query.ExecuteNonQuery().ThrowIfNotEqual(1, ErrorCodes.SQLExecutionError);
var entry = _corporationManager.GetYellowPages(corporationeid);
var result = new Dictionary <string, object> {
{ k.data, entry }
};
Message.Builder.FromRequest(request).WithData(result).Send();
CorporationData.RemoveFromCache(corporationeid);
scope.Complete();
}
}
public void HandleRequest(IZoneRequest request)
{
var isAdmin = request.Session.AccessLevel.IsAdminOrGm() && request.Data.ContainsKey(k.all);
var character = request.Session.Character;
Corporation.GetCorporationEidAndRoleFromSql(character, out long corporationEid, out CorporationRole role);
DefaultCorporationDataCache.IsCorporationDefault(corporationEid).ThrowIfTrue(ErrorCodes.CharacterMustBeInPrivateCorporation);
if (!isAdmin)
{
role.IsAnyRole(CorporationRole.viewPBS, CorporationRole.CEO, CorporationRole.DeputyCEO).ThrowIfFalse(ErrorCodes.InsufficientPrivileges);
}
var result = new Dictionary <string, object>
{
{ k.zoneID, request.Zone.Id },
};
var ourBaseOnZone = false;
var network = new Dictionary <string, object>();
var ourNodes = new List <Unit>();
var orphanedNodes = new List <Unit>();
foreach (var unit in request.Zone.Units.Where(o => o is IPBSObject))
{
var pbsObject = (IPBSObject)unit;
if (isAdmin || unit.Owner == corporationEid || pbsObject.IsOrphaned)
{
if (unit.Owner == corporationEid)
{
ourNodes.Add(unit);
if (unit is PBSDockingBase)
{
ourBaseOnZone = true;
}
continue;
}
if (pbsObject.IsOrphaned)
{
orphanedNodes.Add(unit);
}
}
}
var counter = 0;
foreach (var node in ourNodes)
{
network.Add("c" + counter++, node.ToDictionary());
}
//if we own a docking base on the zone we'll see the orphaned nodes regardless of the owner
if (ourBaseOnZone)
{
foreach (var orphanedNode in orphanedNodes)
{
network.Add("c" + counter++, orphanedNode.ToDictionary());
}
}
result.Add(k.buildings, network);
Message.Builder.FromRequest(request).WithData(result).Send();
}
/// <summary>
/// Checks variuos zone and plantrule conditions to plant
/// </summary>
/// <param name="zone"></param>
/// <param name="player"></param>
public override void Deploy(IZone zone, Player player)
{
//plant it under the player
_targetPosition = player.CurrentPosition;
//this item will plant this plant
_targetPlantType = GetTargetPlantType();
_plantRule = zone.Configuration.PlantRules.GetPlantRule(_targetPlantType);
if (_plantRule == null)
{
//the desired plantrule was not found on zone
#if DEBUG
Logger.Error("consistency error. no plantrule found for seed:" + Definition + " planttype:" + _targetPlantType);
#endif
//different errormessage for concrete placing
_targetPlantType.ThrowIfEqual(PlantType.Devrinol, ErrorCodes.ZoneNotTerraformable);
throw new PerpetuumException(ErrorCodes.PlantNotFertileOnThisZone);
}
//copy units to local for many iterations
_currentUnits = zone.Units.ToArray();
//save the players corporationeid to check beta and gamma conditions
_corporationEid = player.CorporationEid;
if (!_plantRule.PlacesConcrete)
{
CheckNonConcreteAndThrow(zone);
}
//these plants can't be placed on alpha
if (zone.Configuration.IsAlpha)
{
(_targetPlantType == PlantType.Devrinol).ThrowIfTrue(ErrorCodes.OnlyUnProtectedZonesAllowed);
}
else
{
//on beta and gamma we need corporationeid to match with stuff
DefaultCorporationDataCache.IsCorporationDefault(_corporationEid).ThrowIfTrue(ErrorCodes.CharacterMustBeInPrivateCorporation);
}
if (_targetPlantType == PlantType.Wall)
{
PBSHelper.CheckWallPlantingAndThrow(zone, _currentUnits, _targetPosition, _corporationEid);
}
if (_plantRule.PlacesConcrete)
{
zone.Configuration.Terraformable.ThrowIfFalse(ErrorCodes.ZoneNotTerraformable);
PlaceConcreteOrThrow(zone);
}
else
{
PutPlantOrThrow(zone, _targetPosition.intX, _targetPosition.intY);
}
var b = TransactionLogEvent.Builder().SetTransactionType(TransactionType.ItemDeploy).SetCharacter(player.Character).SetItem(Definition, 1);
player.Character.LogTransaction(b);
}
public void HandleRequest(IRequest request)
{
using (var scope = Db.CreateTransaction())
{
var character = request.Session.Character;
var lockBase = request.Data.GetOrDefault <int>(k.locked) == 1;
double?standingLimit = request.Data.GetOrDefault <double>(k.standing);
var baseEid = request.Data.GetOrDefault <long>(k.baseEID);
var eventType = IntrusionEvents.dockingRightsSet;
if (!lockBase)
{
standingLimit = null; //opening the outpost for everyone
eventType = IntrusionEvents.dockingRightsClear;
}
if (!(_dockingBaseHelper.GetDockingBase(baseEid) is Outpost outpost))
{
throw new PerpetuumException(ErrorCodes.OperationAllowedOnlyOnIntrusionSites);
}
var siteInfo = outpost.GetIntrusionSiteInfo();
if (siteInfo.DockingStandingLimit == standingLimit)
{
//nothing to do => exit
Message.Builder.FromRequest(request).WithData(new Dictionary <string, object> {
{ k.baseEID, outpost.Eid }
}).Send();
return;
}
var owner = siteInfo.Owner.ThrowIfNull(ErrorCodes.AccessDenied);
var corporationEid = character.CorporationEid;
//only owner corp controls the docking rights
corporationEid.ThrowIfNotEqual((long)owner, ErrorCodes.AccessDenied);
DefaultCorporationDataCache.IsCorporationDefault(corporationEid).ThrowIfTrue(ErrorCodes.CharacterMustBeInPrivateCorporation);
var role = Corporation.GetRoleFromSql(character);
role.IsAnyRole(CorporationRole.CEO, CorporationRole.DeputyCEO, CorporationRole.Accountant).ThrowIfFalse(ErrorCodes.InsufficientPrivileges);
var stabilityLimit = Outpost.GetDockingRightsStabilityLimit();
siteInfo.Stability.ThrowIfLess(stabilityLimit, ErrorCodes.StabilityTooLow);
var dockingControlLimit = siteInfo.DockingControlLimit;
if (dockingControlLimit != null)
{
DateTime.Now.ThrowIfLess((DateTime)dockingControlLimit, ErrorCodes.DockingRightsChangeCooldownInProgress);
}
outpost.SetDockingControlDetails(standingLimit, !lockBase);
outpost.InsertDockingRightsLog(character, standingLimit, corporationEid, eventType);
Transaction.Current.OnCommited(() => outpost.SendSiteInfoToOnlineCharacters());
Message.Builder.FromRequest(request).WithData(new Dictionary <string, object> {
{ k.baseEID, baseEid }
}).Send();
scope.Complete();
}
}
public DefaultCorporation GetTrainingCorporation()
{
var eid = DefaultCorporationDataCache.GetByAlliance(Owner).FirstOrDefault();
return((DefaultCorporation)Corporation.GetOrThrow(eid));
}
public void HandleRequest(IRequest request)
{
using (var scope = Db.CreateTransaction())
{
var seller = request.Session.Character;
var itemEid = request.Data.GetOrDefault <long>(k.itemEID);
var duration = request.Data.GetOrDefault <int>(k.duration);
var pricePerPiece = request.Data.GetOrDefault <double>(k.price);
var quantity = request.Data.GetOrDefault <int>(k.quantity);
var useSellerCorporationWallet = request.Data.GetOrDefault <int>(k.useCorporationWallet) == 1;
var containerEid = request.Data.GetOrDefault <long>(k.container);
var forMyCorporation = request.Data.GetOrDefault <int>(k.forMembersOf) == 1;
var targetOrderId = request.Data.GetOrDefault <int>(k.targetOrder);
seller.IsDocked.ThrowIfFalse(ErrorCodes.CharacterHasToBeDocked);
seller.CheckPrivilegedTransactionsAndThrowIfFailed();
quantity.ThrowIfLessOrEqual(0, ErrorCodes.WTFErrorMedicalAttentionSuggested);
pricePerPiece.ThrowIfLessOrEqual(0, ErrorCodes.IllegalMarketPrice);
duration.ThrowIfLess(1, ErrorCodes.MinimalDurationNotReached);
var market = seller.GetCurrentDockingBase().GetMarketOrThrow();
var corporationEid = seller.CorporationEid;
var publicContainer = seller.GetPublicContainerWithItems();
var sourceContainer = (Container)publicContainer.GetItemOrThrow(containerEid, true);
long?forMembersOf = null;
if (forMyCorporation)
{
if (!DefaultCorporationDataCache.IsCorporationDefault(corporationEid))
{
forMembersOf = corporationEid;
}
else
{
forMyCorporation = false;
}
}
//unstack a fraction or take the whole item, check for conditions
var itemToSell = market.PrepareItemForSale(seller, itemEid, quantity, sourceContainer);
if (_marketInfoService.CheckAveragePrice)
{
var avgPrice = _marketHandler.GetAveragePriceByMarket(market, itemToSell.Definition);
if (avgPrice != null && avgPrice.AveragePrice > 0)
{
(pricePerPiece <avgPrice.AveragePrice * (1 - _marketInfoService.Margin) ||
pricePerPiece> avgPrice.AveragePrice * (1 + _marketInfoService.Margin)).ThrowIfTrue(ErrorCodes.PriceOutOfAverageRange);
}
}
MarketOrder highestBuyOrder;
if (targetOrderId > 0)
{
//target order was defined by user
highestBuyOrder = _marketOrderRepository.Get(targetOrderId).ThrowIfNull(ErrorCodes.ItemNotFound);
//for my corp?
highestBuyOrder.forMembersOf?.ThrowIfNotEqual(corporationEid, ErrorCodes.AccessDenied);
//sell to order
market.FulfillSellOrderInstantly(seller, useSellerCorporationWallet, highestBuyOrder, itemToSell, sourceContainer);
}
else
{
//try to find a buy order for the currently submitted item, it finds the closest buy order
highestBuyOrder = _marketOrderRepository.GetHighestBuyOrder(itemToSell.Definition, pricePerPiece, seller.Eid, market, corporationEid);
if (!forMyCorporation && highestBuyOrder != null)
{
//sell to order
market.FulfillSellOrderInstantly(seller, useSellerCorporationWallet, highestBuyOrder, itemToSell, sourceContainer);
}
else
{
if (!forMyCorporation)
{
_marketHelper.CheckSellOrderCounts(seller).ThrowIfFalse(ErrorCodes.MarketItemsExceed);
}
var realMarketFee = Market.GetRealMarketFee(seller, duration);
//cash market fee anyways
_marketHelper.CashInMarketFee(seller, useSellerCorporationWallet, realMarketFee);
market.GetDockingBase().AddCentralBank(TransactionType.marketFee, realMarketFee);
market.CreateSellOrder(seller.Eid, itemToSell, duration, pricePerPiece, quantity, useSellerCorporationWallet, forMembersOf);
}
}
publicContainer.Save();
var containerData = publicContainer.ToDictionary();
Message.Builder.SetCommand(Commands.ListContainer)
.WithData(containerData)
.ToCharacter(seller)
.Send();
scope.Complete();
}
}
public bool IsInDefaultCorporation()
{
return(DefaultCorporationDataCache.IsCorporationDefault(CorporationEid));
}
public void HandleRequest(IRequest request)
{
using (var scope = Db.CreateTransaction())
{
var buyer = request.Session.Character;
var itemDefinition = request.Data.GetOrDefault <int>(k.definition);
var duration = request.Data.GetOrDefault <int>(k.duration);
var pricePerPiece = request.Data.GetOrDefault <double>(k.price);
var quantity = request.Data.GetOrDefault(k.quantity, 1);
var useBuyerCorporationWallet = request.Data.GetOrDefault <int>(k.useCorporationWallet) == 1;
var forMyCorporation = request.Data.GetOrDefault <int>(k.forMembersOf) == 1;
quantity.ThrowIfLessOrEqual(0, ErrorCodes.AmountTooLow);
buyer.IsDocked.ThrowIfFalse(ErrorCodes.CharacterHasToBeDocked);
buyer.CheckPrivilegedTransactionsAndThrowIfFailed();
pricePerPiece.ThrowIfLessOrEqual(0, ErrorCodes.IllegalMarketPrice);
duration.ThrowIfLessOrEqual(1, ErrorCodes.MinimalDurationNotReached);
var ed = EntityDefault.Get(itemDefinition).ThrowIfEqual(EntityDefault.None, ErrorCodes.DefinitionNotSupported);
ed.IsSellable.ThrowIfFalse(ErrorCodes.ItemNotSellable);
var market = buyer.GetCurrentDockingBase().GetMarketOrThrow();
var realMarketFee = Market.GetRealMarketFee(buyer, duration);
var corporationEid = buyer.CorporationEid;
//cash market fee anyways
_marketHelper.CashInMarketFee(buyer, useBuyerCorporationWallet, realMarketFee);
buyer.GetCurrentDockingBase().AddCentralBank(TransactionType.marketFee, realMarketFee);
if (_marketInfoService.CheckAveragePrice)
{
var avgPrice = _marketHandler.GetAveragePriceByMarket(market, itemDefinition);
if (avgPrice != null && avgPrice.AveragePrice > 0)
{
if (pricePerPiece < avgPrice.AveragePrice * (1 - _marketInfoService.Margin) || pricePerPiece > avgPrice.AveragePrice * (1 + _marketInfoService.Margin))
{
throw new PerpetuumException(ErrorCodes.PriceOutOfAverageRange);
}
}
}
var publicContainer = buyer.GetPublicContainerWithItems();
long?forMembersOf = null;
if (forMyCorporation)
{
if (!DefaultCorporationDataCache.IsCorporationDefault(corporationEid))
{
forMembersOf = corporationEid;
}
else
{
forMyCorporation = false;
}
}
if (!forMyCorporation)
{
_marketHelper.CheckBuyOrderCounts(buyer).ThrowIfFalse(ErrorCodes.MarketItemsExceed);
}
var lowestSellOrder = _marketOrderRepository.GetLowestSellOrder(itemDefinition, pricePerPiece, buyer.Eid, market, corporationEid);
if (!forMyCorporation && lowestSellOrder != null)
{
// requested item was found on the market, make immediate transaction
market.FulfillBuyOrderInstantly(buyer, useBuyerCorporationWallet, lowestSellOrder, pricePerPiece, duration, quantity, publicContainer, forMembersOf);
}
else
{
var deposit = pricePerPiece * quantity;
// take the deposit from the character
_marketHelper.CashIn(buyer, useBuyerCorporationWallet, pricePerPiece, itemDefinition, quantity, TransactionType.buyOrderDeposit);
//store the deposit in the central bank
market.AddCentralBank(TransactionType.buyOrderDeposit, deposit);
// create a new buy order
var newBuyOrder = market.CreateBuyOrder(buyer, itemDefinition, duration, pricePerPiece, quantity, useBuyerCorporationWallet, forMembersOf);
var data = new Dictionary <string, object>
{
{ k.buyOrder, newBuyOrder.ToDictionary() }
};
Message.Builder.SetCommand(Commands.MarketBuyOrderCreated)
.WithData(data)
.ToCharacter(buyer)
.Send();
}
publicContainer.Save();
Message.Builder.SetCommand(Commands.ListContainer)
.WithData(publicContainer.ToDictionary())
.ToCharacter(buyer)
.Send();
scope.Complete();
}
}
