/// <summary>
/// Gets a bidirectional relation between user and target. Traverses recursively up, so that alliance relations are used
/// </summary>
/// <param name="user"></param>
/// <param name="target"></param>
/// <returns></returns>
private FullDiplomaticRelationProposals getFullDiplomaticRelationProposals(DiplomaticEntity user, DiplomaticEntity target)
{
//fetch user parent data
if (user.group != null)
{
FullDiplomaticRelationProposals proposal = getFullDiplomaticRelationProposals(user.group, target);
proposal.sender = user;
proposal.target = target;
return(proposal);
}
//fetch target parent data
if (target.group != null)
{
FullDiplomaticRelationProposals proposal = getFullDiplomaticRelationProposals(user, target.group);
proposal.sender = user;
proposal.target = target;
return(proposal);
}
//no more parents left - fetch data
Relation offer = Relation.Neutral;
Relation received = Relation.Neutral;
Relation current = Relation.Neutral;
if (DiplomaticEntityState.ContainsKey(user) && DiplomaticEntityState[user].ContainsKey(target))
{
offer = DiplomaticEntityState[user][target];
}
if (DiplomaticEntityState.ContainsKey(target) && DiplomaticEntityState[target].ContainsKey(user))
{
received = DiplomaticEntityState[target][user];
}
if (target is User)
{
if (((User)target).AiId > 0 && ((User)target).AiRelation < (int)Relation.Neutral)
{
received = UserRelations.Min(received, ((Relation)((User)target).AiRelation));
}
}
current = Min(offer, received);
FullDiplomaticRelationProposals fullDiplomatics = new FullDiplomaticRelationProposals(
user,
target,
(int)offer,
(int)received,
(int)current
);
return(fullDiplomatics);
}
//returns absolute relation (no proposals)
public Relation getRelation(DiplomaticEntity user, DiplomaticEntity target)
{
Relation relation = Relation.Neutral;
if (user == target)
{
return(Relation.AllianceMember);
}
try
{
if (user.group != null)
{
return(getRelation(user.group, target));
}
if (target.group != null)
{
return(getRelation(user, target.group));
}
Relation userTowardsTarget = DiplomaticEntityState.ContainsKey(user) &&
DiplomaticEntityState[user].ContainsKey(target) ? DiplomaticEntityState[user][target] : Relation.Neutral;
if (user is User)
{
if (((User)user).AiId > 0 && ((User)user).AiRelation < (int)Relation.Neutral)
{
userTowardsTarget = UserRelations.Min(userTowardsTarget, ((Relation)((User)user).AiRelation));
}
}
Relation targetTowardsUser = DiplomaticEntityState.ContainsKey(target) &&
DiplomaticEntityState[target].ContainsKey(user) ? DiplomaticEntityState[target][user] : Relation.Neutral;
if (target is User)
{
if (((User)target).AiId > 0 && ((User)target).AiRelation < (int)Relation.Neutral)
{
targetTowardsUser = UserRelations.Min(targetTowardsUser, ((Relation)((User)target).AiRelation));
}
}
relation = Min(userTowardsTarget, targetTowardsUser);
}
catch (Exception ex)
{
var userStr = new System.Web.Script.Serialization.JavaScriptSerializer().Serialize(user);
SpacegameServer.Core.Core.Instance.writeToLog(userStr);
var targetStr = new System.Web.Script.Serialization.JavaScriptSerializer().Serialize(user);
SpacegameServer.Core.Core.Instance.writeToLog(targetStr);
var DiplomaticEntityStateStr = new System.Web.Script.Serialization.JavaScriptSerializer().Serialize(DiplomaticEntityState);
SpacegameServer.Core.Core.Instance.writeToLog(DiplomaticEntityStateStr);
SpacegameServer.Core.Core.Instance.writeExceptionToLog(ex);
}
return(relation);
}
/// <summary>
/// set the relation between two entities
/// </summary>
/// <param name="sender"></param>
/// <param name="target"></param>
/// <param name="relation"></param>
/// <param name="relations">Is needed to write result to DB (and generate XML?) </param>
/// <remarks>called with input data is already checked</remarks>
protected void SetRelation(DiplomaticEntity sender, DiplomaticEntity target, Relation relation, List <DiplomaticRelation> relations)
{
Relation currentRelation = Relation.Neutral;
if (DiplomaticEntityState.ContainsKey(sender) &&
DiplomaticEntityState[sender].ContainsKey(target) &&
DiplomaticEntityState.ContainsKey(target) &&
DiplomaticEntityState[target].ContainsKey(sender))
{
currentRelation = Min(DiplomaticEntityState[sender][target], DiplomaticEntityState[target][sender]);
}
//worsening of the relation
if (relation < currentRelation)
{
//Todo: lock all users, ships and alliances. Use a priority lock (to be implemented), since a lot of objects can be part of the transaction
worsenRelation(sender, target, relation, relations);
//always worth a Galactic Event
GalacticEvents.CreateEventFromDiplomacy(sender, target, relation, currentRelation);
return;
}
//relationion is not worsened:
//either a proposal is done or
// a proposal is accepted (and perhaps an additional proposal is done)
//if targetRelationToSender is the currentRelation
Relation targetRelationToSender = Relation.Neutral;
if (DiplomaticEntityState.ContainsKey(target) &&
DiplomaticEntityState[target].ContainsKey(sender))
{
targetRelationToSender = (Relation)DiplomaticEntityState[target][sender];
}
Relation newCurrentRelation = (Relation)Math.Min((int)targetRelationToSender, (int)relation);
if (newCurrentRelation != currentRelation)
{
//change of relation: always worth a Galactic Event
GalacticEvents.CreateEventFromDiplomacy(sender, target, newCurrentRelation, currentRelation);
}
//Some Relations can't be changed
if (target is User)
{
if (((User)target).AiId > 0 && ((User)target).AiRelation < (int)Relation.Neutral)
{
newCurrentRelation = UserRelations.Min(newCurrentRelation, ((Relation)((User)target).AiRelation));
}
}
/*
* //all senderusers should be set to newCurrentRelation
* //create list of sender-Users
* List<DiplomaticEntity> senders = sender.getMembers();
*
* //create list of target-Users
* List<DiplomaticEntity> targets = target.getMembers();
*
* //update all users that are mebers and have a lower relationship than the new one:
* foreach(var senderUser in senders)
* {
* foreach(var targetUser in targets)
* {
* if (UserRelations.IsLower( getRelation(senderUser, targetUser) , newCurrentRelation))
* {
* setDiplomaticEntityState(senderUser, targetUser, newCurrentRelation);
* relations.Add(new DiplomaticRelation(senderUser.GetHashCode(), targetUser.GetHashCode(), (int)newCurrentRelation));
* }
* if (UserRelations.IsLower(getRelation(targetUser, senderUser) , newCurrentRelation))
* {
* setDiplomaticEntityState(targetUser, senderUser, newCurrentRelation);
* relations.Add(new DiplomaticRelation(targetUser.GetHashCode(), senderUser.GetHashCode(), (int)newCurrentRelation));
* }
* }
* }
*
*
* //and senderDiplomaticEntity proposes "his" relation
* setDiplomaticEntityState(sender, target, relation);
*/
foreach (var senderUser in sender.GetAllEntities())
{
foreach (var targetUser in target.GetAllEntities())
{
setDiplomaticEntityState(senderUser, targetUser, relation);
relations.Add(new DiplomaticRelation(senderUser.GetHashCode(), targetUser.GetHashCode(), (int)relation));
/*
* if (UserRelations.IsLower(getRelation(senderUser, targetUser), newCurrentRelation))
* {
* setDiplomaticEntityState(senderUser, targetUser, newCurrentRelation);
* relations.Add(new DiplomaticRelation(senderUser.GetHashCode(), targetUser.GetHashCode(), (int)newCurrentRelation));
* }
* if (UserRelations.IsLower(getRelation(targetUser, senderUser), newCurrentRelation))
* {
* setDiplomaticEntityState(targetUser, senderUser, newCurrentRelation);
* relations.Add(new DiplomaticRelation(targetUser.GetHashCode(), senderUser.GetHashCode(), (int)newCurrentRelation));
* }
*/
}
}
}
