void DoGetCsvFields()
{
CsvData _data = CsvData.GetReference(reference.Value);
if (_data == null)
{
Fsm.Event(errorEvent);
fields.Resize(0);
return;
}
int _record = zeroBasedIndexing?record.Value:record.Value - 1;
if (_data.RecordCount <= _record)
{
LogError("Csv Data '" + reference.Value + "' doesn't have " + (_record + 1) + " records, only " + _data.RecordCount);
Fsm.Event(errorEvent);
fields.Resize(0);
return;
}
fields.stringValues = _data.GetRecordAt(_record);
fields.SaveChanges();
}
public override void OnEnter()
{
int sort;
if (mStaticThings.I == null)
{
sort = 0;
return;
}
else
{
sort = mStaticThings.I.GetSortNumber(mStaticThings.I.mAvatarID);
AllAvatars.Resize(0);
AllAvatarNames.Resize(0);
ActiveAvatars.Resize(0);
ActiveNickNames.Resize(0);
AllAvatars.Values = mStaticThings.I.GetAllStaticAvatarList().ToArray().Clone() as object[];
AllAvatarNames.Values = mStaticThings.I.GetAllStaticAvatarsDicNames().ToArray().Clone() as object[];
ActiveAvatars.Values = mStaticThings.I.GetAllActiveAvatarList().ToArray().Clone() as object[];
ActiveNickNames.Values = mStaticThings.I.GetAllActiveAvatarsDicNames().ToArray().Clone() as object[];
AllAvatars.SaveChanges();
AllAvatarNames.SaveChanges();
ActiveAvatars.SaveChanges();
ActiveNickNames.SaveChanges();
}
Sort.Value = sort;
Finish();
}
void DoSortByDistance()
{
root = orDistanceFromVector3.Value;
_rootGo = Fsm.GetOwnerDefaultTarget(distanceFrom);
if (_rootGo != null)
{
root += _rootGo.transform.position;
}
// bubble-sort transforms
for (int e = 0; e < array.Length - 1; e++)
{
GameObject _item_e0 = (GameObject)array.objectReferences[e + 0];
GameObject _item_e1 = (GameObject)array.objectReferences[e + 1];
float sqrMag1 = (_item_e0.transform.position - root).sqrMagnitude;
float sqrMag2 = (_item_e1.transform.position - root).sqrMagnitude;
UnityEngine.Debug.Log(sqrMag1 + " " + sqrMag2);
if (sqrMag2 < sqrMag1)
{
GameObject tempStore = (GameObject)array.objectReferences[e];
array.objectReferences[e] = array.objectReferences[e + 1];
array.objectReferences[e + 1] = tempStore;
e = 0;
}
}
array.SaveChanges();
}
private void DoSetFsmArrayCopy()
{
var go = Fsm.GetOwnerDefaultTarget(gameObject);
if (!UpdateCache(go, fsmName.Value))
{
return;
}
var fsmArray = fsm.FsmVariables.GetFsmArray(variableName.Value);
if (fsmArray != null)
{
if (fsmArray.ElementType != storeValue.ElementType)
{
LogError("Can only copy arrays with the same elements type. Found <" + fsmArray.ElementType + "> and <" + storeValue.ElementType + ">");
return;
}
storeValue.Resize(0);
if (copyValues)
{
storeValue.Values = fsmArray.Values.Clone() as object[];
}
else
{
storeValue.Values = fsmArray.Values;
}
storeValue.SaveChanges();
}
else
{
DoVariableNotFound(variableName.Value);
}
}
public override void OnEnter()
{
var trimCharsArray = trimChars.Value.ToCharArray();
if (!stringToSplit.IsNone && !stringArray.IsNone)
{
stringArray.stringValues = stringToSplit.Value.Split(separators.Value.ToCharArray());
if (trimStrings.Value)
{
for (var i = 0; i < stringArray.stringValues.Length; i++)
{
var s = stringArray.stringValues[i];
if (!trimChars.IsNone && trimCharsArray.Length > 0)
{
stringArray.Set(i, s.Trim(trimCharsArray));
}
else
{
stringArray.Set(i, s.Trim());
}
}
stringArray.SaveChanges();
}
}
Finish();
}
public override void OnEnter()
{
if (mStaticThings.I == null)
{
return;
}
else
{
roomids.Resize(0);
voiceids.Resize(0);
List <string> temproomids = new List <string>();
List <string> tempvoiceids = new List <string>();
for (int i = 0; i < mStaticThings.I.LastIDLinkChanelRoomList.Count; i++)
{
temproomids.Add(mStaticThings.I.LastIDLinkChanelRoomList[i].roomid);
}
for (int i = 0; i < mStaticThings.I.LastIDLinkChanelRoomList.Count; i++)
{
tempvoiceids.Add(mStaticThings.I.LastIDLinkChanelRoomList[i].voiceid);
}
roomids.Values = temproomids.ToArray().Clone() as object[];
voiceids.Values = tempvoiceids.ToArray().Clone() as object[];
roomids.SaveChanges();
voiceids.SaveChanges();
}
Finish();
}
void DoGetCsvColumn()
{
CsvData _data = CsvData.GetReference(reference.Value);
if (_data == null)
{
Fsm.Event(errorEvent);
result.Resize(0);
return;
}
int _column = zeroBasedIndexing?column.Value:column.Value - 1;
if (_data.ColumnCount <= _column)
{
LogError("Csv Data '" + reference.Value + "' doesn't have " + (_column) + " columns, only " + _data.ColumnCount);
Fsm.Event(errorEvent);
result.Resize(0);
return;
}
result.Resize(_data.RecordCount);
for (int i = 0; i < _data.RecordCount; i++)
{
result.Set(i, _data.GetFieldAt(i, _column, false));
}
result.SaveChanges();
}
public override void OnEnter()
{
char[] array = trimChars.Value.ToCharArray();
if (!stringToSplit.IsNone && !stringArray.IsNone)
{
stringArray.Values = stringToSplit.Value.Split(separators.Value.ToCharArray());
if (trimStrings.Value)
{
for (int i = 0; i < stringArray.Values.Length; i++)
{
string text = stringArray.Values[i] as string;
if (text != null)
{
if (!trimChars.IsNone && array.Length > 0)
{
stringArray.Set(i, text.Trim(array));
}
else
{
stringArray.Set(i, text.Trim());
}
}
}
}
stringArray.SaveChanges();
}
Finish();
}
public override void OnEnter()
{
FindChildrenRecursive(Owner);
if (children.Count != 0)
{
result.Resize(children.Count);
int i = 0;
foreach (var child in children)
{
result.Set(i, child);
i++;
}
result.SaveChanges();
Fsm.Event(successEvent);
}
else
{
Fsm.Event(failedEvent);
}
Finish();
}
public override void OnEnter()
{
if (UpdateCache(Fsm.GetOwnerDefaultTarget(gameObject)))
{
keywords.SaveChanges();
this.cachedComponent.SetKeyword(keywords.stringValues);
}
Finish();
}
void DoCalculatePath()
{
GameObject _sourceGameObject = Fsm.GetOwnerDefaultTarget(sourceGameObject);
if (_sourceGameObject == null)
{
return;
}
GameObject _targetGameObject = targetGameObject.Value;
if (_targetGameObject == null)
{
return;
}
_getNavMeshPathProxy();
UnityEngine.AI.NavMeshPath _path = new UnityEngine.AI.NavMeshPath();
bool _found = UnityEngine.AI.NavMesh.CalculatePath(_sourceGameObject.transform.position, _targetGameObject.transform.position, passableMask.Value, _path);
if (_NavMeshPathProxy != null)
{
_NavMeshPathProxy.path = _path;
}
if (!calculatedPathCorners.IsNone)
{
calculatedPathCorners.Resize(_path.corners.Length);
for (int i = 0; i < calculatedPathCorners.Length; i++)
{
calculatedPathCorners.Set(i, _path.corners [i]);
}
calculatedPathCorners.SaveChanges();
}
resultingPathFound.Value = _found;
if (_found)
{
if (!FsmEvent.IsNullOrEmpty(resultingPathFoundEvent))
{
Fsm.Event(resultingPathFoundEvent);
}
}
else
{
if (!FsmEvent.IsNullOrEmpty(resultingPathNotFoundEvent))
{
Fsm.Event(resultingPathNotFoundEvent);
}
}
}
public override void OnUpdate()
{
if (cloud != null && cloud.isDone)
{
var downloadedFilenames = cloud.filenames;
filenames.Resize(cloud.filenames.Length);
for (int i = 0; i < downloadedFilenames.Length; i++)
{
filenames.Set(i, downloadedFilenames [i]);
}
filenames.SaveChanges();
}
base.OnUpdate();
}
private void DoRemoveValue()
{
value.UpdateValue();
var list = new List <object>(array.Values);
if (allMatches.Value)
{
list.RemoveAll(x => x == value.GetValue());
}
else
{
list.Remove(value.GetValue());
}
array.Values = list.ToArray();
array.SaveChanges();
}
void DoCalculatePath()
{
_getNavMeshPathProxy();
UnityEngine.AI.NavMeshPath _path = new UnityEngine.AI.NavMeshPath();
bool _found = UnityEngine.AI.NavMesh.CalculatePath(sourcePosition.Value, targetPosition.Value, passableMask.Value, _path);
if (_NavMeshPathProxy != null)
{
_NavMeshPathProxy.path = _path;
}
if (!calculatedPathCorners.IsNone)
{
calculatedPathCorners.Resize(_path.corners.Length);
for (int i = 0; i < calculatedPathCorners.Length; i++)
{
calculatedPathCorners.Set(i, _path.corners [i]);
}
calculatedPathCorners.SaveChanges();
}
resultingPathFound.Value = _found;
if (_found)
{
if (!FsmEvent.IsNullOrEmpty(resultingPathFoundEvent))
{
Fsm.Event(resultingPathFoundEvent);
}
}
else
{
if (!FsmEvent.IsNullOrEmpty(resultingPathNotFoundEvent))
{
Fsm.Event(resultingPathNotFoundEvent);
}
}
}
public static void Add <T>(this FsmArray array, T entry)
{
if (array == null)
{
return;
}
array.SetType(entry.GetVariableType());
if (entry != null)
{
array.Resize(array.Length + 1);
array.Set(array.Length - 1, (object)entry);
}
else
{
array.Resize(0);
}
array.SaveChanges();
}
public override void OnEnter()
{
if (!arrays.Contains(result))
{
_source = result.Values;
}
else
{
_source = new object[0];
}
foreach (FsmArray fsmArray in arrays)
{
ArrayUtility.AddRange(ref _source, fsmArray.Values);
}
result.Values = _source;
result.SaveChanges();
Finish();
}
public void GetAllChilds(GameObject parent)
{
childs = parent.GetComponentsInChildren <Transform>(includeInactive.Value);
list = new List <GameObject>();
foreach (Transform trans in childs)
{
if (!includeParent.Value && trans.gameObject == parent)
{
continue;
}
if (trans.parent == parent.transform)
{
list.Add(trans.gameObject);
}
}
storeChildren.objectReferences = list.ToArray();
storeChildren.SaveChanges();
}
private void DoRemoveValue()
{
value.UpdateValue();
List <object> _new = new List <object>();
int i = 0;
foreach (object _obj in array.Values)
{
if (!_obj.Equals(value.GetValue()))
{
_new.Add(_obj);
}
i++;
}
array.Values = _new.ToArray();
array.SaveChanges();
}
void DoGetCsvColumn()
{
CsvData _data = CsvData.GetReference(reference.Value);
if (_data == null)
{
Fsm.Event(errorEvent);
fields.Resize(0);
return;
}
if (!_data.HasHeader)
{
LogError("Csv Data '" + reference.Value + "' has no header");
Fsm.Event(errorEvent);
fields.Resize(0);
return;
}
int _column = _data.HeaderKeys.IndexOf(key.Value);
if (_data.ColumnCount <= _column)
{
LogError("Csv Data '" + reference.Value + "' doesn't have " + (_column + 1) + " columns based on key " + key.Value + ", only " + _data.ColumnCount);
Fsm.Event(errorEvent);
fields.Resize(0);
return;
}
fields.Resize(_data.RecordCount);
for (int i = 0; i < _data.RecordCount; i++)
{
fields.Set(i, _data.GetFieldAt(i, _column, false));
}
fields.SaveChanges();
}
void DoGetCsvHeader()
{
CsvData _data = CsvData.GetReference(reference.Value);
if (_data == null)
{
Fsm.Event(errorEvent);
header.Resize(0);
return;
}
if (!_data.HasHeader)
{
LogError("Csv Data '" + reference.Value + "' has no header");
Fsm.Event(errorEvent);
header.Resize(0);
return;
}
header.stringValues = _data.HeaderKeys.ToArray();
header.SaveChanges();
}
public override void OnEnter()
{
_channelsOK = new List <string>();
int i = 0;
foreach (string _channel in LastChannels)
{
if (LastResults[i])
{
_channelsOK.Add(_channel);
}
i++;
}
channelCount = LastChannels.Length;
validChannelCount = _channelsOK.Count;
if (!validChannels.IsNone)
{
validChannels.RawValue = _channelsOK.ToArray();
validChannels.SaveChanges();
}
if (!channels.IsNone)
{
channels.stringValues = LastChannels;
channels.SaveChanges();
}
if (!results.IsNone)
{
results.boolValues = LastResults;
results.SaveChanges();
}
Finish();
}
public override void Enter()
{
directories.Values = ES3.GetDirectories(directoryPath.Value, GetSettings());
directories.SaveChanges();
}
public override void Enter()
{
keys.Values = ES3.GetKeys(filePath.Value, GetSettings());
keys.SaveChanges();
}
public override void Enter()
{
keys.Values = es3File.GetKeys();
keys.SaveChanges();
}
public override void OnEnter()
{
if (!PhotonNetwork.insideLobby)
{
Fsm.Event(notInLobbyEvent);
Finish();
return;
}
rooms = PhotonNetwork.GetRoomList();
for (int x = 0; x < customPropertiesValues.Length; x++)
{
if (!customPropertiesValues[x].IsNone)
{
customPropertiesValues[x].Resize(rooms.Length);
}
}
if (!names.IsNone)
{
names.Resize(rooms.Length);
}
if (!playerCounts.IsNone)
{
playerCounts.Resize(rooms.Length);
}
if (!maxPlayers.IsNone)
{
playerCounts.Resize(maxPlayers.Length);
}
int i = 0;
foreach (RoomInfo room in rooms)
{
if (!names.IsNone)
{
names.Set(i, room.Name);
}
if (!playerCounts.IsNone)
{
playerCounts.Set(i, room.PlayerCount);
}
if (!maxPlayers.IsNone)
{
maxPlayers.Set(i, room.MaxPlayers);
}
// get the custom properties
int k = 0;
foreach (FsmString key in customPropertyKeys)
{
if (room.CustomProperties.ContainsKey(key.Value) && !customPropertiesValues[k].IsNone)
{
customPropertiesValues[k].Set(i, room.CustomProperties[key.Value]);
}
k++;
}
i++;
}
if (!names.IsNone)
{
names.SaveChanges();
}
if (!playerCounts.IsNone)
{
playerCounts.SaveChanges();
}
if (!maxPlayers.IsNone)
{
maxPlayers.SaveChanges();
}
for (int x = 0; x < customPropertiesValues.Length; x++)
{
if (!customPropertiesValues[x].IsNone)
{
customPropertiesValues[x].SaveChanges();
}
}
}
public override void OnEnter()
{
array.SaveChanges();
Finish();
}
public override void OnEnter()
{
if (otherPLayerOnly.Value)
{
players = PhotonNetwork.PlayerListOthers;
}
else
{
players = PhotonNetwork.PlayerList;
}
if (!names.IsNone)
{
names.Resize(players.Length);
}
if (!userIds.IsNone)
{
userIds.Resize(players.Length);
}
if (!ids.IsNone)
{
ids.Resize(players.Length);
}
if (!isInactives.IsNone)
{
isInactives.Resize(players.Length);
}
if (!isLocals.IsNone)
{
isLocals.Resize(players.Length);
}
if (!isMasterClients.IsNone)
{
isMasterClients.Resize(players.Length);
}
for (int x = 0; x < customPropertiesValues.Length; x++)
{
if (!customPropertiesValues[x].IsNone)
{
customPropertiesValues[x].Resize(players.Length);
}
}
int i = 0;
foreach (Player player in players)
{
if (!names.IsNone)
{
names.Set(i, player.NickName);
}
if (!userIds.IsNone)
{
userIds.Set(i, player.UserId);
}
if (!ids.IsNone)
{
ids.Set(i, player.ActorNumber);
}
if (!isInactives.IsNone)
{
isInactives.Set(i, player.IsInactive);
}
if (!isLocals.IsNone)
{
isLocals.Set(i, player.IsLocal);
}
if (!isMasterClients.IsNone)
{
isMasterClients.Set(i, player.IsMasterClient);
}
// get the custom properties
int k = 0;
foreach (FsmString key in customPropertyKeys)
{
if (player.CustomProperties.ContainsKey(key.Value) && !customPropertiesValues[k].IsNone)
{
customPropertiesValues[k].Set(i, player.CustomProperties[key.Value]);
}
k++;
}
i++;
}
if (!names.IsNone)
{
names.SaveChanges();
}
if (!userIds.IsNone)
{
userIds.SaveChanges();
}
if (!ids.IsNone)
{
ids.SaveChanges();
}
if (!isInactives.IsNone)
{
isInactives.SaveChanges();
}
if (!isLocals.IsNone)
{
isLocals.SaveChanges();
}
if (!isMasterClients.IsNone)
{
isMasterClients.SaveChanges();
}
for (int x = 0; x < customPropertiesValues.Length; x++)
{
if (!customPropertiesValues[x].IsNone)
{
customPropertiesValues[x].SaveChanges();
}
}
}
public override void OnEnter()
{
/******************************
*********** FsmVar ************
******************************/
//you need to call .UpdateValue() before using an FsmVar
variable.UpdateValue();
if (variable.gameObjectValue != null)
{
//"Owner" returns the GameObject this FSM is attached to
variable.gameObjectValue = Owner;
}
/******************************
******* Compound Arrays *******
******************************/
//going through the elements of the compound array
for (int i = 0; i < compareTos.Length; i++)
{
//skip if it's 'None'
if (compareTos[i].IsNone)
{
continue;
}
//send the event with the same index as the first array
if (compareTos[i] == targetGameObject)
{
Fsm.Event(compareEvents[i]);
}
}
/******************************
**** Pre-defined Variables ****
******************************/
//examples of pre-defined variables that hold a specific, fsm-related value
//that get derived from FsmStateAction
Fsm currentFSM = Fsm;
FsmState currentState = State;
string currentStateName = Name;
/******************************
*********** FsmArray **********
******************************/
//best to reset an FsmArrays values before using it to
//make sure it doesn't keep any values when re-entering
anyArrayResult.Reset();
List <string> fieldValues = new List <string>();
for (int i = 0; i < normalStringArray.Length; i++)
{
anyArrayResult.Set(i, (object)normalStringArray[i]);
}
anyArrayResult.SaveChanges();
/******************************
********* Finish Event ********
******************************/
//"Finished" returns wheter every action in the current state has been finished,
//thus can be used to only send an event when every other action has finished
if (Finished)
{
//if you want to send an event from your current action
Event(onFinishEvent);
}
Fsm.SendEventToFsmOnGameObject(targetGameObject.Value, "FSM", onFinishEvent);
}
public void splitText()
{
string _text;
if (OrThisString.Value.Length == 0)
{
if (textAsset == null)
{
return;
}
else
{
_text = textAsset.text;
}
}
else
{
_text = OrThisString.Value;
}
result.Reset();
string[] rawlines;
if (OrThisChar.Value.Length == 0)
{
char _split = '\n';
switch (split)
{
case SplitSpecialChars.Tab:
_split = '\t';
break;
case SplitSpecialChars.Space:
_split = ' ';
break;
}
rawlines = _text.Split(_split);
}
else
{
rawlines = _text.Split(OrThisChar.Value.ToCharArray());
}
int start = startIndex.Value;
int count = rawlines.Length;
if (parseRange.Value > 0)
{
count = Mathf.Min(count - start, parseRange.Value);
}
string[] lines = new string[count];
int j = 0;
for (int i = start; i < start + count; i++)
{
lines[j] = rawlines[i];
j++;
}
result.Resize(count);
if (parseAsType == ArrayParseStringAs.String)
{
result.Values = lines;
}
else if (parseAsType == ArrayParseStringAs.Int)
{
int i = 0;
int _value_i = 0;
foreach (String text in lines)
{
int.TryParse(text, out _value_i);
result.Set(i, _value_i);
++i;
}
result.SaveChanges();
}
else if (parseAsType == ArrayParseStringAs.Float)
{
int i = 0;
float _result_float = 0f;
foreach (String text in lines)
{
float.TryParse(text, out _result_float);
result.Set(i, _result_float);
++i;
}
result.SaveChanges();
}
}
public override void OnEnter()
{
stringArray.Values = SteamApps.GetAvailableGameLanguages().Split(",".ToCharArray());
stringArray.SaveChanges();
Finish();
}
