/// <summary>
/// Ejecuta las funciones llamadas desde el explorador
/// </summary>
public void ExecuteFromExplorer(string arguments)
{
if (!arguments.IsEmpty())
{
string[] parameters = arguments.Split('|');
if (parameters.Length == 2)
{
BlogEntryViewModel entry = Entries.Search(parameters[1]);
if (entry != null)
{
BlogEntriesCollectionViewModel entries = new BlogEntriesCollectionViewModel {
entry
};
EntryAction action = parameters[0].GetEnum(EntryAction.Unknown);
switch (action)
{
case EntryAction.MarkRead:
if (entry.Entry.Status == EntryModel.StatusEntry.Read)
{
SetStatusEntries(entries, EntryModel.StatusEntry.NotRead);
}
else
{
SetStatusEntries(entries, EntryModel.StatusEntry.Read);
}
break;
case EntryAction.MarkInteresting:
if (entry.Entry.Status == EntryModel.StatusEntry.Interesting)
{
SetStatusEntries(entries, EntryModel.StatusEntry.Read);
}
else
{
SetStatusEntries(entries, EntryModel.StatusEntry.Interesting);
}
break;
case EntryAction.Delete:
DeleteEntries(entries);
break;
case EntryAction.Play:
PlayEntry();
break;
}
}
}
}
}
public static ScriptNode Read(Reader reader, Pointer offset, Script script) {
MapLoader l = MapLoader.Loader;
ScriptNode sn = new ScriptNode(offset);
sn.script = script;
sn.param = reader.ReadUInt32();
sn.param_ptr = Pointer.GetPointerAtOffset(offset); // if parameter is pointer
if (Settings.s.platform == Settings.Platform.DC) reader.ReadUInt32();
if (Settings.s.mode == Settings.Mode.Rayman3GC) {
reader.ReadByte();
reader.ReadByte();
reader.ReadByte();
sn.type = reader.ReadByte();
reader.ReadByte();
reader.ReadByte();
sn.indent = reader.ReadByte();
reader.ReadByte();
} else {
reader.ReadByte();
reader.ReadByte();
sn.indent = reader.ReadByte();
sn.type = reader.ReadByte();
}
sn.nodeType = NodeType.Unknown;
if (Settings.s.aiTypes != null) sn.nodeType = Settings.s.aiTypes.GetNodeType(sn.type);
if (sn.param_ptr != null && sn.nodeType != NodeType.Unknown) {
//l.print("ScriptNode " + offset + " - " + sn.nodeType + " (" + sn.type + ") - " + sn.param_ptr);
if (sn.nodeType == NodeType.WayPointRef) {
WayPoint waypoint = WayPoint.FromOffsetOrRead(sn.param_ptr, reader);
} else if (sn.nodeType == NodeType.String) {
Pointer.DoAt(ref reader, sn.param_ptr, () => {
string str = reader.ReadNullDelimitedString();
l.strings[sn.param_ptr] = str;
});
} else if (sn.nodeType == NodeType.ObjectTableRef) {
// In R2 some objects have object tables that aren't listed normally, but are referenced through scripts.
} else if (sn.nodeType == NodeType.Button) {
EntryAction.FromOffsetOrRead(sn.param_ptr, reader);
} else if (sn.nodeType == NodeType.GameMaterialRef) {
GameMaterial.FromOffsetOrRead(sn.param_ptr, reader);
} else if (sn.nodeType == NodeType.VisualMaterial) {
VisualMaterial.FromOffsetOrRead(sn.param_ptr, reader);
}
}
return sn;
}
private EntryAction CreateEntryAction(User user, EntryState entryState, Entry entry,
ActionTypesEnum actionTypesEnum)
{
var entryAction = new EntryAction
{
ActionType = actionTypesEnum,
Entry = entry,
EntryState = entryState,
User = user,
DateTime = DateTime.Now,
IsRestorable = true
};
return(entryAction);
}
public async Task <Status> GetEntryPassword(int userId, int entryId)
{
var userEntries = await _mainDbContext.UsersEntries
.Include(x => x.Entry.CurrentEntryState)
.Include(x => x.User)
.Where(x => x.EntryId == entryId && x.UserId == userId)
.FirstOrDefaultAsync();
if (userEntries == null)
{
return new Status {
Success = false, Message = "No entry founded"
}
}
;
var userOwnerHash = await _mainDbContext.UsersEntries
.Include(x => x.User)
.Where(x => x.EntryId == entryId && x.IsUserOwner)
.Select(x => x.User.PasswordHash)
.FirstOrDefaultAsync();
var password = SymmetricEncryptor.DecryptToString(userEntries.Entry.CurrentEntryState.PasswordE, userOwnerHash);
EntryAction newEntryAction = CreateEntryAction(userEntries.User, userEntries.Entry.CurrentEntryState,
userEntries.Entry, ActionTypesEnum.View);
try
{
await _mainDbContext.AddAsync(newEntryAction);
await _mainDbContext.SaveChangesAsync();
return(new Status {
Success = true, Message = password
});
}
catch (Exception e)
{
Console.WriteLine(e);
return(new Status
{
Success = false,
Message = "Something went wrong"
});
}
}
public ActivationPreferenceSetter(T[] existingList, T entry, EntryAction entryAction, long maxValue, long defaultMaxInterval)
{
if (entryAction == EntryAction.Insert && (existingList == null || existingList.Length == 0) && entry.DesiredValue != 1)
{
throw new ArgumentException("DesiredValue has to be 1, when inserting into an empty list.");
}
if (existingList == null)
{
this.m_existingList = new T[0];
}
else
{
this.m_existingList = existingList;
Array.Sort <T>(this.m_existingList);
}
this.m_entry = entry;
this.m_entryAction = entryAction;
this.m_maxValue = maxValue;
this.m_defaultMaxInterval = defaultMaxInterval;
}
public static string EntryActionToCSharpClass(EntryAction action)
{
string str = EntryActionToCSharp(action);
Regex entryActionRegex = new Regex("EntryAction\\{([^,]+), (.+)\\}");
Match entryActionMatch = entryActionRegex.Match(str);
if (!entryActionMatch.Success)
{
return("");
}
string entryActionName = entryActionMatch.Groups[1].Value.Replace("\"", "");
str = entryActionRegex.Replace(str,
"public class " + entryActionName + " : EntryAction { " + Environment.NewLine +
"public override bool Check() {" + Environment.NewLine +
"return $2;" + Environment.NewLine +
"}" + Environment.NewLine +
"}"
);
return(str);
}
public void Read(Reader reader)
{
offset = Pointer.Current(reader);
switch (type)
{
case DsgVarInfoEntry.DsgVarType.Boolean:
valueBool = reader.ReadBoolean(); break;
case DsgVarInfoEntry.DsgVarType.Byte:
valueByte = reader.ReadSByte(); break;
case DsgVarInfoEntry.DsgVarType.UByte:
valueUByte = reader.ReadByte(); break;
case DsgVarInfoEntry.DsgVarType.Float:
valueFloat = reader.ReadSingle(); break;
case DsgVarInfoEntry.DsgVarType.Int:
valueInt = reader.ReadInt32(); break;
case DsgVarInfoEntry.DsgVarType.UInt:
valueUInt = reader.ReadUInt32(); break;
case DsgVarInfoEntry.DsgVarType.Short:
valueShort = reader.ReadInt16(); break;
case DsgVarInfoEntry.DsgVarType.UShort:
valueUShort = reader.ReadUInt16(); break;
case DsgVarInfoEntry.DsgVarType.Vector:
float x = reader.ReadSingle();
float y = reader.ReadSingle();
float z = reader.ReadSingle();
valueVector = new Vector3(x, y, z);
break;
case DsgVarInfoEntry.DsgVarType.Text:
valueText = reader.ReadInt32(); break;
case DsgVarInfoEntry.DsgVarType.Graph:
valuePointer = Pointer.Read(reader);
valueGraph = Graph.FromOffsetOrRead(valuePointer, reader);
break;
case DsgVarInfoEntry.DsgVarType.WayPoint:
valuePointer = Pointer.Read(reader);
valueWayPoint = WayPoint.FromOffsetOrRead(valuePointer, reader);
break;
case DsgVarInfoEntry.DsgVarType.GameMaterial:
valuePointer = Pointer.Read(reader);
valueGameMaterial = GameMaterial.FromOffsetOrRead(valuePointer, reader);
break;
case DsgVarInfoEntry.DsgVarType.VisualMaterial:
valuePointer = Pointer.Read(reader);
valueVisualMaterial = VisualMaterial.FromOffsetOrRead(valuePointer, reader);
break;
case DsgVarInfoEntry.DsgVarType.ObjectList:
valuePointer = Pointer.Read(reader);
valueObjectList = ObjectList.FromOffsetOrRead(valuePointer, reader);
break;
case DsgVarInfoEntry.DsgVarType.List:
valueList = new List();
valueList.Read(reader);
break;
case DsgVarInfoEntry.DsgVarType.Light:
valuePointer = Pointer.Read(reader);
valueLight = MapLoader.Loader.FromOffsetOrRead <LightInfo>(reader, valuePointer);
break;
case DsgVarInfoEntry.DsgVarType.Comport:
valuePointer = Pointer.Read(reader);
valueComport = MapLoader.Loader.FromOffsetOrRead <Behavior>(reader, valuePointer);
break;
case DsgVarInfoEntry.DsgVarType.Input:
valuePointer = Pointer.Read(reader);
valueInput = EntryAction.FromOffsetOrRead(valuePointer, reader);
break;
// Fill these in after loading
case DsgVarInfoEntry.DsgVarType.Perso:
valuePointer = Pointer.Read(reader);
// Don't fill in perso yet
MapLoader.Loader.onPostLoad.Add(InitPostLoad);
break;
case DsgVarInfoEntry.DsgVarType.Action:
valuePointer = Pointer.Read(reader);
// Don't fill in state yet
MapLoader.Loader.onPostLoad.Add(InitPostLoad);
break;
case DsgVarInfoEntry.DsgVarType.SuperObject:
valuePointer = Pointer.Read(reader);
// Don't fill in SO yet
MapLoader.Loader.onPostLoad.Add(InitPostLoad);
break;
// TODO: Figure these out
case DsgVarInfoEntry.DsgVarType.Caps:
valueCaps = reader.ReadUInt32(); break;
case DsgVarInfoEntry.DsgVarType.SOLinks:
valueSOLinks = reader.ReadUInt32(); break;
case DsgVarInfoEntry.DsgVarType.SoundEvent:
valueSoundEvent = reader.ReadUInt32(); break;
case DsgVarInfoEntry.DsgVarType.Way:
valueWay = reader.ReadUInt32(); break;
// Arrays
case DsgVarInfoEntry.DsgVarType.ActionArray:
case DsgVarInfoEntry.DsgVarType.FloatArray:
case DsgVarInfoEntry.DsgVarType.IntegerArray:
case DsgVarInfoEntry.DsgVarType.PersoArray:
case DsgVarInfoEntry.DsgVarType.SoundEventArray:
case DsgVarInfoEntry.DsgVarType.SuperObjectArray:
case DsgVarInfoEntry.DsgVarType.TextArray:
case DsgVarInfoEntry.DsgVarType.TextRefArray:
case DsgVarInfoEntry.DsgVarType.VectorArray:
case DsgVarInfoEntry.DsgVarType.WayPointArray:
case DsgVarInfoEntry.DsgVarType.GraphArray:
case DsgVarInfoEntry.DsgVarType.Array11:
case DsgVarInfoEntry.DsgVarType.Array9:
ReadArray(reader); break;
}
}
public string ToString(Perso perso, TranslatedScript.TranslationSettings ts, bool advanced = false)
{
MapLoader l = MapLoader.Loader;
short mask = 0;
AITypes aiTypes = Settings.s.aiTypes;
Vector3 vector3 = new Vector3 {
x = 0, y = 0, z = 0
};
switch (nodeType)
{
case ScriptNode.NodeType.KeyWord: // KeyWordFunctionPtr
if (param < aiTypes.keywordTable.Length)
{
if (ts.exportMode)
{
if (aiTypes.keywordTable[param] == "Me")
{
return("this");
}
if (aiTypes.keywordTable[param] == "MainActor")
{
return("Controller.MainActor");
}
if (aiTypes.keywordTable[param] == "Nobody" || aiTypes.keywordTable[param] == "NoInput" || aiTypes.keywordTable[param] == "Nowhere" || aiTypes.keywordTable[param] == "NoGraph" || aiTypes.keywordTable[param] == "NoAction" || aiTypes.keywordTable[param] == "CapsNull")
{
return("null");
}
}
return(aiTypes.keywordTable[param]);
}
return("UnknownKeyword_" + param);
case ScriptNode.NodeType.Condition: // GetConditionFunctionPtr
if (param < aiTypes.conditionTable.Length)
{
return(aiTypes.conditionTable[param]);
}
return("UnknownCondition_" + param);
case ScriptNode.NodeType.Operator: // GetOperatorFunctionPtr
if (advanced)
{
if (param < aiTypes.operatorTable.Length)
{
return(aiTypes.operatorTable[param] + " (" + param + ")");
}
}
if (param < aiTypes.operatorTable.Length)
{
return(aiTypes.operatorTable[param]);
}
return("UnknownOperator_" + param);
case ScriptNode.NodeType.Function: // GetFunctionFunctionPtr
if (param < aiTypes.functionTable.Length)
{
return(aiTypes.functionTable[param]);
}
return("UnknownFunction_" + param);
case ScriptNode.NodeType.Procedure: // ProcedureFunctionReturn
if (param < aiTypes.procedureTable.Length)
{
return(aiTypes.procedureTable[param]);
}
return("UnknownProcedure_" + param);
case ScriptNode.NodeType.MetaAction: // meta action
if (param < aiTypes.metaActionTable.Length)
{
return(aiTypes.metaActionTable[param]);
}
return("UnknownMetaAction_" + param);
case ScriptNode.NodeType.BeginMacro:
return("BeginMacro");
case ScriptNode.NodeType.EndMacro:
return("EndMacro");
case ScriptNode.NodeType.Field:
if (param < aiTypes.fieldTable.Length)
{
return(aiTypes.fieldTable[param]);
}
return("UnknownField_" + param);
case ScriptNode.NodeType.DsgVarRef: // Dsg Var
if (perso != null && perso.brain != null && perso.brain.mind != null)
{
Mind mind = perso.brain.mind;
if (mind.dsgMem != null && mind.dsgMem.dsgVar != null)
{
if (param < mind.dsgMem.dsgVar.dsgVarInfos.Length)
{
return(mind.dsgMem.dsgVar.dsgVarInfos[param].NiceVariableName);
}
}
else if (mind.AI_model != null && mind.AI_model.dsgVar != null)
{
if (param < mind.AI_model.dsgVar.dsgVarInfos.Length)
{
return(mind.AI_model.dsgVar.dsgVarInfos[param].NiceVariableName);
}
}
}
return("dsgVar_" + param);
case ScriptNode.NodeType.Constant:
if (advanced)
{
return("Constant: " + BitConverter.ToInt32(BitConverter.GetBytes(param), 0));
}
return(BitConverter.ToInt32(BitConverter.GetBytes(param), 0).ToString());
case ScriptNode.NodeType.Real:
NumberFormatInfo nfi = new NumberFormatInfo()
{
NumberDecimalSeparator = "."
};
if (advanced)
{
return("Real: " + BitConverter.ToSingle(BitConverter.GetBytes(param), 0).ToString(nfi));
}
return(BitConverter.ToSingle(BitConverter.GetBytes(param), 0).ToString(nfi) + "f");
case ScriptNode.NodeType.Button: // Button/entryaction
EntryAction ea = EntryAction.FromOffset(param_ptr);
if (ea == null)
{
return("ERR_ENTRYACTION_NOTFOUND");
}
string eaName = (advanced ? ea.ToString() : ea.ToBasicString());
if (advanced)
{
return("Button: " + eaName + "(" + param_ptr + ")");
}
if (!ts.expandEntryActions && ea != null)
{
return("\"" + ea.ExportName + "\"");
}
return(eaName);
case ScriptNode.NodeType.ConstantVector:
return("Constant Vector: " + "0x" + param.ToString("x8")); // TODO: get from address
case ScriptNode.NodeType.Vector:
return("new Vector3"); // TODO: same
case ScriptNode.NodeType.Mask:
mask = (short)param; // TODO: as short
if (advanced)
{
return("Mask: " + (mask).ToString("x4"));
}
if (ts.exportMode)
{
return("\"" + (mask).ToString("x4") + "\"");
}
return("Mask(" + (mask).ToString("x4") + ")");
case ScriptNode.NodeType.ModuleRef:
if (advanced)
{
return("ModuleRef: " + "0x" + (param).ToString("x8"));
}
return("GetModule(" + (int)param + ")");
case ScriptNode.NodeType.DsgVarId:
if (advanced)
{
return("DsgVarId: " + "0x" + (param).ToString("x8"));
}
return("DsgVarId(" + param + ")");
case ScriptNode.NodeType.String:
string str = "ERR_STRING_NOTFOUND";
if (l.strings.ContainsKey(param_ptr))
{
str = l.strings[param_ptr];
}
if (advanced)
{
return("String: " + param_ptr + " (" + str + ")");
}
return("\"" + str + "\"");
case ScriptNode.NodeType.LipsSynchroRef:
return("LipsSynchroRef: " + param_ptr);
case ScriptNode.NodeType.FamilyRef:
if (advanced)
{
return("FamilyRef: " + param_ptr);
}
Family f = Family.FromOffset(param_ptr);
if (f != null)
{
return("GetFamily(\"" + f.name + "\")");
}
else
{
return("Family.FromOffset(\"" + param_ptr + "\")");
}
case ScriptNode.NodeType.PersoRef:
Perso argPerso = Perso.FromOffset(param_ptr);
if (argPerso != null && perso != null && argPerso.offset == perso.offset)
{
if (advanced)
{
return("PersoRef: this");
}
return("this");
}
string persoName = argPerso == null ? "ERR_PERSO_NOTFOUND" : argPerso.fullName;
if (advanced)
{
return("PersoRef: " + param_ptr + " (" + persoName + ")");
}
if (argPerso?.brain?.mind?.AI_model != null)
{
AIModel aiModel = argPerso.brain.mind.AI_model;
// Make sure to add a cast in case the AI Model is accessed
return("((" + aiModel.name + ")GetPerso(\"" + argPerso.namePerso + "\"))");
}
return("GetPerso(\"" + argPerso.namePerso + "\")");
case ScriptNode.NodeType.ActionRef:
State state = State.FromOffset(param_ptr);
string stateName = state == null ? "ERR_STATE_NOTFOUND" : state.ShortName;
if (advanced)
{
return("ActionRef: " + param_ptr + " " + stateName);
}
if (ts.useStateIndex)
{
return("GetAction(" + state.index.ToString() + ")");
}
return(stateName);
case ScriptNode.NodeType.SuperObjectRef:
if (advanced)
{
return("SuperObjectRef: " + param_ptr);
}
SuperObject so = SuperObject.FromOffset(param_ptr);
if (so != null)
{
return("GetSuperObject(\"" + so.Gao.name + "\")");
}
else
{
return("SuperObject.FromOffset(\"" + param_ptr + "\")");
}
case ScriptNode.NodeType.WayPointRef:
if (advanced)
{
return("WayPointRef: " + param_ptr);
}
return("WayPoint.FromOffset(\"" + param_ptr + "\")");
case ScriptNode.NodeType.TextRef:
if (l.localization == null)
{
return("TextRef");
}
if (advanced)
{
return("TextRef: " + param + " (" + l.localization.GetTextForHandleAndLanguageID((int)param, 0) + ")");
}
if (ts.expandStrings)
{
return("\"" + l.localization.GetTextForHandleAndLanguageID((int)param, 0) + "\""); // Preview in english
}
else
{
return("new TextReference(" + (int)param + ")");
}
case ScriptNode.NodeType.ComportRef:
Behavior comportRef = Behavior.FromOffset(param_ptr);
if (comportRef == null)
{
if (advanced)
{
return("ComportRef: " + param_ptr + " (null)");
}
return("null");
}
else
{
return(comportRef.ShortName);
//string type = comportRef.type == Behavior.BehaviorType.Normal ? "normalBehavior" : "reflexBehavior";
//return type + "[" + script.behaviorOrMacro.aiModel.GetBehaviorIndex(comportRef) + "]";
}
case ScriptNode.NodeType.SoundEventRef:
if (advanced)
{
return("SoundEventRef: " + (int)param);
}
return("SoundEvent.FromID(0x" + ((int)param).ToString("X8") + ")");
case ScriptNode.NodeType.ObjectTableRef:
if (advanced)
{
return("ObjectTableRef: " + param_ptr);
}
if (ts.useHashIdentifiers)
{
string objectListJson = ObjectList.FromOffset(param_ptr).ToJSON();
string objectListHash = HashUtils.MD5Hash(objectListJson);
return("ObjectList.FromHash(\"" + objectListHash + "\")");
}
return("ObjectTable.FromOffset(\"" + param_ptr + "\")");
case ScriptNode.NodeType.GameMaterialRef:
if (advanced)
{
return("GameMaterialRef: " + param_ptr);
}
if (ts.useHashIdentifiers)
{
string gmtJson = GameMaterial.FromOffset(param_ptr).ToJSON();
string gmtHash = HashUtils.MD5Hash(gmtJson);
return("GameMaterial.FromHash(\"" + gmtHash + "\")");
}
return("GameMaterial.FromOffset(\"" + param_ptr + "\")");
case ScriptNode.NodeType.ParticleGenerator:
return("ParticleGenerator: " + "0x" + (param).ToString("x8"));
case ScriptNode.NodeType.VisualMaterial:
if (advanced)
{
return("VisualMaterial: " + param_ptr);
}
if (ts.useHashIdentifiers)
{
string vmtJson = VisualMaterial.FromOffset(param_ptr).ToJSON();
string vmtHash = HashUtils.MD5Hash(vmtJson);
return("VisualMaterial.FromHash(\"" + vmtHash + "\")");
}
return("VisualMaterial.FromOffset(\"" + param_ptr + "\")");
case ScriptNode.NodeType.ModelRef: // ModelCast
if (advanced)
{
return("AIModel: " + param_ptr);
}
AIModel model = AIModel.FromOffset(param_ptr);
return(model != null ? model.name : "null");
case ScriptNode.NodeType.DataType42:
if (advanced)
{
return("EvalDataType42: " + "0x" + (param).ToString("x8"));
}
return("EvalDataType42(" + "0x" + (param).ToString("x8") + ")");
case ScriptNode.NodeType.CustomBits:
if (advanced)
{
return("CustomBits: " + "0x" + (param).ToString("x8"));
}
if (ts.exportMode)
{
return("0x" + (param).ToString("x8"));
}
return("CustomBits(" + "0x" + (param).ToString("x8") + ")");
case ScriptNode.NodeType.Caps:
if (advanced)
{
return("Caps: " + "0x" + (param).ToString("x8"));
}
if (ts.exportMode)
{
return("0x" + (param).ToString("x8"));
}
return("Caps(" + "0x" + (param).ToString("x8") + ")");
case ScriptNode.NodeType.SubRoutine:
if (advanced)
{
return("Eval SubRoutine: " + param_ptr);
}
Macro macro = Macro.FromOffset(param_ptr);
if (macro == null)
{
return("null");
}
return("evalMacro(" + macro.ShortName + ");");
case ScriptNode.NodeType.Null:
return("null");
case ScriptNode.NodeType.GraphRef:
if (advanced)
{
return("Graph: " + "0x" + (param).ToString("x8"));
}
return("Graph.FromOffset(\"" + param_ptr + "\")");
}
return("unknown");
}
private void RaiseActionEvent(EntryAction action)
{
Action?.BeginInvoke(this, new ActionEventArgs(action), null, null);
}
public ActionEventArgs(EntryAction action)
{
Action = action;
}
public static string EntryActionToCSharp(EntryAction action)
{
string name = "EntryAction_" + action.offset.offset;
string str = action.ToBasicString();
Regex entryActionRegex = new Regex("EntryAction\\{([^,]+), (.+)\\}");
// Check if the EntryAction is not empty
Match entryActionMatch = entryActionRegex.Match(str);
if (!entryActionMatch.Success)
{
return("");
}
// Keyboard
Regex regexKeyPressed = new Regex("KeyPressed\\(([^\\)]+)\\)");
Regex regexKeyJustPressed = new Regex("KeyJustPressed\\(([^\\)]+)\\)");
Regex regexKeyReleased = new Regex("KeyReleased\\(([^\\)]+)\\)");
Regex regexKeyJustReleased = new Regex("KeyJustReleased\\(([^\\)]+)\\)");
str = regexKeyPressed.Replace(str, (m) =>
{
return("UnityEngine.Input.GetKey(UnityEngine.KeyCode." + ConvertKeyCode(m.Groups[1].Value) + ")");
});
str = regexKeyJustPressed.Replace(str, (m) =>
{
return("UnityEngine.Input.GetKeyDown(UnityEngine.KeyCode." + ConvertKeyCode(m.Groups[1].Value) + ")");
});
str = regexKeyReleased.Replace(str, (m) =>
{
return("(!UnityEngine.Input.GetKey(UnityEngine.KeyCode." + ConvertKeyCode(m.Groups[1].Value) + "))");
});
str = regexKeyJustReleased.Replace(str, (m) =>
{
return("UnityEngine.Input.GetKeyUp(UnityEngine.KeyCode." + ConvertKeyCode(m.Groups[1].Value) + ")");
});
// Joystick
Regex regexJoystickAxeValue = new Regex("JoystickAxeValue\\(([XY]), ([\\-0-9]+), ([\\-0-9]+)\\)");
str = regexJoystickAxeValue.Replace(str, "Controller.InputManager.JoystickAxeValue(\"$1\", $2, $3)");
Regex regexJoystickPressed = new Regex("JoystickOrPadPressed\\(([^)]+)\\)");
str = regexJoystickPressed.Replace(str, "UnityEngine.Input.GetButton(\"$1\")");
// ActionValidated
Regex regexActionValidated = new Regex("ActionValidated\\{EntryAction\\{(\\\"[^\\\"]+\\\"), ([^\\}]+)[\\}]+");
str = regexActionValidated.Replace(str, "Controller.InputManager.IsActionValidated($1)");
// Sequences
str = str.Replace("Sequence", "Controller.InputManager.CheckSequence");
return(str);
}
public ActivationPreferenceSetter(T[] existingList, T entry, EntryAction entryAction) : this(existingList, entry, entryAction, 2147483647L, 134217727L)
{
}
/// <summary>
/// Obtiene un vínculo a una llamada de función externa en JavaScript
/// </summary>
private string GetJavaScriptExternalFuction(BlogEntryViewModel entry, string title, EntryAction action)
{
return($"<a href='' onclick=\"window.external.ExternalFunction('{action.ToString()}|{entry.Entry.URL}');return false;\">{title}</a>");
}
/// <summary>
/// Invokes EnterAction event.
/// </summary>
/// <param name="symbol"></param>
public void OnEntryAction(TInSymbol symbol)
{
EntryAction?.Invoke(this, new ActionEventArgs(symbol));
}
EntryAction DrawEntry(PListDictionary dic, int index)
{
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField(dic.StringValue(DISPLAY_NAME_KEY), GUILayout.MaxWidth(400));
EditorGUILayout.LabelField(dic.StringValue(SETTING_KEY), GUILayout.MaxWidth(400));
var type = (SettingType)System.Enum.Parse(typeof(SettingType), dic.StringValue(TYPE_KEY));
EditorGUILayout.LabelField(type.ToString(), GUILayout.MaxWidth(200));
switch (type)
{
case SettingType.Bool:
DrawBoolEntry(dic);
break;
case SettingType.String:
DrawStringEntry(dic);
break;
case SettingType.Enum:
DrawEnumEntry(dic);
break;
case SettingType.Array:
case SettingType.StringList:
DrawArrayEntry(dic);
break;
default:
EditorGUILayout.LabelField("UNKNOWN", GUILayout.MaxWidth(600));
break;
}
EditorGUILayout.Space();
EditorGUILayout.LabelField(index.ToString(), GUILayout.MaxWidth(40));
EntryAction action = EntryAction.None;
if (GUILayout.Button("^", GUILayout.MaxWidth(40)))
{
action = EntryAction.MoveUp;
}
if (GUILayout.Button("v", GUILayout.MaxWidth(40)))
{
action = EntryAction.MoveDown;
}
if (GUILayout.Button("e", GUILayout.MaxWidth(40)))
{
action = EntryAction.Edit;
}
if (GUILayout.Button("-", GUILayout.MaxWidth(40)))
{
if (EditorUtility.DisplayDialog("Remove Entry?", "Remove entry: " + dic.StringValue(DISPLAY_NAME_KEY) + " - " + dic.StringValue(SETTING_KEY), "Remove", "Cancel"))
{
action = EntryAction.Remove;
}
}
EditorGUILayout.EndHorizontal();
return(action);
}
void DrawEntries()
{
//populate default fold out state data if requried
if (_foldoutState.Count != _groups.Length)
{
foreach (var group in _groups)
{
_foldoutState[group] = true;
}
}
var settings = _plist.Root.ArrayValue(_settingsDicKey);
if (settings == null)
{
EditorGUILayout.LabelField("Error loading settings");
return;
}
int actionIndex = -1;
EntryAction action = EntryAction.None;
Color normalColor = GUI.color;
Color altColor = Color.green;
bool useAltColor = false;
//draw the foldouts
foreach (var group in _groups)
{
GUI.color = normalColor;
useAltColor = false;
_foldoutState[group] = EditorGUILayout.Foldout(_foldoutState[group], group, _style.Foldout());
if (!_foldoutState[group])
{
continue;
}
EditorGUI.indentLevel++;
for (int ii = 0; ii < settings.Count; ++ii)
{
var dic = settings.DictionaryValue(ii);
if (dic.StringValue(GROUP_KEY) != group)
{
continue;
}
var a = DrawEntry(dic, ii);
if (a != EntryAction.None)
{
action = a;
actionIndex = ii;
}
useAltColor = !useAltColor;
GUI.color = useAltColor ? altColor : normalColor;
}
EditorGUI.indentLevel--;
}
GUI.color = normalColor;
switch (action)
{
case EntryAction.Edit:
PopulateEdit(settings.DictionaryValue(actionIndex));
break;
case EntryAction.MoveUp:
if (actionIndex > 0)
{
var entry = settings[actionIndex];
settings.RemoveAt(actionIndex);
int newIndex = actionIndex - 1;
settings.Insert(newIndex, entry);
_plist.Save();
}
break;
case EntryAction.MoveDown:
if (actionIndex < settings.Count - 1)
{
var entry = settings[actionIndex];
settings.RemoveAt(actionIndex);
int newIndex = actionIndex + 1;
settings.Insert(newIndex, entry);
_plist.Save();
}
break;
case EntryAction.Remove:
settings.RemoveAt(actionIndex);
_plist.Save();
break;
default:
break;
}
}
