public PathfindingSettings GetPathfindingSettings()
{
PathfindingSettings settings = new PathfindingSettings();
settings.PartyCharacters.Add(this);
return(settings);
}
public override ExitUsageRequirements CanUseExit(MajorModelEntities model, PathfindingSettings settings)
{
var reqs = new ExitUsageRequirements();
if (settings.PartyCharacters.Any(x => x.Class.Number == ClassNotAllowed) || settings.PartyCharacters.Any(x => x.Class.Number != ClassAllowed))
{
// Detected a disallowed class.
reqs.Method = ExitMethod.CannotPass;
return(reqs);
}
// All party members can pass
reqs.Method = ExitMethod.Normal;
return(reqs);
}
public override ExitUsageRequirements CanUseExit(MajorModelEntities model, PathfindingSettings settings)
{
var reqs = new ExitUsageRequirements();
if (settings.PartyCharacters.Any(x => x.Level < MinimumLevel) || settings.PartyCharacters.Any(x => x.Level > MaximumLevel))
{
// Detected a disallowed level.
reqs.Method = ExitMethod.CannotPass;
return(reqs);
}
// All party members can pass
reqs.Method = ExitMethod.Normal;
return(reqs);
}
public override ExitUsageRequirements CanUseExit(MajorModelEntities model, PathfindingSettings settings)
{
var reqs = new ExitUsageRequirements();
if (settings.PartyCharacters.Any(p => !p.Items.Any(i => i.Number == ItemRequired)))
{
// At least one member does not have the required item
reqs.Method = ExitMethod.NeedItem;
reqs.RequiredItemNumber = ItemRequired;
return(reqs);
}
// All party members have the required item, we're good to go.
reqs.Method = ExitMethod.Normal;
return(reqs);
}
public override ExitUsageRequirements CanUseExit(MajorModelEntities model, PathfindingSettings settings)
{
var reqs = new ExitUsageRequirements();
var moneyRequired = model.TollMultiplier * TollAmountRequired;
if (settings.PartyCharacters.Any(x => x.GetTotalMoney(model) < moneyRequired))
{
// someone doesn't have enough money, or hasn't disclosed that they have the money.
// So, mark the exit as needing money.
reqs.Method = ExitMethod.NeedMoney;
reqs.RequiredMoneyAmount = moneyRequired;
return(reqs);
}
// All party members have the required money, we're good to go.
reqs.Method = ExitMethod.Normal;
return(reqs);
}
public static ExitUsageRequirements CanUseExit(MajorModelEntities model, PathfindingSettings settings, int chanceToPickOrBash, int keyRequired)
{
var reqs = new ExitUsageRequirements();
int chanceOfPicking = settings.PartyCharacters.Max(p => p.Picklocks) + chanceToPickOrBash;
int chanceOfBashing = settings.PartyCharacters.Max(p => p.Strength) + chanceToPickOrBash;
if (chanceOfPicking > settings.JustPickOrBashThreshold || chanceOfBashing > settings.JustPickOrBashThreshold)
{
// Good chance of picking or bashing this lock, pick/bash it even if the user has the item to save
// the number of uses on it.
reqs.Method = ExitMethod.PickOrBash;
return(reqs);
}
if (keyRequired != 0 && settings.PartyCharacters.Any(p => p.Items.Any(x => x.Number == keyRequired)))
{
// Low or no chance of picking lock, but a party member has the item, so use it.
reqs.Method = ExitMethod.UseItem;
reqs.RequiredItemNumber = keyRequired;
return(reqs);
}
if (chanceOfPicking > 0 || chanceOfBashing > 0)
{
// Low but some chance of picking the lock, user does not have the item
reqs.Method = ExitMethod.PickOrBash;
return(reqs);
}
if (keyRequired == 0)
{
// There is no way through this exit; you cannot pick it, and there is no key to obtain.
reqs.Method = ExitMethod.CannotPass;
return(reqs);
}
// User cannot pick, user has no item. Note the restriction so you can offer him a way around.
reqs.Method = ExitMethod.NeedItem;
reqs.RequiredItemNumber = keyRequired;
return(reqs);
}
public override ExitUsageRequirements CanUseExit(MajorModelEntities model, PathfindingSettings settings)
{
return(DoorExitData.CanUseExit(model, settings, ChanceToPickOrBash, KeyRequired));
}
public static List <OutputCommand> Pathfind(MajorModelEntities model, RoomNumber start, RoomNumber finish, PathfindingSettings settings)
{
var dictionary = new Dictionary <RoomNumber, RoomInfo>();
var queue = new C5.IntervalHeap <RoomInfo>(new RoomInfoComparer());
var firstRoom = model.GetRoom(start);
var firstInfo = new RoomInfo()
{
Room = firstRoom, Distance = 0
};
queue.Add(ref firstInfo.Handle, firstInfo);
dictionary[firstRoom.RoomNumber] = firstInfo;
RoomInfo destination = null;
while (!queue.IsEmpty)
{
var info = queue.DeleteMin();
// we found the finish, so exit.
if (info.Room.RoomNumber == finish)
{
destination = info;
break;
}
var exits = from exit in info.Room.GetExits()
where exit.ExitType != ExitType.RemoteAction
select exit;
foreach (var exit in exits)
{
// query the exit to see if it can be used in our current state.
var requirements = exit.CanUseExit(model, settings);
if (requirements.Method == ExitMethod.CannotPass)
{
continue;
}
var adjacentNumber = exit.AdjacentRoomNumber;
RoomInfo adjacent = null;
if (!dictionary.TryGetValue(adjacentNumber, out adjacent))
{
adjacent = new RoomInfo();
adjacent.Room = model.GetRoom(adjacentNumber);
adjacent.Distance = Int32.MaxValue;
dictionary[adjacentNumber] = adjacent;
}
int travelCost = 1; // TODO: set to 1 for now, adjust later as heuristics play out.
if (info.Distance + travelCost < adjacent.Distance)
{
adjacent.Distance = info.Distance + travelCost;
adjacent.Previous = info;
adjacent.PreviousExit = exit;
adjacent.Requirements = requirements;
if (adjacent.Handle == null)
{
queue.Add(ref adjacent.Handle, adjacent);
}
else
{
queue.Replace(adjacent.Handle, adjacent);
}
}
}
}
if (destination != null)
{
List <OutputCommand> list = new List <OutputCommand>();
var x = destination;
while (x.Previous != null)
{
list.Add(x.PreviousExit.GetOutputCommand(x.Requirements));
x = x.Previous;
}
list.Reverse();
return(list);
}
else
{
return(null);
}
}
public virtual ExitUsageRequirements CanUseExit(MajorModelEntities model, PathfindingSettings settings)
{
return(new ExitUsageRequirements());
}
