public void OperateReverse(Operation op)
{
switch (op.opType)
{
case 0:
{
generalPanelUI.RemovePuzzle(op.opPuzzle, false);
break;
}
case 1:
{
PuzzleItemData opPuzzleItemData = op.opPuzzle.GetComponent <PuzzleItemUI>().puzzleItemData;
generalPanelUI.generalPanelData.ModiLayout(GeneralPanelData.GridType.Blank, opPuzzleItemData);
opPuzzleItemData.PanelGridIndex = op.lastGridIndex;
generalPanelUI.InsertPuzzle(op.opPuzzle, false);
break;
}
case 2:
{
generalPanelUI.InsertPuzzle(op.opPuzzle, false);
break;
}
default:
break;
}
}
public void AddToRedGridIndices(PuzzleItemData puzzleItemData, int[] blankLayout)
{
int gridIndex = puzzleItemData.PanelGridIndex;
int x = gridIndex % pwidth;
int y = gridIndex / pwidth;
// Debug.Log("GridIndex when show pregrid：" + gridIndex);//!Test
int[] puzzleLayout = puzzleItemData.Playout;
//添加redGridIndices
for (int i = 0; i < puzzleLayout.Length; ++i)
{
if (puzzleLayout[i] == 1)
{
int ix = i % puzzleItemData.Pwidth;
int iy = i / puzzleItemData.Pwidth;
int offsetX = ix - puzzleItemData.Pcenter[0];
int offsetY = iy - puzzleItemData.Pcenter[1];
if (blankLayout[i] == (int)GridType.Blank || blankLayout[i] == (int)GridType.Fix)
{
int gx = x + offsetX;
int gy = y + offsetY;
redGridIndices.Add(gx + gy * pwidth);
}
}
}
}
public void UnlockAdPuzzle()
{
//TODO：接入广告界面
AdMgr.GetInstance().showRewardVideo(() =>
{
Debug.Log("play ad succ");
//隐藏广告按钮
if (puzzleBarForFreeLayoutTrans.childCount > 0)
{
puzzleBarForFreeLayoutTrans.GetChild(0).gameObject.SetActive(false);
}
//将拼图lockstate设置为false
if (adPuzzleNum == 1)
{
Transform adPuzzleTrans = this.transform.GetChild(this.transform.childCount - 1);
PuzzleItemUI adPuzzleUI = adPuzzleTrans.GetComponent <PuzzleItemUI>();
PuzzleItemData adPuzzleData = adPuzzleUI.puzzleItemData;
adPuzzleData.Plockstate = false;
}
//将useflag设为true
//adPuzzleUseFlag = true;//没有用于实际判断，暂时注释
},
() =>
{
Debug.Log("play ad fail");
},
() =>
{
Debug.Log("close ad");
});
}
public void InitComp(/*Camera playFieldCamera,*/ GeneralPanelUI generalPanelUI, Transform puzzleMoveTrans, DragController dragController /* , CanvasScaler canvasScaler*/)
{
// this.playFieldCamera = playFieldCamera;
this.generalPanelUI = generalPanelUI;
this.puzzleMoveTrans = puzzleMoveTrans;
this.dragController = dragController;
// this.canvasScaler = canvasScaler;
puzzleItemData = new PuzzleItemData();
screenSpaceRectTransform = GetComponent <RectTransform>();
canRorate = true;
}
public void ShowPreCheckResult(int state, PuzzleItemUI puzzleItemUI = null, int[] blankLayout = null)
{
//Fit state：
//0 表示Fit，
//1 表示unFit，
//2 及以上表示没在格子上，全部PreCheck的红绿格都要隐藏
if (state >= 2)
{
ClearBothIndices();
return;
}
//FINISH：bug fixed 旋转之后产生了无法正确对应的问题，有可能是panelgridindex计算出错，真实原因是中心格子下标固定，不需要通过计算获取
PuzzleItemData puzzleItemData = puzzleItemUI.puzzleItemData;
int gridIndex = puzzleItemData.PanelGridIndex;
if (generalPanelData.CheckDirtyFlag(gridIndex))
{
if (state == 0)//绿色
{
//清空greenGridIndices和redGridIndices
ClearBothIndices();
//添加greenGridIndices
generalPanelData.AddToGreenGridIndices(puzzleItemData);
//显示绿色的grids
ShowGreenGrids();
}
else if (state == 1)//红色
{
//清空greenGridIndices和redGridIndices
ClearBothIndices();
//添加redGridIndices
generalPanelData.AddToRedGridIndices(puzzleItemData, blankLayout);
//显示红色的grid
ShowRedGrids();
}
generalPanelData.LastGridIndex = gridIndex;
}
else
{
//如果dirtyflag是false，不刷新
//do nothing
}
}
public void RefreshSettlePuzzleList()
{
m_recoder.settlePuzzleList.Clear();
int childCount = puzzleContainPanelTrans.childCount;
for (int i = 0; i < childCount; ++i)
{
GameObject puzzle = puzzleContainPanelTrans.GetChild(i).gameObject;
if (puzzle.activeSelf)
{
PuzzleItemUI settlePuzzleUI = puzzle.GetComponent <PuzzleItemUI>();
PuzzleItemData settlePuzzleData = settlePuzzleUI.puzzleItemData;
SettlePuzzle settlePuzzle = new SettlePuzzle(settlePuzzleData.PID, settlePuzzleUI.RotateState, settlePuzzleData.PanelGridIndex);
m_recoder.settlePuzzleList.Add(settlePuzzle);
}
}
}
public void OnDrag(PointerEventData pointerEventData, PuzzleItemUI puzzleItemUI, GeneralPanelUI generalPanelUI)
{
if (gameOverFlag)//限制游戏结束时不可拖动
{
return;
}
if (puzzleItemUI.puzzleItemData.Plockstate)//限制广告方块上锁时不可拖动
{
return;
}
if (!puzzleItemUI.DraggedState)//限制未设置拖动状态的拼图不可拖动，即被拖动拼图之外其他的拼图
{
return;
}
if (firstDragPointerID != pointerEventData.pointerId)//限制手指pointerId不同的不可被拖动，可用于限制只能单指操作
{
return;
}
miniMapController.RefreshFlag = true;
PuzzleItemData puzzleItemData = puzzleItemUI.puzzleItemData;
//拖动时拼图跟随手指位置移动
//FINISH:在此过程中拼图会和面板产生交互
Vector3 puzzlePosPre = Camera.main.ScreenToWorldPoint(pointerEventData.position) + Vector3.up * upMoveDistance;
puzzleItemUI.cloneForMove.transform.position = new Vector3(puzzlePosPre.x, puzzlePosPre.y, puzzleItemUI.cloneForMove.transform.position.z);
curPointerEventData.position = pointerEventData.position;
int gridIndex = -1;
int[] blankLayout = null;
int interactRet = generalPanelUI.InteractWithPuzzle(puzzleItemUI.cloneForMove.GetComponent <PuzzleItemUI>(), out gridIndex, out blankLayout);
puzzleItemData.PanelGridIndex = gridIndex;
generalPanelUI.ShowPreCheckResult(interactRet, puzzleItemUI, blankLayout);
puzzleItemUI.DraggedState = true;
}
public void MakeMovePuzzle()
{
if (cloneForMove == null)
{
cloneForMove = GameObject.Instantiate(this.gameObject, puzzleMoveTrans);
PuzzleItemUI clonePuzzleItemUI = cloneForMove.GetComponent <PuzzleItemUI>();
clonePuzzleItemUI.puzzleItemData = new PuzzleItemData();
PuzzleItemData clonePuzzleItemData = clonePuzzleItemUI.puzzleItemData;
clonePuzzleItemData.InitButtomPuzzleItemData(
puzzleItemData.PID,
puzzleItemData.Pwidth,
puzzleItemData.Pheight,
puzzleItemData.Playout,
puzzleItemData.Pcenter);
clonePuzzleItemUI.screenSpaceRectTransform = this.screenSpaceRectTransform;
cloneForMove.name = this.gameObject.name + "Move";
}
cloneForMove.SetActive(false);
}
public void RemovePuzzle(GameObject puzzle, bool opRecordFlag = true)
{
Debug.Log("remove!");
PuzzleItemUI puzzleItemUI = puzzle.GetComponent <PuzzleItemUI>();
PuzzleItemData puzzleItemData = puzzleItemUI.puzzleItemData;
//必定是已经摆放了的
int[] oldLayout = generalPanelData.Playout;
generalPanelData.ModiLayout(GeneralPanelData.GridType.Blank, puzzleItemData);
int[] newLayout = generalPanelData.Playout;
puzzle.SetActive(false);
if (opRecordFlag)
{
// deleteParticleEffect.Play();
//FINISH：操作历史记录
Operation op = new Operation(2, oldLayout, newLayout, puzzle);
operationHistoryRecorder.Record(op);
}
}
public void AddToGreenGridIndices(PuzzleItemData puzzleItemData = null)
{
int gridIndex = puzzleItemData.PanelGridIndex;
int x = gridIndex % pwidth;
int y = gridIndex / pwidth;
int[] puzzleLayout = puzzleItemData.Playout;
//添加greenGridIndices
for (int i = 0; i < puzzleLayout.Length; ++i)
{
if (puzzleLayout[i] == 1)
{
int ix = i % puzzleItemData.Pwidth;
int iy = i / puzzleItemData.Pwidth;
int offsetX = ix - puzzleItemData.Pcenter[0];
int offsetY = iy - puzzleItemData.Pcenter[1];
int gx = x + offsetX;
int gy = y + offsetY;
greenGridIndices.Add(gx + gy * pwidth);
}
}
}
public void SettlePuzzleFunc(SettlePuzzle settlePuzzle)
{
int pid = settlePuzzle.puzzleID;
int prs = settlePuzzle.puzzleRotateState;
int pgi = settlePuzzle.puzzleGridIndex;
Debug.Log("pid:" + pid);
Debug.Log("puzzleBarTrans.childCount:" + puzzleBarTrans.childCount);
GameObject settlePuzzleOrigin = puzzleBarTrans.GetChild(pid).gameObject;
GameObject settlePuzzleTemp = GameObject.Instantiate(settlePuzzleOrigin);
PuzzleItemUI settlePuzzleOriginUI = settlePuzzleOrigin.GetComponent <PuzzleItemUI>();
PuzzleItemData settlePuzzleOriginData = settlePuzzleOriginUI.puzzleItemData;
PuzzleItemUI settlePuzzleTempUI = settlePuzzleTemp.GetComponent <PuzzleItemUI>();
PuzzleItemData settlePuzzleTempData = settlePuzzleTempUI.puzzleItemData;
settlePuzzleTempData.InitButtomPuzzleItemData(
settlePuzzleOriginData.PID,
settlePuzzleOriginData.Pwidth,
settlePuzzleOriginData.Pheight,
settlePuzzleOriginData.Playout,
settlePuzzleOriginData.Pcenter);
settlePuzzleTempUI.cloneForMove = settlePuzzleOriginUI.cloneForMove;
settlePuzzleTempUI.screenSpaceRectTransform = settlePuzzleOriginUI.screenSpaceRectTransform;
settlePuzzleTempData.PanelGridIndex = pgi;
settlePuzzleTempUI.RotatePuzzleToState(prs);
InsertPuzzle(settlePuzzleTemp, false);
Destroy(settlePuzzleTemp);
}
public void ModiLayout(GridType gridType, PuzzleItemData puzzleItemData)
{
int gridIndex = puzzleItemData.PanelGridIndex;
int[] newPuzzleLayout = puzzleItemData.Playout;
int x = gridIndex % pwidth;
int y = gridIndex / pwidth;
for (int i = 0; i < newPuzzleLayout.Length; ++i)
{
if (newPuzzleLayout[i] == 1)
{
int ix = i % puzzleItemData.Pwidth;
int iy = i / puzzleItemData.Pwidth;
int offsetX = ix - puzzleItemData.Pcenter[0];
int offsetY = iy - puzzleItemData.Pcenter[1];
int gx = x + offsetX;
int gy = y + offsetY;
int gi = gx + gy * pwidth;
playout[gi] = (int)gridType;
}
}
}
public void InsertPuzzle(GameObject puzzle = null, bool opRecordFlag = true)
{
Debug.Log("insert!");
PuzzleItemUI puzzleItemUI = puzzle.GetComponent <PuzzleItemUI>();
PuzzleItemData puzzleItemData = puzzleItemUI.puzzleItemData;
int gridIndex = puzzleItemData.PanelGridIndex;
if (puzzleItemData.NotSettleFlag)
{
//删除摄像机后不存在屏幕空间与世界空间的区分，但仍保留放置与否的区分
//如果是从底部拖上来的拼图：
//插入拼图时，生成一份新的拼图放在当前面板的同级面板puzzleContainPanel中
//FINISH：如果在puzzleContainPanel中（即settlePuzzleList中）存在一个位置（gridIndex）相同，playout和rotatestate也相同的拼图，直接setactive即可
bool existFlag = false;
GameObject opPuzzle = null;
for (int i = 0; i < puzzleContainPanelTrans.childCount; ++i)
{
GameObject settlePuzzle = puzzleContainPanelTrans.GetChild(i).gameObject;
PuzzleItemUI settlePuzzleItemUI = settlePuzzle.GetComponent <PuzzleItemUI>();
PuzzleItemData settlePuzzleItemData = settlePuzzleItemUI.puzzleItemData;
// Debug.Log(
// "difference:" + "\n" +
// settlePuzzleItemUI.RotateState + " " + puzzleItemUI.RotateState + "\n" +
// settlePuzzleItemData.PanelGridIndex + " " + puzzleItemData.PanelGridIndex + "\n" +
// MatrixUtil.PrintIntArray(settlePuzzleItemData.Playout) + " " + MatrixUtil.PrintIntArray(puzzleItemData.Playout)
// );
//!数组不可直接用==进行对比//已修改成直接用PID进行对比
if (settlePuzzleItemUI.RotateState == puzzleItemUI.RotateState &&
settlePuzzleItemData.PanelGridIndex == puzzleItemData.PanelGridIndex &&
settlePuzzleItemData.PID == puzzleItemData.PID)
{
existFlag = true;
opPuzzle = settlePuzzle;
break;
}
}
if (existFlag)
{
opPuzzle.transform.localScale = Vector3.one;
opPuzzle.GetComponent <PuzzleItemUI>().cloneForMove = puzzleItemUI.cloneForMove;
}
else
{
//这里还需要根据拼图的中心与pcenter的位置关系修改位置关系
Transform gridTrans = this.transform.GetChild(gridIndex);
float pwidthCenter = puzzleItemData.Pwidth / 2.0f;
float pheightCenter = puzzleItemData.Pheight / 2.0f;
float pcenterX = puzzleItemData.Pcenter[0] + 0.5f;
float pcenterY = puzzleItemData.Pcenter[1] + 0.5f;
float offsetX = (pwidthCenter - pcenterX) * gridLength;
float offsetY = (pheightCenter - pcenterY) * gridLength;
Vector3 gridTransCanvasSpacePos = gridTrans.GetComponent <RectTransform>().anchoredPosition;//Camera.main.WorldToScreenPoint(gridTrans.position);
Vector3 newPos = new Vector3(gridTransCanvasSpacePos.x + offsetX, gridTransCanvasSpacePos.y - offsetY, puzzle.transform.position.z);
// Debug.Log("PcenterX" + pcenterX + "PcenterY" + pcenterY + "\n" +
// "gridIndex:" + gridIndex + "\n" + "newPos:" + newPos + "\n" +
// "gridTrans.position:" + gridTrans.position + " " + gridTransCanvasSpacePos + "\n" +
// "offsetX:" + offsetX + "\n" +
// "offsetY:" + offsetY + "\n" +
// "gridLength:" + gridLength + "\n" +
// "canvasScaler.scaleFactor:" + canvasScaler.scaleFactor);
//Debug.Log("Insert Puzzle:" + puzzle.name);
GameObject newPuzzle = GameObject.Instantiate(puzzle, puzzleContainPanelTrans);
RectTransform newPuzzleRectTrans = newPuzzle.GetComponent <RectTransform>();
newPuzzleRectTrans.anchorMin = new Vector2(0, 1);
newPuzzleRectTrans.anchorMax = new Vector2(0, 1);
newPuzzleRectTrans.anchoredPosition = newPos;
//Debug.LogWarning(gridIndex + " " + gridTransCanvasSpacePos + " " + gridTrans.position + " " + newPos);
// settlePuzzleList.Add(newPuzzle);
newPuzzle.name = "SettlePuzzle";
//将raycastTarget设为false避免触摸空白区域会拖动当前拼图
newPuzzle.GetComponent <Image>().raycastTarget = false;
// Debug.Log("gen pos:" + newPuzzle.transform.position + " " + Camera.main.WorldToScreenPoint(newPuzzle.transform.position));
PuzzleItemUI newPuzzleItemUI = newPuzzle.GetComponent <PuzzleItemUI>();
newPuzzleItemUI.puzzleItemData = new PuzzleItemData();
PuzzleItemData newPuzzleItemData = newPuzzleItemUI.puzzleItemData;
//newPuzzleItemData=puzzleItemData;
newPuzzleItemData.InitButtomPuzzleItemData(
puzzleItemData.PID,
puzzleItemData.Pwidth,
puzzleItemData.Pheight,
puzzleItemData.Playout,
puzzleItemData.Pcenter);
newPuzzleItemData.PanelGridIndex = puzzleItemData.PanelGridIndex;
newPuzzleItemUI.ScaleRatio = puzzleItemUI.ScaleRatio;
newPuzzleItemUI.RotateState = puzzleItemUI.RotateState;
newPuzzleItemUI.screenSpaceRectTransform = puzzleItemUI.screenSpaceRectTransform;
if (newPuzzleItemUI.RotateState == 0 || newPuzzleItemUI.RotateState == 2)
{
newPuzzle.GetComponent <RectTransform>().sizeDelta = new Vector2(gridLength * newPuzzleItemData.Pwidth, gridLength * newPuzzleItemData.Pheight);
}
else
{
newPuzzle.GetComponent <RectTransform>().sizeDelta = new Vector2(gridLength * newPuzzleItemData.Pheight, gridLength * newPuzzleItemData.Pwidth);
}
newPuzzle.GetComponent <GridLayoutGroup>().cellSize = new Vector2(gridLength, gridLength);
//要为拼图设置可以移动的拼图
newPuzzleItemData.NotSettleFlag = false;
newPuzzleItemUI.cloneForMove = puzzleItemUI.cloneForMove;
newPuzzleItemUI.screenSpaceRectTransform = puzzleItemUI.screenSpaceRectTransform;
opPuzzle = newPuzzle;
}
int[] oldLayout = generalPanelData.Playout;
generalPanelData.ModiLayout(GeneralPanelData.GridType.Fill, puzzleItemData);
int[] newLayout = generalPanelData.Playout;
opPuzzle.SetActive(true);
if (opRecordFlag)
{
//操作历史记录
//TODO:记录摆放的拼图
Operation op = new Operation(0, oldLayout, newLayout, opPuzzle);
operationHistoryRecorder.Record(op);
//播放下落动画
// StartCoroutine(PuzzleDownMove(opPuzzle, 0.5f, 0.1f, () =>
// {
// //检查游戏是否结束
// if (generalPanelData.CheckOver())
// {
// //通关
// //跳转到UIEnd
// uiplayPage.LevelOverStep1();
// }
// }));
StartCoroutine(PuzzleSettleAnim(opPuzzle, () => { }));
}
}
else
{
//-删除摄像机后不存在屏幕空间与世界空间的区分，但仍保留放置与否的区分
//如果是从面板中拖出的拼图：
//直接修改拼图的位置即可
puzzle.transform.localScale = Vector3.one;
Transform gridTrans = this.transform.GetChild(gridIndex);
float pwidthCenter = puzzleItemData.Pwidth / 2.0f;
float pheightCenter = puzzleItemData.Pheight / 2.0f;
float pcenterX = puzzleItemData.Pcenter[0] + 0.5f;
float pcenterY = puzzleItemData.Pcenter[1] + 0.5f;
float offsetX = (pwidthCenter - pcenterX) * gridLength;
float offsetY = (pheightCenter - pcenterY) * gridLength;
Vector3 gridTransCanvasSpacePos = gridTrans.GetComponent <RectTransform>().anchoredPosition;
Vector3 newPos = new Vector3(gridTransCanvasSpacePos.x + offsetX, gridTransCanvasSpacePos.y - offsetY, puzzle.transform.position.z);
RectTransform puzzleRectTrans = puzzle.GetComponent <RectTransform>();
puzzleRectTrans.anchorMin = new Vector2(0, 1);
puzzleRectTrans.anchorMax = new Vector2(0, 1);
puzzleRectTrans.anchoredPosition = newPos;
// puzzle.transform.position = Camera.main.ScreenToWorldPoint(newPos);
int[] oldLayout = generalPanelData.Playout;
generalPanelData.ModiLayout(GeneralPanelData.GridType.Fill, puzzleItemData);
int[] newLayout = generalPanelData.Playout;
puzzle.SetActive(true);
if (opRecordFlag)
{
//FINISH：操作历史记录
Operation op = new Operation(1, oldLayout, newLayout, puzzle, puzzleItemData.LastPanelGridIndex, gridIndex);
operationHistoryRecorder.Record(op);
//播放下落动画
// StartCoroutine(PuzzleDownMove(puzzle, 0.5f, 0.1f, () => { }));
StartCoroutine(PuzzleSettleAnim(puzzle, () => { }));
}
}
}
// Coroutine deleteAreaCorou;
// public Coroutine DeleteAreaCorou
// {
// get { return deleteAreaCorou; }
// set { deleteAreaCorou = value; }
// }
public int InteractWithPuzzle(PuzzleItemUI puzzleItemUI, out int panelGridIndex, out int[] outputBlankLayout)
{
//关于返回值：0表示拼图在面板中的位置是满足填充条件的位置，可以填充；1表示拼图在面板中，但不满足填充条件；2表示拼图不在面板中，也不在删除区；3表示拼图在删除区
PuzzleItemData puzzleItemData = puzzleItemUI.puzzleItemData;
PointerEventData pointerData = new PointerEventData(EventSystem.current);
// Debug.Log("grid index of puzzle:" + (puzzleItemData.Pcenter[0] + puzzleItemData.Pwidth * puzzleItemData.Pcenter[1]).ToString());//!Test
//!show precheck grid不正确对应的bug发生原因：原本通过centerx和centery寻找下标，实际上并不需要寻找，因为顺序是固定的，下标不改变
pointerData.position = Camera.main.WorldToScreenPoint(puzzleItemUI.transform.GetChild((int)(puzzleItemData.PcenterOrigin)).position);
List <RaycastResult> results = new List <RaycastResult>();
EventSystem.current.RaycastAll(pointerData, results);
if (results.Count > 0)
{
//此时results[0]是当前拼图上的格子，results[...]才是底下的东西
//如果射到的是格子，其父对象必为当前脚本挂载的对象，即GeneralPanel面板
GameObject hitObj = results.Find((RaycastResult a) => a.gameObject.transform.parent == this.transform).gameObject;
if (hitObj != null)
{
int gridIndex = hitObj.transform.GetSiblingIndex();
int[] blankLayout;
bool isFit = generalPanelData.IsFit(puzzleItemData, gridIndex, out blankLayout);
panelGridIndex = gridIndex;
outputBlankLayout = MatrixUtil.ArrayCopy(blankLayout);
onDeleteAreaFlag = false;
//TODO:deleteArea缩小为1
StartCoroutine(DeleteAreaLinearScaleDown());
if (isFit)
{
return(0);
}
else
{
return(1);
}
}
// 输出射线射到的所有对象：
// string allhit = "hit:::\n";
// foreach (RaycastResult r in results)
// {
// allhit += r.gameObject.name + "\n";
// }
// Debug.Log(allhit);
if (DetectDeleteArea(puzzleItemUI))
{
panelGridIndex = -1;
outputBlankLayout = null;
return(3);
}
}
panelGridIndex = -1;
outputBlankLayout = null;
return(2);
}
//private bool adPuzzleUseFlag = false;//没有用于实际判断，暂时注释
public void InitPuzzleBar()
{
//FINISH:读入数据，获得界面下方的PuzzlePanel中要放的拼图的种类的信息
uint curLevelID = LevelMgr.GetInstance().CurLevelID;
LevelData curLevelData = LevelMgr.GetInstance().GetLevelConfig(curLevelID);
Dictionary <string, int[]> FillTypeMap = new Dictionary <string, int[]>();
Dictionary <string, int> WidthMap = new Dictionary <string, int>();
Google.Protobuf.Collections.RepeatedField <string> usablePuzzleStrList = new Google.Protobuf.Collections.RepeatedField <string>();
int adPuzzleAvailFlagInt = 0;
if (curLevelData == null || curLevelData.Config == null)
{
//!模拟读入
FillTypeMap = new Dictionary <string, int[]>()
{
{ "0", new int[] { 0, 0, 1, 1, 1, 1 } },
{ "1", new int[] { 1, 1 } },
{ "2", new int[] { 1, 1, 0, 0 } },
{ "3", new int[] { 1 } },
};
WidthMap = new Dictionary <string, int>()
{
{ "0", 3 },
{ "1", 2 },
{ "2", 2 },
{ "3", 1 },
};
usablePuzzleStrList = new Google.Protobuf.Collections.RepeatedField <string>()
{
"0", "1", "3"
};
adPuzzleAvailFlagInt = 1;
}
else
{
ToolMapArray toolMapArray = LevelMgr.GetInstance().GetToolMapArray();
FillTypeMap = toolMapArray.FillTypeMap;
WidthMap = toolMapArray.WidthMap;
usablePuzzleStrList = curLevelData.Config.LevelPixel;
adPuzzleAvailFlagInt = curLevelData.Config.AdPuzzle;
}
//Debug.Log("usablePuzzleStrList.Count" + usablePuzzleStrList.Count);
//FINISH:读入数据后，根据数据生成相应的若干PuzzleItem
int i = 0;
foreach (string usablePuzzleStr in usablePuzzleStrList)
{
int[] usablePuzzleLayout = new int[] { };
if (FillTypeMap.TryGetValue(usablePuzzleStr, out usablePuzzleLayout))
{
int[] puzzleLayout = MatrixUtil.ArrayCopy(usablePuzzleLayout);
int puzzleWidth = WidthMap[usablePuzzleStr];
int puzzleHeight = puzzleLayout.Length / puzzleWidth;
int puzzleCenterX = 0;
int puzzleCenterY = 0;
float puzzleCenterXFloor = Mathf.Floor((float)puzzleWidth / 2.0f);
float puzzleCenterYFloor = Mathf.Floor((float)puzzleHeight / 2.0f);
if ((float)puzzleWidth / 2.0f - puzzleCenterXFloor > 0.9f)
{
puzzleCenterX = (int)puzzleCenterXFloor + 1;
}
else
{
puzzleCenterX = (int)puzzleCenterXFloor;
}
if ((float)puzzleHeight / 2.0f - puzzleCenterYFloor > 0.9f)
{
puzzleCenterY = (int)puzzleCenterYFloor + 1;
}
else
{
puzzleCenterY = (int)puzzleCenterYFloor;
}
// Debug.Log("puzzleCenterX" + puzzleCenterX);
// Debug.Log("puzzleCenterY" + puzzleCenterY);
int[] puzzleCenter = new int[2] {
puzzleCenterX, puzzleCenterY
};
GameObject puzzleItem = GameObject.Instantiate(puzzleItemPrefab, this.transform);
PuzzleItemUI puzzleItemUI = puzzleItem.GetComponent <PuzzleItemUI>();
// puzzleItemUIList.Add(puzzleItemUI);
// puzzleItemUI.InitComp(playFieldCamera, generalPanelUI, puzzleMoveTrans, dragControlMgr, canvasScaler);
puzzleItemUI.InitComp(generalPanelUI, puzzleMoveTrans, dragController);
puzzleItemUI.puzzleItemData.InitButtomPuzzleItemData(i, puzzleWidth, puzzleHeight, puzzleLayout, puzzleCenter);
puzzleItemUI.InitButtomPuzzleItemUI();
puzzleItemUI.ScaleRatioOfPanelGrid = scaleRatioOfPanelGrid;
i++;
}
else
{
Debug.Log("NOT usablePuzzstr:" + usablePuzzleStr);
}
}
//TODO:判断是否可用广告方块
if (adPuzzleAvailFlagInt == 0)
{
//不可用广告方块
if (puzzleBarForFreeLayoutTrans.childCount > 0)
{
Transform adButtonTrans = puzzleBarForFreeLayoutTrans.GetChild(0);
adButtonTrans.gameObject.SetActive(false);
}
}
else//adPuzzleAvailFlagInt==1
{
//可用广告方块
//TODO:添加广告方块
GameObject adPuzzle = AddAdPuzzle();
//TODO:添加看广告按钮
Transform adButtonTrans;
if (puzzleBarForFreeLayoutTrans.childCount > 0)
{
adButtonTrans = puzzleBarForFreeLayoutTrans.GetChild(0);
}
else
{
GameObject adButton = GameObject.Instantiate(adButtonPrefab, puzzleBarForFreeLayoutTrans);
adButtonTrans = adButton.transform;
}
//添加判断是否已经付费去广告
if (XPlayerPrefs.GetInt(AdMgr.Pay2RemoveAD_Tag) == 1)
{
adButtonTrans.gameObject.SetActive(false);
if (adPuzzleNum == 1)
{
Transform adPuzzleTrans = this.transform.GetChild(this.transform.childCount - 1);
PuzzleItemUI adPuzzleUI = adPuzzleTrans.GetComponent <PuzzleItemUI>();
PuzzleItemData adPuzzleData = adPuzzleUI.puzzleItemData;
adPuzzleData.Plockstate = false;
}
}
else
{
//TODO:设置按钮的方法
Button adButtonComp = adButtonTrans.GetComponent <Button>();
adButtonComp.onClick.RemoveAllListeners();
adButtonComp.onClick.AddListener(() =>
{
UnlockAdPuzzle();
});
//TODO:设置按钮位置，在协程中等待到当前帧的fixedupdate时进行，原因是adPuzzle的位置受horizontalLayout的影响会在fixedupdate时才生效
StartCoroutine(SetAdButtonPos(adButtonTrans, adPuzzle));
}
}
}
public void OnEndDrag(PointerEventData pointerEventData, PuzzleItemUI puzzleItemUI, GeneralPanelUI generalPanelUI)
{
if (gameOverFlag)
{
return;
}
if (puzzleItemUI.puzzleItemData.Plockstate)
{
return;
}
if (!puzzleItemUI.DraggedState)
{
return;
}
if (firstDragPointerID != pointerEventData.pointerId)//限制手指pointerId不同的不可被放置，可用于限制只能单指操作
{
return;
}
miniMapController.RefreshFlag = true;
//拖动结束后，满足一定条件时拼图可以被插进面板，否则移除生成的拼图（隐藏显示）
PuzzleItemData puzzleItemData = puzzleItemUI.puzzleItemData;
Debug.Log("End Drag At:" + pointerEventData.position);
puzzleItemUI.cloneForMove.SetActive(false);
int gridIndex = -1;
int[] blankLayout = null;
int interactRet = generalPanelUI.InteractWithPuzzle(puzzleItemUI.cloneForMove.GetComponent <PuzzleItemUI>(), out gridIndex, out blankLayout);
puzzleItemData.PanelGridIndex = gridIndex;
generalPanelUI.ShowPreCheckResult(2);
//FINISH：进行操作记录，interactRet为0时，进行填充记录或位置移动记录；interactRet为3时，进行删除记录(操作历史记录的实现写于GeneralPanelUI中)
if (interactRet == 0)//如果拼图在满足填充条件的位置
{
//把拼图插入
generalPanelUI.InsertPuzzle(puzzleItemUI.gameObject);
}
else if (interactRet == 1 || interactRet == 2) //如果拼图在不满足填充条件以及不在删除区的其他位置
{
if (!puzzleItemData.NotSettleFlag) //如果被开始拖的拼图已经放置了
{
puzzleItemData.PanelGridIndex = puzzleItemData.LastPanelGridIndex;
generalPanelUI.InsertPuzzle(puzzleItemUI.gameObject, false);
}
Debug.Log("not fit " + interactRet);
}
else if (interactRet == 3)//如果拼图在删除区
{
//删除
if (!puzzleItemData.NotSettleFlag)
{
Debug.Log("删除拼图");
puzzleItemData.PanelGridIndex = puzzleItemData.LastPanelGridIndex;
generalPanelUI.RemovePuzzle(puzzleItemUI.gameObject);
}
generalPanelUI.deleteParticleEffect.Play();
DragController.VibrateFeedbackIntern();
}
//FINISH:deleteArea缩小为1
generalPanelUI.OnDeleteAreaFlag = false;
StartCoroutine(generalPanelUI.DeleteAreaLinearScaleDown());
// generalPanelUI.deleteArea.transform.localScale = Vector3.one;
puzzleItemUI.DraggedState = false;
generalDragFlag = false;
//TODO：deleteArea置為透明
generalPanelUI.SetDeleteAreaTransparent(true);
}
public void OnBeginDrag(PointerEventData pointerEventData, PuzzleItemUI puzzleItemUI, GeneralPanelUI generalPanelUI)
{
Debug.Log("OnBeginDrag");
if (gameOverFlag)
{
Debug.Log("gameover");
return;
}
if (puzzleItemUI.puzzleItemData.Plockstate)
{
Debug.Log("lock");
return;
}
if (Input.touchCount > 1)
{
return;
}
if (!generalDragFlag)
{
miniMapController.RefreshFlag = true;
generalDragFlag = true;
puzzleItemUI.DraggedState = true;
firstDragPointerID = pointerEventData.pointerId;
Debug.Log("OnBeginDrag2");
//Debug.Log("Drag begin");
//TODO：手机震动一下
VibrateFeedbackIntern();
PuzzleItemData puzzleItemData = puzzleItemUI.puzzleItemData;
//FINISH:开始拖动拼图时，生成（或显示）一块可以跟随手指的拼图，生成（显示）时规定好位置和大小（修改scale缩放即可）
if (!puzzleItemData.NotSettleFlag)
{
//?如果开始拖动的是已经摆放好的拼图，就先隐藏，但是隐藏会影响多个接口的使用，可以把它scale缩小为0
puzzleItemUI.transform.localScale = Vector3.zero;
//FINISH:同时还要修改GeneralPanel的layout数组，先记录一次上次插入时的格子的坐标，再消去Puzzle
puzzleItemData.LastPanelGridIndex = puzzleItemData.PanelGridIndex;
generalPanelUI.generalPanelData.ModiLayout(GeneralPanelData.GridType.Blank, puzzleItemData);
}
float gridLength = generalPanelUI.GridLength;
//FINISH:修改大小
//FINISH:加上双指缩放的比例
//根据panelTC缩放比例调整拼图的scaleratio
puzzleItemUI.SetScaleRatio();
float ratio = puzzleItemUI.ScaleRatio * panelTransformationController.ScaleRatio;
Debug.Log(ratio + " " + puzzleItemUI.ScaleRatio + " " + panelTransformationController.ScaleRatio);
puzzleItemUI.cloneForMove.GetComponent <RectTransform>().localScale = new Vector3(ratio, ratio, 1);
//FINISH:修改旋转
//根据PuzzleItemUI的RotateState进行旋转
PuzzleItemUI cloneForMovePuzzleItemUI = puzzleItemUI.cloneForMove.GetComponent <PuzzleItemUI>();
cloneForMovePuzzleItemUI.RotatePuzzleToState(puzzleItemUI.RotateState);
//FINISH:修改位置
Vector3 puzzleBeginPosPre = Camera.main.ScreenToWorldPoint(pointerEventData.position);
puzzleItemUI.cloneForMove.transform.position = new Vector3(puzzleBeginPosPre.x, puzzleBeginPosPre.y, puzzleItemUI.cloneForMove.transform.position.z);
puzzleItemUI.cloneForMove.SetActive(true);
if (!puzzleItemData.NotSettleFlag)
{
//如果是已放置的拼圖
StartCoroutine(UpMove(Vector3.up * finalUpMoveDistance_SettlePuzzle, finalUpMoveTime_SettlePuzzle));//!可以调整上移的距离和下落时间
}
else
{
//如果是從下方拉起的拼圖
StartCoroutine(UpMove(Vector3.up * finalUpMoveDistance, finalUpMoveTime));//!可以调整上移的距离和下落时间
}
curPointerEventData.position = pointerEventData.position;
StartCoroutine(UpdatePos(puzzleItemUI.cloneForMove.transform));
//TODO：deleteArea置為不透明
generalPanelUI.SetDeleteAreaTransparent(false);
// !Test：输出cloneForMove的旋转角度：
// float angle;
// Vector3 axis;
// puzzleItemUI.cloneForMove.transform.rotation.ToAngleAxis(out angle, out axis);
// Debug.Log("angle::" + angle + "\n" + "axis::" + axis);
// !Test：输出puzzleItemUI cloneForMove的layout:
// string test = "puzzleItemUI cloneForMove Layout::\n";
// PuzzleItemData testpd = puzzleItemUI.cloneForMove.GetComponent<PuzzleItemUI>().puzzleItemData;
// int[] testlayout = testpd.Playout;
// for (int i = 0; i < testlayout.Length; ++i)
// {
// test += testlayout[i].ToString() + " ";
// if (i > 0 && (i + 1) % (testpd.Pwidth) == 0)
// {
// test += "\n";
// }
// }
// Debug.Log(test);
}
}
public bool IsFit(PuzzleItemData puzzleItemData, int gridIndex, out int[] outputBlankLayout)
{
//FINISH：面板的数据层中，该IsFit函数仅处理拼图的layout和面板的layout的关系
int[] puzzleCenter = puzzleItemData.Pcenter;//获取拼图的中心的内部坐标
int puzzleCenterX = puzzleCenter[0];
int puzzleCenterY = puzzleCenter[1];
int puzzleWidth = puzzleItemData.Pwidth; //获取拼图宽方向的格子数
int puzzleHeight = puzzleItemData.Pheight; //获取拼图高方向的格子数
int x = gridIndex % pwidth;
int y = gridIndex / pwidth;
int[] puzzleLayout = puzzleItemData.Playout;
//创建一个和puzzlelayout相同大小的一维数组，用来记录面板上同样大小的格子中的空位，2为有空位，1为无空位（存在非可填的格子），0为没有格子（超出面板边界）
int[] blankLayout = new int[puzzleLayout.Length];
//按照puzzle的center和layout遍历面板上的格子
int i = 0;
for (int iy = y - puzzleCenterY; iy < y - puzzleCenterY + puzzleHeight; ++iy)
{
for (int ix = x - puzzleCenterX; ix < x - puzzleCenterX + puzzleWidth; ++ix)
{
if ((ix < 0 || ix > pwidth - 1) || (iy < 0 || iy > pheight - 1))
{
//超出边界的情况
// Debug.Log("存在超出边界的格子");
// Debug.Log("coo:" + ix.ToString() +" "+ iy.ToString());
blankLayout[i] = 0;
}
else
{
if (playout[ix + iy * pwidth] != (int)GridType.Blank)
{
//没超出边界但是存在非可填格子的情况
// Debug.Log("存在非可填格子");
// Debug.Log("coo:" + (ix + iy * pwidth).ToString());
blankLayout[i] = 1;
}
else
{
blankLayout[i] = 2;
}
}
i++;
}
}
outputBlankLayout = blankLayout;
//对比puzzleLayout和blankLayout即可
for (i = 0; i < puzzleLayout.Length; ++i)
{
int si = blankLayout[i];
int pi = puzzleLayout[i];
if (si == 0 && pi == 1)
{
//超出边界的面板上的格子
return(false);
}
if (si == 1 && pi == 1)
{
//非可填格子
return(false);
}
}
return(true);
}
