// ================================================================ //
// 블록을 떨어뜨린다.
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.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);
}
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);
}
// 인수 color의 색으로 블록을 칠한다.
public void setColor(Block.COLOR color)
{
this.color = color; // 이번에 지정된 색을 멤버 변수에 보관.
Color color_value; // Color클래스는 색을 나타낸다.
switch (this.color) // 칠할 색에 따라서 갈라진다.
{
default:
case Block.COLOR.PINK:
color_value = new Color(1.0f, 0.5f, 0.5f);
break;
case Block.COLOR.BLUE:
color_value = Color.blue;
break;
case Block.COLOR.YELLOW:
color_value = Color.yellow;
break;
case Block.COLOR.GREEN:
color_value = Color.green;
break;
case Block.COLOR.MAGENTA:
color_value = Color.magenta;
break;
case Block.COLOR.ORANGE:
color_value = new Color(1.0f, 0.46f, 0.0f);
break;
}
// 이 GameObject의 머티리얼 색상을 변경.
this.renderer.material.color = color_value;
}
public Block.COLOR selectBlockColor()
{
Block.COLOR color = Block.COLOR.FIRST;
// 이번 레벨의 레벨 데이터를 가져온다.
LevelData level_data =
this.level_control.getCurrentLevelData();
float rand = Random.Range(0.0f, 1.0f); // 0.0~1.0 사이의 난수.
float sum = 0.0f; // 출현 확률의 합계.
int i = 0;
// 블록의 종류 전체를 처리하는 루프.
for (i = 0; i < level_data.probability.Length - 1; i++)
{
if (level_data.probability[i] == 0.0f)
{
continue; // 출현 확률이 0이면 루프의 처음으로 점프.
}
sum += level_data.probability[i]; // 출현 확률을 더한다.
if (rand < sum)
{ // 합계가 난숫값을 웃돌면.
break; // 루프를 빠져나온다.
}
}
color = (Block.COLOR)i; // i번째 색을 반환한다.
return(color);
}
// 引数colorの色で、ブロックを塗る
public void setColor(Block.COLOR color)
{
this.color = color; // 今回指定された色をメンバー変数に保管
Color color_value; // Colorクラスは色を表す
switch (this.color) // 塗るべき色によって分岐
{
default:
case Block.COLOR.PINK:
color_value = new Color(1.0f, 0.5f, 0.5f);
break;
case Block.COLOR.BLUE:
color_value = Color.blue;
break;
case Block.COLOR.YELLOW:
color_value = Color.yellow;
break;
case Block.COLOR.GREEN:
color_value = Color.green;
break;
case Block.COLOR.MAGENTA:
color_value = Color.magenta;
break;
case Block.COLOR.ORANGE:
color_value = new Color(1.0f, 0.46f, 0.0f);
break;
}
// このGameObjectのマテリアルカラーを変更
gameObject.GetComponent <Renderer>().material.color = color_value;
}
// 블록의 색을 설정한다.
public void setColor(Block.COLOR color)
{
this.color = color;
if (this.models != null)
{
foreach (var model in this.models)
{
model.SetActive(false);
}
switch (this.color)
{
case Block.COLOR.PINK:
case Block.COLOR.BLUE:
case Block.COLOR.YELLOW:
case Block.COLOR.GREEN:
case Block.COLOR.MAGENTA:
case Block.COLOR.ORANGE:
case Block.COLOR.NECO:
{
this.models[(int)this.color].SetActive(true);
}
break;
}
}
}
// 블록을 만들어 내고 가로 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);
}
}
}
public void setColor(Block.COLOR color)
{
this.color = color;
Color color_value;
switch (this.color)
{
default:
case Block.COLOR.PINK:
color_value = new Color(1.0f, 0.5f, 0.5f);
break;
case Block.COLOR.BLUE:
color_value = Color.blue;
break;
case Block.COLOR.YELLOW:
color_value = Color.yellow;
break;
case Block.COLOR.GREEN:
color_value = Color.green;
break;
case Block.COLOR.MAGENTA:
color_value = Color.magenta;
break;
case Block.COLOR.ORANGE:
color_value = new Color(1.0f, 0.46f, 0.0f);
break;
}
this.GetComponent <Renderer>().material.color = color_value;
}
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 Block.COLOR selectBlockColor()
{
Block.COLOR color = Block.COLOR.FIRST;
// 今回のレベルのレベルデータを取得
LevelData level_data = this.level_control.getCurrentLevelData();
float rand = Random.Range(0.0f, 1.0f); // 0.0～1.0の間の乱数値
float sum = 0.0f; // 出現確率の合計
int i = 0;
// ブロックの種類全てを処理するループ
for (i = 0; i < level_data.probability.Length - 1; i++)
{
if (level_data.probability[i] == 0.0f)
{
continue; // 出現確率が0ならループの先頭にジャンプ
}
sum += level_data.probability[i]; // 出現確率を加算
if (rand < sum) // 合計が乱数値を上回ったら
{
break; // ループを抜ける
}
}
color = (Block.COLOR)i; // i番目の色を返す
return(color);
}
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 setColor(Block.COLOR color)
{
this.color = color;
if(this.models != null) {
foreach(var model in this.models) {
model.SetActive(false);
}
switch(this.color) {
case Block.COLOR.PINK:
case Block.COLOR.BLUE:
case Block.COLOR.YELLOW:
case Block.COLOR.GREEN:
case Block.COLOR.MAGENTA:
case Block.COLOR.ORANGE:
case Block.COLOR.NECO:
{
this.models[(int)this.color].SetActive(true);
}
break;
}
}
}
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 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); // 이동할 곳의 블록 이동을 시작.
}
// 섬의 수를 센다.
private void count_islands()
{
for (int y = 0; y < Block.BLOCK_NUM_Y; y++)
{
for (int x = 0; x < Block.BLOCK_NUM_X; x++)
{
this.block_islands[x, y] = -1;
}
}
int island_index = 0;
int max_connect = 0;
Block.COLOR block_color = Block.COLOR.NONE;
for (int y = 0; y < Block.BLOCK_NUM_Y; y++)
{
for (int x = 0; x < Block.BLOCK_NUM_X; x++)
{
block_color = this.blocks[x, y].color;
int connect_count = this.check_island_sub(x, y, block_color, island_index, 0);
if (connect_count > 0)
{
island_index++;
max_connect = Mathf.Max(max_connect, connect_count);
}
}
}
this.score_counter.setIslandCount(island_index);
this.score_counter.setMaxIslandSize(max_connect);
}
public void beginRespawn(int start_ipos_y)
{
// 指定位置までy座標を移動
this.position_offset.y = (float)(start_ipos_y - this.i_pos.y) * Block.COLLISION_SIZE;
this.next_step = Block.STEP.FALL;
// 現在のレベルの出現確率に基づいて、ブロックの色を決める
Block.COLOR color = this.block_root.selectBlockColor();
this.setColor(color);
}
public void beginRespawn(int start_ipos_y)
{ // 색이바꿔낙하상태로하고지정한위치에재배치한다.
this.position_offset.y = (float)(start_ipos_y - this.i_pos.y) * Block.COLLISION_SIZE; // 지정위치까지y좌표를이동.
this.next_step = Block.STEP.FALL;
// 주석처리혹은삭제
// int color_index= Random.Range((int)Block.COLOR.FIRST, (int)Block.COLOR.LAST+ 1);
// this.setColor((Block.COLOR)color_index);
// 현재레벨의출현확률을바탕으로블록의색을결정한다.
Block.COLOR color = this.block_root.selectBlockColor();
this.setColor(color);
//this.GetComponent<MeshRenderer>().material.mainTexture = Resources.Load("Sword_Square") as Texture;
}
// 초기 배치.
public void initialSetUp()
{
// 블록 생성, 배치.
this.blocks = new BlockControl[Block.BLOCK_NUM_X, Block.BLOCK_NUM_Y];
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++)
{
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;
block.leave_block_root = this.leave_block_root;
//
Vector3 position = BlockRoot.calcBlockPosition(block.i_pos);
block.transform.position = position;
color = this.selectBlockColor();
block.setColor(color);
// 하이어라키 뷰에서 위치를 확인하기 쉽게 블록의 좌표를 이름에 붙여 둔다.
block.name = "block(" + block.i_pos.x.ToString() + "," + block.i_pos.y.ToString() + ")";
}
}
//
this.block_islands = new int[Block.BLOCK_NUM_X, Block.BLOCK_NUM_Y];
for (int y = 0; y < Block.BLOCK_NUM_Y; y++)
{
for (int x = 0; x < Block.BLOCK_NUM_X; x++)
{
this.block_islands[x, y] = -1;
}
}
}
// 사라진 후에 위에서 내려오는 처리 시작.
public void beginRespawn(int start_ipos_y)
{
this.position_offset.y = (float)(start_ipos_y - this.i_pos.y) * Block.COLLISION_SIZE;
this.next_step = Block.STEP.FALL;
Block.COLOR color = this.block_root.selectBlockColor();
this.setColor(color);
for (int i = 0; i < this.connected_block.Length; i++)
{
this.connected_block[i].clear();
}
}
public void beginRespawn(int start_ipos_y)
{
// 지정 위치까지 y좌표를 이동.
this.position_offset.y =
(float)(start_ipos_y - this.i_pos.y) *
Block.COLLISION_SIZE;
this.next_step = Block.STEP.FALL;
// int color_index = Random.Range(
// (int)Block.COLOR.FIRST, (int)Block.COLOR.LAST + 1);
// this.setColor((Block.COLOR)color_index);
// 현재 레벨의 출현 확률을 바탕으로 블록의 색을 결정한다.
Block.COLOR color = this.block_root.selectBlockColor();
this.setColor(color);
}
// 블록을 만들어 내고, 가로 아홉 칸 세로 아홉 칸으로 배치.
public void initialSetUp()
{
// 크기는 9×9로 한다.
this.blocks =
new BlockControl[Block.BLOCK_NUM_X, Block.BLOCK_NUM_Y];
// 블록의 색 번호.
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 클래스를 가져온다.
BlockControl block = game_object.GetComponent <BlockControl>();
// 블록을 칸에 넣는다.
this.blocks[x, y] = block;
// 블록의 위치 정보(그리드 좌표)를 설정.
block.i_pos.x = x;
block.i_pos.y = y;
// 각 BlockControl이 연계하는 GameRoot는 자신이라고 설정.
block.block_root = this;
// 그리드 좌표를 실제 위치(씬 좌표)로 변환.
Vector3 position = BlockRoot.calcBlockPosition(block.i_pos);
// 씬 상의 블록 위치를 이동.
block.transform.position = position;
// 블록의 색을 변경.
// 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);
}
}
}
private int check_island_sub(int x, int y, Block.COLOR color, int island_index, int connect_count)
{
do
{
if (this.block_islands[x, y] != -1)
{
break;
}
if (!this.blocks[x, y].isVanishing())
{
continue;
}
if (this.blocks[x, y].color != color)
{
break;
}
//
this.block_islands[x, y] = island_index;
connect_count++;
if (0 < x)
{
connect_count = this.check_island_sub(x - 1, y, color, island_index, connect_count);
}
if (x < Block.BLOCK_NUM_X - 1)
{
connect_count = this.check_island_sub(x + 1, y, color, island_index, connect_count);
}
if (0 < y)
{
connect_count = this.check_island_sub(x, y - 1, color, island_index, connect_count);
}
if (y < Block.BLOCK_NUM_Y - 1)
{
connect_count = this.check_island_sub(x, y + 1, color, island_index, connect_count);
}
} while(false);
return(connect_count);
}
// ブロックを作り出して、横9ます、縦9マスに配置
public void initialSetUp()
{
// マス目のサイズを9×9にする
this.blocks = new BlockControl[Block.BLOCK_NUM_X, Block.BLOCK_NUM_Y];
// ブロックの色番号
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クラスを取得
BlockControl block = game_object.GetComponent <BlockControl>();
// ブロックをマス目に格納
this.blocks[x, y] = block;
// ブロックの位置情報（グリッド座標）を設定
block.i_pos.x = x;
block.i_pos.y = y;
// 各BlockControlが連携するGameRootは自分だと設定
block.block_root = this;
// グリッド座標を実際の位置（シーン上の座標）に変換
Vector3 position = BlockRoot.calcBlockPosition(block.i_pos);
// シーン上のブロックの位置を移動
block.transform.position = position;
// 今の出現確率に基づいて色を決める
color = this.selectBlockColor();
block.setColor(color);
// ブロックの名前を設定（後述）
block.name = "block(" + block.i_pos.x.ToString() + "," + block.i_pos.y.ToString() + ")";
// 全種類の色の中から、ランダムに1色を選択
color_index = Random.Range(0, (int)Block.COLOR.NORMAL_COLOR_NUM);
}
}
}
// 인수 color의 색으로 블록을 칠한다.
public void setColor(Block.COLOR color)
{
this.color = color; // 이번에 지정된 색을 멤버 변수에 보관한다.
Color color_value; // Color 클래스는 색을 나타낸다.
switch (this.color)
{ // 칠할 색에 따라서 갈라진다.
default:
case Block.COLOR.DOWN: //우
color_value = new Color(1.0f, 1.0f, 1.0f);
this.GetComponent <MeshRenderer>().material.mainTexture = Resources.Load("down") as Texture;
break;
case Block.COLOR.LEFT: // 공격
color_value = new Color(1.0f, 1.0f, 1.0f);
this.GetComponent <MeshRenderer>().material.mainTexture = Resources.Load("left") as Texture;
break;
case Block.COLOR.UP: // 가드
color_value = new Color(1.0f, 1.0f, 1.0f);
this.GetComponent <MeshRenderer>().material.mainTexture = Resources.Load("up") as Texture;
break;
case Block.COLOR.RIGHT: //상
color_value = new Color(1.0f, 1.0f, 1.0f);
this.GetComponent <MeshRenderer>().material.mainTexture = Resources.Load("right") as Texture;
break;
case Block.COLOR.ATTACK: //하
color_value = new Color(1.0f, 1.0f, 1.0f);
this.GetComponent <MeshRenderer>().material.mainTexture = Resources.Load("sword") as Texture;
break;
case Block.COLOR.SKILL: //좌
color_value = new Color(1.0f, 1.0f, 1.0f);
this.GetComponent <MeshRenderer>().material.mainTexture = Resources.Load("shiled") as Texture;
break;
}
this.GetComponent <Renderer>().material.color = color_value; // 이 게임 오브젝트의 색상을 변경한다.
}
public void SetColor(Block.COLOR color)
{
this.color = color;
Color color_value;
switch (this.color)
{
default:
case Block.COLOR.red:
color_value = Color.red;
break;
case Block.COLOR.blue:
color_value = Color.blue;
break;
case Block.COLOR.yellow:
color_value = Color.yellow;
break;
case Block.COLOR.green:
color_value = Color.green;
break;
case Block.COLOR.magenta:
color_value = Color.magenta;
break;
case Block.COLOR.cyan:
color_value = Color.cyan;
break;
case Block.COLOR.gray:
color_value = Color.gray;
break;
}
Renderer rd = GetComponent <Renderer>();
rd.material.color = color_value;
}
// 두 블록을 교체한다.
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 Block.COLOR selectBlockColor()
{
Block.COLOR color = Block.COLOR.FIRST;
LevelData level_data = this.level_control.getCurrentLevelData();
float rand = Random.Range(0.0f, 1.0f);
float sum = 0.0f;
int i = 0;
for (i = 0; i < level_data.probability.Length - 1; i++)
{
if (level_data.probability[i] == 0.0f)
{
continue;
}
sum += level_data.probability[i];
if (rand < sum)
{
break;
}
}
color = (Block.COLOR)i;
if (this.neco_fever)
{
if (color == Block.COLOR.BLUE)
{
color = Block.COLOR.NECO;
}
}
return(color);
}
// Update is called once per frame
void Update()
{
Vector3 mouse_position;
this.block_root.unprojectMousePosition(out mouse_position, Input.mousePosition);
Vector2 mouse_position_xy = new Vector2(mouse_position.x, mouse_position.y);
if (this.vanish_timer >= 0.0f)
{
this.vanish_timer -= Time.deltaTime;
if (this.vanish_timer < 0.0f)
{
if (this.step != Block.STEP.SLIDE)
{
this.vanish_timer = -1.0f;
this.next_step = Block.STEP.VACANT;
}
else
{
this.vanish_timer = 0.0f;
}
}
}
this.step_timer += Time.deltaTime;
float slide_time = 0.2f;
if (this.next_step == Block.STEP.NONE)
{
switch (this.step)
{
case Block.STEP.SLIDE:
if (this.step_timer >= slide_time)
{
if (this.vanish_timer == 0.0f)
{
this.next_step = Block.STEP.VACANT;
}
else
{
this.next_step = Block.STEP.IDLE;
}
}
break;
case Block.STEP.IDLE:
this.GetComponent <Renderer>().enabled = true;
break;
case Block.STEP.FALL:
if (this.position_offset.y <= 0.0f)
{
this.next_step = Block.STEP.IDLE;
this.position_offset.y = 0.0f;
}
break;
}
}
while (this.next_step != Block.STEP.NONE)
{
this.step = this.next_step;
this.next_step = Block.STEP.NONE;
switch (this.step)
{
case Block.STEP.IDLE:
this.position_offset = Vector3.zero;
this.transform.localScale = Vector3.one * 1.0f;
break;
case Block.STEP.GRABBED:
this.transform.localScale = Vector3.one * 1.2f;
break;
case Block.STEP.RELEASED:
this.position_offset = Vector3.zero;
this.transform.localScale = Vector3.one * 1.0f;
break;
case Block.STEP.VACANT:
this.position_offset = Vector3.zero;
this.setVisible(false);
break;
case Block.STEP.RESPAWN:
int color_index = Random.Range(0, (int)Block.COLOR.NORMAL_COLOR_NUM);
this.setColor((Block.COLOR)color_index);
this.next_step = Block.STEP.IDLE;
break;
case Block.STEP.FALL:
this.setVisible(true);
this.fall.velocity = 0.0f;
break;
}
this.step_timer = 0.0f;
}
switch (this.step)
{
case Block.STEP.GRABBED:
this.slide_dir = this.calcSlideDir(mouse_position_xy);
break;
case Block.STEP.SLIDE:
float rate = this.step_timer / slide_time;
rate = Mathf.Min(rate, 1.0f);
rate = Mathf.Sin(rate * Mathf.PI / 2.0f);
this.position_offset = Vector3.Lerp(this.position_offset_initial, Vector3.zero, rate);
break;
case Block.STEP.FALL:
this.fall.velocity += Physics.gravity.y * Time.deltaTime * 0.3f;
this.position_offset.y += this.fall.velocity * Time.deltaTime;
if (this.position_offset.y < 0.0f)
{
this.position_offset.y = 0.0f;
}
break;
}
Vector3 position = BlockRoot.calcBlockPosition(this.i_pos) + this.position_offset;
this.transform.position = position;
this.setColor(this.color);
if (this.vanish_timer >= 0.0f)
{
Color color0 = Color.Lerp(this.GetComponent <Renderer>().material.color, Color.white, 0.5f);
Color color1 = Color.Lerp(this.GetComponent <Renderer>().material.color, Color.black, 0.5f);
if (this.vanish_timer < Block.VANISH_TIME / 2.0f)
{
color0.a = this.vanish_timer / (Block.VANISH_TIME / 2.0f);
color1.a = color0.a;
this.GetComponent <Renderer>().material = this.transparent_material;
}
float rate = 1.0f - this.vanish_timer / Block.VANISH_TIME;
this.GetComponent <Renderer>().material.color = Color.Lerp(color0, color1, rate);
}
}
void Update()
{
Vector3 mouse_position; // マウスの位置
this.block_root.unprojectMousePosition(out mouse_position, Input.mousePosition); // マウスの位置を取得
// 取得したマウス位置をXとYだけにする
Vector2 mouse_position_xy = new Vector2(mouse_position.x, mouse_position.y);
if (this.vanish_timer >= 0.0f) // タイマーが0以上なら
{
this.vanish_timer -= Time.deltaTime; // タイマーの値を減らす
if (this.vanish_timer < 0.0f) // タイマーが0未満なら
{
if (this.step != Block.STEP.SLIDE) // スライド中でないなら
{
this.vanish_timer = -1.0f;
this.next_step = Block.STEP.VACANT; // 状態を「消滅中」に
}
else
{
this.vanish_timer = 0.0f;
}
}
}
this.step_timer += Time.deltaTime;
float slide_time = 0.2f;
if (this.next_step == Block.STEP.NONE) // 「状態情報なし」の場合
{
switch (this.step)
{
case Block.STEP.SLIDE:
if (this.step_timer >= slide_time)
{
// スライド中にブロックが消滅したら、VACANT(消える)状態に移行
if (this.vanish_timer == 0.0f)
{
this.next_step = Block.STEP.VACANT;
}
else // vanish_timerが0でないなら、IDLE(待機)状態に移行
{
this.next_step = Block.STEP.IDLE;
}
}
break;
case Block.STEP.IDLE:
this.GetComponent <Renderer>().enabled = true;
break;
case Block.STEP.FALL:
if (this.position_offset.y <= 0.0f)
{
this.next_step = Block.STEP.IDLE;
this.position_offset.y = 0.0f;
}
break;
}
}
// 「次のブロック」の状態が「情報なし」以外である間
// ＝「次のブロック」の状態が変更されていた場合
while (this.next_step != Block.STEP.NONE)
{
this.step = this.next_step;
this.next_step = Block.STEP.NONE;
switch (this.step)
{
case Block.STEP.IDLE: // 「待機」状態
this.position_offset = Vector3.zero;
// ブロックの表示サイズを通常サイズにする
this.transform.localScale = Vector3.one * 1.0f;
break;
case Block.STEP.GRABBED: // 「つかまれている」状態
// ブロックの表示サイズを大きくする
this.transform.localScale = Vector3.one * 1.2f;
break;
case Block.STEP.RELEASED: // 「離されている」状態
this.position_offset = Vector3.zero;
// ブロックの表示サイズを通常サイズにする
this.transform.localScale = Vector3.one * 1.0f;
break;
case Block.STEP.VACANT:
this.position_offset = Vector3.zero;
this.setVisible(false); // ブロックを非表示に
break;
case Block.STEP.RESPAWN:
// 色をランダムに選び、ブロックをその色に設定
int color_index = Random.Range(0, (int)Block.COLOR.NORMAL_COLOR_NUM);
this.setColor((Block.COLOR)color_index);
this.next_step = Block.STEP.IDLE;
break;
case Block.STEP.FALL:
this.setVisible(true); // ブロックを表示
this.fall.velocity = 0.0f; // 落下速度をリセット
break;
}
this.step_timer = 0.0f;
}
switch (this.step)
{
case Block.STEP.GRABBED: // 「つかまれた」状態
// 「つかまれた」状態のときは、常にスライド方向をチェック
this.slide_dir = this.calcSlideDir(mouse_position_xy);
break;
case Block.STEP.SLIDE: // スライド（入れ替え）中
// ブロックを徐々に移動する処理（難しいので今は分からなくても大丈夫です）
float rate = this.step_timer / slide_time;
rate = Mathf.Min(rate, 1.0f);
rate = Mathf.Sin(rate * Mathf.PI / 2.0f);
this.position_offset = Vector3.Lerp(this.position_offset_initial, Vector3.zero, rate);
break;
case Block.STEP.FALL:
// 速度に、重力の影響を与える
this.fall.velocity += Physics.gravity.y * Time.deltaTime * 0.3f;
// 縦方向の位置を計算
this.position_offset.y += this.fall.velocity * Time.deltaTime;
if (this.position_offset.y < 0.0f) // 落下しきったら
{
this.position_offset.y = 0.0f; // その場に留める
}
break;
}
// グリッド座標を実座標（シーン上の座標）に変換し、position_offsetを加える
Vector3 position = BlockRoot.calcBlockPosition(this.i_pos) + this.position_offset;
// 実際の位置を、新しい位置に変更
this.transform.position = position;
this.setColor(this.color);
if (this.vanish_timer >= 0.0f)
{
// 現在のレベルの燃焼時間に設定
float vanish_time = this.block_root.level_control.getVanishTime();
Color color0 = Color.Lerp(this.GetComponent <Renderer>().material.color, Color.white, 0.5f); // 現在の色と白との中間色
Color color1 = Color.Lerp(this.GetComponent <Renderer>().material.color, Color.black, 0.5f); // 現在の色と黒との中間色
// 着火演出時間の半分を過ぎたら
if (this.vanish_timer < Block.VANISH_TIME / 2.0f)
{
// 透明度(a)を設定
color0.a = this.vanish_timer / (Block.VANISH_TIME / 2.0f);
color1.a = color0.a;
// 半透明マテリアルを適用
this.GetComponent <Renderer>().material = this.transparent_material;
}
// vanish_timerが減るほど1に近づく
float rate = 1.0f - this.vanish_timer / Block.VANISH_TIME;
// じわ～っと色を変える
this.GetComponent <Renderer>().material.color = Color.Lerp(color0, color1, rate);
}
}
void Update()
{
Vector3 mouse_position; // 마우스 위치.
this.block_root.unprojectMousePosition( // 마우스 위치를 가져온다.
out mouse_position, Input.mousePosition);
// 가져온 마우스 위치를 X와 Y만으로 한다(하나의 Vector2로 모은다).
Vector2 mouse_position_xy = new Vector2(mouse_position.x, mouse_position.y);
if(this.vanish_timer >= 0.0f) { // 타이머가 0 이상이면.
this.vanish_timer -= Time.deltaTime; // 타이머의 값을 줄인다.
if(this.vanish_timer < 0.0f) { // 타이머가 0 미만이면.
if(this.step != Block.STEP.SLIDE) { // 슬라이드 중이 아니라면.
this.vanish_timer = -1.0f;
this.next_step = Block.STEP.VACANT; // 상태를 '소멸 중'으로.
} else {
this.vanish_timer = 0.0f;
}
}
}
this.step_timer += Time.deltaTime;
float slide_time = 0.2f;
if(this.next_step == Block.STEP.NONE) { // 상태 정보가 없는 상태.
switch(this.step) {
case Block.STEP.SLIDE:
if(this.step_timer >= slide_time) {
// vanish_timer(사라질 때까지의 시간)가 0이면.
// VACANT(사라지는)상태로 전환.
if(this.vanish_timer == 0.0f) {
this.next_step = Block.STEP.VACANT;
// vanish_timer가 0이 아니면.
// IDLE(대기)상태로 전환.
} else {
this.next_step = Block.STEP.IDLE;
}
}
break;
case Block.STEP.IDLE:
this.GetComponent<Renderer>().enabled = true;
break;
case Block.STEP.FALL:
if(this.position_offset.y <= 0.0f) {
this.next_step = Block.STEP.IDLE;
this.position_offset.y = 0.0f;
}
break;
}
}
// '다음 블록'의 상태가 '정보 없음' 이외인 동안에.
// = '다음 블록'의 상태가 변경된 경우.
while(this.next_step != Block.STEP.NONE) {
this.step = this.next_step;
this.next_step = Block.STEP.NONE;
switch(this.step) {
case Block.STEP.IDLE: // '대기' 상태.
this.position_offset = Vector3.zero;
// 블록 표시 크기를 일반 크기로 한다.
this.transform.localScale = Vector3.one * 1.0f;
break;
case Block.STEP.GRABBED: // '잡힌 상태'.
// 블록 표시 크기를 크게 한다.
this.transform.localScale = Vector3.one * 1.2f;
break;
case Block.STEP.RELEASED: // '놓은 상태'.
this.position_offset = Vector3.zero;
// 블록 표시 크기를 일반 크기로 한다.
this.transform.localScale = Vector3.one * 1.0f;
break;
case Block.STEP.VACANT:
this.position_offset = Vector3.zero;
this.setVisible(false); // 블록이 표시되지 않게.
break;
case Block.STEP.RESPAWN:
// 색을 랜덤하게 선택하여 블록을 선택한 색으로 설정.
int color_index = Random.Range(
0, (int)Block.COLOR.NORMAL_COLOR_NUM);
this.setColor((Block.COLOR)color_index);
this.next_step = Block.STEP.IDLE;
break;
case Block.STEP.FALL:
this.setVisible(true); // 블록을 표시.
this.fall.velocity = 0.0f; // 낙하 속도를 리셋.
break;
}
this.step_timer = 0.0f;
}
switch(this.step) {
case Block.STEP.GRABBED: // '잡힌 상태'.
// '잡힌 상태'일 때는 항상 슬라이드 방향을 체크.
this.slide_dir = this.calcSlideDir(mouse_position_xy);
break;
case Block.STEP.SLIDE: // 슬라이드(교체) 중.
// 블록을 서서히 이동하는 처리.
// (어려우니 지금은 몰라도 괜찮다).
float rate = this.step_timer / slide_time;
rate = Mathf.Min(rate, 1.0f);
rate = Mathf.Sin(rate*Mathf.PI / 2.0f);
this.position_offset = Vector3.Lerp(
this.position_offset_initial, Vector3.zero, rate);
break;
case Block.STEP.FALL:
// 속도에 중력의 영향을 준다.
this.fall.velocity += Physics.gravity.y * Time.deltaTime * 0.3f;
// 세로 방향 위치를 계산.
this.position_offset.y += this.fall.velocity * Time.deltaTime;
if(this.position_offset.y < 0.0f) { // 다 내려왔다면.
this.position_offset.y = 0.0f; // 그 자리에 머문다.
}
break;
}
// 그리드 좌표를 실제 좌표(씬의 좌표)로 변환하고.
// position_offset를 더한다.
Vector3 position =
BlockRoot.calcBlockPosition(this.i_pos) + this.position_offset;
// 실제 위치를 새로운 위치로 변경.
this.transform.position = position;
this.setColor(this.color);
if(this.vanish_timer >= 0.0f) {
Color color0 = // 현재 색과 흰색의 중간 색.
Color.Lerp(this.GetComponent<Renderer>().material.color, Color.white, 0.5f);
Color color1 = // 현재 색과 검은색의 중간 색.
Color.Lerp(this.GetComponent<Renderer>().material.color, Color.black, 0.5f);
// 발화 연출 시간의 절반을 지났다면.
if(this.vanish_timer < Block.VANISH_TIME / 2.0f) {
// 투명도(a)를 설정.
color0.a = this.vanish_timer / (Block.VANISH_TIME / 2.0f);
color1.a = color0.a;
// 반투명 머티리얼을 적용.
this.GetComponent<Renderer>().material = this.transparent_material;
}
// vanish_timer가 줄어들 수록 1에 가까워진다.
float rate = 1.0f - this.vanish_timer / Block.VANISH_TIME;
// 서서히 색을 바꾼다.
this.GetComponent<Renderer>().material.color = Color.Lerp(color0, color1, rate);
}
}
// 인수 color의 색으로 블록을 칠한다.
public void setColor(Block.COLOR color)
{
this.color = color; // 현재 지정된 색을 멤버 변수에 보관.
Color color_value; // Color 클래스는 색을 나타낸다.
switch(this.color) { // 칠할 색에 따라서 분기한다.
default:
case Block.COLOR.PINK:
color_value = new Color(1.0f, 0.5f, 0.5f);
break;
case Block.COLOR.BLUE:
color_value = Color.blue;
break;
case Block.COLOR.YELLOW:
color_value = Color.yellow;
break;
case Block.COLOR.GREEN:
color_value = Color.green;
break;
case Block.COLOR.MAGENTA:
color_value = Color.magenta;
break;
case Block.COLOR.ORANGE:
color_value = new Color(1.0f, 0.46f, 0.0f);
break;
}
// 이 GameObject의 머티리얼 색상을 변경.
this.GetComponent<Renderer>().material.color = color_value;
}
public void setColor(Block.COLOR color)
{
this.color=color;
Color color_value;
switch(this.color) {
default:
case Block.COLOR.PINK:
color_value = new Color(1.0f,0.5f,0.5f);
break;
case Block.COLOR.BLUE:
color_value= Color.blue;
break;
case Block.COLOR.YELLOW:
color_value=Color.yellow;
break;
case Block.COLOR.GREEN:
color_value=Color.green;
break;
case Block.COLOR.MAGENTA:
color_value=Color.magenta;
break;
case Block.COLOR.ORANGE:
color_value = new Color(1.0f,0.46f,0.0f);
break;
}
this.renderer.material.color = color_value;
}
void Update()
{
Vector3 mouse_position; // 마우스 위치.
this.block_root.unprojectMousePosition( // 마우스 위치를 가져온다.
out mouse_position, Input.mousePosition);
// 가져온 마우스 위치를 하나의 Vector2에 모은다.
Vector2 mouse_position_xy = new Vector2(mouse_position.x, mouse_position.y);
if (this.vanish_timer >= 0.0f) // 타이머가 0이상이면.
{
this.vanish_timer -= Time.deltaTime; // 타이머의 값을 줄인다.
if (this.vanish_timer < 0.0f) // 타이머가 0 미만이면.
{
if (this.step != Block.STEP.SLIDE) // 슬라이드 중이 아니라면.
{
this.vanish_timer = -1.0f;
this.next_step = Block.STEP.VACANT; // 상태를 '소멸 중'으로.
}
else
{
this.vanish_timer = 0.0f;
}
}
}
this.step_timer += Time.deltaTime;
float slide_time = 0.2f;
if (this.next_step == Block.STEP.NONE) // 상태 정보 없음인 경우.
{
switch (this.step)
{
case Block.STEP.SLIDE:
if (this.step_timer >= slide_time)
{
// vanish_timer(사라질 때까지의 시간)가 0이면.
// VACANT(사라진)상태로 전환.
if (this.vanish_timer == 0.0f)
{
this.next_step = Block.STEP.VACANT;
// vanish_timer가 0이 아니면.
// IDLE（대기）상태로 전환.
}
else
{
this.next_step = Block.STEP.IDLE;
}
}
break;
case Block.STEP.IDLE:
this.renderer.enabled = true;
break;
case Block.STEP.FALL:
if (this.position_offset.y <= 0.0f)
{
this.next_step = Block.STEP.IDLE;
this.position_offset.y = 0.0f;
}
break;
}
}
// '다음 블록'의 상태가 '정보 없음' 이외인 동안.
// = '다음 블록'의 상태가 변경된 경우.
while (this.next_step != Block.STEP.NONE)
{
this.step = this.next_step;
this.next_step = Block.STEP.NONE;
switch (this.step)
{
case Block.STEP.IDLE: // '대기' 상태.
this.position_offset = Vector3.zero;
// 블록의 표시 크기를 일반 크기로 한다.
this.transform.localScale = Vector3.one * 1.0f;
break;
case Block.STEP.GRABBED: // '잡힌 상태'.
// 블록 표시 크기를 크게 한다.
this.transform.localScale = Vector3.one * 1.2f;
break;
case Block.STEP.RELEASED: // '놓은 상태'.
this.position_offset = Vector3.zero;
// 블록의 표시 크기를 일반 크기로 한다.
this.transform.localScale = Vector3.one * 1.0f;
break;
case Block.STEP.VACANT:
this.position_offset = Vector3.zero;
this.setVisible(false); // 블록을 비표시로.
break;
case Block.STEP.RESPAWN:
// 색을 랜덤하게 선택하여 블록을 그 색으로 설정.
int color_index = Random.Range(
0, (int)Block.COLOR.NORMAL_COLOR_NUM);
this.setColor((Block.COLOR)color_index);
this.next_step = Block.STEP.IDLE;
break;
case Block.STEP.FALL:
this.setVisible(true); // 블록을 표시.
this.fall.velocity = 0.0f; // 낙하 속도를 리셋.
break;
}
this.step_timer = 0.0f;
}
switch (this.step)
{
case Block.STEP.GRABBED: // '잡힌 상태'.
// '잡힌 상태'일 때는 항상 슬라이드 방향을 체크.
this.slide_dir = this.calcSlideDir(mouse_position_xy);
break;
case Block.STEP.SLIDE: // 슬라이드(교체) 중.
// 블록을 서서히 이동하는 처리.
// (어려우므로 지금은 몰라도 괜찮다).
float rate = this.step_timer / slide_time;
rate = Mathf.Min(rate, 1.0f);
rate = Mathf.Sin(rate * Mathf.PI / 2.0f);
this.position_offset = Vector3.Lerp(
this.position_offset_initial, Vector3.zero, rate);
break;
case Block.STEP.FALL:
// 속도에 중력의 영향을 준다.
this.fall.velocity += Physics.gravity.y * Time.deltaTime * 0.3f;
// 세로 방향 위치를 계산.
this.position_offset.y += this.fall.velocity * Time.deltaTime;
if (this.position_offset.y < 0.0f) // 다 내려왔다면.
{
this.position_offset.y = 0.0f; // 그 자리에 머문다.
}
break;
}
// 그리드 좌표를 실제 좌표(씬의 좌표)로 변환하고.
// position_offset를 더한다.
Vector3 position =
BlockRoot.calcBlockPosition(this.i_pos) + this.position_offset;
// 실제 위치를 새로운 위치로 변경.
this.transform.position = position;
this.setColor(this.color);
if (this.vanish_timer >= 0.0f)
{
Color color0 = // 현재 색과 흰색의 중간 색.
Color.Lerp(this.renderer.material.color, Color.white, 0.5f);
Color color1 = // 현재 색과 검은색의 중간 색.
Color.Lerp(this.renderer.material.color, Color.black, 0.5f);
// 발화 연출 시간의 절반을 지났다면.
if (this.vanish_timer < Block.VANISH_TIME / 2.0f)
{
// 투명도(a)를 설정.
color0.a = this.vanish_timer / (Block.VANISH_TIME / 2.0f);
color1.a = color0.a;
// 반투명 머티리얼을 적용.
this.renderer.material = this.transparent_material;
}
// vanish_timer가 줄어들 수록 1에 가까워진다.
float rate = 1.0f - this.vanish_timer / Block.VANISH_TIME;
// 서서히 색을 바꾼다.
this.renderer.material.color = Color.Lerp(color0, color1, rate);
}
}
// Update is called once per frame
void Update()
{
Vector3 mouse_position;
this.block_root.unprojectMousePosition(
out mouse_position, Input.mousePosition);
Vector2 mouse_position_xy =
new Vector2 (mouse_position.x, mouse_position.y);
if(this.vanish_timer>= 0.0f){
this.vanish_timer-=Time.deltaTime;
if(this.vanish_timer<0.0f){
if(this.step != Block.STEP.SLIDE){
this.vanish_timer=-1.0f;
this.next_step=Block.STEP.VACANT;
}else{
this.vanish_timer=0.0f;
}
}
}
this.step_timer += Time.deltaTime;
float slide_time=0.2f;
if(this.next_step==Block.STEP.NONE){
switch(this.step){
case Block.STEP.SLIDE:
if(this.step_timer>=slide_time){
if(this.vanish_timer==0.0f){
this.next_step=Block.STEP.VACANT;
}else{
this.next_step=Block.STEP.IDLE;
}
}
break;
case Block.STEP.IDLE:
this.renderer.enabled=true;
break;
case Block.STEP.FALL:
if(this.position_offset.y<=0.0f){
this.next_step=Block.STEP.IDLE;
this.position_offset.y=0.0f;
}
break;
}
}
while(this.next_step != Block.STEP.NONE){
this.step =this.next_step;
this.next_step=Block.STEP.NONE;
switch(this.step){
case Block.STEP.IDLE:
this.position_offset=Vector3.zero;
this.transform.localScale=Vector3.one*1.0f;
break;
case Block.STEP.GRABBED:
this.transform.localScale=Vector3.one*1.2f;
break;
case Block.STEP.RELEASED:
this.position_offset=Vector3.zero;
this.transform.localScale=Vector3.one*1.0f;
break;
case Block.STEP.VACANT:
this.position_offset=Vector3.zero;
this.setVisible(false);
break;
case Block.STEP.RESPAWN:
int color_index=Random.Range(0,(int)Block.COLOR.NORMAL_COLOR_NUM);
this.setColor((Block.COLOR)color_index);
this.next_step=Block.STEP.IDLE;
break;
}
this.step_timer=0.0f;
}
switch(this.step){
case Block.STEP.GRABBED:
this.slide_dir=this.calcSlideDir(mouse_position_xy);
break;
case Block.STEP.SLIDE:
float rate = this.step_timer/slide_time;
rate=Mathf.Min(rate,1.0f);
rate=Mathf.Sin (rate*Mathf.PI/2.0f);
this.position_offset=Vector3.Lerp(
this.position_offset_initial,Vector3.zero,rate);
break;
case Block.STEP.FALL:
this.fall.velocity+=Physics.gravity.y*Time.deltaTime*0.3f;
this.position_offset.y+=this.fall.velocity*Time.deltaTime;
if(this.position_offset.y<0.0f){
this.position_offset.y=0.0f;
}
break;
}
Vector3 position= BlockRoot.calcBlockPosition(this.i_pos)+this.position_offset;
this.transform.position=position;
this.setColor(this.color);
if(this.vanish_timer >= 0.0f){
Color color0=
Color.Lerp(this.renderer.material.color,Color.white,0.5f);
Color color1=
Color.Lerp(this.renderer.material.color,Color.black,0.5f);
if(this.vanish_timer<Block.VANISH_TIME/2.0f){
color0.a = this.vanish_timer/(Block.VANISH_TIME/2.0f);
color1.a=color0.a;
this.renderer.material=this.transparent_material;
}
float rate = 1.0f - this.vanish_timer/Block.VANISH_TIME;
this.renderer.material.color=Color.Lerp(color0,color1,rate);
}
}
void Update()
{
Vector3 mouse_position; // マウスの位置.
this.block_root.unprojectMousePosition( // マウスの位置を取得.
out mouse_position, Input.mousePosition);
// 取得したマウス位置を1つのVector2にまとめる.
Vector2 mouse_position_xy = new Vector2(mouse_position.x, mouse_position.y);
if(this.vanish_timer >= 0.0f) { // タイマーが0以上なら.
this.vanish_timer -= Time.deltaTime; // タイマーの値を減らす.
if(this.vanish_timer < 0.0f) { // タイマーが0未満なら.
if(this.step != Block.STEP.SLIDE) { // スライド中でないなら.
this.vanish_timer = -1.0f;
this.next_step = Block.STEP.VACANT; // 状態を「消滅中」に.
} else {
this.vanish_timer = 0.0f;
}
}
}
this.step_timer += Time.deltaTime;
float slide_time = 0.2f;
if(this.next_step == Block.STEP.NONE) { // 「状態情報なし」の場合.
switch(this.step) {
case Block.STEP.SLIDE:
if(this.step_timer >= slide_time) {
// vanish_timer(消えるまでの時間)が0なら、.
// VACANT(消える)状態に移行.
if(this.vanish_timer == 0.0f) {
this.next_step = Block.STEP.VACANT;
// vanish_timerが0でないなら、.
// IDLE（待機）状態に移行.
} else {
this.next_step = Block.STEP.IDLE;
}
}
break;
case Block.STEP.IDLE:
this.renderer.enabled = true;
break;
case Block.STEP.FALL:
if(this.position_offset.y <= 0.0f) {
this.next_step = Block.STEP.IDLE;
this.position_offset.y = 0.0f;
}
break;
}
}
// 「次のブロック」の状態が「情報なし」以外である間.
// ＝「次のブロック」の状態が変更されていた場合.
while(this.next_step != Block.STEP.NONE) {
this.step = this.next_step;
this.next_step = Block.STEP.NONE;
switch(this.step) {
case Block.STEP.IDLE: // 「待機」状態.
this.position_offset = Vector3.zero;
// ブロックの表示サイズを通常サイズにする.
this.transform.localScale = Vector3.one * 1.0f;
break;
case Block.STEP.GRABBED: // 「つかまれている」状態.
// ブロックの表示サイズを大きくする.
this.transform.localScale = Vector3.one * 1.2f;
break;
case Block.STEP.RELEASED: // 「離されている」状態.
this.position_offset = Vector3.zero;
// ブロックの表示サイズを通常サイズにする.
this.transform.localScale = Vector3.one * 1.0f;
break;
case Block.STEP.VACANT:
this.position_offset = Vector3.zero;
this.setVisible(false); // ブロックを非表示に.
break;
case Block.STEP.RESPAWN:
// 色をランダムに選び、ブロックをその色に設定.
int color_index = Random.Range(
0, (int)Block.COLOR.NORMAL_COLOR_NUM);
this.setColor((Block.COLOR)color_index);
this.next_step = Block.STEP.IDLE;
break;
case Block.STEP.FALL:
this.setVisible(true); // ブロックを表示.
this.fall.velocity = 0.0f; // 落下速度をリセット.
break;
}
this.step_timer = 0.0f;
}
switch(this.step) {
case Block.STEP.GRABBED: // 「つかまれた」状態.
// 「つかまれた」状態のときは、常にスライド方向をチェック.
this.slide_dir = this.calcSlideDir(mouse_position_xy);
break;
case Block.STEP.SLIDE: // スライド（入れ替え）中.
// ブロックを徐々に移動する処理.
// （難しいので、今はわからなくても大丈夫です）.
float rate = this.step_timer / slide_time;
rate = Mathf.Min(rate, 1.0f);
rate = Mathf.Sin(rate*Mathf.PI / 2.0f);
this.position_offset = Vector3.Lerp(
this.position_offset_initial, Vector3.zero, rate);
break;
case Block.STEP.FALL:
// 速度に、重力の影響を与える.
this.fall.velocity += Physics.gravity.y * Time.deltaTime * 0.3f;
// 縦方向の位置を計算.
this.position_offset.y += this.fall.velocity * Time.deltaTime;
if(this.position_offset.y < 0.0f) { // 落下しきったら.
this.position_offset.y = 0.0f; // その場に留める.
}
break;
}
// グリッド座標を実座標（シーン上の座標）に変換し、.
// position_offsetを加える.
Vector3 position =
BlockRoot.calcBlockPosition(this.i_pos) + this.position_offset;
// 実際の位置を、新しい位置に変更.
this.transform.position = position;
this.setColor(this.color);
if(this.vanish_timer >= 0.0f) {
Color color0 = // 現在の色と白との中間色.
Color.Lerp(this.renderer.material.color, Color.white, 0.5f);
Color color1 = // 現在の色と黒との中間色.
Color.Lerp(this.renderer.material.color, Color.black, 0.5f);
// 着火演出時間の半分を過ぎたら.
if(this.vanish_timer < Block.VANISH_TIME / 2.0f) {
// 透明度（a）を設定.
color0.a = this.vanish_timer / (Block.VANISH_TIME / 2.0f);
color1.a = color0.a;
// 半透明マテリアルを適用.
this.renderer.material = this.transparent_material;
}
// vanish_timerが減るほど1に近づく.
float rate = 1.0f - this.vanish_timer / Block.VANISH_TIME;
// じわ〜っと色を変える.
this.renderer.material.color = Color.Lerp(color0, color1, rate);
}
}
// 引数colorの色で、ブロックを塗る.
public void setColor(Block.COLOR color)
{
this.color = color; // 今回指定された色をメンバー変数に保管.
Color color_value; // Colorクラスは色を表す.
switch(this.color) { // 塗るべき色によって分岐.
default:
case Block.COLOR.PINK:
color_value = new Color(1.0f, 0.5f, 0.5f);
break;
case Block.COLOR.BLUE:
color_value = Color.blue;
break;
case Block.COLOR.YELLOW:
color_value = Color.yellow;
break;
case Block.COLOR.GREEN:
color_value = Color.green;
break;
case Block.COLOR.MAGENTA:
color_value = Color.magenta;
break;
case Block.COLOR.ORANGE:
color_value = new Color(1.0f, 0.46f, 0.0f);
break;
}
// このGameObjectのマテリアルカラーを変更.
this.renderer.material.color = color_value;
}
