/// <inheritdoc />
public override void Process(Entity entity)
{
ScriptGroup scripts = entity.GetComponent <ScriptGroup>();
if (!scripts.ContainsKey(ScriptEvent.OnHeartbeat) ||
string.IsNullOrWhiteSpace(scripts[ScriptEvent.OnHeartbeat]))
{
return;
}
Heartbeat hb = entity.GetComponent <Heartbeat>();
if (hb.Interval <= 0.0f)
{
return;
}
hb.CurrentTimer += _world.DeltaSeconds();
if (hb.CurrentTimer < hb.Interval)
{
return;
}
_scriptService.QueueScript(scripts[ScriptEvent.OnHeartbeat], entity);
hb.CurrentTimer = 0.0f;
}
private void HandleSelectCharacterRequest(string username, PacketBase p)
{
CharacterSelectedPacket packet = (CharacterSelectedPacket)p;
// If player is already added to the game world, we don't want to add another. Ignore this request.
if (_pcs.ContainsKey(username))
{
_logger.Info($"Player {username} is already added to the game world. Ignoring request.");
return;
}
string path = _pathService.ServerVaultDirectory + username + "/" + packet.PCGlobalID + ".pcf";
if (!File.Exists(path))
{
_logger.Error($"PC file '{packet.PCGlobalID}.pcf' does not exist for username {username}. Cannot select character. Ignoring request.");
return;
}
PCData pcData = _dataService.Load <PCData>(path);
Entity player = _entityFactory.Create <Player, PCData>(pcData);
_pcs.Add(username, player);
ScriptGroup scripts = _gameModule.GetComponent <ScriptGroup>();
string script = scripts[ScriptEvent.OnModulePlayerEnter];
_scriptService.QueueScript(script, _gameModule);
CharacterAddedToWorldPacket response = new CharacterAddedToWorldPacket();
_networkService.SendMessage(PacketDeliveryMethod.ReliableUnordered, response, username);
}
/// *******************************************************
/// <summary>コンストラクタ</summary>
/// *******************************************************
public MoveScript(EnemyScriptMain mng, ScriptGroup group, string key, float wait = -1)
{
Manager = mng;
Scripts = group;
if (string.IsNullOrEmpty(key) == false)
{
Scripts.ActivateLine(line => {
CommandAttribute atr = line.GetAttribute("key");
if (atr == null)
{
return(true);
}
return(atr.CompareStrValue(key));
});
}
Limit = LIMIT_TYPE.TIME;
PastTime = 0;
WaitTime = Mathf.RoundToInt(wait);
LineIndex = -1;
Shots = new List <ShotScript>();
RemoveShots = new List <ShotScript>();
}
/// *******************************************************
/// <summary>コンストラクタ</summary>
/// *******************************************************
public WaveScript(StageScriptMain mng, WaveScript prnt, ScriptGroup group)
{
Manager = mng;
Parent = prnt;
Scripts = group;
ChildScript = null;
}
private static MapScriptGroup CreateMapScriptGroup(ScriptGroup scriptGroup, SceneSettings sceneSettings)
{
return(new MapScriptGroup(
scriptGroup.Name,
CreateMapScripts(scriptGroup.Scripts, sceneSettings),
scriptGroup.IsActive,
scriptGroup.IsSubroutine));
}
private static MapScriptGroup CreateMapScriptGroup(ScriptGroup scriptGroup)
{
return(new MapScriptGroup(
scriptGroup.Name,
CreateMapScripts(scriptGroup.Scripts),
scriptGroup.IsActive,
scriptGroup.IsSubroutine));
}
/// *******************************************************
/// <summary>コンストラクタ</summary>
/// *******************************************************
public SpawnScript(EnemyScriptMain mng, ScriptGroup group, string keyword = null)
{
Manager = mng;
Scripts = group;
FindRunScript("common");
if (string.IsNullOrEmpty(keyword))
{
keyword = "default";
}
FindRunScript(keyword);
}
public void GetScriptName_ShouldReturnValue()
{
EntityWorld world = TestHelpers.CreateEntityWorld();
Entity entity = world.CreateEntity();
ScriptGroup scriptGroup = new ScriptGroup();
scriptGroup.Add(ScriptEvent.OnAreaEnter, "TestScriptName");
entity.AddComponent(scriptGroup);
string result = _scriptingMethods.GetScriptName(entity, ScriptEvent.OnAreaEnter);
Assert.AreEqual(result, "TestScriptName");
}
/// <inheritdoc />
public void BuildEntity(Entity entity)
{
entity.AddComponent(_componentFactory.Create <Nameable>());
entity.AddComponent(_componentFactory.Create <Tag>());
entity.AddComponent(_componentFactory.Create <Resref>());
entity.AddComponent(_componentFactory.Create <Description>());
ScriptGroup scriptGroup = _componentFactory.Create <ScriptGroup>();
scriptGroup.Add(ScriptEvent.OnAbilityActivated, string.Empty);
entity.AddComponent(scriptGroup);
}
/// *******************************************************
/// <summary>スクリプト解析</summary>
/// *******************************************************
private void ParseScript()
{
WaveWarehouse = new Dictionary <string, WaveScript>();
ScriptGroup group = Group.Find(grp => grp.GroupName == LIST_SCRIPT);
WaveList = new List <string>();
WaveMessage = new List <string>();
group.ScriptLine.ForEach(line => {
if (line.CommandName.CompareTo("wave") == 0)
{
line.Attributes.ForEach(atr => {
if (atr.Name.CompareTo("target") == 0)
{
string trg = atr.StringValue;
if (string.IsNullOrEmpty(trg) == false)
{
WaveScript wave;
if (WaveWarehouse.TryGetValue(trg, out wave) == false)
{
wave = new WaveScript(this, null, Group.Find(grp => grp.GroupName == trg));
if (wave != null)
{
WaveWarehouse.Add(trg, wave);
}
}
if (wave != null)
{
WaveList.Add(trg);
}
}
}
});
}
else if (line.CommandName.CompareTo("build") == 0)
{
WaveList.Add("build");
}
string msg = "";
line.Attributes.ForEach(atr => {
if (atr.Name.CompareTo("msg") == 0)
{
msg = atr.StringValue;
}
});
WaveMessage.Add(msg);
});
}
private void PlayerDisconnected(string username)
{
if (_pcs.ContainsKey(username))
{
ScriptGroup scripts = _gameModule.GetComponent <ScriptGroup>();
string script = scripts[ScriptEvent.OnModulePlayerLeaving];
_scriptService.QueueScript(script, _gameModule);
_pcs[username].Delete();
_pcs.Remove(username);
script = scripts[ScriptEvent.OnModulePlayerLeft];
_scriptService.QueueScript(script, _gameModule);
}
}
private static void DrawScriptGroup(ScriptGroup scriptGroup)
{
if (ImGui.TreeNodeEx(GetScriptDetails(scriptGroup.Name, scriptGroup.IsActive, scriptGroup.IsSubroutine), ImGuiTreeNodeFlags.DefaultOpen))
{
foreach (var childGroup in scriptGroup.Groups)
{
DrawScriptGroup(childGroup);
}
foreach (var script in scriptGroup.Scripts)
{
DrawScript(script);
}
ImGui.TreePop();
}
}
private void LoadModule()
{
ModuleData modData = _moduleService.GetLoadedModuleData();
_gameModule = _entityFactory.Create <Module, ModuleData>(modData);
LoadAreas();
// Mod load script should be run last - after everything else has loaded.
ScriptGroup scripts = _gameModule.GetComponent <ScriptGroup>();
string modLoadScript = scripts[ScriptEvent.OnModuleLoad];
if (!string.IsNullOrWhiteSpace(modLoadScript))
{
_scriptService.QueueScript(modLoadScript, _gameModule);
}
}
// Adds a new ScriptData item to a given category
static void AddToGroup(List <ScriptGroup> list, ScriptData script)
{
var dllPath = AssetDatabase.GetAssetPath(script.Script);
var group = list.FirstOrDefault(g => g.dllPath == dllPath);
if (group == null)
{
group = new ScriptGroup(dllPath, null);
list.Add(group);
}
var scriptItem = group.scripts.FirstOrDefault(item => item.oldScript == script);
if (scriptItem == null)
{
group.scripts.Add(new ScriptItem {
oldScript = script
});
}
}
private void WriteScriptGroup(ScriptGroup group)
{
var header = new Header()
{
Index = GetIndex("ScriptGroup"),
Magic = 2,
Length = group.GetSize(false)
};
WriteHeader(header);
WriteString(group.Name);
writer.Write(group.IsActive);
writer.Write(group.IsSubroutine);
foreach (var script in group.Scripts)
{
WriteScript(script);
}
}
private static ITreeItem CreateScriptGroupTreeItem(ScriptGroup scriptGroup)
{
var treeItem = new TreeItem
{
Text = GetScriptDetails(scriptGroup.Name, scriptGroup.IsActive, scriptGroup.IsSubroutine),
Expanded = true
};
foreach (var childGroup in scriptGroup.Groups)
{
treeItem.Children.Add(CreateScriptGroupTreeItem(childGroup));
}
foreach (var script in scriptGroup.Scripts)
{
treeItem.Children.Add(CreateScriptTreeItem(script));
}
return(treeItem);
}
/// *******************************************************
/// <summary>スクリプト解析</summary>
/// *******************************************************
private void ParseScript()
{
ScriptGroup spawn = Group.Find(grp => grp.GroupName == SPAWN_SCRIPT);
ScriptGroup move = Group.Find(grp => grp.GroupName == MOVE_SCRIPT);
float wait = -1;
if (spawn != null)
{
SpawnScript spawn_script = new SpawnScript(this, spawn, SpawnKey);
wait = spawn_script.WaitTime;
}
if ((Initial != null) && (Initial.Override_WateTime == true))
{
wait = Initial.WateTime;
}
if (move != null)
{
MovePlayer = new MoveScript(this, move, SpawnKey, wait);
}
}
private ScriptGroup ReadScriptGroup(int length)
{
var group = new ScriptGroup();
long start = reader.BaseStream.Position;
group.Name = ReadString();
Write("ScriptGroup", group.Name);
group.IsActive = reader.ReadBoolean();
group.IsSubroutine = reader.ReadBoolean();
indention++;
while (reader.BaseStream.Position < start + length)
{
var header = ReadHeader();
Assert(header.Magic == 2);
group.Scripts.Add(ReadScript(header.Length));
}
indention--;
return(group);
}
/// *******************************************************
/// <summary>Wave進行 / 更新処理</summary>
/// *******************************************************
public bool OnUpdate()
{
if (ChildScript != null)
{
if (ChildScript.OnUpdate() == false)
{
ChildScript = null;
}
return(true);
}
PastTime++;
if (PastTime > WaitTime)
{
bool isOpenRandom = false;
List <ScriptLine> GroupLines = new List <ScriptLine>();
while (true)
{
if (Scripts == null)
{
return(false);
}
if (Scripts.ScriptLine == null)
{
return(false);
}
if (LineIndex >= Scripts.ScriptLine.Count)
{
return(false);
}
ScriptLine line = Scripts.ScriptLine[LineIndex];
LineIndex++;
string CommandName = line.CommandName;
if (isOpenRandom == true)
{
if (CommandName.CompareTo("/random") == 0)
{
isOpenRandom = false;
if ((GroupLines != null) && (GroupLines.Count > 0))
{
float rndtotal = 0;
GroupLines.ForEach(grp => rndtotal += grp.GetAttribute("rate").FloatValue);
float rndans = Random.value * rndtotal;
int selectindex = 0;
for (int i = 0; i < GroupLines.Count; i++)
{
rndans = rndans - GroupLines[i].GetAttribute("rate").FloatValue;
if (rndans <= 0)
{
selectindex = i;
break;
}
}
string childname = GroupLines[selectindex].GetAttribute("target").StringValue;
ScriptGroup group = Manager.Group.Find(grp => grp.GroupName == childname);
ChildScript = new WaveScript(Manager, this, group);
ChildScript.StartWave();
}
}
else if (CommandName.CompareTo("group") == 0)
{
GroupLines.Add(line);
}
}
else
{
if (CommandName.CompareTo("interval") == 0)
{
IntervalLine(line);
PastTime = 0;
break;
}
else if (CommandName.CompareTo("random") == 0)
{
isOpenRandom = true;
GroupLines = new List <ScriptLine>();
}
else
{
SpawnLine(line);
}
}
}
}
return(true);
}
private void control_DoubleClick(object sender, EventArgs e)
{
AdaptableControl d2dHoverControl = (AdaptableControl)sender;
Point clientPoint = d2dHoverControl.PointToClient(Control.MousePosition);
D2dGraphAdapter <ScriptNode, ScriptNodeConnection, ICircuitPin> graphAdapter =
d2dHoverControl.As <D2dGraphAdapter <ScriptNode, ScriptNodeConnection, ICircuitPin> >();
GraphHitRecord <ScriptNode, ScriptNodeConnection, ICircuitPin> hitRecord = graphAdapter.Pick(clientPoint);
ScriptGroup subGraph = null;
var subGraphReference = hitRecord.Node.As <ScriptGroupReference>();
if (subGraphReference != null)
{
var templatingContext = m_contextRegistry.GetMostRecentContext <TemplatingContext>();
if (templatingContext != null && templatingContext.IsExternalTemplate(subGraphReference.Template))
{
return; // templates should only be editable in the document that owns the template
}
DialogResult checkResult = DialogResult.No; //direct editing
if (checkResult == DialogResult.No)
{
subGraph = subGraphReference.Group.As <ScriptGroup>();
var graphValidator = subGraphReference.DomNode.GetRoot().Cast <ScriptValidator>();
graphValidator.UpdateTemplateInfo(subGraph);
}
}
else
{
subGraph = hitRecord.Node.As <ScriptGroup>();
}
if (subGraph != null)
{
var viewingContext = subGraph.Cast <ViewingContext>();
if (viewingContext.Control != null)
{
// sub-graph is already open, just show control
m_controlHostService.Show(viewingContext.Control);
}
else
{
// create new circuit editing control for sub-circuit
AdaptableControl subCircuitControl = CreateNodeControl(subGraph.DomNode);
viewingContext.Control = subCircuitControl;
// use group’s hierarchy as control name
string name = string.Empty;
bool first = true;
foreach (var domNode in subGraph.DomNode.GetPath())
{
if (domNode.Is <ScriptGroup>())
{
if (first)
{
name = domNode.Cast <ScriptGroup>().TitleText;
first = false;
}
else
{
name += "/" + domNode.Cast <ScriptGroup>().TitleText;
}
}
}
string description = name;
var editingContext = subGraph.DomNode.Cast <TongScriptEditingContext>();
editingContext.GetLocalBound = GetLocalBound;
editingContext.GetWorldOffset = GetWorldOffset;
editingContext.GetTitleHeight = GetTitleHeight;
editingContext.GetLabelHeight = GetLabelHeight;
editingContext.GetSubContentOffset = GetSubContentOffset;
subCircuitControl.Context = editingContext;
// Disabled
//editingContext.SchemaLoader = m_schemaLoader; // schema needed for cut and paste between applications
ControlInfo controlInfo = new ControlInfo(name, description, StandardControlGroup.Center);
//controlInfo.Docking = new ControlInfo.DockingInfo() // smart docking behavior
//{
// GroupTag = subGraph.DomNode.Lineage.AsIEnumerable<Group>().Last(),// use the top-level parent group
// Order = subGraph.Level
//};
m_circuitControlRegistry.RegisterControl(subGraph.DomNode, subCircuitControl, controlInfo, this);
var enumerableContext = subGraph.DomNode.Cast <TongScriptEditingContext>().Cast <IEnumerableContext>();
var items = (enumerableContext != null) ? enumerableContext.Items : null;
subCircuitControl.As <IViewingContext>().Frame(items);
}
}
}