public static int SaveQuestConnection(QuestConnection input)
{
IQuestRepository repo = new EFQuestRepository();
var questConnection = repo.QuestConnections.FirstOrDefault(q => q.Id == input.Id);
if (questConnection == null)
{
questConnection = new QuestConnection();
}
questConnection.ActionName = input.ActionName;
questConnection.ConnectionName = input.ConnectionName;
questConnection.HideIfRequirementsNotMet = input.HideIfRequirementsNotMet;
questConnection.QuestId = input.QuestId;
questConnection.QuestStateFromId = input.QuestStateFromId;
questConnection.QuestStateToId = input.QuestStateToId;
questConnection.QuestStateFailToId = input.QuestStateFailToId;
questConnection.RankInList = input.RankInList;
questConnection.Notes = input.Notes;
questConnection.Text = input.Text;
// always set this to something, even if it's just empty string
if (questConnection.ConnectionName == null)
{
questConnection.ConnectionName = "-- QUEST CONNECTION NOT NAMED --";
}
repo.SaveQuestConnection(questConnection);
return(questConnection.Id);
}
public void SaveQuestConnection(QuestConnection QuestConnection)
{
if (QuestConnection.Id == 0)
{
context.QuestConnections.Add(QuestConnection);
}
else
{
var editMe = context.QuestConnections.Find(QuestConnection.Id);
if (editMe != null)
{
// dbEntry.Name = QuestConnection.Name;
// dbEntry.Message = QuestConnection.Message;
// dbEntry.TimeStamp = QuestConnection.TimeStamp;
}
}
try
{
context.SaveChanges();
}
catch (OptimisticConcurrencyException)
{
//context.(RefreshMode.ClientWins, dbModels.Models.QuestConnection);
//context.SaveChanges();
}
// context.SaveChanges();
}
public static MvcHtmlString PrintDiceIcon(QuestConnection connection)
{
var output = "";
if (connection.RequiresRolls())
{
output = $"<img src='{PvPStatics.ImageURL}Icons/dice.png' style='width: 24px; height: 24px; '>";
}
return(new MvcHtmlString(output));
}
public virtual ActionResult QuestConnection(int Id, int QuestId, int FromQuestId, int ToQuestId)
{
IQuestRepository repo = new EFQuestRepository();
var questConnection = repo.QuestConnections.FirstOrDefault(q => q.Id == Id);
if (questConnection == null)
{
questConnection = new QuestConnection
{
QuestId = QuestId,
QuestConnectionRequirements = new List <QuestConnectionRequirement>(),
QuestStateFromId = FromQuestId,
QuestStateToId = ToQuestId,
QuestStateFailToId = 0,
};
}
var output = new QuestConnectionFormViewModel
{
QuestConnection = questConnection,
};
if (FromQuestId > 0)
{
output.FromQuestState = QuestProcedures.GetQuestState(FromQuestId);
}
if (ToQuestId > 0)
{
output.ToQuestState = QuestProcedures.GetQuestState(ToQuestId);
}
if (questConnection.QuestStateFailToId > 0)
{
output.FailToQuestState = QuestProcedures.GetQuestState(questConnection.QuestStateFailToId);
}
return(PartialView(MVC.QuestWriter.Views.QuestConnection, output));
}
/// <summary>
/// Returns true if a player passes all rolls for a quest connection.
/// </summary>
/// <param name="connection"></param>
/// <param name="player">Player attempting to go down this connection</param>
/// <param name="buffs">Player's statistics from effects and equipment</param>
/// <param name="variables">All quest variables created by this player previously in the quest</param>
/// <returns></returns>
public static bool RollForQuestConnection(QuestConnection connection, Player player, BuffBox buffs, IEnumerable <QuestPlayerVariable> variables)
{
foreach (var q in connection.QuestConnectionRequirements)
{
if (!q.IsRandomRoll)
{
continue;
}
var playerValue = GetValueFromType(q, buffs);
var chance = q.RollModifier * playerValue + q.RollOffset;
var r = new Random();
var roll = r.NextDouble() * 100;
if (roll > chance)
{
return(false);
}
}
return(true);
}
public static int SaveQuestConnectionRequirement(QuestConnectionRequirement input, QuestConnection connection)
{
IQuestRepository repo = new EFQuestRepository();
var QuestConnectionRequirement = repo.QuestConnectionRequirements.FirstOrDefault(q => q.Id == input.Id);
// QuestState dbState = repo.QuestStates.FirstOrDefault(s => s.Id == state.Id);
if (QuestConnectionRequirement == null)
{
QuestConnectionRequirement = new QuestConnectionRequirement
{
QuestId = connection.QuestId,
};
}
QuestConnectionRequirement.Id = input.Id;
QuestConnectionRequirement.Operator = input.Operator;
QuestConnectionRequirement.RequirementType = input.RequirementType;
QuestConnectionRequirement.RequirementValue = input.RequirementValue;
if (input.VariabledbName != null)
{
QuestConnectionRequirement.VariabledbName = input.VariabledbName.ToUpper();
}
QuestConnectionRequirement.QuestConnectionId = repo.QuestConnections.FirstOrDefault(q => q.Id == connection.Id);
QuestConnectionRequirement.QuestConnectionRequirementName = input.QuestConnectionRequirementName;
QuestConnectionRequirement.RollModifier = input.RollModifier;
QuestConnectionRequirement.RollOffset = input.RollOffset;
QuestConnectionRequirement.IsRandomRoll = input.IsRandomRoll;
repo.SaveQuestConnectionRequirement(QuestConnectionRequirement);
return(QuestConnectionRequirement.Id);
}
/// <summary>
/// Constructor method
/// </summary>
public QuestConnectionBuilder()
{
this._questConnection = new QuestConnection();
this._questConnection.QuestConnectionRequirements = new List <QuestConnectionRequirement>();
}
public static string GetRequirementsAsString(QuestConnection q, BuffBox buffs)
{
var output = "";
if (!q.QuestConnectionRequirements.Any())
{
return(output);
}
var len = q.QuestConnectionRequirements.Count();
var i = 0;
output += "[";
foreach (var qs in q.QuestConnectionRequirements.ToList())
{
// don't print anything for variables or gender requirements
if (qs.RequirementType == (int)QuestStatics.RequirementType.Variable ||
qs.RequirementType == (int)QuestStatics.RequirementType.Gender ||
qs.RequirementType == (int)QuestStatics.RequirementType.Form)
{
continue;
}
// random roll, calculate % chance and display that
if (qs.IsRandomRoll)
{
var playerValue = GetValueFromType(qs, buffs);
var chance = Math.Round(qs.RollModifier * playerValue + qs.RollOffset, 1);
if (chance < 0)
{
chance = 0;
}
else if (chance > 100)
{
chance = 100;
}
output += qs.PrintRequirementStatAsString() + " - " + chance + "%";
}
// strict requirement
else
{
output += qs.PrintOperatorAsString() + " " + qs.RequirementValue + " " + qs.PrintRequirementStatAsString();
}
if (i < len - 1)
{
output += ", ";
}
i++;
}
output += "]";
// no requirements were found, so clear up
if (output == "[]")
{
output = "";
}
return(output);
}
/// <summary>
/// Returns true if a connection is available to the player to take.
/// </summary>
/// <param name="questConnection"></param>
/// <param name="player">Player attempting to go down this connection</param>
/// <param name="buffs">Player's statistics from effects and equipment</param>
/// <param name="variables">All quest variables created by this player previously in the quest</param>
/// <returns></returns>
public static bool QuestConnectionIsAvailable(QuestConnection questConnection, Player player, BuffBox buffs, IEnumerable <QuestPlayerVariable> variables)
{
var isAvailable = true;
if (questConnection.QuestStateFromId < 0 || questConnection.QuestStateToId < 0)
{
return(false);
}
foreach (var q in questConnection.QuestConnectionRequirements)
{
// skip all roll-based requirements; a player can always attempt a roll
if (q.IsRandomRoll)
{
continue;
}
// evaluate variable
if (q.RequirementType == (int)QuestStatics.RequirementType.Variable)
{
var var = variables.FirstOrDefault(v => v.VariableName == q.VariabledbName);
// variable has never been set, so fail
if (var == null)
{
return(false);
}
isAvailable = ExpressionIsTrue(float.Parse(var.VariableValue), q);
if (!isAvailable)
{
return(false);
}
else
{
continue;
}
}
else if (q.RequirementType == (int)QuestStatics.RequirementType.Gender)
{
if (q.RequirementValue == PvPStatics.GenderMale && player.Gender != PvPStatics.GenderMale)
{
return(false);
}
else if (q.RequirementValue == PvPStatics.GenderFemale && player.Gender != PvPStatics.GenderFemale)
{
return(false);
}
else
{
continue;
}
}
// evaluate player buff/ability
var playerValue = GetValueFromType(q, buffs);
isAvailable = ExpressionIsTrue(playerValue, q);
if (!isAvailable)
{
return(false);
}
}
return(true);
}
