public static T Instance()
{
if (instance == null)
{
instance = FindObjectOfType <T>();
if (FindObjectsOfType <T>().Length > 1)
{
ZDebug.Log("More than 1!");
}
return(instance);
}
if (instance == null)
{
string instanceName = typeof(T).Name;
ZDebug.Log("Instance Name: " + instanceName);
GameObject instanceGO = GameObject.Find(instanceName);
if (instanceGO == null)
{
instanceGO = new GameObject(instanceName);
}
instance = instanceGO.AddComponent <T>();
DontDestroyOnLoad(instanceGO); // 不会被释放
ZDebug.Log("Add New Singleton " + instance.name + " in Game!");
}
else
{
ZDebug.Log("Already exist: " + instance.name);
}
return(instance);
}
/// <summary>
/// Load an operand, either a variable or a constant.
/// </summary>
/// <param name="aType"></param>
/// <param name="aArg"></param>
private void LoadOperand(byte aType, out ushort aArg)
{
if ((aType & 0x02) > 0) // Variable
{
_machine.Memory.CodeByte(out byte xVariable);
if (xVariable == 0)
{
aArg = _machine.Memory.Stack.Pop();
}
else if (xVariable < 16)
{
aArg = _machine.Memory.Stack[_machine.Memory.Stack.BP - xVariable];
}
else
{
ushort xAddress = (ushort)(_machine.Story.Header.GlobalsOffset + 2 * (xVariable - 16));
_machine.Memory.GetWord(xAddress, out aArg);
}
}
else if ((aType & 1) > 0) // Small Constant
{
_machine.Memory.CodeByte(out byte xValue);
aArg = xValue;
}
else // Large Constant
{
_machine.Memory.CodeWord(out aArg);
}
_argCount++;
ZDebug.Output($" Storing operand: {_argCount - 1} -> {aArg}");
}
/// <summary>
/// Copy value
/// </summary>
/// <typeparam name="TSource"></typeparam>
/// <typeparam name="TTarget"></typeparam>
/// <param name="source"></param>
/// <param name="target"></param>
/// <param name="copyField"></param>
/// <returns></returns>
public static bool CopyValueTo <TSource, TTarget>(this TSource source, TTarget target, bool copyField = false)
where TSource : class
where TTarget : TSource
{
if (source == null || target == null)
{
ZDebug.LogError("argument NULL");
return(false);
}
foreach (PropertyInfo pi in source.GetType().GetProperties())
{
if (pi.CanRead && pi.CanWrite)
{
pi.SetValue(target, pi.GetValue(source, null), null);
}
}
if (copyField)
{
foreach (FieldInfo fi in source.GetType().GetFields())
{
fi.SetValue(target, fi.GetValue(source));
}
}
return(true);
}
public int RemoveFrame()
{
ZDebug.Output($"Removing Frame: {Frames}");
SP = BP;
Frames--;
int callType = Pop();
callType = callType >> 8;
BP = Pop();
BP++;
long lowPC = Pop();
long highPC = Pop();
highPC = highPC << 9;
long pc = highPC | lowPC;
_memory.PC = pc;
if (_memory.PC < _memory.StartPC)
{
throw new Exception("Program counter is less than the start location!");
}
return(callType);
}
private void InvokeOpcode_VAROP(Opcode aInstruction, int aOpcode, ushort aArg0, ushort aArg1, ushort aArg2, ushort aArg3, ushort aArg4, ushort aArg5, ushort aArg6, ushort aArg7, ushort aArgCount)
{
ZDebug.Output($"Invoking: {aOpcode.ToHex(2)} -> {aInstruction}:{aArgCount} -> {_invokeCount}");
aInstruction.Execute(aArg0, aArg1, aArg2, aArg3, aArg4, aArg5, aArg6, aArg7, aArgCount);
_invokeCount++;
}
/// <summary>
/// Store an operand, either as a variable or pushed on the stack.
/// </summary>
/// <param name="value"></param>
protected void Store(ushort value)
{
ZDebug.Output($"PC = {Machine.Memory.PC}");
ZDebug.Output($"BP = {Machine.Memory.Stack.BP}");
ZDebug.Output($"SP = {Machine.Memory.Stack.SP}");
byte variable;
Machine.Memory.CodeByte(out variable);
if (variable == 0)
{
Machine.Memory.Stack.Push(value);
ZDebug.Output($" Storing {value} on stack at {Machine.Memory.Stack.SP}");
}
else if (variable < 16)
{
Machine.Memory.Stack[Machine.Memory.Stack.BP - variable] = value;
ZDebug.Output($" Storing {value} on stack as Variable {variable} at {Machine.Memory.Stack.SP}");
}
else
{
ushort addr = (ushort)(Machine.Story.Header.GlobalsOffset + 2 * (variable - 16));
Machine.Memory.SetWord(addr, value);
ZDebug.Output($" Storing {value} at {addr}");
}
}
private void Dispatch()
{
if (_events.Count > 0)
{
IEvent evt = _events.Dequeue();
if (!_listeners.ContainsKey(evt.Name))
{
ZDebug.LogError("Event " + evt.Name + " has no listeners");
return;
}
for (int i = 0; i < _listeners[evt.Name].Count; i++)
{
IEventListener listener = _listeners[evt.Name][i];
if (listener == null)
{
_listeners[evt.Name].RemoveAt(i);
}
else
{
listener.HandleEvent(evt);
}
}
}
}
public void Notify <T>(T sender, string propName) where T : class
{
if (sender == null)
{
ZDebug.LogError(string.Format("Notify property sender is null! type: {0}, propertyName: {1}", typeof(T),
propName));
return;
}
if (string.IsNullOrEmpty(propName))
{
ZDebug.LogError(string.Format("Notify property Name cannot be null or empty! sender: {0}, propertyName: {1}", sender,
propName));
return;
}
PropertyInfo prop = sender.GetType().GetProperty(propName);
if (prop == null)
{
ZDebug.LogError(string.Format("Notify property not found! sender: {0}, propertyName: {1}", sender,
propName));
return;
}
Notify(prop);
}
public void DisposeAll()
{
foreach (IZDisposable disposable in _disposables)
{
if (disposable.Dispose())
{
ZDebug.Log(disposable.GetType() + " has been disposed");
}
}
}
private void OnApplicationQuit()
{
foreach (IZDisposable disposable in _disposables)
{
if (disposable.DisposeOnApplicationQuit())
{
ZDebug.Log(disposable.GetType() + " has been disposed");
}
}
}
protected void Branch(bool flag)
{
ZDebug.Output($"PC = {Machine.Memory.PC}");
ZDebug.Output($"BP = {Machine.Memory.Stack.BP}");
ZDebug.Output($"SP = {Machine.Memory.Stack.SP}");
ushort offset;
byte specifier;
byte off1;
byte off2;
Machine.Memory.CodeByte(out specifier);
off1 = (byte)(specifier & 0x3f);
if (!flag)
{
specifier ^= 0x80;
}
if ((specifier & 0x40) == 0)
{
if ((off1 & 0x20) > 0)
{
off1 |= 0xc0;
}
Machine.Memory.CodeByte(out off2);
offset = (ushort)((off1 << 8) | off2);
ZDebug.Output($"long branch: {offset}");
}
else
{
offset = off1;
ZDebug.Output($"short branch: {offset}");
}
if ((specifier & 0x80) > 0)
{
if (offset > 1)
{
long pc = Machine.Memory.PC;
pc += (short)offset - 2;
Machine.Memory.PC = pc;
ZDebug.Output($"normal branch: {pc}");
}
else
{
ZDebug.Output($"special branch: {offset}");
Return(offset);
}
}
}
public void RemoveCommand <T>(string name) where T : ICommand
{
if (!HasCommand <T>(name))
{
ZDebug.LogError(string.Format("Error in {0} Command '{1}' not registered.", this, name));
return;
}
lock (_commandList)
{
_commandList[name].Remove(typeof(T));
}
}
/// <summary>
/// Return from the current routine and restore the previous stack frame.
/// The result may be stored (o), thrown away (1), or pushed on the stack (2).
/// In the latter case a direct call has been finished and we must exit the interpreter loop.
/// </summary>
/// <param name="value"></param>
protected void Return(ushort value)
{
ZDebug.Output($"PC = {Machine.Memory.PC}");
ZDebug.Output($"BP = {Machine.Memory.Stack.BP}");
ZDebug.Output($"SP = {Machine.Memory.Stack.SP}");
int callType = Machine.Memory.Stack.RemoveFrame();
if (callType == CallType.CallStore)
{
Store(value);
}
}
public ushort this[int index]
{
get
{
ZDebug.Output($"{index} -> {_data[index].ToString()}");
return(_data[index]);
}
set
{
ZDebug.Output($"{index} <- {value}");
_data[index] = value;
}
}
public void Interpret()
{
do
{
_machine.Memory.CodeByte(out byte opcode);
long pc = _machine.Memory.PC;
_argCount = 0;
ZDebug.Output($"CODE: {pc - 1} -> {opcode.ToHex(2)}");
ushort xArg0 = 0, xArg1 = 0, xArg2 = 0, xArg3 = 0, xArg4 = 0, xArg5 = 0, xArg6 = 0, xArg7 = 0;
if (opcode < 0x80) // 2OP Opcodes
{
LoadOperand((byte)((opcode & 0x40) > 0 ? 2 : 1), out xArg0);
LoadOperand((byte)((opcode & 0x20) > 0 ? 2 : 1), out xArg1);
int op = opcode & 0x1f;
InvokeOpcode_2OP(OP2Opcodes[op], opcode, xArg0, xArg1);
}
else if (opcode < 0xb0) // 1OP opcodes
{
LoadOperand((byte)(opcode >> 4), out xArg0);
int op = opcode & 0x0f;
InvokeOpcode_1OP(OP1Opcodes[op], opcode, xArg0);
}
else if (opcode < 0xc0) // 0OP opcodes
{
int op = opcode - 0xb0;
InvokeOpcode_0OP(OP0Opcodes[op], opcode);
}
else // VAR opcodes
{
_machine.Memory.CodeByte(out byte xSpecifier1);
int xArgsCount = LoadAllOperands(xSpecifier1, out xArg0, out xArg1, out xArg2, out xArg3);
// Call opcodes with up to 8 arguments
if (opcode == 0xec || opcode == 0xfa)
{
_machine.Memory.CodeByte(out byte xSpecifier2);
xArgsCount += LoadAllOperands(xSpecifier2, out xArg4, out xArg5, out xArg6, out xArg7);
}
int op = opcode - 0xc0;
InvokeOpcode_VAROP(VAROpcodes[op], opcode, xArg0, xArg1, xArg2, xArg3, xArg4, xArg5, xArg6, xArg7, (ushort)xArgsCount);
}
_machine.Tick();
} while (Finished == 0);
}
public void RemoveModel(string name)
{
if (!HasModel(name))
{
ZDebug.LogError(string.Format("Error in {0} Model '{1}' not registered.", this, name));
return;
}
lock (_models)
{
_models[name].Dispose();
_models.Remove(name);
}
}
public void RemoveWire(string name)
{
if (!HasWire(name))
{
ZDebug.LogError(string.Format("Error in {0} Wire '{1}' not registered.", this, name));
return;
}
lock (_wires)
{
_wires[name].Dispose();
_wires.Remove(name);
}
}
public void RemoveView(string name)
{
if (!HasView(name))
{
ZDebug.Log(string.Format("Error in {0} View '{1}' don't registered.", this, name));
return;
}
lock (_views)
{
_views[name].Dispose();
_views.Remove(name);
}
}
public void AddFrame(int aArgCount, int aCallType)
{
long pc = _memory.PC;
Push((ushort)(pc >> 9));
Push((ushort)(pc & 0x1ff));
Push((ushort)(BP - 1));
Push((ushort)(aArgCount | (aCallType << 8)));
BP = SP;
Frames++;
ZDebug.Output($"Added Frame: {Frames} -> {this[SP + 0]}:{this[SP + 1]}:{this[SP + 2]}:{this[SP + 3]}");
}
IEnumerator Start()
{
// 这个GameManager需要自己实现
// yield return StartCoroutine (GameManager.Instance ().OnStart ());
ZConsole.Instance();
ZDebug.Init();
if (!APP_CONFIG.DEBUG)
{
ZDebug.DisplayType = ZDebug.OutputType.File;
ZDebug.DisplayMethod = ZDebug.ConsoleLogMethod.Selected;
}
ZDebug.SelectType <App>();
ZDebug.Log("App Started!");
yield return(null);
}
/// <summary>
/// Load mapped class
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public bool Load <T>()
{
ResetMap();
//Check mapping
if (!Attribute.IsDefined(typeof(T), typeof(CSVMapperAttribute), false))
{
ZDebug.LogError(string.Format("CSV mapping attribute not found in type: {0}", typeof(T)));
return(false);
}
CSVMapperAttribute mapper =
Attribute.GetCustomAttribute(typeof(T), typeof(CSVMapperAttribute), false) as CSVMapperAttribute;
_keyRow = mapper.KeyRow;
_descRow = mapper.DescRow;
_startRow = mapper.StartRow;
if (string.IsNullOrEmpty(mapper.Path))
{
ZDebug.LogError(string.Format("CSV path not found: {0}", mapper.Path));
return(false);
}
//Read text
TextAsset asset = Resources.Load <TextAsset>(mapper.Path);
if (asset == null)
{
ZDebug.LogError(string.Format("CSV file not found: {0}", mapper.Path));
return(false);
}
string content = asset.text;
bool result = Load(content, mapper.Separator);
if (result)
{
if (_keyRow < 0 || _records[_keyRow].Any(string.IsNullOrEmpty))
{
ZDebug.LogError(
string.Format("Encoding Error! No key column found. Make sure target file is in UTF-8 format. Path: {0}",
mapper.Path));
return(false);
}
}
return(result);
}
public void removeBlock(IntVector3 point)
{
if (!shipInfo.isInsideArray(point))
{
Debug.Log("removeBlock got request outside array " + ZDebug.toString(point));
return;
}
if (!shipInfo.isBlockOccupied(point))
{
Debug.Log("removeBlock got unoccupied request " + ZDebug.toString(point));
return;
}
ship3DView.removeBlock(point);
shipModel.removeBlock(point);
}
public void StateChange(IGameState newState)
{
if (newState == null)
{
ZDebug.LogError("State error!");
return;
}
if (CurrentState != null)
{
CurrentState.OnExit();
}
CurrentState = newState;
CurrentState.OnEnter();
}
/// <summary>
/// Load resource by key
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public Object Load(string key)
{
if (CanLoad)
{
ZResource.Resource resource = Instance._resource[key];
if (resource != null && resource.resource != null)
{
return(resource.resource);
}
ZDebug.LogError("Resource not found: " + key);
return(null);
}
ZDebug.LogError("Resource cannot be loaded: " + key);
return(null);
}
/// <summary>
/// Get raw value by CSVColumnAttribute or name
/// </summary>
/// <param name="attribute"></param>
/// <param name="fields"></param>
/// <param name="keys"></param>
/// <param name="name"></param>
/// <returns></returns>
private string GetRawValue(CSVColumnAttribute attribute, List <string> fields, List <string> keys, string name)
{
if (attribute.Column >= 0 && fields.Count > attribute.Column)
{
return(fields[attribute.Column]);
}
if (!string.IsNullOrEmpty(attribute.Key) && keys.Contains(attribute.Key))
{
return(fields[keys.IndexOf(attribute.Key)]);
}
if (keys.Contains(name))
{
return(fields[keys.IndexOf(name)]);
}
ZDebug.LogError(string.Format("Mapping Error! Column: {0}, Key: {1}, Name:{2}", attribute.Column,
attribute.Key ?? "NULL", name));
return(name);
}
public void createBlock(int blockCode, IntVector3 position)
{
if (!shipInfo.isInsideArray(position))
{
Debug.Log("aborted createBlock. bad coordinates: " + ZDebug.toString(position));
return;
}
if (shipInfo.isBlockOccupied(position))
{
Debug.Log("aborted createBlock. occupied coordinates: " + ZDebug.toString(position));
return;
}
BlockData blockData = BlockDataLookup.getBlockDataByCode(blockCode).getCopy();
Block block = ship3DView.createBlock(blockData, position);
shipModel.createBlock(blockData, position);
}
/// <summary>
/// Decode CSV file to target mapped type.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="path"></param>
/// <returns></returns>
public IEnumerable <T> Decode <T>() where T : new()
{
if (_records == null || _keyRow < 0 || _descRow < 0 || _startRow < 0)
{
ZDebug.LogError(string.Format("Decoding Failed: {0}", typeof(T)));
yield break;
}
//Decode each row
for (int i = _startRow; i < _records.Count; i++)
{
if (i == _keyRow || i == _descRow)
{
continue;
}
yield return(DecodeRow <T>(_records[i], _records[_keyRow]));
}
}
/// <summary>
/// Load string content
/// </summary>
/// <param name="content"></param>
/// <param name="separator"></param>
/// <returns></returns>
public bool Load(string content, char separator = ',')
{
//Dispose records
ClearRecord();
if (string.IsNullOrEmpty(content))
{
ZDebug.LogError(string.Format("CSV file content empty!"));
return(false);
}
bool check = CheckLegal(content, separator);
if (!check)
{
return(false);
}
Separator = separator;
_records = new List <List <string> >();
foreach (string row in content.Split('\r').Where(line => !string.IsNullOrEmpty(line.Trim())))
{
List <string> columns = row.Split(separator).Select(s => s.Trim()).ToList();
//Check each row's column count. They must match
if (ColumnCount != 0 && columns.Count != ColumnCount)
{
ZDebug.LogError(
string.Format("CSV parsing error at line {0} : columns counts do not match! Separator: '{1}'",
content.IndexOf(row), separator));
return(false);
}
ColumnCount = columns.Count;
_records.Add(columns);
}
RowCount = _records.Count;
if (_records == null || !_records.Any())
{
ZDebug.LogWarning(string.Format("CSV file parsing failed(empty records)!"));
return(false);
}
return(true);
}
/// <summary>
/// Load resource by key
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns></returns>
public T Load <T>(string key) where T : Object
{
Object resource = Load(key);
if (resource == null)
{
return(null);
}
T result = resource as T;
if (result != null)
{
return(result);
}
ZDebug.LogError("Resource converting failed: " + key + " --> " + typeof(T));
return(null);
}
public void AddModel(IModel model)
{
if (model == null)
{
ZDebug.LogError(string.Format("Error in {0} Model can't be null.", this));
return;
}
if (HasModel(model.Name))
{
ZDebug.LogError(string.Format("Error in {0} Model '{1}' already registered.", this, model.Name));
return;
}
lock (_models)
{
_models[model.Name] = model;
model.Dispatcher = _dispatcher;
model.Init();
}
}
