protected StoryVar objGet(StoryVar obj, string key)
{
StoryVar output = default(StoryVar);
obj.ConvertValueTo <Dictionary <string, StoryVar> >().TryGetValue(key, out output);
return(output);
}
public override bool Combine(Operator op, object b, out StoryVar result)
{
result = default(StoryVar);
switch (op)
{
case Operator.Add: {
if (!(b is HarloweDatamap))
{
return(false);
}
var bMap = (HarloweDatamap)b;
var output = new Dictionary <string, StoryVar>(this.Dictionary);
bMap.Dictionary.ToList().ForEach(x => output[x.Key] = x.Value);
result = new HarloweDatamap(output);
break;
}
case Operator.Subtract: {
// Going out on a limb here, adding subtraction support to Harlowe:
// Treat any set as keys to remove from the dictionary
IEnumerable <string> keys;
if (b is HarloweDatamap)
{
keys = ((HarloweDatamap)b).Dictionary.Keys;
}
else if (b is HarloweDataset)
{
keys = ((HarloweDataset)b).Values.Select(v => v.ToString());
}
else if (b is HarloweArray)
{
keys = ((HarloweArray)b).Values.Select(v => v.ToString());
}
else
{
return(false);
}
var keySet = new HashSet <string>(keys);
// A little linq-fu
result = new HarloweDatamap(this.Dictionary
.Where(pair => !keySet.Contains(pair.Key))
.ToDictionary(
pair => pair.Key,
pair => pair.Value,
System.StringComparer.OrdinalIgnoreCase
)
);
break;
}
default:
return(false);
}
return(true);
}
public override bool Combine(Operator op, object b, out StoryVar result)
{
result = default(StoryVar);
if (!(b is HarloweDataset))
{
return(false);
}
var bSet = (HarloweDataset)b;
switch (op)
{
case Operator.Add:
result = new StoryVar(new HarloweDataset(Values.Concat(bSet.Values)));
break;
case Operator.Subtract:
result = new StoryVar(new HarloweDataset(Values.Except(bSet.Values)));
break;
default:
return(false);
}
return(true);
}
public override StoryVar GetMember(StoryVar member)
{
StoryVar val;
if (TryGetMemberArray(member, out val))
{
return(val);
}
var memberName = member.ToString().ToLower();
if (memberName == "length")
{
val = this.Length;
}
else
{
int index;
if (HarloweUtils.TryPositionToIndex(memberName, Values.Count, out index))
{
try { val = Values[index]; }
catch (System.IndexOutOfRangeException)
{
throw new VarTypeMemberException(string.Format("The array doesn't have a {0} position.", memberName));
}
}
else
{
throw new VarTypeMemberException(string.Format("The array doesn't have a member called {0}.", memberName));
}
}
return(new StoryVar(val));
}
public StoryVar datanames(StoryVar datamap)
{
return(new HarloweArray(datamap.ConvertValueTo <HarloweDatamap>().Dictionary.Keys
.OrderBy(key => key, StringComparer.InvariantCulture)
.Select(key => new StoryVar(key))
));
}
public StoryVar datavalues(StoryVar datamap)
{
return(new HarloweArray(datamap.ConvertValueTo <HarloweDatamap>().Dictionary
.OrderBy(pair => pair.Key, StringComparer.InvariantCulture)
.Select(pair => pair.Value)
));
}
public override bool Compare(Operator op, object b, out bool result)
{
result = false;
switch (op)
{
case Operator.Equals: {
if (!(b is HarloweDatamap))
{
return(false);
}
var bMap = (HarloweDatamap)b;
result =
new HashSet <string>(Dictionary.Keys).SetEquals(bMap.Dictionary.Keys) &&
new HashSet <StoryVar>(Dictionary.Values).SetEquals(bMap.Dictionary.Values);
break;
}
case Operator.Contains: {
result = this.ContainsKey(StoryVar.ConvertTo <string>(b));
break;
}
}
return(true);
}
public StoryVar text(params StoryVar[] vals)
{
var buffer = new StringBuilder();
foreach (StoryVar val in HarloweSpread.Flatten(vals))
{
buffer.Append(StoryVar.ConvertTo <string>(val, false));
}
return(buffer.ToString());
}
public static StoryVar GetVariable(string name)
{
if (!instance.globals.ContainsKey(name))
{
StoryVar dummy = StoryVar.Empty;
instance.globals.Add(name, dummy);
}
return(instance.globals[name].Duplicate());
}
protected bool arrayContains(StoryVar arr, StoryVar value, int position = 0)
{
if (position > 0)
{
return(arr.ConvertValueTo <List <StoryVar> >().Skip(position).Contains(value));
}
else
{
return(arr.ConvertValueTo <List <StoryVar> >().Contains(value));
}
}
public static bool TryPositionToIndex(StoryVar position, int total, out int index)
{
index = -1;
bool fromEnd = false;
if (StoryVar.TryConvertTo <int>(position, out index))
{
if (index <= 0)
{
index = Math.Abs(index);
fromEnd = true;
}
else
{
index -= 1;
}
}
else
{
string str;
if (!StoryVar.TryConvertTo <string>(position, out str))
{
return(false);
}
Match match = rx_Position.Match(str);
if (!match.Success)
{
return(false);
}
fromEnd = match.Groups["last"].Success;
if (match.Groups["index"].Success)
{
index = int.Parse(match.Groups["index"].Value) - 1;
}
else if (fromEnd)
{
index = 0;
}
else
{
return(false);
}
}
if (fromEnd)
{
index = total - 1 - index;
}
return(true);
}
public override StoryVar GetMember(StoryVar member)
{
var memberName = member.ToString().ToLower();
if (memberName == "length")
{
return(this.Length);
}
EnsureNotPosition(memberName);
throw new VarTypeMemberException(string.Format("The dataset doesn't have a member called {0}.", memberName));
}
public override void SetMember(StoryVar member, StoryVar value)
{
var memberName = member.ToString().ToLower();
if (memberName == "length")
{
throw new VarTypeMemberException("'length' cannot be modified.");
}
EnsureNotPosition(memberName);
throw new VarTypeMemberException(string.Format("The dataset doesn't have a member called {0}.", memberName));
}
void Update()
{
// Clean all previous recorded changes
_changes.Clear();
// Go over every story and check for changed variables
for (int i = 0; i < Stories.Length; i++)
{
Story story = Stories[i];
StoryVarSet previousValues;
// If no previous values were stored for this story, create a new set to store them in
if (!_previousValues.TryGetValue(story, out previousValues))
{
_previousValues.Add(story, previousValues = new StoryVarSet());
}
// Go over every variable and compare with its previous value
foreach (var variable in story.Vars)
{
// Get current and previous values for this story
StoryVar currentValue = variable.Value;
StoryVar previousValue = default(StoryVar);
// Compare to previous
if (previousValues.TryGetValue(variable.Key, out previousValue))
{
// A change has been detected in this variable, and no other story has changed it in this frame
if (previousValue != currentValue && !_changes.ContainsKey(variable.Key))
{
_changes.Add(variable.Key, currentValue);
}
}
// Keep track of the previous value
previousValues[variable.Key] = currentValue;
}
}
// Go over every story again, this time applying the changed variables
for (int i = 0; i < Stories.Length; i++)
{
Story story = Stories[i];
foreach (var variable in _changes)
{
if (story.Vars.ContainsKey(variable.Key))
{
story.Vars[variable.Key] = variable.Value;
}
}
}
}
public static void SetVariable(string name, StoryVar val)
{
if (instance.globals.ContainsKey(name))
{
instance.globals[name] = val.Duplicate();
}
else
{
instance.globals.Add(name, val.Duplicate());
}
//Save Game
}
protected bool arrayContainsAll(StoryVar arr, StoryVar valArray)
{
var valArr = valArray.InnerValue as List <StoryVar>;
if (valArr != null)
{
return(arrayContainsAll(arr, valArr.ToArray()));
}
else
{
return(arrayContains(arr, valArray));
}
}
protected StoryVar arrayDeleteAt(StoryVar arr, params int[] indices)
{
var curArr = arr.ConvertValueTo <List <StoryVar> >();
var newArr = new List <StoryVar>();
foreach (int index in indices.OrderByDescending(i => i))
{
newArr.Add(curArr[index]);
curArr.RemoveAt(index);
}
return(new StoryVar(newArr));
}
public void assertStyle(string setting, StoryVar value)
{
StoryStyle style = this.Story.GetCurrentStyle();
IntegrationTest.Assert(
value == style[setting],
string.Format("Group's \"{0}\" style setting is not {1}", setting, value)
);
IntegrationTest.Assert(
this.Story.Output.Reverse <StoryOutput>().Any(output => value == output.GetAppliedStyle()[setting]),
string.Format("The \"{0}\" style setting was not applied to any output", setting)
);
}
public StoryVar range(int start, int end)
{
int temp = start;
start = Math.Min(start, end);
end = Math.Max(temp, end);
StoryVar[] values = new StoryVar[end - start + 1];
for (int i = 0; i < values.Length; i++)
{
values[i] = start + i;
}
return(new HarloweArray(values));
}
protected StoryVar arrayDelete(StoryVar arr, params StoryVar[] values)
{
var newArr = new List <StoryVar>();
arr.ConvertValueTo <List <StoryVar> >().RemoveAll(v => {
bool remove = values.Contains(v);
if (remove)
{
newArr.Add(v);
}
return(remove);
});
return(new StoryVar(newArr));
}
public HarloweDatamap(params StoryVar[] vals) : this()
{
if (vals.Length % 2 != 0)
{
throw new VarTypeException("To create a datamap you must pass an even number of parameters.");
}
for (int i = 0; i < vals.Length; i += 2)
{
string key;
if (!StoryVar.TryConvertTo <string>(vals[i], out key))
{
throw new VarTypeException("To create a datamap, every odd parameter (an entry name) must be string.");
}
Dictionary[key] = vals[i + 1];
}
}
public StoryVar shuffled(params StoryVar[] vals)
{
// http://stackoverflow.com/questions/273313/randomize-a-listt-in-c-sharp
var array = new HarloweArray(vals);
int n = array.Length;
while (n > 1)
{
n--;
int k = shuffleRandomizer.Next(n + 1);
StoryVar value = array.Values[k];
array.Values[k] = array.Values[n];
array.Values[n] = value;
}
return(array);
}
public override StoryVar GetMember(StoryVar member)
{
StoryVar val;
if (TryGetMemberArray(member, out val))
{
return(val);
}
var memberName = member.ToString();
if (!Dictionary.TryGetValue(memberName, out val))
{
throw new VarTypeMemberException(string.Format("The datamap doesn't have an entry under the name '{0}'.", memberName));
}
return(new StoryVar(val));
}
protected bool TryGetMemberArray(StoryVar member, out StoryVar val)
{
// Special case when member is an array
if (member.Value is HarloweArray)
{
var memberArray = (HarloweArray)member.Value;
StoryVar[] valueArray = new StoryVar[memberArray.Length];
for (int i = 0; i < memberArray.Length; i++)
{
valueArray[i] = GetMember(memberArray.Values[i]);
}
val = new HarloweArray(valueArray);
return(true);
}
else
// Anything else treat as a property
{
val = default(StoryVar);
return(false);
}
}
// ................................
// Objects
protected StoryVar obj(params StoryVar[] vals)
{
if (vals.Length % 2 != 0)
{
throw new VarTypeException("To create an object you must pass an even number of parameters.");
}
var dictionary = new Dictionary <string, StoryVar>();
for (int i = 0; i < vals.Length; i += 2)
{
string key;
if (!StoryVar.TryConvertTo <string>(vals[i], out key))
{
throw new VarTypeException("To create an object, every odd parameter (an entry name) must be a string.");
}
dictionary[key] = vals[i + 1];
}
return(new StoryVar(dictionary));
}
public override StoryVar GetMember(string container, StoryVar member)
{
// Special case when member is an array
if (member.Value is HarloweArray)
{
var memberArray = (HarloweArray)member.Value;
var buffer = new char[memberArray.Length];
for (int i = 0; i < memberArray.Length; i++)
{
buffer[i] = GetMember(container, StoryVar.ConvertTo <int>(memberArray.Values[i])).ToString()[0];
}
return(new string(buffer));
}
int index;
if (HarloweUtils.TryPositionToIndex(member, container.Length, out index))
{
return(new StoryVar(container[index].ToString()));
}
return(base.GetMember(container, member));
}
public override void RemoveMember(StoryVar member)
{
var memberName = member.ToString().ToLower();
if (memberName == "length")
{
throw new VarTypeMemberException("'length' cannot be modified.");
}
int index;
if (HarloweUtils.TryPositionToIndex(memberName, Values.Count, out index))
{
try { Values.RemoveAt(index); }
catch (System.IndexOutOfRangeException)
{
throw new VarTypeMemberException(string.Format("The array doesn't have a {0} position.", memberName));
}
}
else
{
throw new VarTypeMemberException(string.Format("The array doesn't have a member called {0}.", memberName));
}
}
public override void SetMember(StoryVar member, StoryVar value)
{
var memberName = member.ToString();
Dictionary[memberName] = value.Duplicate();
}
public override bool Unary(Operator op, out StoryVar result)
{
result = default(StoryVar);
return(false);
}
public override void RemoveMember(StoryVar member)
{
var memberName = member.ToString();
Dictionary.Remove(memberName);
}
