public void CompileSwitchBlock(SwitchBlock switchBlock) { XmlElement previousElement = currentElement; XmlElement tmpElement = document.CreateElement("SwitchBlock"); if (switchBlock.DefaultCase < int.MaxValue) { tmpElement.SetAttribute("DefaultCase", switchBlock.DefaultCase.ToString()); } currentElement = document.CreateElement("Expression"); switchBlock.Expression.AcceptCompiler(this); tmpElement.AppendChild(currentElement); if (switchBlock.Cases.Length > 0) { XmlElement casesElement = document.CreateElement("Cases"); foreach (CaseLabel _case in switchBlock.Cases) { ProcessSwitchCase(casesElement, _case); } tmpElement.AppendChild(casesElement); } currentElement = document.CreateElement("Statements"); foreach (Statement statement in switchBlock.Statements) { statement.AcceptCompiler(this); } tmpElement.AppendChild(currentElement); previousElement.AppendChild(tmpElement); currentElement = previousElement; }
public void SwitchBlock_NoDefaultBlock() { var sst = new SwitchBlock { Reference = SSTUtil.VariableReference("a"), Sections = { new CaseBlock { Label = new ConstantValueExpression{ Value = "1" }, Body = { new BreakStatement(), new BreakStatement() } }, new CaseBlock { Label = new ConstantValueExpression{ Value = "2" }, Body = { new BreakStatement() } } } }; AssertPrint( sst, "switch (a)", "{", " case 1:", " break;", " break;", " case 2:", " break;", "}"); }
public void LinkSwitchToController(SwitchBlock negative, SwitchBlock positive) { negativeSwitch = negative; positiveSwitch = positive; negativeSwitch.BlockClickEvent += DetectBlockClick; positiveSwitch.BlockClickEvent += DetectBlockClick; }
internal void EmitSwitch(object[] labels) { _emitState.AdjustStack(-1); int curStack = _emitState.CurStack; foreach (object label in labels) { LabelInfo ld; if (!_labelInfos.TryGetValue(label, out ld)) { _labelInfos.Add(label, new LabelInfo(curStack, true)); } else { Debug.Assert(ld.stack == curStack, "branches to same label with different stacks"); if (!ld.targetOfConditionalBranches) { _labelInfos[label] = ld.SetTargetOfConditionalBranches(); } } } SwitchBlock switchBlock = this.CreateSwitchBlock(); switchBlock.BranchLabels = labels; this.EndBlock(); }
public SwitchBlock CreateSwitchBlock(ILBuilder builder) { SwitchBlock block = new SwitchBlock(builder, builder.EnclosingExceptionHandler); AddBlock(block); return(block); }
public void DetectBlockClick(SwitchBlock block) { if (neighborController[0].isActivated || neighborController[1].isActivated) { return; } HandleWithSwitch(block, GetPrevSwitchState()); }
public void Equality_Default() { var a = new SwitchBlock(); var b = new SwitchBlock(); Assert.AreEqual(a, b); Assert.AreEqual(a.GetHashCode(), b.GetHashCode()); }
private SwitchBlock CreateSwitchBlock() { // end the current block EndBlock(); SwitchBlock switchBlock = _scopeManager.CreateSwitchBlock(this); UpdatesForCreatedBlock(switchBlock); return switchBlock; }
internal void BirdCounting3() { double noise = 0.2; int maxBirds = 8; Range numBirdRange = new Range(maxBirds + 1).Named("numBirdRange"); Variable <int> numBirds = Variable.DiscreteUniform(numBirdRange).Named("numBirds"); SwitchBlock block = Variable.Switch(numBirds); Range bird = new Range(maxBirds).Named("bird"); VariableArray <bool> isMale = Variable.Array <bool>(bird).Named("isMale"); isMale[bird] = Variable.Bernoulli(0.5).ForEach(bird); Variable <int> numObserved = Variable.New <int>().Named("numObserved"); Range observedBird = new Range(numObserved).Named("observedBird"); VariableArray <bool> observedMale = Variable.Array <bool>(observedBird).Named("observedMale"); //VariableArray<int> birdIndices = Variable.Array<int>(observedBird).Named("birdIndices"); using (Variable.ForEach(observedBird)) { //birdIndices[observedBird] = Variable.DiscreteUniform(numBirds); //Variable<int> birdIndex = birdIndices[observedBird]; Variable <int> birdIndex = Variable.DiscreteUniform(bird, numBirds).Named("birdIndex"); using (Variable.Switch(birdIndex)) { #if true //Variable.ConstrainEqual(observedMale[observedBird], isMale[birdIndex]); observedMale[observedBird] = (isMale[birdIndex] == Variable.Bernoulli(1 - noise)); #else using (Variable.If(isMale[birdIndex])) { observedMale[observedBird] = Variable.Bernoulli(0.8); } using (Variable.IfNot(isMale[birdIndex])) { observedMale[observedBird] = Variable.Bernoulli(0.2); } #endif } } block.CloseBlock(); InferenceEngine engine = new InferenceEngine(); for (int numObservedInt = 6; numObservedInt <= 10; numObservedInt++) { Console.WriteLine("numObserved = {0}", numObservedInt); // weird behavior with 1 different out of >=9 obs, no obs noise bool[] data = new bool[numObservedInt]; int numObservedMale = 0; for (int i = 0; i < data.Length; i++) { data[i] = (i < numObservedMale); } numObserved.ObservedValue = data.Length; observedMale.ObservedValue = data; //Console.WriteLine("birdIndices = {0}", engine.Infer(birdIndices)); Console.WriteLine("isMale = {0}", engine.Infer(isMale)); Console.WriteLine("numBirds = {0}", engine.Infer(numBirds)); Console.WriteLine(" exact = {0}", BallCountingExact(maxBirds, numObservedInt, numObservedMale, noise)); } }
public void Equality_DifferentReference() { var a = new SwitchBlock { Reference = SomeVarRef("a") }; var b = new SwitchBlock(); Assert.AreNotEqual(a, b); Assert.AreNotEqual(a.GetHashCode(), b.GetHashCode()); }
public void Equality_DifferentSections() { var a = new SwitchBlock(); a.Sections.Add(new CaseBlock()); var b = new SwitchBlock(); Assert.AreNotEqual(a, b); Assert.AreNotEqual(a.GetHashCode(), b.GetHashCode()); }
SwitchBlock GetSwitchBlock() { SwitchBlock switchBlk = GetBlock() as SwitchBlock; if (switchBlk == null) { throw new InvalidOperationException("Statement can be used only in a switch block"); } return(switchBlk); }
SwitchBlock GetSwitchBlock() { SwitchBlock switchBlk = GetBlock() as SwitchBlock; if (switchBlk == null) { throw new InvalidOperationException(Properties.Messages.ErrInvalidSwitchStatement); } return(switchBlk); }
public void Equality_DifferentDefaultSection() { var a = new SwitchBlock(); a.DefaultSection.Add(new ReturnStatement()); var b = new SwitchBlock(); Assert.AreNotEqual(a, b); Assert.AreNotEqual(a.GetHashCode(), b.GetHashCode()); }
public void DefaultValues() { var sut = new SwitchBlock(); Assert.AreEqual(new VariableReference(), sut.Reference); Assert.AreEqual(Lists.NewList <IStatement>(), sut.Sections); Assert.AreEqual(Lists.NewList <IStatement>(), sut.DefaultSection); Assert.AreNotEqual(0, sut.GetHashCode()); Assert.AreNotEqual(1, sut.GetHashCode()); }
public void RegisterSwitchBlock(SwitchBlock switchBlock) { if (switchBlock.Color == GameColor.None) { #if SWITCH_BLOCK_MANAGER Debug.LogFormat(switchBlock, "Switch Block {0} has color None, cannot be registered by SwitchBlockManager.", switchBlock); #endif return; } m_SwitchBlocksDict[switchBlock.Color].Add(switchBlock); }
private static void MarkReachableFromSwitch(ArrayBuilder <BasicBlock> reachableBlocks, BasicBlock block) { SwitchBlock switchBlock = (SwitchBlock)block; ArrayBuilder <BasicBlock> blockBuilder = ArrayBuilder <BasicBlock> .GetInstance(); switchBlock.GetBranchBlocks(blockBuilder); foreach (BasicBlock targetBlock in blockBuilder) { PushReachableBlockToProcess(reachableBlocks, targetBlock); } blockBuilder.Free(); }
public void ChildrenIdentity() { var sut = new SwitchBlock { Reference = SomeVarRef("a"), Sections = { new CaseBlock() }, DefaultSection = { new ReturnStatement() } }; AssertChildren(sut, sut.Reference, sut.DefaultSection.First()); }
public override void VisitSwitchStatement(ISwitchStatement block, IList <IStatement> body) { AddIf(block, CompletionCase.EmptyCompletionBefore, body); var switchBlock = new SwitchBlock { Reference = _exprVisitor.ToVariableRef(block.Condition, body) }; foreach (var section in block.Sections) { IKaVEList <IStatement> currentSection = null; foreach (var label in section.CaseLabels) { currentSection = new KaVEList <IStatement>(); if (label.IsDefault) { switchBlock.DefaultSection = currentSection; } else { switchBlock.Sections.Add( new CaseBlock { Label = _exprVisitor.ToSimpleExpression(label.ValueExpression, body), Body = currentSection }); } AddIf(label, CompletionCase.InBody, currentSection); } AddIf(section, CompletionCase.InBody, currentSection); foreach (var statement in section.Statements) { statement.Accept(this, currentSection); } switch (1) { case 1 * 2: case 0: break; } } body.Add(switchBlock); AddIf(block, CompletionCase.EmptyCompletionAfter, body); }
private void SetSwitchBlock() { for (int i = 0; i < axisIndex; i++) //axisIndex(0 -> x) axisIndex(1 -> y)axisIndex(2 -> z) { GameObject blockUnder = Instantiate(swithBlockPrefab) as GameObject; SwitchBlock switchBlockNegative = blockUnder.GetComponent <SwitchBlock>(); switchBlockNegative.Initialize(i, blockSize, 0); switchArray[i, 0] = switchBlockNegative; GameObject blockUpper = Instantiate(swithBlockPrefab) as GameObject; SwitchBlock switchBlockPositive = blockUpper.GetComponent <SwitchBlock>(); switchBlockPositive.Initialize(i, blockSize, blockSize); switchArray[i, 1] = switchBlockPositive; } }
public void CompileSwitchBlock(SwitchBlock switchBlock) { textWriter.Write("switch ("); switchBlock.Expression.AcceptCompiler(this); textWriter.WriteLine(")"); textWriter.WriteLine("{"); ++textWriter.Indentation; int counter = 0; while (counter < switchBlock.Statements.Length) { foreach (CaseLabel caseLabel in switchBlock.Cases) { if (caseLabel.Address != counter) { continue; } textWriter.Write("case "); DumpDynamic(caseLabel.Value); textWriter.WriteLine(":"); } if (counter == switchBlock.DefaultCase) { textWriter.WriteLine("default:"); } foreach (var pair in switchBlock.Labels) { if (pair.Value.Address != counter) { continue; } ++textWriter.Indentation; textWriter.WriteLine("{0}:", SafeName(pair.Key)); --textWriter.Indentation; } MayBeIndent(switchBlock.Statements[counter]); ++counter; } --textWriter.Indentation; textWriter.WriteLine("}"); }
public void SettingValues() { var sut = new SwitchBlock { Reference = SomeVarRef("a"), Sections = { new CaseBlock() }, DefaultSection = { new ReturnStatement() } }; Assert.AreEqual(SomeVarRef("a"), sut.Reference); Assert.AreEqual(Lists.NewList(new CaseBlock()), sut.Sections); Assert.AreEqual(Lists.NewList(new ReturnStatement()), sut.DefaultSection); }
// Build a switch block statement public static void BuildSwitchBlock(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode) { var s = new SwitchBlock(parentExpression, currentNode.Token.Convert()); parentExpression.ChildExpressions.Add(s); // Get the expression being tested parser.ConsumeParseTree(root, s.Variable, currentNode.ChildNodes[1]); // Build each case block if (currentNode.ChildNodes[2].ChildNodes.Count > 0) { foreach (var node in currentNode.ChildNodes[2].ChildNodes[0].ChildNodes) { BuildCaseBlock(parser, root, s, node); } } }
public void BallCounting2() { double noise = 0.2; int maxBalls = 8; Range ball = new Range(maxBalls).Named("ball"); Variable <int> numBalls = Variable.DiscreteUniform(maxBalls + 1).Named("numBalls"); numBalls.SetValueRange(new Range(maxBalls + 1)); SwitchBlock block = Variable.Switch(numBalls); Variable <int> numTrue = Variable.Binomial(numBalls, 0.5).Named("numTrue"); Variable <int> numObserved = Variable.New <int>().Named("numObserved"); Range observedBall = new Range(numObserved).Named("observedBall"); VariableArray <bool> observedTrue = Variable.Array <bool>(observedBall).Named("observedTrue"); using (Variable.ForEach(observedBall)) { Variable <int> ballIndex = Variable.DiscreteUniform(ball, numBalls).Named("ballIndex"); observedTrue[observedBall] = ((ballIndex < numTrue) == Variable.Bernoulli(1 - noise)); } block.CloseBlock(); InferenceEngine engine = new InferenceEngine(); for (int numObservedInt = 10; numObservedInt <= 10; numObservedInt++) { Console.WriteLine("numObserved = {0}", numObservedInt); // weird behavior with 1 different out of >=9 obs, no obs noise bool[] data = new bool[numObservedInt]; int numObservedTrue = 0; for (int i = 0; i < data.Length; i++) { data[i] = (i < numObservedTrue); } numObserved.ObservedValue = data.Length; observedTrue.ObservedValue = data; //Console.WriteLine("numTrue = {0}", engine.Infer(numTrue)); Discrete numBallsActual = engine.Infer <Discrete>(numBalls); Console.WriteLine("numBalls = {0}", numBallsActual); Discrete numBallsExpected = BallCountingExact(maxBalls, numObservedInt, numObservedTrue, noise); Console.WriteLine(" exact = {0}", numBallsExpected); Assert.True(numBallsExpected.MaxDiff(numBallsActual) < 1e-10); } }
// Generate a series of codedom if statements representing a switch block. // (Codedom doesn't support switch) public static CodeStatement Emit(SwitchBlock switchBlock) { // Create the expression for whatever we're switching on. var codeVar = CodeDomEmitter.EmitCodeExpression(switchBlock.Variable.ChildExpressions[0]); // Store the first and previous if statements here, since it's needed on future loops. CodeConditionStatement codeIf = null; CodeConditionStatement lastIf = null; foreach (var e in switchBlock.ChildExpressions) { // Get the value being compared to: the right operand. var right = CodeDomEmitter.EmitCodeExpression((e as CaseBlock).Variable.ChildExpressions[0]); // Create the next if statement. var nestedIf = new CodeConditionStatement(); // Each case block will compare codeVar (left) to the right operand. nestedIf.Condition = new CodeBinaryOperatorExpression(codeVar, CodeBinaryOperatorType.ValueEquality, right); nestedIf.TrueStatements.Add(new CodeCommentStatement("If condition is true, execute these statements.")); foreach (var s in e.ChildExpressions) { nestedIf.TrueStatements.Add(CodeDomEmitter.EmitCodeStatement(s)); } nestedIf.FalseStatements.Add(new CodeCommentStatement("If condition is false, execute these statements.")); // if codeIf is null, this is the first if statement. if (codeIf == null) { codeIf = nestedIf; } else // It's not the first if statement, so attach it to the previous one. { lastIf.FalseStatements.Add(nestedIf); } // Store the last if block for the next iteration. lastIf = nestedIf; } return(codeIf); }
public void Equality_ReallyTheSame() { var a = new SwitchBlock { Reference = SomeVarRef("a"), Sections = { new CaseBlock() }, DefaultSection = { new ReturnStatement() } }; var b = new SwitchBlock { Reference = SomeVarRef("a"), Sections = { new CaseBlock() }, DefaultSection = { new ReturnStatement() } }; Assert.AreEqual(a, b); Assert.AreEqual(a.GetHashCode(), b.GetHashCode()); }
internal void updateSwitch(int switchID) { if (switchTargets == null) { switchTargets = new Dictionary <int, HashSet <MapObject> >(); } if (targetSwitches == null) { targetSwitches = new Dictionary <MapObject, HashSet <int> >(); } SwitchBlock switchBlock = switchMap[switchID]; if (switchTargets.ContainsKey(switchID)) { //this switch has targets foreach (MapObject mo in switchTargets[switchID]) { //for each of this switches targets, check their state switchBlock.updateObject(mo); } } }
public SwitchStatement(IApexNode parenthesizedExpression56, SwitchBlock switchBlockLabels57) { // TODO: Complete member initialization this.parenthesizedExpression56 = parenthesizedExpression56; this.switchBlockLabels57 = switchBlockLabels57; }
public void AddSwtichBlock(SwitchBlock block){ switchBlocks.Add (block); }
private void RealizeBlocks() { // drop dead code. // We do not want to deal with unreachable code even when not optimizing. // sometimes dead code may have subtle verification violations // for example illegal fall-through in unreachable code is still illegal, // but compiler will not enforce returning from dead code. // it is easier to just remove dead code than make sure it is all valid MarkReachableBlocks(); RewriteSpecialBlocks(); DropUnreachableBlocks(); if (_optimizations == OptimizationLevel.Release && OptimizeLabels()) { // redo unreachable code elimination if some labels were optimized // as that could result in more dead code. MarkAllBlocksUnreachable(); MarkReachableBlocks(); DropUnreachableBlocks(); } // some gotos must become leaves RewriteBranchesAcrossExceptionHandlers(); // now we can compute block offsets and adjust branches while (ComputeOffsetsAndAdjustBranches()) { // if branches were optimized, we may have more unreachable code // redo unreachable code elimination and if anything was dropped redo adjusting. MarkAllBlocksUnreachable(); MarkReachableBlocks(); if (!DropUnreachableBlocks()) { // nothing was dropped, we are done adjusting break; } } // Now linearize everything with computed offsets. Cci.PooledBlobBuilder writer = Cci.PooledBlobBuilder.GetInstance(); for (BasicBlock block = leaderBlock; block != null; block = block.NextBlock) { // If the block has any IL markers, we can calculate their real IL offsets now int blockFirstMarker = block.FirstILMarker; if (blockFirstMarker >= 0) { int blockLastMarker = block.LastILMarker; Debug.Assert(blockLastMarker >= blockFirstMarker); for (int i = blockFirstMarker; i <= blockLastMarker; i++) { int blockOffset = _allocatedILMarkers[i].BlockOffset; int absoluteOffset = writer.Count + blockOffset; _allocatedILMarkers[i] = new ILMarker() { BlockOffset = blockOffset, AbsoluteOffset = absoluteOffset }; } } block.RegularInstructions?.WriteContentTo(writer); switch (block.BranchCode) { case ILOpCode.Nop: break; case ILOpCode.Switch: // switch (N, t1, t2... tN) // IL ==> ILOpCode.Switch < unsigned int32 > < int32 >... < int32 > WriteOpCode(writer, ILOpCode.Switch); SwitchBlock switchBlock = (SwitchBlock)block; writer.WriteUInt32(switchBlock.BranchesCount); int switchBlockEnd = switchBlock.Start + switchBlock.TotalSize; ArrayBuilder <BasicBlock> blockBuilder = ArrayBuilder <BasicBlock> .GetInstance(); switchBlock.GetBranchBlocks(blockBuilder); foreach (BasicBlock branchBlock in blockBuilder) { writer.WriteInt32(branchBlock.Start - switchBlockEnd); } blockBuilder.Free(); break; default: WriteOpCode(writer, block.BranchCode); if (block.BranchLabel != null) { int target = block.BranchBlock.Start; int curBlockEnd = block.Start + block.TotalSize; int offset = target - curBlockEnd; if (block.BranchCode.GetBranchOperandSize() == 1) { sbyte btOffset = (sbyte)offset; Debug.Assert(btOffset == offset); writer.WriteSByte(btOffset); } else { writer.WriteInt32(offset); } } break; } } this.RealizedIL = writer.ToImmutableArray(); writer.Free(); RealizeSequencePoints(); this.RealizedExceptionHandlers = _scopeManager.GetExceptionHandlerRegions(); }
/// <summary> /// Deserializes the world blocks from an Everybody Edits world based on a <see cref="Message"/> object. /// </summary> /// <param name="m">The Message object that contains the data about the Everybody Edits world.</param> /// <param name="worldWidth">The width of the Everybody Edits world.</param> /// <param name="worldHeight">The height of the Everybody Edits world.</param> /// <returns> /// A 3-dimensional array of type <see cref="Block"/>. The first dimension represents layer, the second represents horizontal coordinate, and the third represents /// vertical coordinate. /// </returns> public static Block[,,] DeserializeBlocks(Message m, int worldWidth, int worldHeight) { if (!CanDeserializeBlocks(m)) { throw new Exception($"Can not deserialize world blocks from \"{m.Type}\" message."); } Block[,,] worldBlocks = InitalizeWorldBlocksArray(2, worldWidth, worldHeight); uint currentBlockChunk = GetWorldStart(m) + 1; while (m[currentBlockChunk] as string != EverybodyEditsMessage.WorldEnd) { int blockId = m.GetInt(currentBlockChunk); int layer = m.GetInt(currentBlockChunk + 1); byte[] xPositions = m.GetByteArray(currentBlockChunk + 2); byte[] yPositions = m.GetByteArray(currentBlockChunk + 3); uint chunkArgsRead = 4; for (int i = 0; i < xPositions.Length; i += 2) { int x = (xPositions[i] << 8) | (xPositions[i + 1]); int y = (yPositions[i] << 8) | (yPositions[i + 1]); switch (blockId) { case 77: case 83: case 1520: { int soundId = m.GetInt(currentBlockChunk + 4); worldBlocks[layer, x, y] = new MusicBlock(blockId, soundId); chunkArgsRead = 5; } break; case 113: case 184: case 185: case 467: case 1619: case 1620: case 1079: case 1080: { uint switchId = m.GetUInt(currentBlockChunk + 4); worldBlocks[layer, x, y] = new SwitchBlock(blockId, switchId); chunkArgsRead = 5; } break; case 242: case 381: { int portalId = m.GetInt(currentBlockChunk + 4); int targetId = m.GetInt(currentBlockChunk + 5); int rotationId = m.GetInt(currentBlockChunk + 6); worldBlocks[layer, x, y] = new PortalBlock(blockId, portalId, targetId, rotationId); chunkArgsRead = 7; } break; case 1582: { int spawnId = m.GetInt(currentBlockChunk + 4); worldBlocks[layer, x, y] = new WorldPortalSpawnBlock(blockId, spawnId); chunkArgsRead = 5; } break; case 374: { string targetWorldId = m.GetString(currentBlockChunk + 4); int targetSpawn = m.GetInt(currentBlockChunk + 5); worldBlocks[layer, x, y] = new WorldPortalBlock(blockId, targetWorldId, targetSpawn); chunkArgsRead = 6; } break; case 385: { string text = m.GetString(currentBlockChunk + 4); int rotationId = m.GetInt(currentBlockChunk + 5); worldBlocks[layer, x, y] = new SignBlock(blockId, text, rotationId); chunkArgsRead = 6; } break; case 417: case 418: case 419: case 420: case 423: case 453: case 461: case 1517: case 1584: { int effectId = m.GetInt(currentBlockChunk + 4); worldBlocks[layer, x, y] = new EffectBlock(blockId, effectId); chunkArgsRead = 5; } break; case 421: case 422: { int duration = m.GetInt(currentBlockChunk + 4); worldBlocks[layer, x, y] = new TimedEffectBlock(blockId, duration); chunkArgsRead = 5; } break; case 1550: case 1551: case 1552: case 1553: case 1554: case 1556: case 1557: case 1558: case 1571: case 1572: case 1573: case 1576: case 1579: { string name = m.GetString(currentBlockChunk + 4); string[] messages = { m.GetString(currentBlockChunk + 5), m.GetString(currentBlockChunk + 6), m.GetString(currentBlockChunk + 7) }; worldBlocks[layer, x, y] = new NonPlayableCharacterBlock(blockId, name, messages); chunkArgsRead = 8; } break; case 273: case 275: case 276: case 277: case 279: case 280: case 327: case 328: case 329: case 338: case 339: case 340: case 361: case 376: case 377: case 378: case 379: case 380: case 438: case 439: case 440: case 447: case 448: case 449: case 451: case 452: case 456: case 457: case 458: case 464: case 465: case 471: case 499: case 1001: case 1002: case 1003: case 1004: case 1116: case 1117: case 1118: case 1119: case 1120: case 1121: case 1122: case 1123: case 1124: case 1125: case 1041: case 1042: case 1043: case 1052: case 1053: case 1054: case 1055: case 1056: case 1092: case 1134: case 1135: case 1140: case 1141: case 1500: case 1502: case 1506: case 1507: case 1535: case 1536: case 1537: case 1538: case 1155: case 1160: case 1581: case 1587: case 1588: case 1592: case 1593: case 1594: case 1595: case 1596: case 1597: case 1605: case 1606: case 1607: case 1608: case 1609: case 1610: case 1611: case 1612: case 1613: case 1614: case 1615: case 1616: case 1617: case 1633: { int morphId = m.GetInt(currentBlockChunk + 4); worldBlocks[layer, x, y] = new MorphableBlock(blockId, morphId); chunkArgsRead = 5; } break; default: { worldBlocks[layer, x, y] = new Block(blockId); chunkArgsRead = 4; } break; } } currentBlockChunk += chunkArgsRead; } return(worldBlocks); }