public void swapBlock(BlockControl block0, Block.DIR4 dir, BlockControl block1)
{
Block.COLOR color0 = block0.color;
Block.COLOR color1 = block1.color;
Vector3 scale0 = block0.transform.localScale;
Vector3 scale1 = block1.transform.localScale;
float vanish_timer0 = block0.vanish_timer;
float vanish_timer1 = block1.vanish_timer;
Vector3 offset0 = BlockRoot.getDirVector(dir);
Vector3 offset1 = BlockRoot.getDirVector(BlockRoot.getOppositeDir(dir));
block0.setColor(color1);
block1.setColor(color0);
block0.transform.localScale = scale1;
block1.transform.localScale = scale0;
block0.vanish_timer = vanish_timer1;
block1.vanish_timer = vanish_timer0;
block0.beginSlide(offset0);
block1.beginSlide(offset1);
}
private void OnTriggerEnter2D(Collider2D collider)
{
if (layer == 0 && GC > 0 && curMask.Equals("Goat") && (collider.CompareTag("Wall") || collider.CompareTag("Block")))
{
layer += 1;
GC -= 1;
}
if (collider.CompareTag("Floor") || collider.CompareTag("Exit"))
{
return;
}
else if (layer == 0 && collider.CompareTag("Block") && curMask.Equals("Bull") && BC > 0)
{
blockScript = collider.GetComponent <BlockControl>();
blockScript.Push(direction);
BC -= 1;
}
else if (layer == 0)
{
transform.Translate(reverse);
if (curMask.Equals("Hawk"))
{
HC += 1;
}
}
}
public BlockControl getNextBlock(
BlockControl block, Block.DIR4 dir)
{
// スライド先のブロックをここに格納.
BlockControl next_block = null;
switch(dir) {
case Block.DIR4.RIGHT:
if(block.i_pos.x < Block.BLOCK_NUM_X - 1) {
// グリッド内なら.
next_block = this.blocks[block.i_pos.x + 1, block.i_pos.y];
}
break;
case Block.DIR4.LEFT:
if(block.i_pos.x > 0) { // グリッド内なら.
next_block = this.blocks[block.i_pos.x - 1, block.i_pos.y];
}
break;
case Block.DIR4.UP:
if(block.i_pos.y < Block.BLOCK_NUM_Y - 1) { // グリッド内なら.
next_block = this.blocks[block.i_pos.x, block.i_pos.y + 1];
}
break;
case Block.DIR4.DOWN:
if(block.i_pos.y > 0) { // グリッド内なら.
next_block = this.blocks[block.i_pos.x, block.i_pos.y - 1];
}
break;
}
return(next_block);
}
public BlockControl getNextBlock(
BlockControl block, Block.DIR4 dir)
{
// 슬라이드할 곳의 블록을 여기에 저장.
BlockControl next_block = null;
switch(dir) {
case Block.DIR4.RIGHT:
if(block.i_pos.x < Block.BLOCK_NUM_X - 1) {
// 그리드 안이라면.
next_block = this.blocks[block.i_pos.x + 1, block.i_pos.y];
}
break;
case Block.DIR4.LEFT:
if(block.i_pos.x > 0) { // 그리드 안이라면.
next_block = this.blocks[block.i_pos.x - 1, block.i_pos.y];
}
break;
case Block.DIR4.UP:
if(block.i_pos.y < Block.BLOCK_NUM_Y - 1) { // 그리드 안이라면.
next_block = this.blocks[block.i_pos.x, block.i_pos.y + 1];
}
break;
case Block.DIR4.DOWN:
if(block.i_pos.y > 0) { // 그리드 안이라면.
next_block = this.blocks[block.i_pos.x, block.i_pos.y - 1];
}
break;
}
return(next_block);
}
// 블록을 만들어 내고 가로 9칸, 세로 9칸에 배치한다.
public void initialSetUp()
{
this.blocks = new BlockControl[Block.BLOCK_NUM_X, Block.BLOCK_NUM_Y]; // 그리드의 크기를 9×9로 한다.
int color_index = 0; // 블록의 색 번호.
Block.COLOR color = Block.COLOR.FIRST;
for (int y = 0; y < Block.BLOCK_NUM_Y; y++)
{ // 처음~마지막행
for (int x = 0; x < Block.BLOCK_NUM_X; x++)
{ // 왼쪽~오른쪽
// BlockPrefab의 인스턴스를 씬에 만든다.
GameObject game_object = Instantiate(this.BlockPrefab) as GameObject;
BlockControl block = game_object.GetComponent <BlockControl>(); // 블록의 BlockControl 클래스를 가져온다.
this.blocks[x, y] = block; // 블록을 그리드에 저장한다.
block.i_pos.x = x; // 블록의 위치 정보(그리드 좌표)를 설정한다.
block.i_pos.y = y;
block.block_root = this; // 각 BlockControl이 연계할 GameRoot는 자신이라고 설정한다.
Vector3 position = BlockRoot.calcBlockPosition(block.i_pos); // 그리드 좌표를 실제 위치(씬의 좌표)로 변환
block.transform.position = position; // 씬의 블록 위치를 이동한다.
block.setColor((Block.COLOR)color_index); // 블록의 색을 변경한다.
// 블록의 이름을 설정(후술)한다. 나중에 블록 정보 확인때 필요.
// block.setColor((Block.COLOR)color_index); // 주석처리혹은삭제한다.
// 현재출현확률을바탕으로색을결정한다.
color = this.selectBlockColor();
block.setColor(color);
block.name = "block(" + block.i_pos.x.ToString() + "," + block.i_pos.y.ToString() + ")";
// 전체 색 중에서 임의로 하나의 색을 선택한다.
color_index = Random.Range(0, (int)Block.COLOR.NORMAL_COLOR_NUM);
}
}
}
/// <summary>
/// Add a block with given parameters.
/// </summary>
public void AddBlock(string label, string documentPath, double xPos,
double yPos, double height, double width, int zIndex, int blockId, bool setActive)
{
UndoManager.Instance.SaveState();
BlockControl newBlock = new BlockControl(label, documentPath, blockId);
newBlock.Width = width;
newBlock.Height = height;
newBlock.Position(new Thickness(xPos, yPos, 0, 0));
Panel.SetZIndex(newBlock, zIndex);
if (zIndex > topmostZIndex)
{
topmostZIndex = zIndex;
}
if (blockId > currentBlockId)
{
currentBlockId = blockId;
}
blockList.Add(newBlock);
if (setActive)
{
SetActiveBlock(newBlock);
}
VirtualSpaceControl.Instance.InsertBlock(newBlock);
}
public void beginFall(BlockControl start)
{
this.next_step = Block.STEP.FALL;
// 지정된 블록에서 좌표를 계산해 낸다.
this.position_offset.y =
(float)(start.i_pos.y - this.i_pos.y) * Block.COLLISION_SIZE;
}
public void initialSetUp()
{
this.blocks = new BlockControl[Block.BLOCK_NUM_X, Block.BLOCK_NUM_Y];
int color_index = 0;
for (int y = 0; y < Block.BLOCK_NUM_Y; y++)
{
for (int x = 0; x < Block.BLOCK_NUM_X; x++)
{
GameObject game_object = Instantiate(this.BlockPrefab) as GameObject;
BlockControl block = game_object.GetComponent <BlockControl>();
this.blocks[x, y] = block;
block.i_pos.x = x;
block.i_pos.y = y;
block.block_root = this;
Vector3 position = BlockRoot.calcBlockPosition(block.i_pos);
block.transform.position = position;
block.setColor((Block.COLOR)color_index);
block.name = "block(" + block.i_pos.x.ToString() + "," + block.i_pos.y.ToString() + ")";
color_index = Random.Range(0, (int)Block.COLOR.NORMAL_COLOR_NUM);
}
}
}
// ================================================================ //
// 블록을 떨어뜨린다.
public void fallBlock(BlockControl block0, Block.DIR4 dir, BlockControl block1)
{
// 낙하시킬 블록이 잡는 중이라면 놓는다.
if (this.grabbed_block == block0 || this.grabbed_block == block1)
{
this.hideArrow();
this.grabbed_block = null;
}
//
Block.COLOR color0 = block0.color;
Block.COLOR color1 = block1.color;
Vector3 scale0 = block0.transform.localScale;
Vector3 scale1 = block1.transform.localScale;
float vanish_timer0 = block0.vanish_timer;
float vanish_timer1 = block1.vanish_timer;
bool visible0 = block0.isVisible();
bool visible1 = block1.isVisible();
Block.STEP step0 = block0.step;
Block.STEP step1 = block1.step;
float frame0 = 0.0f;
float frame1 = 0.0f;
if (color1 == Block.COLOR.NECO)
{
frame0 = block0.getNekoMotion()["00_Idle"].time;
frame1 = block1.getNekoMotion()["00_Idle"].time;
}
//
block0.setColor(color1);
block1.setColor(color0);
block0.transform.localScale = scale1;
block1.transform.localScale = scale0;
block0.vanish_timer = vanish_timer1;
block1.vanish_timer = vanish_timer0;
block0.setVisible(visible1);
block1.setVisible(visible0);
block0.step = step1;
block1.step = step0;
if (color1 == Block.COLOR.NECO)
{
block0.getNekoMotion()["00_Idle"].time = frame1;
block1.getNekoMotion()["00_Idle"].time = frame0;
}
block0.beginFall(block1);
}
public void swapBlock(BlockControl block0, Block.DIR4 dir, BlockControl block1)
{
// 각각의 블록 패턴을 기억해 둔다.
Block.PATTERN color0 = block0.pattern;
Block.PATTERN color1 = block1.pattern;
// 각각의 블록 숫자를 기억해 둔다.
Block.NUMBER number0 = block0.num;
Block.NUMBER number1 = block1.num;
// 각각의 블록의 확대율을 기억해 둔다.
Vector3 scale0 = block0.transform.localScale;
Vector3 scale1 = block1.transform.localScale;
// 각각의 블록의 '사라지는 시간'을 기억해 둔다.
float vanish_timer0 = block0.vanish_timer;
float vanish_timer1 = block1.vanish_timer;
// 각각의 블록의 이동할 곳을 구한다.
Vector3 offset0 = BlockRoot.getDirVector(dir);
Vector3 offset1 = BlockRoot.getDirVector(BlockRoot.getOppositDir(dir));
// 패턴을 교체한다.
block0.setColor(color1);
block1.setColor(color0);
// 숫자를 교체한다.
block0.setNumber(number1);
block1.setNumber(number0);
// 확대율을 교체한다.
block0.transform.localScale = scale1;
block1.transform.localScale = scale0;
// '사라지는 시간'을 교체한다.
block0.vanish_timer = vanish_timer1;
block1.vanish_timer = vanish_timer0;
block0.beginSlide(offset0); // 원래 블록 이동을 시작한다.
block1.beginSlide(offset1); // 이동할 위치의 블록 이동을 시작한다.
}
private void Block_BlockMoved(BlockControl block, bool up)
{
var controlIndex = _flow.Controls.IndexOf(block);
if (up)
{
// Topmost is index 1, second is index 3, etc. because of the dividers in between each one..
if (controlIndex >= 3)
{
var partner = _flow.Controls[controlIndex - 2];
_flow.Controls.SetChildIndex(block, controlIndex - 2);
_flow.Controls.SetChildIndex(partner, controlIndex);
}
}
else
{
var lastControlIndex = _flow.Controls.Count - 2; // skip the last divider
if (controlIndex < lastControlIndex)
{
var partner = _flow.Controls[controlIndex + 2];
_flow.Controls.SetChildIndex(partner, controlIndex);
_flow.Controls.SetChildIndex(block, controlIndex + 2);
}
}
}
public void swapBlock(BlockControl block0, Block.DIR4 dir, BlockControl block1)
{
// 각각의 블록 색을 기억해둔다
Block.COLOR color0 = block0.color;
Block.COLOR color1 = block1.color;
// 각각의 블록의 확대율을 기억해둔다
Vector3 scale0 = block0.transform.localScale;
Vector3 scale1 = block1.transform.localScale;
// 각각의 블록의 사라지는 시간을 기억해둔다
float vanish_timer0 = block0.vanish_timer;
float vanish_timer1 = block1.vanish_timer;
// 각각의 블록의 이동할 곳을 구한다
Vector3 offset0 = BlockRoot.getDirVector(dir);
Vector3 offset1 = BlockRoot.getDirVector(BlockRoot.getOppositDir(dir));
// 색을 교체한다
block0.SetColor(color1);
block1.SetColor(color0);
// 확대율 교체
block0.transform.localScale = scale1;
block1.transform.localScale = scale0;
// 사라지는 시간 교체
block0.vanish_timer = vanish_timer1;
block1.vanish_timer = vanish_timer0;
block0.beginSlide(offset0); // 원래 블록 이동 시작
block1.beginSlide(offset1); // 이동할 위치의 블록 이동을 시작
}
public static void MoveAllBlocksDown()
{
foreach (Block b in BlockControl.GetAllBlocks())
{
if (b != null)
{
if (b.GetComponent <Collider2D>() != null && !b.GetBlockTag.Equals("selector"))
{
b.CheckIsBlockOnBottom();
if (!b.IsBlockOnBottom)
{
blocksMovedDown = false;
break;
}
else
{
blocksMovedDown = true;
}
}
}
}
if (blocksMovedDown)
{
DestroyBlocks();
}
}
public void swapBlock(BlockControl block0, Block.DIR4 dir, BlockControl block1)
{
// それぞれのブロックの色を覚えておく
Block.COLOR color0 = block0.color;
Block.COLOR color1 = block1.color;
// それぞれのブロックの拡大率を覚えておく
Vector3 scale0 = block0.transform.localScale;
Vector3 scale1 = block1.transform.localScale;
// それぞれのブロックの「消える時間」を覚えておく
float vanish_timer0 = block0.vanish_timer;
float vanish_timer1 = block1.vanish_timer;
// それぞれのブロックの移動先を求める
Vector3 offset0 = BlockRoot.getDirVector(dir);
Vector3 offset1 = BlockRoot.getDirVector(BlockRoot.getOppositDir(dir));
// 色を入れ替える
block0.setColor(color1);
block1.setColor(color0);
// 拡大率を入れ替える
block0.transform.localScale = scale1;
block1.transform.localScale = scale0;
// 「消える時間」を入れ替える
block0.vanish_timer = vanish_timer1;
block1.vanish_timer = vanish_timer0;
block0.beginSlide(offset0); // 元のブロックの移動を開始
block1.beginSlide(offset1); // 元のブロックの移動を開始
}
public void fallBlock(BlockControl block0, Block.DIR4 dir, BlockControl block1)
{
// block0과 block1의 색, 크기, 사라질 때까지 걸리는 시간, 표시, 비표시, 상태를 기록.
Block.COLOR color0 = block0.color;
Block.COLOR color1 = block1.color;
Vector3 scale0 = block0.transform.localScale;
Vector3 scale1 = block1.transform.localScale;
float vanish_timer0 = block0.vanish_timer;
float vanish_timer1 = block1.vanish_timer;
bool visible0 = block0.isVisible();
bool visible1 = block1.isVisible();
Block.STEP step0 = block0.step;
Block.STEP step1 = block1.step;
// block0과 block1의 각종 속성을 교체한다.
block0.SetColor(color1);
block1.SetColor(color0);
block0.transform.localScale = scale1;
block1.transform.localScale = scale0;
block0.vanish_timer = vanish_timer1;
block1.vanish_timer = vanish_timer0;
block0.setVisible(visible1);
block1.setVisible(visible0);
block0.step = step1;
block1.step = step0;
block0.beginFall(block1);
}
public void fallBlock(BlockControl block0, Block.DIR4 dir, BlockControl block1)
{
// block0とblock1の色、サイズ、消えるまでの時間、表示・非表示、状態を記録
Block.COLOR color0 = block0.color;
Block.COLOR color1 = block1.color;
Vector3 scale0 = block0.transform.localScale;
Vector3 scale1 = block1.transform.localScale;
float vanish_timer0 = block0.vanish_timer;
float vanish_timer1 = block1.vanish_timer;
bool visible0 = block0.isVisible();
bool visible1 = block1.isVisible();
Block.STEP step0 = block0.step;
Block.STEP step1 = block1.step;
//
block0.setColor(color1);
block1.setColor(color0);
block0.transform.localScale = scale1;
block1.transform.localScale = scale0;
block0.vanish_timer = vanish_timer1;
block1.vanish_timer = vanish_timer0;
block0.setVisible(visible1);
block1.setVisible(visible0);
block0.step = step1;
block1.step = step0;
block0.beginFall(block1);
}
//===============================================================================//
public void EnableBlockSelection()
{
//unselect all blocks
foreach (Block b in BlockControl.GetAllBlocks())
{
if (b != null)
{
if (b.GetComponent <Collider2D>() != null)
{
b.SetIsSelected = false;
}
}
}
foreach (Block b in BlockControl.GetAllBlocks())
{
if (b != null)
{
if (b.GetComponent <Collider2D>() != null)
{
if (b.GetBlockID == Block.previouslySelectedBlockID)
{
b.SetIsSelected = true;
block = this;
break;
}
}
}
}
}
//===============================================================================//
public void MoveAllBlocksDown()
{
bool blocksMovedDown = false;
foreach (Block b in BlockControl.GetAllBlocks())
{
if (b != null)
{
if (b.GetComponent <Collider2D>() != null)
{
b.CheckIsBlockOnBottom();
if (!b.IsBlockOnBottom)
{
blocksMovedDown = false;
break;
}
else
{
blocksMovedDown = true;
}
}
}
}
// Used just to take out annoying Visual Code massage
if (blocksMovedDown)
{
blocksMovedDown = true;
}
}
public void swapBlock(BlockControl block0, Block.DIR4 dir, BlockControl block1)
{
// 각 블록의 색을 기억해 둔다.
Block.COLOR color0 = block0.color;
Block.COLOR color1 = block1.color;
// 각 블록의.
// 확대율을 기억해 둔다.
Vector3 scale0 =
block0.transform.localScale;
Vector3 scale1 =
block1.transform.localScale;
// 각 블록의 '사라지는 시간'을 기억해 둔다.
float vanish_timer0 = block0.vanish_timer;
float vanish_timer1 = block1.vanish_timer;
// 각 블록이 이동할 곳을 구한다.
Vector3 offset0 = BlockRoot.getDirVector(dir);
Vector3 offset1 = BlockRoot.getDirVector(BlockRoot.getOppositDir(dir));
block0.setColor(color1); // 색을 교체한다.
block1.setColor(color0);
block0.transform.localScale = scale1; // 확대율을 교체한다.
block1.transform.localScale = scale0;
block0.vanish_timer = vanish_timer1; // 사라지는 시간을 교체한다.
block1.vanish_timer = vanish_timer0;
block0.beginSlide(offset0); // 원래 블록의 이동을 시작.
block1.beginSlide(offset1); // 이동할 곳의 블록 이동을 시작.
}
public void InitialSetUp()
{
this.blocks = new BlockControl[Block.BLOCK_NUM_X, Block.BLOCK_NUM_Y];
int color_index = 0;
for (int y = 0; y < Block.BLOCK_NUM_Y; y++)
{
for (int x = 0; x < Block.BLOCK_NUM_X; x++)
{
// BlockPrefab의 인스턴스를 씬에 만든다
GameObject game_object = Instantiate(this.BlockPrefab) as GameObject;
BlockControl block = game_object.GetComponent <BlockControl>();
this.blocks[x, y] = block;
block.i_pos.x = x;
block.i_pos.y = y;
block.block_root = this;
Vector2 position = BlockRoot.calcBlockPosition(block.i_pos);
block.transform.position = position;
block.transform.localScale = new Vector3(0.7f, 0.7f, 0.7f);
block.SetColor((Block.COLOR)color_index);
block.name = "block(" + block.i_pos.x.ToString() + ", " + block.i_pos.y.ToString() + ")";
color_index = Random.Range(0, SizeManager.colorNum);
}
}
}
/*
* The methods in this section are used exclusively externally.
* When this editor is active, this will always be triggered whenever
* a change occurs to the data model, including when this makes changes
* through the core.
*
* DO NOT CALL CORE FUNCTIONS IN ANY OF THESE METHODS
* DO NOT CALL DELETE OR ANYTHING THAT CAUSES A CORE FUNCTION TO BE CALLED
*/
/// <summary>
/// Creates a new block for a specific IConnectable Item
/// </summary>
/// <param name="temp"></param>
public void CreateBlock(IConnectable temp)
{
IDrawableIConnectable newDrawable;
lock (ControlPanel.RenderLock)
{
BlockControl.MakeCurrent();
// Create a new Block depending on the type
if (temp is DataFilter)
{
// Create the main Block
var dfBlock = new DrawableFilter(_core, temp as DataFilter);
if (dfBlock.Object.PositionX == 0 && dfBlock.Object.PositionY == 0)
{
dfBlock.Object.PositionX = BlockControl.Width / 2;
dfBlock.Object.PositionY = BlockControl.Height / 2;
}
_renderables.Add(dfBlock.Z, dfBlock);
_objectMapping.Add(temp, dfBlock);
newDrawable = dfBlock;
}
else if (temp is DataConnection)
{
var dcBlock = new DrawableInputOutput(_core, temp as DataConnection);
if (dcBlock.Object.PositionX == 0 && dcBlock.Object.PositionY == 0)
{
dcBlock.Object.PositionX = BlockControl.Width / 2;
dcBlock.Object.PositionY = BlockControl.Height / 2;
}
_renderables.Add(dcBlock.Z, dcBlock);
_objectMapping.Add(temp, dcBlock);
newDrawable = dcBlock;
}
else
{
throw new NotSupportedException($"The type {temp.GetType()} does not have an associated block symbol");
}
// Create an input and an output port as needed
if (temp.OutputCount != 0)
{
var oPort = new DrawablePort(_core, temp, true);
_renderables.Add(oPort.Z, oPort);
newDrawable.MappedObjects.Add(oPort);
}
if (temp.InputCount != 0)
{
var iPort = new DrawablePort(_core, temp, false);
_renderables.Add(iPort.Z, iPort);
newDrawable.MappedObjects.Add(iPort);
}
BlockControl.Context.MakeCurrent(null);
}
// Select the block
SelectObject(newDrawable as DrawableObject);
Render();
}
public static void CheckAllBloks()
{
bool test = false;
foreach (Block b in BlockControl.GetAllBlocks())
{
if (b != null)
{
if (b.GetComponent <Collider2D>() != null && !b.GetBlockTag.Equals("selector"))
{
if (b.IsBlockMoving || b.IsBlockFalling)
{
test = false;
break;
}
else
{
test = true;
}
}
}
}
if (test)
{
BlockControl.EnableBlockSelection();
}
}
public void createEffect(BlockControl block)
{
GameObject fx_prefab = null;
switch (block.color)
{
case Block.COLOR.BLUE: fx_prefab = eff_blue; break;
case Block.COLOR.YELLOW: fx_prefab = eff_yellow; break;
case Block.COLOR.ORANGE: fx_prefab = eff_orange; break;
case Block.COLOR.MAGENTA: fx_prefab = eff_purple; break;
case Block.COLOR.GREEN: fx_prefab = eff_green; break;
case Block.COLOR.PINK: fx_prefab = eff_pink; break;
}
if (fx_prefab != null)
{
GameObject go = Instantiate(fx_prefab) as GameObject;
go.AddComponent <FruitEffect>();
go.transform.position = block.transform.position + Vector3.back * 3.0f;
}
}
void OnTriggerExit2D(Collider2D col)
{
bc = (BlockControl)col.gameObject.GetComponent<BlockControl>();
if (col.gameObject.tag == "block") {
bc.busyBlock -= 1;
}
}
private BlockManager()
{
blockList = new List <BlockControl>();
selectedBlocks = new List <BlockControl>();
activeBlock = null;
topmostZIndex = MINIMUM_Z_INDEX;
currentBlockId = MINIMUM_BLOCK_ID;
}
public BlockControl AddControl(string label, ControlView control)
{
BlockControl block = new BlockControl(label, control);
inputContainer.Add(block);
controls.Add(block);
return(block);
}
public void DeletePart(BlockControl part)
{
var index = _flow.Controls.IndexOf(part);
_flow.Controls.RemoveAt(index); // the part itself
_flow.Controls.RemoveAt(index); // the divider after the part
OnSizeChanged(EventArgs.Empty);
}
public void breakBlock()
{
BlockControl _sManager = _player.GetComponent <BlockControl>();
_mainBlock.SetActive(false);
//Instantiate(_particle, _mainBlock.transform.position, _mainBlock.transform.rotation);
_sManager.addSeed(_noSeedDrop);
Destroy(this);
}
/// <summary>
/// Remove the given block. If it is the active block, set the next
/// topmost block as active.
/// </summary>
public void RemoveBlock(BlockControl block)
{
VirtualSpaceControl.Instance.DeleteBlock(block);
blockList.Remove(block);
RemoveBlockSelection(block);
if (block.Equals(activeBlock))
{
SetTopmostBlockAsActive();
}
}
private static void BindBlockControl(BlockControl control)
{
BindingOperations.SetBinding(control, BlockControl.TypeNameProperty, new Binding("Name"));//OneWay
SetBinding(control, BlockControl.LabelProperty, "Label");
SetBinding(control, BlockControl.TypeFullNameProperty, "FullName");
SetBinding(control, BlockControl.LeftProperty, "Left");
SetBinding(control, BlockControl.TopProperty, "Top");
SetBinding(control, BlockControl.WidthProperty, "Width", _ignoreEmptySizeConverter);
SetBinding(control, BlockControl.HeightProperty, "Height", _ignoreEmptySizeConverter);
}
private static void BindBlockControl(BlockControl control)
{
BindingOperations.SetBinding(control, BlockControl.TypeNameProperty, new Binding("Name"));//OneWay
SetBinding(control, BlockControl.LabelProperty, "Label");
SetBinding(control, BlockControl.TypeFullNameProperty, "FullName");
SetBinding(control, BlockControl.LeftProperty, "Left");
SetBinding(control, BlockControl.TopProperty, "Top");
SetBinding(control, BlockControl.WidthProperty, "Width", _ignoreEmptySizeConverter);
SetBinding(control, BlockControl.HeightProperty, "Height", _ignoreEmptySizeConverter);
}
void Awake()
{
_instance = this;
forGettingTransform = (GameObject.FindGameObjectsWithTag(s_tag));
for (int i = 0; i < block_width; i++)
{
spawnPositions[i] = forGettingTransform[i].GetComponent <Transform>();
}
SpawnBlocks();
}
private void InsertBlockAndDivider(BlockControl block, int dividerPartIndex)
{
InsertBlock(block, dividerPartIndex + 1);
DividerBlockControl bottomDivider = new();
bottomDivider.AddBlock += Divider_AddPart;
InsertBlock(bottomDivider, dividerPartIndex + 2);
block.StartEditing();
}
/// <summary>
/// Remove all blocks and resets fields.
/// </summary>
public void RemoveAllBlocks()
{
foreach (BlockControl block in blockList)
{
VirtualSpaceControl.Instance.DeleteBlock(block);
}
blockList.Clear();
selectedBlocks.Clear();
activeBlock = null;
topmostZIndex = MINIMUM_Z_INDEX;
}
public GameObject eff_yellow; // YELLOW,
#endregion Fields
#region Methods
public void createEffect(BlockControl block)
{
GameObject fx_prefab = null;
switch(block.color) {
case Block.COLOR.BLUE: fx_prefab = eff_blue; break;
case Block.COLOR.YELLOW: fx_prefab = eff_yellow; break;
case Block.COLOR.ORANGE: fx_prefab = eff_orange; break;
case Block.COLOR.MAGENTA: fx_prefab = eff_purple; break;
case Block.COLOR.GREEN: fx_prefab = eff_green; break;
case Block.COLOR.PINK: fx_prefab = eff_pink; break;
}
if(fx_prefab != null) {
GameObject go = Instantiate(fx_prefab) as GameObject;
go.AddComponent<FruitEffect>();
go.transform.position = block.transform.position + Vector3.back*3.0f;
}
}
// 퇴장 연출용 블록을 만든다.
public LeaveBlockControl createLeaveBlock(BlockControl block)
{
GameObject game_object = Instantiate(this.blockPrefab) as GameObject;
LeaveBlockControl leave_block = game_object.GetComponent<LeaveBlockControl>();
//
leave_block.leave_block_root = this;
leave_block.i_pos = block.i_pos;
leave_block.transform.position = block.transform.position;
leave_block.getModelsRoot().transform.localScale = block.getModelsRoot().transform.localScale;
leave_block.getModelsRoot().transform.localPosition = block.getModelsRoot().transform.localPosition;
leave_block.getModelsRoot().transform.localRotation = block.getModelsRoot().transform.localRotation;
leave_block.setColor(block.color);
if(block.color == Block.COLOR.NECO) {
leave_block.getNecoMotion()["00_Idle"].time = block.getNekoMotion()["00_Idle"].time;
}
for(int i = 0;i < (int)Block.DIR4.NUM;i++) {
Block.DIR4 dir = (Block.DIR4)i;
leave_block.setConnectedBlock(dir, block.getConnectedBlock(dir));
}
// 하이어라키 뷰에서 위치를 확인하기 쉽게 블록 좌표를 이름에 붙여 둔다.
leave_block.name = "leave_block(" + block.i_pos.x.ToString() + "," + block.i_pos.y.ToString() + ")";
// 섬(같은 색 블록이 서로 이웃한 덩어리) 블록이
// 전부 갖춰질 때까지 기다린다 .
this.waiting_blocks.Add(leave_block);
return(leave_block);
}
// Initialization.
void Awake()
{
Debug.Log("Initialisation");
startTime = Time.realtimeSinceStartup;
Debug.Log("Awake Time ---> " + startTime);
GameObject.Find("Main Camera").AddComponent<AudioListener>();
GameObject cam = GameObject.Find("Main Camera");
if (cam.GetComponent<AudioListener>() == null) cam.AddComponent<AudioListener>();
//boardArray keeps track of which positions on the board is occupied.
boardArray = new bool[nx,ny,nz];
Array.Clear(boardArray, 0, boardArray.Length);
blockCtrl = GetComponent<BlockControl>();
blockCtrl.enterPressed = false;
//pinsPerShape = blockCtrl.getShapeSize();
blocksLayer = new GameObject [ny];
blocksInLayer = new int[ny];
Array.Clear(blocksInLayer, 0, blocksInLayer.Length);
//creating the bounding walls in the array
for(int i=0; i< ny;i++){
for(int j=0;j < nx;j++){
boardArray[j,i,0] = true;
boardArray[j,i,nz-1] = true;
boardArray[0,i,j] = true;
boardArray[nx-1,i,j] = true;
//print (boardArray[j,i,0]);
}
}
for (int i=0; i<ny; i++){
blocksLayer[i] = new GameObject();
String layerName = "Layer" + i;
blocksLayer[i].name = layerName;
addToScene(blocksLayer[i]);
}
//initialise textures for the GUI.
initTextures();
//Creates an array to store the 4 images of the lego pieces.
//Number of pieces that are suggested and number of total pieces
// are currently hard-coded.
lego = new Texture2D[4];
lego[0] = Resources.Load("L2x1lit") as Texture2D;
lego[1] = Resources.Load("L2x2lit") as Texture2D;
lego[2] = Resources.Load("L3x2lit") as Texture2D;
lego[3] = Resources.Load("L4x2lit") as Texture2D;
legoSuggestions = new int[3];
//shadow layer
GameObject slayer = new GameObject();
String lName = "ShadowLayer";
slayer.name = lName;
addToScene(slayer);
flashPass = 0;
grid = Resources.LoadAssetAtPath("Assets/Resources/grid_square.prefab", typeof(GameObject));
DrawBoard();
createTopCamera();
//first = true;
audio_source = GameObject.Find("Main Camera").GetComponent<AudioSource>();
wrong_piece_sound = GameObject.Find("Main Camera").AddComponent<AudioSource>();
wrong_piece_sound.clip = (AudioClip) Resources.LoadAssetAtPath("Assets/Music/error.wav", typeof(AudioClip));
// Only uncomment if you want to *change* the music
// startMusic("Theme1");
//start gameplay
gOver = GetComponent<GameOver>();
lboard = GetComponent<Leaderboard>();
blockCtrl.assignTimeGap(timeGap);
}
// 슬라이드 화살표를 표시한다.
public void dispArrow(BlockControl block, Block.DIR4 dir)
{
this.arrow.gameObject.SetActive(true);
this.arrow.gameObject.transform.position = block.transform.position + Vector3.back*(Block.COLLISION_SIZE*5.0f + 0.01f);
float angle = 0.0f;
switch(dir) {
case Block.DIR4.RIGHT: angle = 0.0f; break;
case Block.DIR4.LEFT: angle = 180.0f; break;
case Block.DIR4.UP: angle = 90.0f; break;
case Block.DIR4.DOWN: angle = -90.0f; break;
}
this.arrow.gameObject.transform.localRotation = Quaternion.AngleAxis(angle, Vector3.forward);
}
// ================================================================ //
// 착지했는지 조사한다.
private void check_landed()
{
this.is_landed = false;
do {
// 바로 아래를 향해서 선을 늘려서 다른 오브젝트와 충돌하는가
// 조사한다
float line_length;
line_length = COLLISION_SIZE;
// 점프 직후.
if(this.step == STEP.JUMP) {
if(this.is_launched) {
line_length = COLLISION_SIZE/2.0f;
}
}
Vector3 s = this.transform.position;
Vector3 e = s + Vector3.down*line_length;
RaycastHit hit;
// 레이어 마스크를 지정해서 바닥만 조사하게 한다.
// (코인 등은 조사하지 않는다).
int layer_mask = 0;
layer_mask += 1 << LayerMask.NameToLayer("Floor Block");
if(!Physics.Linecast(s, e, out hit, layer_mask)) {
// 다른 오브젝트로와 충돌하지 않았다.
break;
}
// 블록이면 기억해 둔다.
BlockControl block = hit.collider.GetComponent<BlockControl>();
if(block != null) {
this.stepped_block = block;
}
//
this.is_landed = true;
} while(false);
}
public void fallBlock(
BlockControl block0, Block.DIR4 dir, BlockControl block1)
{
// block0とblock1の色、サイズ、消えるまでの時間、表示・非表示、状態を記録.
Block.COLOR color0 = block0.color;
Block.COLOR color1 = block1.color;
Vector3 scale0 = block0.transform.localScale;
Vector3 scale1 = block1.transform.localScale;
float vanish_timer0 = block0.vanish_timer;
float vanish_timer1 = block1.vanish_timer;
bool visible0 = block0.isVisible();
bool visible1 = block1.isVisible();
Block.STEP step0 = block0.step;
Block.STEP step1 = block1.step;
// block0とblock1の各種属性を入れ替える.
block0.setColor(color1);
block1.setColor(color0);
block0.transform.localScale = scale1;
block1.transform.localScale = scale0;
block0.vanish_timer = vanish_timer1;
block1.vanish_timer = vanish_timer0;
block0.setVisible(visible1);
block1.setVisible(visible0);
block0.step = step1;
block1.step = step0;
block0.beginFall(block1);
}
public void swapBlock(BlockControl block0, Block.DIR4 dir, BlockControl block1)
{
// 각 블록의 색을 기억해 둔다.
Block.COLOR color0 = block0.color;
Block.COLOR color1 = block1.color;
// 각 블록의.
// 확대율을 기억해 둔다.
Vector3 scale0 =
block0.transform.localScale;
Vector3 scale1 =
block1.transform.localScale;
// 각 블록의 '사라지는 시간'을 기억해 둔다.
float vanish_timer0 = block0.vanish_timer;
float vanish_timer1 = block1.vanish_timer;
// 각 블록이 이동할 곳을 구한다.
Vector3 offset0 = BlockRoot.getDirVector(dir);
Vector3 offset1 = BlockRoot.getDirVector(BlockRoot.getOppositDir(dir));
block0.setColor(color1); // 색을 교체한다.
block1.setColor(color0);
block0.transform.localScale = scale1; // 확대율을 교체한다.
block1.transform.localScale = scale0;
block0.vanish_timer = vanish_timer1; // 사라지는 시간을 교체한다.
block1.vanish_timer = vanish_timer0;
block0.beginSlide(offset0); // 원래 블록 이동을 시작.
block1.beginSlide(offset1); // 이동할 곳의 블록 이동을 시작.
}
public void fallBlock(BlockControl block0,Block.DIR4 dir,BlockControl block1)
{
Block.COLOR color0 = block0.color;
Block.COLOR color1 = block1.color;
Vector3 scale0 = block0.transform.localScale;
Vector3 scale1 = block1.transform.localScale;
float vanish_timer0 = block0.vanish_timer;
float vanish_timer1 = block1.vanish_timer;
bool visible0 = block0.isVisible();
bool visible1 = block1.isVisible();
Block.STEP step0 = block0.step;
Block.STEP step1 = block1.step;
block0.setColor(color1);
block1.setColor(color0);
block0.transform.localScale = scale1;
block1.transform.localScale = scale0;
block0.vanish_timer=vanish_timer1;
block1.vanish_timer=vanish_timer0;
block0.setVisible(visible1);
block1.setVisible(visible0);
block0.step = step1;
block1.step = step0;
block0.beginFall(block1);
}
// Update is called once per frame
void Update()
{
Vector3 mouse_position;
this.unprojectMousePosition(
out mouse_position,Input.mousePosition);
Vector2 mouse_position_xy =
new Vector2(mouse_position.x,mouse_position.y);
if(this.grabbed_block==null){
if(!this.is_has_falling_block()){
if(Input.GetMouseButtonDown(0)){
foreach(BlockControl block in this.blocks){
if(! block.isGrabbable()){
continue;
}
if(!block.isContainedPosition(mouse_position_xy)){
continue;
}
this.grabbed_block=block;
this.grabbed_block.beginGrab();
break;
}
}
}
}else{
do{
BlockControl swap_target =
this.getNextBlock(grabbed_block,grabbed_block.slide_dir);
if(swap_target==null){
break;
}
if(! swap_target.isGrabbable()){
break;
}
float offset = this.grabbed_block.calcDirOffset(
mouse_position_xy,this.grabbed_block.slide_dir);
if(offset<Block.COLLISION_SIZE/2.0f){
break;
}
this.swapBlock(
grabbed_block,grabbed_block.slide_dir,swap_target);
this.grabbed_block = null;
}while(false);
if(! Input.GetMouseButton(0)){
this.grabbed_block.endGrab();
this.grabbed_block=null;
}
}
if(this.is_has_falling_block()||this.is_has_sliding_block()){
}else{
int ignite_count =0;
foreach(BlockControl block in this.blocks){
if(! block.isIdle()){
continue;
}
if(this.checkConnection(block)){
ignite_count++;
}
}
if(ignite_count >0){
int block_count =0;
foreach(BlockControl block in this.blocks){
if(block.isVanishing()){
block.rewindVanishTimer();
}
}
}
}
bool is_vanishing = this.is_has_vanishing_block();
do{
if(is_vanishing){
break;
}
if(this.is_has_sliding_block()){
break;
}
for(int x=0; x<Block.BLOCK_NUM_X;x++){
if(this.is_has_sliding_block_in_colum(x)){
continue;
}
for(int y=0;y<Block.BLOCK_NUM_Y-1;y++){
if(! this.blocks[x,y].isVacant()){
continue;
}
for(int y1=y+1; y1<Block.BLOCK_NUM_Y;y1++){
if(this.blocks[x,y1].isVacant()){
continue;
}
this.fallBlock(this.blocks[x,y],Block.DIR4.UP,
this.blocks[x,y1]);
break;
}
}
}
for(int x=0; x<Block.BLOCK_NUM_X;x++){
int fall_start_y=Block.BLOCK_NUM_Y;
for(int y=0;y<Block.BLOCK_NUM_Y;y++){
if(! this.blocks[x,y].isVacant()){
continue;
}
this.blocks[x,y].beginRespawn(fall_start_y);
fall_start_y++;
}
}
}while(false);
}
private void RemoveItemFromCanvas(BlockControl block)
{
//先把所有的连接都移除。
foreach (var con in block.Container.Connections)
{
var connection = GetComponent(con) as BlockRelation;
this.Relations.Remove(connection);
}
_canvas.Children.Remove(block.Container);
}
private void AddItemIntoCanvas(BlockControl block)
{
var container = new DesignerItemContainer();
container.Content = block;
block.Container = container;
SetComponent(container, block);
//应用样式
var containerStyle = this.BlockContainerStyle;
if (containerStyle != null) container.Style = containerStyle;
container.DataContext = block;
container.SetBinding(Canvas.LeftProperty, new Binding { Path = new PropertyPath(BlockControl.LeftProperty), Mode = BindingMode.TwoWay });
container.SetBinding(Canvas.TopProperty, new Binding { Path = new PropertyPath(BlockControl.TopProperty), Mode = BindingMode.TwoWay });
_canvas.Children.Add(container);
}
// ================================================================ //
// 같은 색이 나란히 있는지 체크.
public bool checkConnection(BlockControl start)
{
bool ret = false;
int normal_block_num = 0;
if(!start.isVanishing()) {
normal_block_num = 1;
}
// 가로 방향.
// 같은 색이 나란히 있는 범위를 조사한다.
int rx = start.i_pos.x;
int lx = start.i_pos.x;
// start와 같은 색 블록이면 왼쪽으로 나아간다.
for(int x = lx - 1;x > 0;x--) {
BlockControl next_block = this.blocks[x, start.i_pos.y];
if(next_block.color != start.color) {
break;
}
if(next_block.step == Block.STEP.FALL || next_block.next_step == Block.STEP.FALL) {
break;
}
if(next_block.step == Block.STEP.SLIDE || next_block.next_step == Block.STEP.SLIDE) {
break;
}
if(!next_block.isVanishing()) {
normal_block_num++;
}
lx = x;
}
// start 와 같은 색의 블록이면 오른쪽으로 나아간다.
for(int x = rx + 1;x < Block.BLOCK_NUM_X;x++) {
BlockControl next_block = this.blocks[x, start.i_pos.y];
if(next_block.color != start.color) {
break;
}
if(next_block.step == Block.STEP.FALL || next_block.next_step == Block.STEP.FALL) {
break;
}
if(next_block.step == Block.STEP.SLIDE || next_block.next_step == Block.STEP.SLIDE) {
break;
}
if(!next_block.isVanishing()) {
normal_block_num++;
}
rx = x;
}
// rx ~ lx까지의 블록이 같은 색.
//
do {
// ３개 이하면 지우지 않는다.
if(rx - lx + 1 < 3) {
break;
}
// '사라지는 연출 중이 아닌' 블록이 한개도 없으면 사라지지 않는다.
if(normal_block_num == 0) {
break;
}
for(int x = lx;x < rx + 1;x++) {
if(this.blocks[x, start.i_pos.y] == this.grabbed_block) {
this.hideArrow();
this.grabbed_block.endGrab();
this.grabbed_block = null;
}
// 발화 연출 시작
this.blocks[x, start.i_pos.y].toVanishing();
// 이웃 블록을 연결해 둔다.
if(x > lx) {
this.connect_x(x - 1, x, start.i_pos.y);
}
if(x < rx) {
this.connect_x(x, x + 1, start.i_pos.y);
}
}
ret = true;
} while(false);
// ---------------------------------------------------------------- //
// 세로 방향.
normal_block_num = 0;
if(!start.isVanishing()) {
normal_block_num = 1;
}
int uy = start.i_pos.y;
int dy = start.i_pos.y;
for(int y = dy - 1;y > 0;y--) {
BlockControl next_block = this.blocks[start.i_pos.x, y];
if(next_block.color != start.color) {
break;
}
if(next_block.step == Block.STEP.FALL || next_block.next_step == Block.STEP.FALL) {
break;
}
if(next_block.step == Block.STEP.SLIDE || next_block.next_step == Block.STEP.SLIDE) {
break;
}
if(!next_block.isVanishing()) {
normal_block_num++;
}
dy = y;
}
for(int y = uy + 1;y < Block.BLOCK_NUM_Y;y++) {
BlockControl next_block = this.blocks[start.i_pos.x, y];
if(next_block.color != start.color) {
break;
}
if(next_block.step == Block.STEP.FALL || next_block.next_step == Block.STEP.FALL) {
break;
}
if(next_block.step == Block.STEP.SLIDE || next_block.next_step == Block.STEP.SLIDE) {
break;
}
if(!next_block.isVanishing()) {
normal_block_num++;
}
uy = y;
}
do {
if(uy - dy + 1 < 3) {
break;
}
if(normal_block_num == 0) {
break;
}
for(int y = dy;y < uy + 1;y++) {
if(this.blocks[start.i_pos.x, y] == this.grabbed_block) {
this.hideArrow();
this.grabbed_block.endGrab();
this.grabbed_block = null;
}
this.blocks[start.i_pos.x, y].toVanishing();
// 이웃한 블록을 연결해 둔다.
if(y > dy) {
this.connect_y(y - 1, y, start.i_pos.x);
}
if(y < uy) {
this.connect_y(y, y + 1, start.i_pos.x);
}
}
ret = true;
} while(false);
// ---------------------------------------------------------------- //
return(ret);
}
public bool checkConnection(BlockControl start)
{
bool ret = false;
int normal_block_num = 0;
// 引数のブロックが着火後でないなら.
if(! start.isVanishing()) {
normal_block_num = 1;
}
// グリッド座標を覚えておく.
int rx = start.i_pos.x;
int lx = start.i_pos.x;
// ブロックの左側をチェック.
for(int x = lx - 1; x > 0; x--) {
BlockControl next_block = this.blocks[x, start.i_pos.y];
if(next_block.color != start.color) { // 色が違ったら.
break; // ループを脱出.
}
if(next_block.step == Block.STEP.FALL || // 落下中なら.
next_block.next_step == Block.STEP.FALL) {
break; // ループを脱出.
}
if(next_block.step == Block.STEP.SLIDE || // スライド中なら.
next_block.next_step == Block.STEP.SLIDE) {
break; // ループを脱出.
}
if(! next_block.isVanishing()) { // 着火中でなければ.
normal_block_num++; // チェック用カウンターをインクリメント.
}
lx = x;
}
// ブロックの右側をチェック.
for(int x = rx + 1; x < Block.BLOCK_NUM_X; x++) {
BlockControl next_block = this.blocks[x, start.i_pos.y];
if(next_block.color != start.color) {
break;
}
if(next_block.step == Block.STEP.FALL ||
next_block.next_step == Block.STEP.FALL) {
break;
}
if(next_block.step == Block.STEP.SLIDE ||
next_block.next_step == Block.STEP.SLIDE) {
break;
}
if(! next_block.isVanishing()) {
normal_block_num++;
}
rx = x;
}
do {
// 右側のブロックのグリッド番号－左側のブロックのグリッド番号＋.
// 中央のブロック（1）を足した数が3未満なら.
if(rx - lx + 1 < 3) {
break; // ループを脱出.
}
if(normal_block_num == 0) { // 着火中でないブロックが1つもないなら.
break; // ループを脱出.
}
for(int x = lx; x < rx + 1; x++) {
// 揃っている同色ブロックを着火状態に.
this.blocks[x, start.i_pos.y].toVanishing();
ret = true;
}
} while(false);
normal_block_num = 0;
if(! start.isVanishing()) {
normal_block_num = 1;
}
int uy = start.i_pos.y;
int dy = start.i_pos.y;
// ブロックの上側をチェック.
for(int y = dy - 1; y > 0; y--) {
BlockControl next_block = this.blocks[start.i_pos.x, y];
if(next_block.color != start.color) {
break;
}
if(next_block.step == Block.STEP.FALL ||
next_block.next_step == Block.STEP.FALL) {
break;
}
if(next_block.step == Block.STEP.SLIDE ||
next_block.next_step == Block.STEP.SLIDE) {
break;
}
if(! next_block.isVanishing()) {
normal_block_num++;
}
dy = y;
}
// ブロックの下側をチェック.
for(int y = uy + 1; y < Block.BLOCK_NUM_Y; y ++) {
BlockControl next_block = this.blocks[start.i_pos.x, y];
if(next_block.color != start.color) {
break;
}
if(next_block.step == Block.STEP.FALL ||
next_block.next_step == Block.STEP.FALL) {
break;
}
if(next_block.step == Block.STEP.SLIDE ||
next_block.next_step == Block.STEP.SLIDE) {
break;
}
if(! next_block.isVanishing()) {
normal_block_num++;
}
uy = y;
}
do {
if(uy - dy + 1 < 3) {
break;
}
if(normal_block_num == 0) {
break;
}
for(int y = dy; y < uy + 1; y++) {
this.blocks[start.i_pos.x, y].toVanishing();
ret = true;
}
} while(false);
return(ret);
}
void Update()
{
Vector3 mouse_position; // マウスの位置.
this.unprojectMousePosition( // マウスの位置を取得.
out mouse_position, Input.mousePosition);
// 取得したマウス位置を X と Y だけにする.
Vector2 mouse_position_xy =
new Vector2(mouse_position.x, mouse_position.y);
if(this.grabbed_block == null) { // ブロックをつかんでいないとき.
if(!this.is_has_falling_block()) {
if(Input.GetMouseButtonDown(0)) { // マウスボタンが押されたら.
// blocks配列のすべての要素を順に処理する.
foreach(BlockControl block in this.blocks) {
if(! block.isGrabbable()) { // ブロックがつかめないなら.
continue; // 次のブロックへ.
}
// マウス位置がブロックの領域内にないなら.
if(!block.isContainedPosition(mouse_position_xy)) {
continue; // 次のブロックへ.
}
// 処理中のブロックをgrabbed_blockに登録.
this.grabbed_block = block;
// つかんだときの処理を実行.
this.grabbed_block.beginGrab();
break;
}
}
}
} else { // ブロックをつかんでいるとき.
do {
// スライドさせる先のブロックを取得.
BlockControl swap_target =
this.getNextBlock(grabbed_block, grabbed_block.slide_dir);
// スライド先ブロックが空っぽなら.
if(swap_target == null) {
break; // ループを脱出.
}
// スライド先ブロックがつかめる状態にないなら.
if(! swap_target.isGrabbable()) {
break; // ループを脱出.
}
// 現在位置からスライド先までの距離を取得.
float offset = this.grabbed_block.calcDirOffset(
mouse_position_xy, this.grabbed_block.slide_dir);
// 移動距離がブロックサイズの半分より小さいなら.
if(offset < Block.COLLISION_SIZE / 2.0f) {
break; // ループを脱出.
}
// ブロックを入れ替える.
this.swapBlock(
grabbed_block, grabbed_block.slide_dir, swap_target);
this.grabbed_block = null; // いまや、ブロックをつかんでいない.
} while(false);
if(! Input.GetMouseButton(0)) { // マウスボタンが押されていないなら.
this.grabbed_block.endGrab(); // ブロックを離したときの処理を実行.
this.grabbed_block = null; // grabbed_blockを空っぽに設定.
}
}
// 落下中またはスライド中なら.
if(this.is_has_falling_block() || this.is_has_sliding_block()) {
// 何もしない.
// 落下中でもスライド中でもないなら.
} else {
int ignite_count = 0; // 着火数.
// グリッド内の全てのブロックについて処理.
foreach(BlockControl block in this.blocks) {
if(! block.isIdle()) { // 待機中ならループの先頭にジャンプして、.
continue; // 次のブロックを処理する.
}
// 縦または横に同じ色のブロックが3つ以上並んでいるなら.
if(this.checkConnection(block)) {
ignite_count++; // 着火数をインクリメント.
}
}
if(ignite_count > 0) { // 着火数が0より大きいなら.
// ＝1箇所でも揃っているなら.
int block_count = 0; // 着火中のブロック数（次章で使います）.
// グリッド内の全てのブロックについて処理.
foreach(BlockControl block in this.blocks) {
if(block.isVanishing()) { // 着火中（消えつつある）なら.
block.rewindVanishTimer(); // 再着火！.
}
}
}
}
// 1つでも燃焼中のブロックがある？.
bool is_vanishing = this.is_has_vanishing_block();
// 条件が満たされていたらブロックを落としたい.
do {
if(is_vanishing) { // 燃焼中のブロックがあるなら.
break; // 落下処理は行わない.
}
if(this.is_has_sliding_block()) { // 入れ替え中のブロックがあるなら.
break; // 落下処理は行わない.
}
for(int x = 0; x < Block.BLOCK_NUM_X; x++) {
// 列に入れ替え中のブロックがあったらその列は処理せず、次の列に進む.
if(this.is_has_sliding_block_in_column(x)) {
continue;
}
// その列にあるブロックを上からチェック.
for(int y = 0; y < Block.BLOCK_NUM_Y - 1; y++) {
// 指定中のブロックが非表示なら、次のブロックへ.
if(! this.blocks[x, y].isVacant()) {
continue;
}
// 指定中ブロックの下にあるブロックをチェック.
for(int y1 = y + 1; y1 < Block.BLOCK_NUM_Y; y1++) {
// 下にあるブロックが非表示なら、次のブロックへ.
if(this.blocks[x, y1].isVacant()) {
continue;
}
// ブロックを入れ替える.
this.fallBlock(this.blocks[x, y], Block.DIR4.UP,
this.blocks[x, y1]);
break;
}
}
}
// 補充処理.
for(int x = 0; x < Block.BLOCK_NUM_X; x++) {
int fall_start_y = Block.BLOCK_NUM_Y;
for(int y = 0; y < Block.BLOCK_NUM_Y; y++) {
// 非表示ブロックでなかったら、次のブロックへ.
if(! this.blocks[x, y].isVacant()) {
continue;
}
this.blocks[x, y].beginRespawn(fall_start_y); // ブロック復活.
fall_start_y++;
}
}
} while(false);
}
public void swapBlock(BlockControl block0, Block.DIR4 dir, BlockControl block1)
{
// それぞれのブロックの色を覚えておく.
Block.COLOR color0 = block0.color;
Block.COLOR color1 = block1.color;
// それぞれのブロックの.
// 拡大率を覚えておく.
Vector3 scale0 =
block0.transform.localScale;
Vector3 scale1 =
block1.transform.localScale;
// それぞれのブロックの「消える時間」を覚えておく.
float vanish_timer0 = block0.vanish_timer;
float vanish_timer1 = block1.vanish_timer;
// それぞれのブロックの移動先を求める.
Vector3 offset0 = BlockRoot.getDirVector(dir);
Vector3 offset1 = BlockRoot.getDirVector(BlockRoot.getOppositDir(dir));
block0.setColor(color1); // 色を入れ替える.
block1.setColor(color0);
block0.transform.localScale = scale1; // 拡大率を入れ替える.
block1.transform.localScale = scale0;
block0.vanish_timer = vanish_timer1; // 「消える時間」を入れ替える.
block1.vanish_timer = vanish_timer0;
block0.beginSlide(offset0); // 元のブロックの移動を開始.
block1.beginSlide(offset1); // 移動先ブロックの移動を開始.
}
void Update()
{
Vector3 mouse_position; // 마우스 위치.
this.unprojectMousePosition( // 마우스 위치 가져오기.
out mouse_position, Input.mousePosition);
// 가져온 마우스 위치를 Vector2로 모으기.
Vector2 mouse_position_xy =
new Vector2(mouse_position.x, mouse_position.y);
if(this.grabbed_block == null) { // 잡은 블록이 비었으면.
// if(!this.is_has_falling_block()) {
if(Input.GetMouseButtonDown(0)) { //마우스 버튼이 눌렸으면.
// blocks배열의 모든 요소를 차례로 처리한다.
foreach(BlockControl block in this.blocks) {
if(! block.isGrabbable()) { // 블록을 잡을 수 없다면.
continue; // 루프의 시작으로 점프.
}
// 마우스 위치가 블록 영역 안이 아니면.
if(!block.isContainedPosition(mouse_position_xy)) {
continue; // 루프의 처음으로 점프.
}
// 처리 중인 블록을 grabbed_block에 등록.
this.grabbed_block = block;
// 잡았을 때의 처리를 실행.
this.grabbed_block.beginGrab();
break;
}
}
// }
} else { // 잡은 블록이 비어있지 않으면.
do {
// 슬라이드할 곳의 블록을 가져온다.
BlockControl swap_target =
this.getNextBlock(grabbed_block, grabbed_block.slide_dir);
// 슬라이드할 곳의 블록이 비었으면.
if(swap_target == null) {
break; // 루프 탈출.
}
// 슬라이드할 곳의 블록이 잡을 수 있는 상태가 아니면.
if(! swap_target.isGrabbable()) {
break; // 루프 탈출.
}
// 현재 위치에서 슬라이드 위치까지의 거리를 구한다.
float offset = this.grabbed_block.calcDirOffset(
mouse_position_xy, this.grabbed_block.slide_dir);
// 수리 거리가 블록 크기의 절반보다 작다면.
if(offset < Block.COLLISION_SIZE / 2.0f) {
break; // 루프 탈출.
}
// 블록을 교체한다.
this.swapBlock(
grabbed_block, grabbed_block.slide_dir, swap_target);
this.grabbed_block = null; // 지금은 블록을 잡고 있지 않다.
} while(false);
if(! Input.GetMouseButton(0)) { // 마우스 버튼이 눌려져 있지 않으면.
this.grabbed_block.endGrab(); // 블록을 놨을 때의 처리를 실행.
this.grabbed_block = null; // grabbed_block을 비우게 설정.
}
}
}
public bool checkConnection(BlockControl start)
{
bool ret = false;
int normal_block_num =0;
if(! start.isVanishing()){
normal_block_num=1;
}
int rx=start.i_pos.x;
int lx=start.i_pos.x;
for(int x= lx-1; x>0; x--){
BlockControl next_block=this.blocks[x,start.i_pos.y];
if(next_block.color!=start.color){
break;
}
if(next_block.step==Block.STEP.FALL||
next_block.next_step==Block.STEP.FALL){
break;
}
if(next_block.step==Block.STEP.LONG_SLIDE||
next_block.next_step==Block.STEP.SLIDE){
break;
}
if(! next_block.isVanishing()){
normal_block_num++;
}
lx=x;
}
for(int x=rx+1; x<Block.BLOCK_NUM_X; x++){
BlockControl next_block=this.blocks[x,start.i_pos.y];
if(next_block.color !=start.color){
break;
}
if(next_block.step == Block.STEP.FALL||
next_block.next_step==Block.STEP.FALL){
break;
}
if(next_block.step==Block.STEP.SLIDE||
next_block.next_step==Block.STEP.SLIDE){
break;
}
if(! next_block.isVanishing()){
normal_block_num++;
}
rx = x;
}
do{
if(rx-lx+1<3){
break;
}
if(normal_block_num==0){
break;
}
for(int x = lx; x<rx+1; x++){
this.blocks[x,start.i_pos.y].toVanishing();
ret=true;
}
}while(false);
normal_block_num=0;
if(! start.isVanishing()){
normal_block_num =1;
}
int uy=start.i_pos.y;
int dy=start.i_pos.y;
for(int y = dy -1; y>0; y--){
BlockControl next_block=this.blocks[start.i_pos.x,y];
if(next_block.color!=start.color){
break;
}
if(next_block.step==Block.STEP.FALL||
next_block.next_step==Block.STEP.FALL){
break;
}
if(next_block.step==Block.STEP.SLIDE||
next_block.next_step==Block.STEP.SLIDE){
break;
}
if(! next_block.isVanishing()){
normal_block_num++;
}
dy=y;
}
for(int y=uy+1;y<Block.BLOCK_NUM_Y;y++){
BlockControl next_block = this.blocks[start.i_pos.x,y];
if(next_block.color!=start.color){
break;
}
if(next_block.step==Block.STEP.FALL||
next_block.next_step==Block.STEP.FALL){
break;
}
if(next_block.step==Block.STEP.SLIDE||
next_block.next_step==Block.STEP.SLIDE){
break;
}
if(! next_block.isVanishing()){
normal_block_num++;
}
uy=y;
}
do{
if(uy -dy +1<3){
break;
}
if(normal_block_num==0){
break;
}
for(int y=dy;y<uy+1;y++){
this.blocks[start.i_pos.x,y].toVanishing();
ret=true;
}
}while(false);
return(ret);
}
// 두 블록을 교체한다.
public void swapBlock(BlockControl block0, Block.DIR4 dir, BlockControl block1)
{
// 교체 상대는 반대 방향으로 슬라이드.
block1.slide_dir = BlockRoot.getOppositDir(dir);
Block.COLOR color0 = block0.color;
Block.COLOR color1 = block1.color;
Vector3 scale0 = block0.transform.localScale;
Vector3 scale1 = block1.transform.localScale;
float vanish_timer0 = block0.vanish_timer;
float vanish_timer1 = block1.vanish_timer;
Vector3 offset0 = BlockRoot.getDirVector(dir);
Vector3 offset1 = BlockRoot.getDirVector(block1.slide_dir);
float grab_timer0 = block0.grab_timer;
float grab_timer1 = block1.grab_timer;
//
block0.setColor(color1);
block1.setColor(color0);
block0.transform.localScale = scale1;
block1.transform.localScale = scale0;
block0.vanish_timer = vanish_timer1;
block1.vanish_timer = vanish_timer0;
block0.grab_timer = grab_timer1;
block1.grab_timer = grab_timer0;
block0.slide_forward = false;
block1.slide_forward = true;
block0.beginSlide(offset0);
block1.beginSlide(offset1);
}
public void swapBlock(
BlockControl block0, Block.DIR4 dir,BlockControl block1)
{
Block.COLOR color0 = block0.color;
Block.COLOR color1 = block1.color;
Vector3 scale0 = block0.transform.localScale;
Vector3 scale1 = block1.transform.localScale;
float vanish_timer0 = block0.vanish_timer;
float vanish_timer1 = block1.vanish_timer;
Vector3 offset0 = BlockRoot.getDirVector(dir);
Vector3 offset1 = BlockRoot.getDirVector(BlockRoot.getOppositDir(dir));
block0.setColor(color1);
block1.setColor(color0);
block0.transform.localScale = scale1;
block1.transform.localScale = scale0;
block0.vanish_timer = vanish_timer1;
block1.vanish_timer = vanish_timer0;
block0.beginSlide(offset0);
block1.beginSlide(offset1);
}
// ================================================================ //
// dir 방향의 이웃 블록을 얻는다.
public BlockControl getNextBlock(BlockControl block, Block.DIR4 dir)
{
BlockControl next_block = null;
switch(dir) {
case Block.DIR4.RIGHT:
{
if(block.i_pos.x < Block.BLOCK_NUM_X - 1) {
next_block = this.blocks[block.i_pos.x + 1, block.i_pos.y];
}
}
break;
case Block.DIR4.LEFT:
{
if(block.i_pos.x > 0) {
next_block = this.blocks[block.i_pos.x - 1, block.i_pos.y];
}
}
break;
case Block.DIR4.UP:
{
if(block.i_pos.y < Block.BLOCK_NUM_Y - 1) {
next_block = this.blocks[block.i_pos.x, block.i_pos.y + 1];
}
}
break;
case Block.DIR4.DOWN:
{
if(block.i_pos.y > 0) {
next_block = this.blocks[block.i_pos.x, block.i_pos.y - 1];
}
}
break;
}
return(next_block);
}
public void fallBlock(
BlockControl block0, Block.DIR4 dir, BlockControl block1)
{
// block0과 block1의 색, 크기, 사라질 때까지 걸리는 시간, 표시, 비표시, 상태를 기록.
Block.COLOR color0 = block0.color;
Block.COLOR color1 = block1.color;
Vector3 scale0 = block0.transform.localScale;
Vector3 scale1 = block1.transform.localScale;
float vanish_timer0 = block0.vanish_timer;
float vanish_timer1 = block1.vanish_timer;
bool visible0 = block0.isVisible();
bool visible1 = block1.isVisible();
Block.STEP step0 = block0.step;
Block.STEP step1 = block1.step;
// block0과 block1의 각종 속성을 교체한다.
block0.setColor(color1);
block1.setColor(color0);
block0.transform.localScale = scale1;
block1.transform.localScale = scale0;
block0.vanish_timer = vanish_timer1;
block1.vanish_timer = vanish_timer0;
block0.setVisible(visible1);
block1.setVisible(visible0);
block0.step = step1;
block1.step = step0;
block0.beginFall(block1);
}
public bool checkConnection(BlockControl start)
{
bool ret = false;
int normal_block_num = 0;
// 인수인 블록이 착화 후가 아니면.
if(! start.isVanishing()) {
normal_block_num = 1;
}
// 그리드 좌표를 기억해 둔다.
int rx = start.i_pos.x;
int lx = start.i_pos.x;
// 블록의 왼쪽을 검사.
for(int x = lx - 1; x > 0; x--) {
BlockControl next_block = this.blocks[x, start.i_pos.y];
if(next_block.color != start.color) { // 색이 다르면.
break; // 루프를 빠져나간다.
}
if(next_block.step == Block.STEP.FALL || // 낙하 중이면.
next_block.next_step == Block.STEP.FALL) {
break; // 루프를 빠져나간다.
}
if(next_block.step == Block.STEP.SLIDE || // 슬라이드 중이면.
next_block.next_step == Block.STEP.SLIDE) {
break; // 루프를 빠져나간다.
}
if(! next_block.isVanishing()) { // 발화 중이 아니면.
normal_block_num++; // 검사용 카운터를 증가.
}
lx = x;
}
// 블록의 오른쪽을 검사.
for(int x = rx + 1; x < Block.BLOCK_NUM_X; x++) {
BlockControl next_block = this.blocks[x, start.i_pos.y];
if(next_block.color != start.color) {
break;
}
if(next_block.step == Block.STEP.FALL ||
next_block.next_step == Block.STEP.FALL) {
break;
}
if(next_block.step == Block.STEP.SLIDE ||
next_block.next_step == Block.STEP.SLIDE) {
break;
}
if(! next_block.isVanishing()) {
normal_block_num++;
}
rx = x;
}
do {
// 오른쪽 블록의 그리드 번호 - 왼쪽 블록의 그리드 번호 +.
// 중앙 블록(1)을 더한 수가 3미만 이면.
if(rx - lx + 1 < 3) {
break; // 루프 탈출.
}
if(normal_block_num == 0) { // 착화 중이 아닌 블록이 하나도 없으면.
break; // 루프 탈출.
}
for(int x = lx; x < rx + 1; x++) {
// 나열된 같은 색 블록을 착화 상태로.
this.blocks[x, start.i_pos.y].toVanishing();
ret = true;
}
} while(false);
normal_block_num = 0;
if(! start.isVanishing()) {
normal_block_num = 1;
}
int uy = start.i_pos.y;
int dy = start.i_pos.y;
// 블록의 위쪽을 검사.
for(int y = dy - 1; y > 0; y--) {
BlockControl next_block = this.blocks[start.i_pos.x, y];
if(next_block.color != start.color) {
break;
}
if(next_block.step == Block.STEP.FALL ||
next_block.next_step == Block.STEP.FALL) {
break;
}
if(next_block.step == Block.STEP.SLIDE ||
next_block.next_step == Block.STEP.SLIDE) {
break;
}
if(! next_block.isVanishing()) {
normal_block_num++;
}
dy = y;
}
// 블록의 아래쪽을 검사.
for(int y = uy + 1; y < Block.BLOCK_NUM_Y; y ++) {
BlockControl next_block = this.blocks[start.i_pos.x, y];
if(next_block.color != start.color) {
break;
}
if(next_block.step == Block.STEP.FALL ||
next_block.next_step == Block.STEP.FALL) {
break;
}
if(next_block.step == Block.STEP.SLIDE ||
next_block.next_step == Block.STEP.SLIDE) {
break;
}
if(! next_block.isVanishing()) {
normal_block_num++;
}
uy = y;
}
do {
if(uy - dy + 1 < 3) {
break;
}
if(normal_block_num == 0) {
break;
}
for(int y = dy; y < uy + 1; y++) {
this.blocks[start.i_pos.x, y].toVanishing();
ret = true;
}
} while(false);
return(ret);
}
void Update()
{
Vector3 mouse_position; // 마우스 위치.
this.unprojectMousePosition( // 마우스 위치를 획득.
out mouse_position, Input.mousePosition);
// 획득한 마우스 위치를 X와 Y만으로 한다.
Vector2 mouse_position_xy =
new Vector2(mouse_position.x, mouse_position.y);
if(this.grabbed_block == null) { // 블록을 잡지 않았을 때.
if(!this.is_has_falling_block()) {
if(Input.GetMouseButtonDown(0)) { // 마우스 버튼이 눌렸다면.
// blocks 배열의 모든 요소를 차례로 차리한다.
foreach(BlockControl block in this.blocks) {
if(! block.isGrabbable()) { // 블록을 잡을 수 없으면.
continue; // 다음 블록으로.
}
// 마우스 위치가 블록 영역 안에 없으면.
if(!block.isContainedPosition(mouse_position_xy)) {
continue; // 다음 블록으로.
}
// 처리 중인 블록을 grabbed_block에 등록.
this.grabbed_block = block;
// 잡았을 때의 처리를 실행.
this.grabbed_block.beginGrab();
break;
}
}
}
} else { // 블록을 잡고 있을 때.
do {
// 슬라이드할 곳의 블록을 가져온다.
BlockControl swap_target =
this.getNextBlock(grabbed_block, grabbed_block.slide_dir);
// 슬라이드할 곳 블록이 비어 있다면.
if(swap_target == null) {
break; // 루프 탈출.
}
// 슬라이드할 곳 블록을 잡을 수 있는 상태가 아니라면.
if(! swap_target.isGrabbable()) {
break; // 루프 탈출.
}
// 현재 위치에서 슬라이드할 곳까지의 거리를 구한다.
float offset = this.grabbed_block.calcDirOffset(
mouse_position_xy, this.grabbed_block.slide_dir);
// 이동 거리가 블록 크기의 절반보다 작다면 .
if(offset < Block.COLLISION_SIZE / 2.0f) {
break; // 루프 탈출.
}
// 블록을 교체한다.
this.swapBlock(
grabbed_block, grabbed_block.slide_dir, swap_target);
this.grabbed_block = null; // 지금은 블록을 잡고 있지 않다.
} while(false);
if(! Input.GetMouseButton(0)) { // 마우스 버튼이 눌려져 있지 않으면.
this.grabbed_block.endGrab(); // 블록을 놨을 때의 처리를 실행.
this.grabbed_block = null; // grabbed_block을 텅비게 설정.
}
}
// 낙하 중 또는 슬라이드 중이면.
if(this.is_has_falling_block() || this.is_has_sliding_block()) {
// 아무것도 하지 않는다.
// 낙하 중도 슬라이드 중도 아니면.
} else {
int ignite_count = 0; // 발화 수.
// 그리드 안의 모든 블록에 대해서 처리.
foreach(BlockControl block in this.blocks) {
if(! block.isIdle()) { // 대기 중이면 루프의 처음으로 점프하고,.
continue; // 다음 블록을 처리한다.
}
// 세로 또는 가로에 같은 색 블록이 세 개 이상 나열했다면.
if(this.checkConnection(block)) {
ignite_count++; // 발화 수를 증가.
}
}
if(ignite_count > 0) { // 발화 수가 0보다 크면.
// ＝한 군데라도 맞춰진 곳이 있으면.
int block_count = 0; // 발화 중인 블록 수(다음 장에서 사용한다).
// 그리드 내의 모든 블록에 대해서 처리.
foreach(BlockControl block in this.blocks) {
if(block.isVanishing()) { // 발화 중(점점 사라진다)이면.
block.rewindVanishTimer(); // 재점화！.
}
}
}
}
// 하나라도 연소 중인 블록이 있는가?.
bool is_vanishing = this.is_has_vanishing_block();
// 조건이 만족되면 블록을 떨어뜨리고 싶다.
do {
if(is_vanishing) { // 연소 중인 블록이 있다면.
break; // 낙하 처리를 실행하지 않는다.
}
if(this.is_has_sliding_block()) { // 교체 중인 블록이 있다면.
break; // 낙하 처리를 실행하지 않는다.
}
for(int x = 0; x < Block.BLOCK_NUM_X; x++) {
// 열에 교체 중인 블록이 있다면, 그 열은 처리하지 않고 다음 열로 진행한다.
if(this.is_has_sliding_block_in_column(x)) {
continue;
}
// 그 열에 있는 블록을 위에서부터 검사.
for(int y = 0; y < Block.BLOCK_NUM_Y - 1; y++) {
// 지정 중인 블록이 비표시라면, 다음 블록으로.
if(! this.blocks[x, y].isVacant()) {
continue;
}
// 지정 중인 블록 아래에 있는 블록을 검사.
for(int y1 = y + 1; y1 < Block.BLOCK_NUM_Y; y1++) {
// 아래에 있는 블록이 비표시라면, 다음 블록으로.
if(this.blocks[x, y1].isVacant()) {
continue;
}
// 블록을 교체한다.
this.fallBlock(this.blocks[x, y], Block.DIR4.UP,
this.blocks[x, y1]);
break;
}
}
}
// 보충처리.
for(int x = 0; x < Block.BLOCK_NUM_X; x++) {
int fall_start_y = Block.BLOCK_NUM_Y;
for(int y = 0; y < Block.BLOCK_NUM_Y; y++) {
// 비표시 블록이 아니라면 다음 블록으로.
if(! this.blocks[x, y].isVacant()) {
continue;
}
this.blocks[x, y].beginRespawn(fall_start_y); // 블록 부활.
fall_start_y++;
}
}
} while(false);
}
void Update()
{
Vector3 mouse_position;
this.unprojectMousePosition(out mouse_position, Input.mousePosition);
Vector2 mouse_position_xy = new Vector2(mouse_position.x, mouse_position.y);
if(this.grabbed_block == null) {
// 블록을 잡지 않았다.
do {
// 화면 어딘가에 낙하 중인 블록이 있을 때는 잡을 수 없다.
if(this.is_has_falling_block()) {
//break;
}
// 마우스를 클릭한 순간이 아니다.
if(!Input.GetMouseButtonDown(0)) {
break;
}
// 잡을 수 있는지 모든 블록으로 검사한다.
foreach(BlockControl block in this.blocks) {
// 잡을 수 없는 상태의 블록은 패스.
if(!block.isGrabbable()) {
continue;
}
// 마우스 커서가 겹쳐있지 않은 블록은 패스.
if(!block.isContainedPosition(mouse_position_xy)) {
continue;
}
this.grabbed_block = block;
this.grabbed_block.beginGrab();
this.sound_control.playSound(Sound.SOUND.GRAB); // sound.
break;
}
} while(false);
} else {
// 블록 잡는 중.
do {
// (임시) 일단 화살표를 지운다..
this.hideArrow();
BlockControl swap_target = this.getNextBlock(grabbed_block, grabbed_block.slide_dir);
if(swap_target == null) {
break;
}
// 잡을 수 없는 블록(사라지는 중, 낙하 중 등)은 교체할 수 없다.
if(!swap_target.isGrabbable()) {
break;
}
// 슬라이드 할 수 있을 때는 화살표 표시.
this.dispArrow(grabbed_block, grabbed_block.slide_dir);
// 블록의 중심 위치에서 마우스 커서까지의 거리.
float offset = this.grabbed_block.calcDirOffset(mouse_position_xy, this.grabbed_block.slide_dir);
// 잡은 블록이 절반이상 슬라이드했다면 이웃 블록과 교체.
if(offset < Block.COLLISION_SIZE/2.0f) {
break;
}
// 교체 시작.
this.swapBlock(grabbed_block, grabbed_block.slide_dir, swap_target);
this.hideArrow();
this.grabbed_block = null;
this.sound_control.playSound(Sound.SOUND.SLIDE); // sound.
} while(false);
// 버튼에서 손을 떼면 블록을 놓는다
if(!Input.GetMouseButton(0)) {
this.grabbed_block.endGrab();
this.grabbed_block = null;
}
}
// ---------------------------------------------------------------- //
// 발화 검사.
// 낙하 중인 블록이 있다 = 연쇄가 끊겼을 때.
if(this.is_has_falling_block()){
// 연쇄 수를 클리어한다.
this.score_counter.clearIgniteCount();
}
if(this.is_has_falling_block() || this.is_has_sliding_block()) {
// 화면 안 어딘가에서 낙하 중이나 슬라이드 중인 블록이 있을.
// 때는 발화 검사를 하지 않는다.
} else {
// 발화한 블록의 수를 센다.
int ignite_count = 0;
foreach(BlockControl block in this.blocks) {
if(!block.isIdle()) {
continue;
}
if(this.checkConnection(block)) {
ignite_count++;
}
}
// 어딘가에서 블록이 발화했다면.
if(ignite_count > 0) {
// this.sound_control.isSoundPlay(Sound.SOUND.IGNIT1); // sound.
if(!this.is_vanishing_prev) {
// 발화 시작 시에 발화 카운트를 클리어한다.
this.score_counter.clearIgniteCount();
}
// 발화 횟수를 플러스한다.
this.score_counter.addIgniteCount(ignite_count);
this.score_counter.updateTotalScore(); // asuna
// 발화 중인 블록 전체의 발화 중 타이머를 되돌린다.
// 하는 김에 발화 블록 수도 센다.
int block_count = 0;
foreach(BlockControl block in this.blocks) {
if(block.isVanishing()) {
block.rewindVanishTimer();
block_count++;
}
}
// 발화한 블록 수를 센다.
this.score_counter.setIgniteBlockCount(block_count);
if(this.score_counter.getIgniteCount() >= 5) {
this.neco_fever = true;
}
// 섬의 수를 센다.
this.count_islands();
}
}
// ---------------------------------------------------------------- //
// 사라진 블록 위에 있는 블록을 아래로 떨어뜨린다.
bool is_vanishing = this.is_has_vanishing_block();
do {
// 사라지는 중인 블록(정리할 수 있는)後づけできる）이 있는 동안은.
// 낙하를 시작하지 않는다.
if(is_vanishing) {
break;
}
// 슬라이드 중인 블록이 있을 경우도 낙하를 시작하지 않는다.
if(this.is_has_sliding_block()) {
break;
}
// ------------------------------------------------------ //
for(int x = 0;x < Block.BLOCK_NUM_X;x++) {
// 이 예의 어딘가에 슬라이드 중인 블록이 있으면 패스.
if(this.is_has_sliding_block_in_column(x)) {
continue;
}
for(int y = 0;y < Block.BLOCK_NUM_Y - 1;y++) {
if(!this.blocks[x, y].isVacant()) {
continue;
}
for(int y1 = y + 1;y1 < Block.BLOCK_NUM_Y;y1++) {
if(this.blocks[x, y1].isVacant()) {
continue;
}
// [x, y] ~ [x, y1 - 1]의 블록이 사라졌으므로 [x, y1]에 있는.
// 블록을 아래로 떨어뜨린다.
this.fallBlock(this.blocks[x, y], Block.DIR4.UP, this.blocks[x, y1]);
break;
}
}
}
// 스키마 상의 블록을 아래로 떨어뜨린 다음, 비어있는 곳에
// 새로 블록을 만든다(화면 위에서 내려온다).
//
for(int x = 0;x < Block.BLOCK_NUM_X;x++) {
// 새로운 블록이 출현하는 위치.
int fall_start_y = Block.BLOCK_NUM_Y;
for(int y = 0;y < Block.BLOCK_NUM_Y;y++) {
if(!this.blocks[x, y].isVacant()) {
continue;
}
this.blocks[x, y].beginRespawn(fall_start_y);
// 동시에 출현하는 블록이 겹치지 않도록.
// 출현 위치를 위로 올린다.
fall_start_y++;
}
}
} while(false);
// ---------------------------------------------------------------- //
if(!is_vanishing && this.is_vanishing_prev) {
// 총 점수를 갱신한다.
// 발화가 끝나면 이번 발화로 얻은 점수가 합산되어 들어가도록.
this.score_counter.updateTotalScore();
this.sound_control.playSound(Sound.SOUND.CLEAR); // sound.
}
this.is_vanishing_prev = is_vanishing;
}
// 낙하시작(아래에 있는 블록이 사라졌을 때).
public void beginFall(BlockControl start)
{
this.next_step = Block.STEP.FALL;
this.position_offset.y = (float)(start.i_pos.y - this.i_pos.y)*Block.COLLISION_SIZE;
}
// ================================================================ //
// 블록을 떨어뜨린다.
public void fallBlock(BlockControl block0, Block.DIR4 dir, BlockControl block1)
{
// 낙하시킬 블록이 잡는 중이라면 놓는다.
if(this.grabbed_block == block0 || this.grabbed_block == block1) {
this.hideArrow();
this.grabbed_block = null;
}
//
Block.COLOR color0 = block0.color;
Block.COLOR color1 = block1.color;
Vector3 scale0 = block0.transform.localScale;
Vector3 scale1 = block1.transform.localScale;
float vanish_timer0 = block0.vanish_timer;
float vanish_timer1 = block1.vanish_timer;
bool visible0 = block0.isVisible();
bool visible1 = block1.isVisible();
Block.STEP step0 = block0.step;
Block.STEP step1 = block1.step;
float frame0 = 0.0f;
float frame1 = 0.0f;
if(color1 == Block.COLOR.NECO) {
frame0 = block0.getNekoMotion()["00_Idle"].time;
frame1 = block1.getNekoMotion()["00_Idle"].time;
}
//
block0.setColor(color1);
block1.setColor(color0);
block0.transform.localScale = scale1;
block1.transform.localScale = scale0;
block0.vanish_timer = vanish_timer1;
block1.vanish_timer = vanish_timer0;
block0.setVisible(visible1);
block1.setVisible(visible0);
block0.step = step1;
block1.step = step0;
if(color1 == Block.COLOR.NECO) {
block0.getNekoMotion()["00_Idle"].time = frame1;
block1.getNekoMotion()["00_Idle"].time = frame0;
}
block0.beginFall(block1);
}
