internal PushedBlock PushWriteBlock(BlockKind kind, string msg, NewLineKind next)
{
PushBlock(kind);
WriteLine(msg);
WriteOpenBraceAndIndent();
return(new PushedBlock(this, next));
}
//--------------------------------------------------------------------------------------------------------
private void CreateBlocks()
{
// handle the early game using special block-creating logic
switch (turnCount)
{
case 1:
CreateFirstBlock();
return;
case 2:
CreateSecondBlock();
return;
}
int openHexCount = (from hex in hexes where hex.Occupant == null select hex).Count();
if (openHexCount == 0)
{
// how did we get here?
return;
}
// how many blocks are we supposed to create?
int newBlockCount = 1;
float d100Roll = Random.Range(0f, 100f);
if (d100Roll <= CurrentDoubleChance)
{
newBlockCount = 2;
}
else if (d100Roll <= CurrentDoubleChance + CurrentTripleChance)
{
newBlockCount = 3;
}
// if the board only has 2 or 3 hexes open, don't suddenly fill all of them and make the
// player lose - instead, make sure there's still 1 more empty hex after the drop
if (openHexCount > 1 && newBlockCount >= openHexCount)
{
newBlockCount = openHexCount - 1;
}
// create as many blocks as we need
for (int i = 0; i < newBlockCount; i++)
{
d100Roll = Random.Range(0f, 100f);
BlockKind newBlockKind = d100Roll <= CurrentWildChance ? BlockKind.WildCard : BlockKind.Normal;
openHexes = (from hex in hexes where hex.Occupant == null select hex).ToList();
newDropHex = openHexes[Random.Range(0, openHexes.Count - 1)];
CreateBlock(newDropHex, newBlockKind, 1, true);
// if the board is full and there are no moves available, end the game
if (IsBoardFullAndImmobile())
{
EnterGameOverState();
return;
}
}
}
// 対象のピースがマッチしているかの判定を行う
private bool IsMatchBlock(Block block)
{
if (block == null)
{
return(false);
}
// ピースの情報を取得
Vector2 pos = GetBlockBoardPos(block);
BlockKind kind = block.GetKind();
if (block.checkFlag)
{
return(false);
}
CheckingBlockList.Clear();
CheckingBlockList.Add(block);
var MatchCount = GetSameKindBlockNum(kind, pos) + 1;
bool deleteFlag = (MatchCount >= machingCount);
foreach (Block checkingBlock in CheckingBlockList)
{
checkingBlock.SetDeleteFlag(deleteFlag);
}
return(deleteFlag);
}
//--------------------------------------------------------------------------------------------------------
private void CreateBlock(Hex location, BlockKind kind, int level, bool celebrate)
{
if (ForceWildCardNextTurn)
{
kind = BlockKind.WildCard;
ShowWildcardTutorial(location);
ForceWildCardNextTurn = false;
}
newBlock = Instantiate(
original: BlockPrefab,
position: location.transform.position,
rotation: Quaternion.identity,
parent: SushiAnchor.transform).GetComponent <Block>();
newBlock.Initialize(location, level, kind);
location.Occupant = newBlock;
blocks.Add(newBlock);
if (celebrate)
{
Instantiate(
original: CreateCelebrationPrefab,
position: newBlock.transform.position,
rotation: Quaternion.identity,
parent: SushiAnchor.transform);
}
}
public void turnToZombie()
{
gameObject.GetComponent<SpriteRenderer>().sprite = Resources.Load<Sprite>("image/zombieBlock");
gameObject.GetComponent<Animator>().runtimeAnimatorController = Resources.Load("animation/zombieAnimation/zombieAnimator") as RuntimeAnimatorController;
kind = BlockKind.zombie;
healthBar.transform.localScale = new Vector3(1,1,1);
}
public ClassifiedSpan(SourceSpan span, SourceSpan blockSpan, SpanKind spanKind, BlockKind blockKind, AcceptedCharacters acceptedCharacters)
{
Span = span;
BlockSpan = blockSpan;
SpanKind = spanKind;
BlockKind = blockKind;
AcceptedCharacters = acceptedCharacters;
}
/*
* The helper function below checks if the kind of the current block
* matches the kind of the block requested. If it does, the current
* block is returned; if not, a new block is started.
*/
private BlockList CurrentBlock(BlockKind kind)
{
if (_blocks == null || _currentBlock.Kind != kind)
{
StartNewBlock(kind);
}
return(_currentBlock);
}
public void PushBlock(BlockKind kind = BlockKind.Unknown, object obj = null)
{
var block = new Block {
Kind = kind, Object = obj
};
block.Text.CurrentIndentation = CurrentIndentation;
block.Text.IsStartOfLine = ActiveBlock.Text.IsStartOfLine;
block.Text.NeedsNewLine = ActiveBlock.Text.NeedsNewLine;
PushBlock(block);
}
/*
### Creating a Block
###Blocks are constructed dynamically as the source file is parsed. When creating a new
###block only the kind of the block and the output format needs to be specified. Based
###on those the constructor initializes a new block and inserts a correct header to it.
###
###In markdown output whitespace is a bit more important than in HTML. That is why
###we sometimes need to add additional line breaks to the output.
*/
public BlockList(BlockKind kind, OutputFormat format)
{
Kind = kind;
_builder = new StringBuilder();
if (Kind == BlockKind.Code)
{
_builder.Append(format == OutputFormat.html ?
_htmlCodeHeader :
_mdCodeHeader + Environment.NewLine);
}
}
public CodeBlock(CodeLine line, string method, CodeStatementCollection statements, BlockKind kind, CodeBlock parent, string endLabel, string exitLabel)
{
this.line = line;
this.method = method;
this.statements = statements;
Type = BlockType.Expect;
this.kind = kind;
this.parent = parent;
level = int.MaxValue;
this.endLabel = endLabel;
this.exitLabel = exitLabel;
}
public bool HasSolidNeighbour(int x, int y, int z)
{
Block[,,] blocks;
if (x < 0 || x >= World.chunkSize ||
y < 0 || y >= World.chunkSize ||
z < 0 || z >= World.chunkSize)
{
//block in a neighbouring chunkGameObject
//Vector3 neighbourChunkPos = this.Chunk.Position +
// new Position((x - (int)this.Position.X) * World.chunkSize,
// (y - (int)this.Position.Y) * World.chunkSize,
// (z - (int)this.Position.Z) * World.chunkSize);
Position pos = new Position(x, y, z);
////block in a neighbouring chunkGameObject
Position neighbourChunkPos = this.Chunk.Position + ((pos - this.Position) * World.chunkSize);
x = World.ConvertBlockIndexToLocal(x);
y = World.ConvertBlockIndexToLocal(y);
z = World.ConvertBlockIndexToLocal(z);
if (StaticWorld.Instance.Chunks.TryGetValue(neighbourChunkPos, out Chunk nChunk))
{
blocks = nChunk.ChunkData.chunkData;
}
else
{
return(false);
}
} //block in this chunkGameObject
else
{
blocks = this.Chunk.ChunkData.chunkData;
}
try
{
BlockKind neighbourKind = blocks[x, y, z].Kind;
return(neighbourKind == BlockKind.Solid ||
(this.Kind == BlockKind.Transparent && neighbourKind == BlockKind.Transparent) ||
(this.Kind == BlockKind.Glowing && neighbourKind == BlockKind.Glowing)
);
}
catch (IndexOutOfRangeException)
{
Debug.LogWarning("sOME OUT OF RANGE IN block");
}
return(false);
}
public CodeBlock(CodeLine line, string method, CodeStatementCollection statements, BlockKind kind, CodeBlock parent, string endLabel, string exitLabel)
{
this.line = line;
this.method = method;
this.statements = statements;
Type = BlockType.Expect;
this.kind = kind;
this.parent = parent;
level = int.MaxValue;
this.endLabel = endLabel;
this.exitLabel = exitLabel;
}
/*
* The helper function below checks if the kind of the current block
* matches the kind of the block requested. If it does, the current
* block is returned; if not, a new block is started.
*
* A new block is opened also in case the `_startNewBlock` flag is set.
* When this occurs, the flag is reset back to false and a reference
* to the opened block is stored in the `_newBlock` field.
*/
private BlockList CurrentBlock(BlockKind kind)
{
if (_blocks == null || _currentBlock.Kind != kind || _startNewBlock)
{
StartNewBlock(kind);
}
if (_startNewBlock)
{
_startNewBlock = false;
_newBlock = _currentBlock;
}
return(_currentBlock);
}
/*
* Alternatively we can build a block incrementally by first creating it
* and adding text later. Starting a new block closes the previous one
* automatically, if such exists.
*/
private void StartNewBlock(BlockKind kind)
{
var result = new BlockList(kind, _options.Format);
if (_blocks == null)
{
_blocks = result;
}
else
{
_currentBlock.Next = result;
_currentBlock.Close(_options.Format);
}
_currentBlock = result;
}
//--------------------------------------------------------------------------------------------------------
public void Initialize(Hex dropHex, int startLevel, BlockKind blockKind)
{
Level = startLevel;
swipeDestHex = null;
swipeDestPos = null;
swipeDestNeko = null;
Kind = blockKind;
BlocksToEat = new List <Block>();
gameController = GameObject.Find("Game Controller").GetComponent <GameController>();
uiCanvas = GameObject.Find("UI Canvas");
name = "Block on " + dropHex.name + ", Level " + Level + " (" + Kind + ")";
UpdateDisplayImage();
RandomizeSpeed();
isInitialized = true;
}
private void SetKind(Block block)
{
// 生成するピースの種類をランダムに決める
BlockKind kind = (BlockKind)(UnityEngine.Random.Range(0, PuzzleDataV1.COLOR_MAX) % color);
block.SetKind(kind);
// お邪魔情報をセット
if (garbage != 0 && UnityEngine.Random.Range(0, 100) < GarbagePercent)
{
block.SetGarbageKind((GarbageKind)garbage);
}
else
{
block.SetGarbageKind(GarbageKind.None);
}
}
public Block(ID ID = default, src.XPos Pos = default, BlockKind Kind = default, BranchPrediction Likely = default, bool FlagsLiveAtEnd = default, slice <Edge> Succs = default, slice <Edge> Preds = default, array <ptr <Value> > Controls = default, long AuxInt = default, slice <ptr <Value> > Values = default, ref ptr <Func> Func = default, array <Edge> succstorage = default, array <Edge> predstorage = default, array <ptr <Value> > valstorage = default)
{
this.ID = ID;
this.Pos = Pos;
this.Kind = Kind;
this.Likely = Likely;
this.FlagsLiveAtEnd = FlagsLiveAtEnd;
this.Succs = Succs;
this.Preds = Preds;
this.Controls = Controls;
this.AuxInt = AuxInt;
this.Values = Values;
this.Func = Func;
this.succstorage = succstorage;
this.predstorage = predstorage;
this.valstorage = valstorage;
}
// 対象の方向に引数で指定したの種類のピースがいくつあるかを返す
private int GetSameKindBlockNum(BlockKind kind, Vector2 blockPos)
{
if (ExistBlock(blockPos) == false)
{
return(0);
}
Block block = board[(int)blockPos.x, (int)blockPos.y];
if (block.checkFlag)
{
return(0);
}
block.checkFlag = true;
if (block.IsLink() == false)
{
return(0);
}
var count = 0;
Action <Vector2> ProcNextPos = (nextPos) =>
{
if (ExistBlock(nextPos))
{
Block nextBlock = board[(int)nextPos.x, (int)nextPos.y];
BlockKind nextKind = nextBlock.GetKind();
if (nextBlock.IsLink() == true && nextKind == kind && nextBlock.checkFlag == false)
{
CheckingBlockList.Add(nextBlock);
count++;
count += GetSameKindBlockNum(nextKind, nextPos);
}
}
};
ProcNextPos(blockPos + Vector2.up);
ProcNextPos(blockPos + Vector2.right);
ProcNextPos(blockPos + Vector2.down);
ProcNextPos(blockPos + Vector2.left);
return(count);
}
private void DrawBlock(MouseEventArgs e)
{
if (e.Button == MouseButtons.Left)
{
IterateBlocks((x, y) =>
{
Rectangle blockRectangle = CalculateBlockRectangle(x, y);
if (blockRectangle.Contains(e.Location))
{
BlockKind oldKind = _puzzleBlocks[x, y];
if (oldKind != EditBlockKind)
{
_puzzleBlocks[x, y] = EditBlockKind;
Invalidate();
}
}
});
}
}
private void SetLinkDirection(Block block)
{
if (block == null)
{
return;
}
// Tween中はLinkしない
if (block.IsLink() == false)
{
block.SetLinkDirection((int)LinkDirection.None);
return;
}
// ピースの情報を取得
Vector2 blockPos = GetBlockBoardPos(block);
BlockKind kind = block.GetKind();
int linkDirection = (int)LinkDirection.None;
Action <Vector2, int> AddLinkDirection = (nextPos, add) =>
{
if (ExistBlock(nextPos))
{
Block nextBlock = board[(int)nextPos.x, (int)nextPos.y];
if (nextBlock.IsLink() && nextBlock.GetKind() == kind)
{
linkDirection += add;
}
}
};
AddLinkDirection(blockPos + Vector2.up, (int)LinkDirection.Up);
AddLinkDirection(blockPos + Vector2.right, (int)LinkDirection.Right);
AddLinkDirection(blockPos + Vector2.down, (int)LinkDirection.Down);
AddLinkDirection(blockPos + Vector2.left, (int)LinkDirection.Left);
block.SetLinkDirection(linkDirection);
}
private SnapshotSpan GetBlockSpan(BlockKind blockKind, SnapshotPoint point)
{
var option = _motionUtil.GetBlock(blockKind, point);
Assert.True(option.IsSome());
var tuple = option.Value;
return new SnapshotSpan(tuple.Item1, tuple.Item2.Add(1));
}
/*
### Creating a Block
###Blocks are constructed dynamically as the source file is parsed. When creating a new
###block only the kind of the block and the output format needs to be specified. Based
###on those the constructor initializes a new block and inserts a correct header to it.
###
###In markdown output whitespace is a bit more important than in HTML. That is why
###we sometimes need to add additional line breaks to the output.
*/
public BlockList(BlockKind kind, OutputFormat format)
{
Kind = kind;
_builder = new StringBuilder();
}
public void initBlock(BlockKind blockKind)
{
switch (blockKind)
{
//META
case BlockKind.STARTHERE:
keyword = new GolLangKeyword(GKeyword.STARTHERE);
this.blockKind = blockKind;
break;
//Control
case BlockKind.FOR:
keyword = new GolLangKeyword(GKeyword.FOR);
this.blockKind = blockKind;
break;
case BlockKind.IF:
keyword = new GolLangKeyword(GKeyword.IF);
this.blockKind = blockKind;
break;
case BlockKind.ELIF:
keyword = new GolLangKeyword(GKeyword.ELIF);
this.blockKind = blockKind;
break;
case BlockKind.ELSE:
keyword = new GolLangKeyword(GKeyword.ELSE);
this.blockKind = blockKind;
break;
//Int and Bool Compare
case BlockKind.EQ:
keyword = new GolLangKeyword(GKeyword.EQ);
this.blockKind = blockKind;
break;
case BlockKind.NEQ:
keyword = new GolLangKeyword(GKeyword.NEQ);
this.blockKind = blockKind;
break;
//Int only Compare
case BlockKind.GT:
keyword = new GolLangKeyword(GKeyword.GT);
this.blockKind = blockKind;
break;
case BlockKind.LT:
keyword = new GolLangKeyword(GKeyword.LT);
this.blockKind = blockKind;
break;
case BlockKind.GE:
keyword = new GolLangKeyword(GKeyword.GE);
this.blockKind = blockKind;
break;
case BlockKind.LE:
keyword = new GolLangKeyword(GKeyword.LE);
this.blockKind = blockKind;
break;
//Calculate
case BlockKind.PLUS:
keyword = new GolLangKeyword(GKeyword.PLUS);
this.blockKind = blockKind;
break;
case BlockKind.MINUS:
keyword = new GolLangKeyword(GKeyword.MINUS);
this.blockKind = blockKind;
break;
case BlockKind.MUL:
keyword = new GolLangKeyword(GKeyword.MUL);
this.blockKind = blockKind;
break;
case BlockKind.DIV:
keyword = new GolLangKeyword(GKeyword.DIV);
this.blockKind = blockKind;
break;
case BlockKind.MOD:
keyword = new GolLangKeyword(GKeyword.MOD);
this.blockKind = blockKind;
break;
//Negative Num
case BlockKind.NEG:
keyword = new GolLangKeyword(GKeyword.NEG);
this.blockKind = blockKind;
break;
//Logical
case BlockKind.AND:
keyword = new GolLangKeyword(GKeyword.AND);
this.blockKind = blockKind;
break;
case BlockKind.OR:
keyword = new GolLangKeyword(GKeyword.OR);
this.blockKind = blockKind;
break;
case BlockKind.NOT:
keyword = new GolLangKeyword(GKeyword.NOT);
this.blockKind = blockKind;
break;
//Bracket
case BlockKind.BOP:
keyword = new GolLangKeyword(GKeyword.BOP);
this.blockKind = blockKind;
break;
case BlockKind.BCL:
keyword = new GolLangKeyword(GKeyword.BCL);
this.blockKind = blockKind;
break;
//Assignment
case BlockKind.ASS:
keyword = new GolLangKeyword(GKeyword.ASS);
this.blockKind = blockKind;
break;
//ETC
case BlockKind.COMMA:
keyword = new GolLangKeyword(GKeyword.COMMA);
this.blockKind = blockKind;
break;
//Const Int
case BlockKind.CONSTI_0:
keyword = new GolLangKeyword(GKeyword.CONSTI, "0");
this.blockKind = blockKind;
break;
case BlockKind.CONSTI_1:
keyword = new GolLangKeyword(GKeyword.CONSTI, "1");
this.blockKind = blockKind;
break;
case BlockKind.CONSTI_2:
keyword = new GolLangKeyword(GKeyword.CONSTI, "2");
this.blockKind = blockKind;
break;
case BlockKind.CONSTI_3:
keyword = new GolLangKeyword(GKeyword.CONSTI, "3");
this.blockKind = blockKind;
break;
case BlockKind.CONSTI_4:
keyword = new GolLangKeyword(GKeyword.CONSTI, "4");
this.blockKind = blockKind;
break;
case BlockKind.CONSTI_5:
keyword = new GolLangKeyword(GKeyword.CONSTI, "5");
this.blockKind = blockKind;
break;
case BlockKind.CONSTI_6:
keyword = new GolLangKeyword(GKeyword.CONSTI, "6");
this.blockKind = blockKind;
break;
case BlockKind.CONSTI_7:
keyword = new GolLangKeyword(GKeyword.CONSTI, "7");
this.blockKind = blockKind;
break;
case BlockKind.CONSTI_8:
keyword = new GolLangKeyword(GKeyword.CONSTI, "8");
this.blockKind = blockKind;
break;
case BlockKind.CONSTI_9:
keyword = new GolLangKeyword(GKeyword.CONSTI, "9");
this.blockKind = blockKind;
break;
//Const Bool
case BlockKind.CONSTB_TRUE:
keyword = new GolLangKeyword(GKeyword.CONSTB, "1");
this.blockKind = blockKind;
break;
case BlockKind.CONSTB_FALSE:
keyword = new GolLangKeyword(GKeyword.CONSTB, "0");
this.blockKind = blockKind;
break;
//Int Variable
case BlockKind.VARI_a:
keyword = new GolLangKeyword(GKeyword.VARI, "a");
this.blockKind = blockKind;
break;
case BlockKind.VARI_b:
keyword = new GolLangKeyword(GKeyword.VARI, "b");
this.blockKind = blockKind;
break;
case BlockKind.VARI_c:
keyword = new GolLangKeyword(GKeyword.VARI, "c");
this.blockKind = blockKind;
break;
case BlockKind.VARI_i:
keyword = new GolLangKeyword(GKeyword.VARI, "i");
this.blockKind = blockKind;
break;
case BlockKind.VARI_j:
keyword = new GolLangKeyword(GKeyword.VARI, "j");
this.blockKind = blockKind;
break;
case BlockKind.VARI_k:
keyword = new GolLangKeyword(GKeyword.VARI, "k");
this.blockKind = blockKind;
break;
//Bool Variable
case BlockKind.VARB_w:
keyword = new GolLangKeyword(GKeyword.VARB, "w");
this.blockKind = blockKind;
break;
case BlockKind.VARB_x:
keyword = new GolLangKeyword(GKeyword.VARB, "x");
this.blockKind = blockKind;
break;
case BlockKind.VARB_y:
keyword = new GolLangKeyword(GKeyword.VARB, "y");
this.blockKind = blockKind;
break;
case BlockKind.VARB_z:
keyword = new GolLangKeyword(GKeyword.VARB, "z");
this.blockKind = blockKind;
break;
//Function
case BlockKind.FUNC_MELEEATTACK:
keyword = new GolLangKeyword(GKeyword.FUNC, "MeleeAttack");
this.blockKind = blockKind;
break;
case BlockKind.FUNC_RANGEATTACK:
keyword = new GolLangKeyword(GKeyword.FUNC, "RangeAttack");
this.blockKind = blockKind;
break;
case BlockKind.FUNC_OBSERVE:
keyword = new GolLangKeyword(GKeyword.FUNC, "Observe");
this.blockKind = blockKind;
break;
case BlockKind.FUNC_DEFENCE:
keyword = new GolLangKeyword(GKeyword.FUNC, "Defence");
this.blockKind = blockKind;
break;
case BlockKind.FUNC_ENERGYCHARGE:
keyword = new GolLangKeyword(GKeyword.FUNC, "EnergyCharge");
this.blockKind = blockKind;
break;
case BlockKind.FUNC_BREAKSHIELD:
keyword = new GolLangKeyword(GKeyword.FUNC, "BreakShield");
this.blockKind = blockKind;
break;
case BlockKind.FUNC_REPAIR:
keyword = new GolLangKeyword(GKeyword.FUNC, "Repair");
this.blockKind = blockKind;
break;
case BlockKind.FUNC_GOLEMENERGY:
keyword = new GolLangKeyword(GKeyword.FUNC, "GolemEnergy");
this.blockKind = blockKind;
break;
}
}
public void Remove()
{
Kind = BlockKind.NULL;
coord = new Coord(-1, -1);
gameObject.SetActive(false);
}
public void turnToNormal()
{
gameObject.GetComponent<SpriteRenderer>().sprite = Resources.Load<Sprite>("image/humanBlock");
gameObject.GetComponent<Animator>().runtimeAnimatorController = Resources.Load("animation/defaultAnimation/defaultAnimator") as RuntimeAnimatorController;
kind = BlockKind.normal;
}
public Block(BlockKind blockType, int from, int to)
{
Kind = blockType;
From = from;
To = to;
}
private List <Block> ExplodeTrigger(Coord[] coord)
{
//폭발 조건
List <Block> explodelist = new List <Block>();
int[] mxcount = new int[coord.Length], pxcount = new int[coord.Length];
int[] mycount = new int[coord.Length], pycount = new int[coord.Length];
for (int i = 0; i < coord.Length; i++)
{
if (batchedblocks[coord[i].x, coord[i].y] == null)
{
continue;
}
BlockKind kind = batchedblocks[coord[i].x, coord[i].y].Kind;
int mx = coord[i].x - 1;
while (mx >= 0 && mx < game.size.x)
{
if (batchedblocks[mx, coord[i].y] == null)
{
break;
}
if (batchedblocks[mx, coord[i].y].Kind.Equals(kind) &&
!kind.Equals(BlockKind.WALL))
{
mx--;
mxcount[i]++;
}
else
{
break;
}
}
int px = coord[i].x + 1;
while (px >= 0 && px < game.size.x)
{
if (batchedblocks[px, coord[i].y] == null)
{
break;
}
if (batchedblocks[px, coord[i].y].Kind.Equals(kind) &&
!kind.Equals(BlockKind.WALL))
{
px++;
pxcount[i]++;
}
else
{
break;
}
}
int my = coord[i].y - 1;
while (my >= 0 && my < game.size.y)
{
if (batchedblocks[coord[i].x, my] == null)
{
break;
}
if (batchedblocks[coord[i].x, my].Kind.Equals(kind) &&
!kind.Equals(BlockKind.WALL))
{
my--;
mycount[i]++;
}
else
{
break;
}
}
int py = coord[i].y + 1;
while (py >= 0 && py < game.size.y)
{
if (batchedblocks[coord[i].x, py] == null)
{
break;
}
if (batchedblocks[coord[i].x, py].Kind.Equals(kind) &&
!kind.Equals(BlockKind.WALL))
{
py++;
pycount[i]++;
}
else
{
break;
}
}
}
for (int i = 0; i < coord.Length; i++)
{
if (mxcount[i] + 1 + pxcount[i] >= 3)
{
ExplodeListAdd(coord[i], 0, 0, ref explodelist);
for (int j = 1; j <= mxcount[i]; j++)
{
ExplodeListAdd(coord[i], -j, 0, ref explodelist);
}
for (int j = 1; j <= pxcount[i]; j++)
{
ExplodeListAdd(coord[i], j, 0, ref explodelist);
}
}
if (mycount[i] + 1 + pycount[i] >= 3)
{
ExplodeListAdd(coord[i], 0, 0, ref explodelist);
for (int j = 1; j <= mycount[i]; j++)
{
ExplodeListAdd(coord[i], 0, -j, ref explodelist);
}
for (int j = 1; j <= pycount[i]; j++)
{
ExplodeListAdd(coord[i], 0, j, ref explodelist);
}
}
}
if (explodelist.Count > 0)
{
return(explodelist);
}
else
{
return(null);
}
}
public Block FindBlock(BlockKind kind)
{
return(FindBlocks(kind).SingleOrDefault());
}
public CodeBlock(CodeLine line, string method, CodeStatementCollection statements, BlockKind kind, CodeBlock parent)
: this(line, method, statements, kind, parent, null, null)
{
}
public void OnValueChanged(int result)
{
Dropdown objectDropdown = GameObject.Find("ObjectDropdown").GetComponent <Dropdown>();
bool writeBlock = true;
BlockKind blockKind = BlockKind.Red;
GarbageKind garbageKind = GarbageKind.None;
switch (objectDropdown.value)
{
case 0:
writeBlock = false;
break;
case 1:
blockKind = BlockKind.Red;
break;
case 2:
blockKind = BlockKind.Blue;
break;
case 3:
blockKind = BlockKind.Green;
break;
case 4:
blockKind = BlockKind.Yellow;
break;
case 5:
blockKind = BlockKind.Purple;
break;
case 6:
garbageKind = GarbageKind.Garbage;
break;
case 7:
garbageKind = GarbageKind.Hard;
break;
case 8:
blockKind = BlockKind.Red;
garbageKind = GarbageKind.Dark;
break;
case 9:
blockKind = BlockKind.Blue;
garbageKind = GarbageKind.Dark;
break;
case 10:
blockKind = BlockKind.Green;
garbageKind = GarbageKind.Dark;
break;
case 11:
blockKind = BlockKind.Yellow;
garbageKind = GarbageKind.Dark;
break;
case 12:
blockKind = BlockKind.Purple;
garbageKind = GarbageKind.Dark;
break;
}
PuzzleController puzzleController = GameObject.Find("PuzzleController").GetComponent <PuzzleController>();
puzzleController.writeBlock = writeBlock;
puzzleController.writeBlockKind = blockKind;
puzzleController.writeGarbageKind = garbageKind;
}
public CodeBlock(CodeLine line, string method, CodeStatementCollection statements, BlockKind kind, CodeBlock parent)
: this(line, method, statements, kind, parent, null, null)
{
}
//-------------------------------------------------------
// Public Function
//-------------------------------------------------------
public void SetKind(BlockKind blockKind)
{
kind = blockKind;
SetImage();
}
public XmlElement NewBlock(BlockKind kind)
{
string tag = null;
switch (kind) {
case BlockKind.Paragraph:
tag = "p";
break;
case BlockKind.Quotation:
tag = "blockquote";
break;
case BlockKind.Footnote:
tag = "note";
break;
case BlockKind.Separator:
tag = "hr";
break;
case BlockKind.Literal:
case BlockKind.Verse:
tag = "pre";
break;
case BlockKind.ListItem:
tag = "li";
break;
case BlockKind.EnumeratedList:
tag = "ol";
break;
case BlockKind.ItemizedList:
tag = "ul";
break;
case BlockKind.DefinitionList:
tag = "dl";
break;
case BlockKind.DefinitionTag:
tag = "dt";
break;
case BlockKind.DefinitionItem:
tag = "dd";
break;
case BlockKind.Section:
tag = "sect";
break;
default:
return null;
}
return CreateElement(tag);
}
public void BlockSet(BlockKind _kind, Coord _coord)
{
Kind = _kind;
coord = _coord;
transform.position = new Vector2(coord.x, coord.y);
}
public Block(BlockKind kind = BlockKind.ControlFlow) : base(OpCode.Block)
{
this.Kind = kind;
this.Instructions = new InstructionCollection <ILInstruction>(this, 0);
this.FinalInstruction = new Nop();
}
public void turnToKind(BlockKind kind)
{
}
public IEnumerable <Block> FindBlocks(BlockKind kind)
{
return(RootBlock.FindBlocks(kind));
}
public pStatus Parse(string line, int linenumber)
{
bool finishInternal = false;
bool doEsle = false;
if (nested != null)
{
pStatus stat= nested.Parse(line, linenumber);
if (stat==pStatus.Working || stat == pStatus.SyntaxError)
{
return stat;
}
else if (stat == pStatus.Finished)
{
finishInternal = true;
}
}
else
{
//short f=0;
}
int part = indent.doIndentation(line);
if (part < 0)
{
return pStatus.Finished;
}
string shortString = line.Trim(StringUtil.whitespace);
if (finishInternal)
{
CodeBlock b = nested.getBlock();
doEsle = elseMatcher.match(shortString);
if (doEsle)
{
shortString = elseMatcher.getArgs()["condition"];
if (shortString.StartsWith(" "))
{
shortString = shortString.Substring(1);
}
}
if (lastBlockKind == BlockKind.Condition)
{
if (doEsle)
{
b.add(new Opcode(opcodeType.jump, new ArgumentValue(addressMode.constint, substitutionType.EndIf, ClassDatabase.integer)));
}
}
else
{
b.add(new Opcode(opcodeType.jump, new ArgumentValue(addressMode.constint, substitutionType.BlockStart, ClassDatabase.integer)));
}
internalBlock.add(b);
nested = null;
if (!doEsle)
{
block.add(internalBlock);
internalBlock = null;
}
else
{
}
}
if (parseParts.Count > 0)
{
parseParts.Clear();
}
if (localVariableMathcer.match(shortString))
{
Dictionary<string, string> args = localVariableMathcer.getArgs();
if (locals.ContainsKey(args["name"]))
{
ArgumentValue argva = EvalExpression(args["expression"]);
LocalVariable lvar = locals[args["name"]];
if (lvar.kind.isParent(argva.getKind()))
{
block.add(Phrase.assign.toSubstituedPhrase(new[] { argva, new ArgumentValue(addressMode.frameint, getFramePos(lvar.index)) },
null));
}
indent.expect(false, true, true);
}
else
{
ArgumentValue k = EvalExpression(args["expression"]);
block.add(Phrase.assign.toSubstituedPhrase(new[] { k,
new ArgumentValue(addressMode.frameint, getFramePos(locals.Count)),
}, null));
locals.Add(args["name"], new LocalVariable(locals.Count, k.getKind()));
indent.expect(false, true, true);
}
}
else if (ifMatcher.match(shortString))
{
lastBlockKind = BlockKind.Condition;
setUpCondition(ifMatcher.getArgs()["condition"]);
}
else if (whileMatcher.match(shortString))
{
lastBlockKind = BlockKind.Loop;
setUpCondition(whileMatcher.getArgs()["condition"]);
}
else if (doEsle && shortString == ":")
{
setUpCondition();
}
else if (doEsle)
{
throw new Errors.SyntaxError("else without a valid condition");
}
else
{
EvalExpression(shortString, false);
indent.expect(false, true, true);
}
return pStatus.Working;
}
