public static ConstString New(BlockBase parent, string value)
{
var ret = new ConstString();
ret.Parent = parent;
ret.Value = value;
return ret;
}
public static void AddCodes(NodeBase caller, BlockBase parent, NodeBase target, OpModule codes, string op, Addr32 dest)
{
if (target is TypeOf) target = (target as TypeOf).Target;
var v = target as Variant;
if (v != null && parent.GetFunction(v.Name) == null)
{
var fpname = (target as Variant).Name;
var fpt = Types.GetType(parent, fpname);
if (fpt == null || !fpt.Check())
throw caller.Abort("undefined type: {0}", fpname);
codes.AddCodesV(op, dest, codes.GetTypeObject(fpt));
return;
}
var tt = target.Type;
var tr = tt as TypeReference;
var tts = tt.Type as TypeStruct;
if (tr != null && (tr.IsArray || (tts != null && tts.IsClass)))
{
target.AddCodesV(codes, "mov", null);
var label = new OpCode();
codes.Add(I386.Test(Reg32.EAX, Reg32.EAX));
codes.Add(I386.Jcc(Cc.Z, label.Address));
codes.Add(I386.MovRA(Reg32.EAX, Addr32.NewRO(Reg32.EAX, -16)));
codes.Add(label);
codes.AddCodes(op, dest);
}
else
codes.AddCodesV(op, dest, codes.GetTypeObject(tt));
}
public static VarDeclare Array(BlockBase parent, string name, TypeBase type, NodeBase count)
{
var ret = New(parent, name, null);
ret.doneInferType = true;
ret.type = TypeArray.New(type, count);
return ret;
}
public static NodeBase[] Parse(BlockBase parent, Tokenizer token)
{
var parser = Parser.Create(token, parent);
var ret = parser.Parse();
if (token.CanRead) ret = null;
return ret;
}
public static TypeBase GetType(BlockBase parent, string type)
{
if (type == null)
return null;
else if (type == "delegate")
return DelgFunc.GetDefaultType(parent);
else if (type.StartsWith("var:"))
return ToVarType(GetType(parent, type.Substring(4)));
else if (type.EndsWith("*"))
{
var t = type.Substring(0, type.Length - 1).TrimEnd();
return TypePointer.New(GetType(parent, t));
}
else if (type.EndsWith("[]"))
{
var t = type.Substring(0, type.Length - 2).TrimEnd();
return TypeReference.New(GetType(parent, t), true);
}
else if (type.EndsWith("]"))
{
var p = type.IndexOf('[');
var t = GetType(parent, type.Substring(0, p));
var n = type.Substring(p + 1, type.Length - p - 2);
return TypeArray.NewInt(t, int.Parse(n));
}
var ret = Types.GetValueType(type);
if (ret != null) return ret;
return TypeStruct.New(parent, type);
}
protected static VarOperator Init1(VarOperator op, BlockBase parent, NodeBase dest, NodeBase arg)
{
op.Parent = parent;
op.dest = dest;
op.values.Add(arg);
return op;
}
public static TypeOf New(BlockBase parent, NodeBase target)
{
var ret = new TypeOf();
ret.Parent = parent;
ret.Target = target;
return ret;
}
public static Variant NewName(BlockBase parent, string name)
{
var ret = new Variant();
ret.Parent = parent;
ret.name = name;
return ret;
}
protected static Operator Init2(Operator op, BlockBase parent, NodeBase arg1, NodeBase arg2)
{
op.Parent = parent;
if (arg1 != null) op.values.Add(arg1);
if (arg2 != null) op.values.Add(arg2);
return op;
}
public static Null New(BlockBase parent)
{
var ret = new Null();
ret.Parent = parent;
ret.name = "null";
return ret;
}
public static Return New(BlockBase parent, NodeBase value)
{
var ret = new Return();
ret.init(parent);
if (value != null) ret.Value = value;
return ret;
}
public static Arg NewVar(BlockBase parent, VarDeclare target)
{
var ret = new Arg();
ret.init1(parent, target.Name, null);
ret.target = target;
return ret;
}
void Update ()
{
if(!MapEditor.Instance)
{
if(m_cells == null) return;
if(m_selectedBlock == null)
{
for (int y = 0; y < m_cells.Count; ++y)
{
for (int x = 0; x < m_cells[y].Count; ++x)
{
m_selectedBlock = m_cells[y][x].UpdateInput();
if(m_selectedBlock)
return;
}
}
}
else
{
m_selectedBlock.UpdateMovement();
if(!Input.GetMouseButton(0))
m_selectedBlock = null;
}
}
}
public static New New2(BlockBase parent, string type, NodeBase length)
{
var ret = new New();
ret.Parent = parent;
ret.type = TypeReference.New(Types.GetType(parent, type), true);
ret.Length = length;
return ret;
}
public static New New1(BlockBase parent, string type)
{
var ret = new New();
ret.Parent = parent;
ret.type = Types.GetVarType(parent, type);
ret.Length = IntValue.New(-1);
return ret;
}
public static Base New(BlockBase parent)
{
var ret = new Base();
ret.Parent = parent;
ret.name = "base";
ret.Reference = parent.GetVar("this");
return ret;
}
public static Declare New(BlockBase parent, string name, string type)
{
var ret = new Declare();
ret.init1(parent, name, null);
ret.type = Types.GetType(parent, type) as TypeStruct;
if (ret.type == null) throw ret.Abort("type required");
return ret;
}
public static TypeDelegate New(
BlockBase parent, CallType callType, TypeBase retType, VarDeclare[] args)
{
var ret = new TypeDelegate();
ret.init(callType, retType, args);
ret.Parent = parent;
return ret;
}
public static Parser Create(Tokenizer tokenizer, BlockBase parent)
{
var ret = new Parser();
ret.tokenizer = tokenizer;
ret.parent = parent;
ret.InitOperator();
return ret;
}
public static Extern New(BlockBase parent, string name, string module, string alias)
{
var ret = new Extern();
ret.init2(parent, name, false);
ret.module = module;
ret.alias = alias;
return ret;
}
public static Var New(BlockBase parent, VarDeclare var)
{
var ret = new Var();
ret.Parent = parent;
ret.name = var.Name;
ret.Reference = var;
return ret;
}
public static This New(BlockBase parent)
{
var ret = new This();
ret.Parent = parent;
ret.name = "this";
ret.Reference = parent.GetVar(ret.name);
return ret;
}
public static Cast New(BlockBase parent, string type, NodeBase source)
{
var ret = new Cast();
ret.Parent = parent;
ret.name = "__cast";
ret.type = type;
ret.Source = source;
return ret;
}
public static TypeStruct New(BlockBase parent, string name)
{
if (name.EndsWith("]"))
throw new Exception("TypeStruct: invalid type: " + name);
var ret = new TypeStruct();
ret.Parent = parent;
ret.name = name;
return ret;
}
public static Var NewName(BlockBase parent, string name)
{
var ret = new Var();
ret.Parent = parent;
ret.name = name;
ret.Reference = parent.GetVar(name);
if (ret.Reference == null)
throw ret.Abort("undefined pointer: " + name);
return ret;
}
public void SetBlock(BlockBase block)
{
if(m_currentBlock)
{
m_currentBlock.SetParentCell(null);
}
m_currentBlock = block;
if(m_currentBlock)
m_currentBlock.SetParentCell(this);
}
public static TypeBase GetType(BlockBase parent, NodeBase target)
{
var v = target as Variant;
if (v != null)
{
var vt = v.GetVariantType();
if (vt != null) return vt;
return Types.GetType(parent, v.Name);
}
return target.Type;
}
/// <summary>
/// Parses a literal value from a line.
/// </summary>
/// <param name="input">The reference to the line of code</param>
/// <param name="label">Debug information about the expected literal</param>
/// <param name="replace">Whether to perform variable replacement in the literal</param>
/// <param name="data">The BotData needed for variable replacement</param>
/// <returns>The literal without the leading and trailing double quotes</returns>
public static string ParseLiteral(ref string input, string label, bool replace = false, BotData data = null)
{
try {
if (replace)
{
return(BlockBase.ReplaceValues(ParseToken(ref input, TokenType.Literal, true), data));
}
else
{
return(ParseToken(ref input, TokenType.Literal, true));
}
}
catch { throw new ArgumentException($"Expected Literal value for '{label}'"); }
}
public BlockBase CreateAndInitialiseBlock(View hostView, Node parentNode, BlockBase parentBlock, FieldList definitionData, FieldList contentData, bool isRoot)
{
if (definitionData != null)
{
BlockDefinition bd = Core.Definitions.UnpackDefinition(definitionData) as BlockDefinition;
if (bd != null)
{
return(CreateAndInitialiseBlock(hostView, parentNode, parentBlock, bd, contentData, isRoot));
}
}
return(null);
}
public virtual BlockBase Parse(Memory <byte> source)
{
//Memory<byte> sourceMemory = new Memory<byte>(source);
Memory <byte> spanBody = SliceInitialBytes(source, out Memory <byte> spanHeader);
BlockBase blockBase = ParseBody(spanBody, out Memory <byte> nonHeaderBytes);
blockBase.RawData = source.Slice(0, spanHeader.Length + nonHeaderBytes.Length);
FillBlockBaseHeader(blockBase, spanHeader);
return(blockBase);
}
private void CreateOrUpdateEpoch(BlockBase block, List <Transaction> allMessagedTransactions)
{
var epochNumber = block.Depth / (EpochSize + 1) + 1;
if (_stakingStorage.Epochs.TryGetValue(epochNumber - 1, out var previousEpoch))
{
var currentEpoch = _stakingStorage.Epochs.GetOrAdd(epochNumber, new Epoch(previousEpoch, epochNumber));
allMessagedTransactions.ForEach(mt => currentEpoch.Transactions.TryAdd(mt.Id, mt));
}
else
{
Console.WriteLine($"Could not find epoch parent {epochNumber - 1}\nDepth: {block.Depth}");
}
}
private bool Header_GetVersion(ExecutionEngine engine)
{
if (engine.CurrentContext.EvaluationStack.Pop() is InteropInterface _interface)
{
BlockBase header = _interface.GetInterface <BlockBase>();
if (header == null)
{
return(false);
}
engine.CurrentContext.EvaluationStack.Push(header.Version);
return(true);
}
return(false);
}
internal void Clear()
{
for (int y = 0; y < GridObject.GetLength(1); y++)
{
for (int x = 0; x < GridObject.GetLength(0); x++)
{
BlockBase blockToErase = GridObject[x, y];
if (blockToErase != null)
{
blockToErase.DestroyTiles(x, y);
}
}
}
}
protected bool Header_GetTimestamp(ExecutionEngine engine)
{
if (engine.CurrentContext.EvaluationStack.Pop() is InteropInterface _interface)
{
BlockBase header = _interface.GetInterface <BlockBase>();
if (header == null)
{
return(false);
}
engine.CurrentContext.EvaluationStack.Push(header.Timestamp);
return(true);
}
return(false);
}
public static DiagramBlock CreateDiagramBlock(BlockBase block, bool useNextPosition)
{
var className = (block.ID == null) ? block.GetAssemblyClassName() : block.ID;
Image image = Envision.Properties.Resources.unknownicon;
if (block.Picture != null)
{
image = block.Picture;
}
var label = className;
var shortname = typeof(BlockOutputNode).GetProperty("ShortName");
return(new DiagramBlock(image, label, block, block.InputNodes.ToArray <object>(), block.OutputNodes.ToArray <object>(), shortname, true, useNextPosition));
}
protected bool Header_GetPrevHash(ExecutionEngine engine)
{
if (engine.CurrentContext.EvaluationStack.Pop() is InteropContract _interface)
{
BlockBase header = _interface.GetInterface <BlockBase>();
if (header == null)
{
return(false);
}
engine.CurrentContext.EvaluationStack.Push(header.PrevHash.ToArray());
return(true);
}
return(false);
}
private void Process()
{
try {
vm.LS.TakeStep(vm.BotData);
OB.Logger.LogInfo(Components.Stacker, $"Processed {BlockBase.TruncatePretty(vm.LS.CurrentLine, 20)}");
}
catch (Exception ex) {
OB.Logger.LogError(Components.Stacker, $"Processing of line {BlockBase.TruncatePretty(vm.LS.CurrentLine, 20)} failed, exception: {ex.Message}");
}
PrintBotData();
PrintLogBuffer();
DisplayHTML();
}
private bool Header_GetNextConsensus(ExecutionEngine engine)
{
if (engine.CurrentContext.EvaluationStack.Pop() is InteropContract _interface)
{
BlockBase header = _interface.GetInterface <BlockBase>();
if (header == null)
{
return(false);
}
engine.CurrentContext.EvaluationStack.Push(header.NextConsensus.ToArray());
return(true);
}
return(false);
}
public override void OnInputDisconnected(BlockBase src, string srcSlotName, string targetSlotName)
{
base.OnInputDisconnected(src, srcSlotName, targetSlotName);
if (targetSlotName == "set_Grabber" && _streamer != null)
{
_streamer.Stop();
_streamer.Close();
if (_grabber != null)
{
_grabber.Destroy();
}
_grabber = null;
}
}
private static bool Header_GetPrevHash(ApplicationEngine engine)
{
if (engine.CurrentContext.EvaluationStack.Pop() is InteropInterface _interface)
{
BlockBase header = _interface.GetInterface <BlockBase>();
if (header == null)
{
return(false);
}
engine.CurrentContext.EvaluationStack.Push(header.PrevHash.ToArray());
return(true);
}
return(false);
}
protected virtual bool Header_GetNextConsensus(ExecutionEngine engine)
{
if (engine.EvaluationStack.Pop() is InteropInterface _interface)
{
BlockBase header = _interface.GetInterface <BlockBase>();
if (header == null)
{
return(false);
}
engine.EvaluationStack.Push(header.NextConsensus.ToArray());
return(true);
}
return(false);
}
/// <summary>
/// Replaces the values and verifies if a condition is true or false.
/// </summary>
/// <param name="kcCond">The keycheck condition struct</param>
/// <param name="data">The BotData used for variable replacement</param>
/// <returns>Whether the comparison is verified or not.</returns>
public static bool ReplaceAndVerify(KeycheckCondition kcCond, BotData data)
{
var style = NumberStyles.Number | NumberStyles.AllowCurrencySymbol; // Needed when comparing values with a currency symbol
var provider = new CultureInfo("en-US");
var L = BlockBase.ReplaceValuesRecursive(kcCond.Left, data); // The left-hand term can accept recursive values like <LIST[*]>
var r = BlockBase.ReplaceValues(kcCond.Right, data); // The right-hand term cannot
switch (kcCond.Comparer)
{
case Comparer.EqualTo:
return(L.Any(l => l == r));
case Comparer.NotEqualTo:
return(L.Any(l => l != r));
case Comparer.GreaterThan:
return(L.Any(l => decimal.Parse(l.Replace(',', '.'), style, provider) > decimal.Parse(r.Replace(',', '.'), style, provider)));
case Comparer.GreaterOrEqual:
return(L.Any(l => decimal.Parse(l.Replace(',', '.'), style, provider) >= decimal.Parse(r.Replace(',', '.'), style, provider)));
case Comparer.LessThan:
return(L.Any(l => decimal.Parse(l.Replace(',', '.'), style, provider) < decimal.Parse(r.Replace(',', '.'), style, provider)));
case Comparer.LessThanOrEqual:
return(L.Any(l => decimal.Parse(l.Replace(',', '.'), style, provider) <= decimal.Parse(r.Replace(',', '.'), style, provider)));
case Comparer.Contains:
return(L.Any(l => l.Contains(r)));
case Comparer.DoesNotContain:
return(L.Any(l => !l.Contains(r)));
case Comparer.Exists:
return(L.Any(l => l != kcCond.Left)); // Returns true if any replacement took place
case Comparer.DoesNotExist:
return(L.All(l => l == kcCond.Left)); // Returns true if no replacement took place
case Comparer.MatchesRegex:
return(L.Any(l => Regex.Match(l, r).Success));
case Comparer.DoesNotMatchRegex:
return(L.Any(l => !Regex.Match(l, r).Success));
default:
return(false);
}
}
void CompileApply(AstApply ast, BlockBase parent)
{
var e = ast.Block;
var src = e.Source;
var fc = new FunctionCompiler(_compiler, parent);
var p = fc.ResolveExpression(e, null);
if (p.IsInvalid)
{
return;
}
if (p is PartialType)
{
var dt = (p as PartialType).Type;
if (dt.Block != null)
{
dt.PopulateMembers();
dt.Block.Populate();
parent.Members.Add(new Apply(src, ast.Modifier, dt.Block, null));
return;
}
}
else if (p is PartialBlock)
{
var b = (p as PartialBlock).Block;
b.Populate();
parent.Members.Add(new Apply(src, ast.Modifier, b, null));
return;
}
var sym = fc.CompilePartial(p);
if (sym.IsInvalid)
{
return;
}
if (sym.ReturnType.Block != null)
{
sym.ReturnType.PopulateMembers();
sym.ReturnType.Block.Populate();
parent.Members.Add(new Apply(src, ast.Modifier, sym.ReturnType.Block, sym));
return;
}
Log.Error(src, ErrorCode.E3213, "Only 'block', 'class', 'struct' or 'interface' types can be applied");
}
public static List <ODCoverage> GetRecords(BlockBase block, string layer, CoverageType type)
{
List <ODCoverage> recs = new List <ODCoverage>();
var btr = block.IdBtr.GetObject(OpenMode.ForRead) as BlockTableRecord;
var plsCoverage = btr.GetObjects <Polyline>().
Where(p => p.Visible && p.Layer.Equals(layer, StringComparison.OrdinalIgnoreCase));
foreach (var item in plsCoverage)
{
var idPlCoverage = block.CopyEntToModel(btr.Database.CurrentSpaceId, item.Id);
ODCoverage odCoverage = new ODCoverage(idPlCoverage, type);
recs.Add(odCoverage);
}
return(recs);
}
public override bool Begin(BlockBase b)
{
var bp = b.ParentBlock;
if (bp != null && bp.BlockType == BlockType.MetaBlock)
{
if (b.BlockType != BlockType.MetaBlock ||
((MetaBlock)bp).MetaBlockType != MetaBlockType.Scope)
{
Log.Error(b.Source, ErrorCode.E0000, "Block " + b.Quote() + " is not allowed in meta block");
}
}
return(!Environment.IsGeneratingCode);
}
public bool VerifyBlock(BlockBase blockBase)
{
SyncedBlockBase syncedBlockBase = (SyncedBlockBase)blockBase;
ulong syncBlockHeight = syncedBlockBase.SyncBlockHeight;
if (!((_synchronizationContext.LastBlockDescriptor?.BlockHeight.Equals(syncBlockHeight) ?? true) ||
(_synchronizationContext.PrevBlockDescriptor?.BlockHeight.Equals(syncBlockHeight) ?? true)))
{
_log.Error($"Synchronization block height is outdated: {blockBase.RawData.ToArray().ToHexString()}");
return(false);
}
return(CheckSyncPOW(syncedBlockBase));
}
public bool ExecuteApplicationEvent(Anchor anchor, BlockBase sourceBlock, Node sourceNode, long sourceViewID)
{
if (ApplicationEvents != null)
{
ActionSet actions = ApplicationEvents[anchor];
if (actions != null)
{
ExecuteAction(actions, sourceBlock, sourceNode, sourceViewID);
return(true);
}
}
return(false);
}
public void AddBlock(BlockBase block)
{
int position;
if (vm.CurrentBlockIndex == -1)
{
position = vm.Stack.Count;
}
else
{
position = vm.Stack.Count > 0 ? vm.CurrentBlockIndex + 1 : 0;
}
OB.Logger.LogInfo(Components.Stacker, $"Added a block of type {block.GetType()} in position {position}");
vm.AddBlock(block, position);
}
public override void OnOutputConnected(string srcSlotName, BlockBase target, string targetSlotName)
{
base.OnOutputConnected(srcSlotName, target, targetSlotName);
if (srcSlotName == "Grabber" && _grabber != null)
{
_grabber.Restart();
_grabber.Start();
_grabber.SetVolume(_volume);
}
else if (srcSlotName == "Samples" && _grabber != null)
{
_grabber.Start();
_grabber.StartThreadedGrabber();
}
}
public BlockBase GetLastBlock(IKey key)
{
TransactionalBlock transactionalBlock = DataAccessService.Instance.GetLastTransactionalBlock(key);
if (transactionalBlock != null)
{
ITranslator <TransactionalBlock, BlockBase> mapper = _mapperFactory.GetInstance <TransactionalBlock, BlockBase>();
BlockBase block = mapper?.Translate(transactionalBlock);
return(block);
}
return(null);
}
public void TestGetName()
{
var block = new ConvolutionBlock();
Assert.AreEqual(block.Name, BlockBase.GetName(block.GetType()));
Assert.AreEqual("ConvolutionBlock", block.GetAssemblyClassName());
Assert.AreEqual("", BlockBase.GetName(typeof(Object)));
Assert.AreEqual("", BlockBase.GetName(typeof(BlockBase)));
Assert.AreEqual(true, block.HasParameters());
var block2 = new InvertBlock();
Assert.AreEqual(false, block2.HasParameters());
}
// Get a variable.
public Variable GetVariable(string name)
{
BlockBase block = this;
do
{
Variable variable = block.Variables.Where(x => x.Name == name).FirstOrDefault();
if (variable != null)
{
return(variable);
}
block = block.Parent;
} while (block != null);
return(null);
}
public static List <BlockBase> LoadJsonByName(string fileName)
{
currentJsonFileName = fileName;
TextAsset jsonfile = Resources.Load("stage") as TextAsset;
string _data = jsonfile.text;
currentJsonString = _data;
JsonData jdata = JsonMapper.ToObject(_data);
if (jdata.IsArray)
{
List <BlockBase> ret = new List <BlockBase>();
var list = jdata;
for (int i = 0; i < list.Count; ++i)
{
//Debug.Log (DataManager._currentStage.ToString () + " " + list [i] ["stage"]);
if (DataManager._currentStage == toInt(list [i] ["stage"].ToString()))
{
//Debug.Log ("add");
BlockBase bb = new BlockBase();
bb._id = toInt(list [i] ["id"].ToString());
bb._type = (BlockType)toInt(list [i] ["style"].ToString());
bb._startX = toFloat(list [i] ["xHead"].ToString());
bb._endX = toFloat(list [i] ["xEnd"].ToString());
bb._Y = toFloat(list [i] ["yHead"].ToString());
if (bb._type == BlockType.BT_LRSTAIR)
{
bb._stairXStart = toFloat(list [i] ["xMin"].ToString());
bb._stairXEnd = toFloat(list [i] ["xMax"].ToString());
bb._stairMoveTime = toFloat(list [i] ["time"].ToString());
}
if (bb._type == BlockType.BT_UDSTAIR)
{
bb._stairYStart = toFloat(list [i] ["yMin"].ToString());
bb._stairYEnd = toFloat(list [i] ["yMax"].ToString());
bb._stairMoveTime = toFloat(list [i] ["time"].ToString());
}
if (bb._type == BlockType.BT_FALLSTAIR)
{
bb._stairDelay = toFloat(list [i] ["fallTime"].ToString());
}
ret.Add(bb);
}
}
return(ret);
}
return(null);
}
public override void OnInputDisconnected(BlockBase src, string srcSlotName, string targetSlotName)
{
base.OnInputDisconnected(src, srcSlotName, targetSlotName);
if (targetSlotName == "set_Eyes")
{
Eyes = null;
}
if (targetSlotName == "set_Ears")
{
Ears = null;
}
if (targetSlotName == "set_Body")
{
Body = null;
}
}
public override void OnInputDisconnected(BlockBase src, string srcSlotName, string targetSlotName)
{
base.OnInputDisconnected(src, srcSlotName, targetSlotName);
if (targetSlotName == "set_Source1")
{
_sources[0] = null;
}
else if (targetSlotName == "set_Source2")
{
_sources[1] = null;
}
else if (targetSlotName == "set_Source3")
{
_sources[2] = null;
}
}
public BlockItem(BlockBase block)
{
Block = block;
foreach (var e in block.Members)
{
if (e is MetaProperty)
{
AddChild(new MetaPropertyItem(e as MetaProperty));
}
else if (e is Node)
{
AddChild(new BlockItem((e as Node).Block));
}
}
}
public override void OnInputDisconnected(BlockBase src, string srcSlotName, string targetSlotName)
{
base.OnInputDisconnected(src, srcSlotName, targetSlotName);
if (targetSlotName == "set_LeftEye")
{
LeftEye = null;
}
if (targetSlotName == "set_RightEye")
{
RightEye = null;
}
if (targetSlotName == "set_Config")
{
Config = _tmpConfig;
}
}
public static NodeBase GetTarget(BlockBase parent, string name)
{
if (parent == null || name == null)
return null;
var i = parent.GetInt(name);
if (i != null && i.Parent.Parent == null) return i;
var s = parent.GetString(name);
if (s != null && s.Parent.Parent == null) return s;
if (parent.Parent == null) return null;
var v = parent.GetVar(name);
if (v != null && (v.Parent is Define || v.Parent.Parent == null))
return Var.New(parent, v);
return null;
}
public BlockBase CreateBlock(BlockBase.BlockProperty type)
{
string prefabName = null;
switch(type)
{
case BlockBase.BlockProperty.Empty:
break;
case BlockBase.BlockProperty.Movable:
prefabName = "Movable";
break;
case BlockBase.BlockProperty.NonMovable:
prefabName = "NonMovable";
break;
case BlockBase.BlockProperty.SlowPowerUp:
prefabName = "SlowPowerUp";
break;
case BlockBase.BlockProperty.LaneChangerLeft:
prefabName = "LaneChangerLeft";
break;
case BlockBase.BlockProperty.LaneChangerRight:
prefabName = "LaneChangerRight";
break;
default:
break;
}
if(prefabName != null)
{
GameObject block = Game.Instance.ObjectPool.GetFromPool(prefabName, true);
if(block == null)
return null;
return block.GetComponent<BlockBase>();
}
return null;
}
public static bool SetBlock(RaycastHit hit, BlockBase block) {
if (hit.collider == null)
return false;
Chunk chunk = hit.collider.GetComponent<Chunk>();
if (chunk == null)
return false;
WorldPos Pos = GetBlockPos(hit);
chunk.world.SetBlock(Pos.x, Pos.y, Pos.z, block);
// now save whenever i update blocks
//Serialization.SaveChunk(chunk);
return true;
}
