void CaculateAbsorbing(CellObjCtrl cctrl)
{
CellObjCtrl backCtrl = CellObjCtrlUtils.GetNbCellObjCtrl(cctrl, 3);
CCAbsorb ccab = backCtrl.GetComponentInChildren <CCAbsorb> ();
ccab.Invoke("ConfigAbsorbing", _AbsorbingComputeDelay);
}
static private void SClearRing(List <Transform> RingObjsTFs)
{
List <MiroModelV1> ringObjMiros = new List <MiroModelV1> ();
foreach (Transform tf in RingObjsTFs)
{
MiroModelV1 miro = tf.GetComponent <MiroModelV1> ();
if (miro != null)
{
ringObjMiros.Add(miro);
}
}
for (int i = _Rings.Count - 1; i >= 0; i--)
{
var rc = _Rings [i];
List <MiroModelV1> miros = new List <MiroModelV1> ();
foreach (CellObjCtrl ctrl in rc)
{
MiroModelV1 miro = CellObjCtrlUtils.GetMiroModelFromCell(ctrl);
if (miro != null)
{
miros.Add(miro);
}
}
bool bSame =
Lyu.DataStructureUtils.ContainsSame <MiroModelV1> (miros, ringObjMiros);
if (bSame)
{
_Rings.RemoveAt(i);
break;
}
}
}
void DetectRingCtrlsLst(ref List <List <CellObjCtrl> > rings)
{
foreach (CellObjCtrl ctrl in _ctrlLst)
{
bool bChecked = _ctrls [ctrl];
if (bChecked)
{
continue;
}
List <CellObjCtrl> ringObjs = new List <CellObjCtrl> ();
List <CellObjCtrl> chainObjs = new List <CellObjCtrl> ();
bool bDetected = CellObjCtrlUtils.DetectNPCCloseChainFrom(ctrl, ref ringObjs, ref chainObjs);
bDetected = (bDetected && (ringObjs.Count > 2));
// tag each ctrl Checked in chainObjs
foreach (CellObjCtrl rctrl in chainObjs)
{
_ctrls [rctrl] = true;
}
if (bDetected)
{
CellObjCtrlUtils.ReorderRing(ref ringObjs);
rings.Add(ringObjs);
}
_ctrls [ctrl] = true;
}
}
public bool InFaceToFace(Hex coord)
{
CellObjCtrl cctrl = _GridCtrl.GetCellCtrlAt(coord);
bool bIN = CellObjCtrlUtils.IsFaceToFace(cctrl);
return(bIN);
}
private bool ShouldAid()
{
CellObjCtrl FwdCtrl =
CellObjCtrlUtils.GetFwdCellObjCtrl(_cellCtrl);
bool bFwdCtrlling = CellObjCtrlUtils.IsControllingObj(FwdCtrl);
if (!bFwdCtrlling)
{
return(false);
}
MiroV1ModelSetting MyMSetting =
_cellCtrl._TgtObj.GetComponent <MiroV1ModelSetting> ();
MiroV1ModelSetting FwdMSetting =
FwdCtrl._TgtObj.GetComponent <MiroV1ModelSetting> ();
bool bFwdFriend = MyMSetting.IsSameCamp(FwdMSetting);
MiroModelV1 modelMe = CellObjCtrlUtils.GetMiroModelFromCell(_cellCtrl);
bool bAlive = modelMe.IsAlive();
bool bAid = bFwdFriend && bAlive;
if (bAid)
{
//print (_cellCtrl + " bAid?" + bAid + " FwdObj:" + FwdCtrl._TgtObj);
}
return(bAid);
}
void UpdateRotByCellDir()
{
Vector3 dirVec = CellObjCtrlUtils.GetDirVector3(_cctrl);
Quaternion rot = Quaternion.FromToRotation(Vector3.right, dirVec);
transform.rotation = rot;
}
override protected void _Calculate()
{
CellObjCtrl ctrlBwd =
CellObjCtrlUtils.GetNbCellObjCtrl (_cellCtrl, 3);
if (_cellCtrl._TgtObj == null) {
return;
}
bool bBackToBack = CellObjCtrlUtils.IsBackToBack (_cellCtrl);
MiroModelV1 modelMe =
_cellCtrl._TgtObj.GetComponent<MiroModelV1> ();
bool bHasFarm = modelMe.HasFarm ();
bool bToGrow = (!bHasFarm && bBackToBack);
bool bToShrink = (bHasFarm && !bBackToBack);
if (bToGrow) {
MiroModelV1 modelBwd =
ctrlBwd._TgtObj.GetComponent<MiroModelV1> ();
_mgr.CreateEN2FarmFor2 (
modelMe,_cellCtrl.transform,
modelBwd,ctrlBwd.transform);
RecordNewFarm (_cellCtrl, ctrlBwd);
//Debug.Log ("GrowFarm2 at " + _cellCtrl);
} else if (bToShrink) {
ShrinkFarm2 (_cellCtrl);
//Debug.Log ("ShrinkFarm2 at " + _cellCtrl);
}
}
/*
* public static bool IsNbEnemy(CellObjCtrl cctrl, int relativeDir)
* {
* if (cctrl._TgtObj == null) {
* return false;
* }
*
* CellObjCtrl nbCtrl = GetNbCellObjCtrl (cctrl, relativeDir);
* bool bEnemy = false;
* if (nbCtrl != null && nbCtrl._TgtObj!=null) {
* var settingMe =
* cctrl._TgtObj.GetComponent<MiroV1ModelSetting> ();
* var settingNb =
* nbCtrl._TgtObj.GetComponent<MiroV1ModelSetting> ();
* bEnemy = (settingMe._CampName!=settingNb._CampName);
* }
*
* return bEnemy;
* }*/
public static bool IsBackToBack(CellObjCtrl ctrl)
{
if (ctrl == null || ctrl._TgtObj == null)
{
return(false);
}
bool bBwdFriend =
CellObjCtrlUtils.IsNbSameCamp(ctrl, 3);
if (bBwdFriend)
{
CellObjCtrl bwdCtrl = GetNbCellObjCtrl(ctrl, 3);
if (bwdCtrl.GetDir() == ctrl.GetBwdDir())
{
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
public static bool IsFaceToFace(CellObjCtrl ctrl)
{
if (ctrl == null || ctrl._TgtObj == null)
{
return(false);
}
bool bFwdFriend =
CellObjCtrlUtils.IsNbSameCamp(ctrl, 0);
if (bFwdFriend)
{
CellObjCtrl fwdCtrl = GetNbCellObjCtrl(ctrl, 0);
if (fwdCtrl.GetDir() == ctrl.GetBwdDir())
{
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
public bool InBackToBack(Hex coord)
{
CellObjCtrl cctrl = _GridCtrl.GetCellCtrlAt(coord);
bool bIN = CellObjCtrlUtils.IsBackToBack(cctrl);
return(bIN);
}
static public List <MiroModelV1> GetNbEnemiesPointToThis(CellObjCtrl ctrl)
{
List <MiroModelV1> enemies = new List <MiroModelV1> ();
for (int dir = 0; dir < 6; dir++)
{
CellObjCtrl nbCtrl = CellObjCtrlUtils.GetNbCellObjCtrl(ctrl, dir);
if (nbCtrl == null)
{
continue;
}
CellObjCtrl nbCtrlFwdCtrl = CellObjCtrlUtils.GetFwdCellObjCtrl(nbCtrl);
if (nbCtrlFwdCtrl != ctrl)
{
continue;
}
MiroModelV1 nbModel = CellObjCtrlUtils.GetMiroModelFromCell(nbCtrl);
bool bEnemy = IsNbEnemy(ctrl, dir);
if (bEnemy)
{
enemies.Add(nbModel);
}
}
return(enemies);
}
public void UpdateDragDirectionDisp()
{
LineRenderer lr = GetComponent <LineRenderer> ();
bool bDragging = _DragRoter.IsDragging();
//print ("bDragging:" + bDragging);
if (!bDragging)
{
lr.enabled = false;
return;
}
int draggingDir = _DragRoter.GetDragingDir();
CellObjCtrl ctrl = CellObjCtrlUtils.GetNbCellObjCtrlInAbsDir(_CCtrl, draggingDir);
if (ctrl == null)
{
lr.enabled = false;
}
else
{
lr.enabled = true;
Vector3 p0 = _CCtrl.transform.position + new Vector3(0, 0, _zbias);
Vector3 p1 = ctrl.transform.position + new Vector3(0, 0, _zbias);
lr.SetPosition(0, p0);
lr.SetPosition(1, p1);
lr.useWorldSpace = true;
}
}
// 将当前正在操作的棋子取消
public bool CancelOperatingChess(
out Hex coord,
out int dir,
out int campId)
{
CellObjCtrl newestCtrl = _StdChessSpawer.GetSpawningCellObjCtrl();
if (newestCtrl == null)
{
coord = new Hex();
dir = -1;
campId = -1;
return(false);
}
coord = newestCtrl.GetComponent <HexCoord> ()._hex;
dir = newestCtrl.GetDir();
MiroV1ModelSetting msetting = CellObjCtrlUtils.GetModelSettingFromCtrl(newestCtrl);
campId = _MiroMgr.GetIdOfMiroModelSetting(msetting);
_StdChessSpawer.Cancel();
//_GridCtrl.ConfirmOccupiedCells ();
//DisableAllChessOperation ();
_GridCtrl.TurnDragRotatersOnEmptyPlacableCells(true);
return(true);
}
// Update is called once per frame
void Update()
{
MiroModelV1 model =
CellObjCtrlUtils.GetMiroModelFromCell(_CCtrl);
if (model == null)
{
_bON = false;
}
else
{
int movePwr = model.GetMovePwr();
_bON = (movePwr > 0);
}
CircleCollider2D cld = GetComponent <CircleCollider2D> ();
cld.enabled = _bON;
if (_bONPrev != _bON)
{
_bONChanged.Invoke();
_bONPrev = _bON;
}
}
public static bool DetectNPCCloseChainFrom(CellObjCtrl ctrl, ref List <CellObjCtrl> ringObjs, ref List <CellObjCtrl> _chainObjs)
{
bool bDetected = false;
List <CellObjCtrl> lst = new List <CellObjCtrl> ();
lst.Add(ctrl);
while (CellObjCtrlUtils.IsFwdSameCamp(ctrl))
{
ctrl = CellObjCtrlUtils.GetFwdCellObjCtrl(ctrl);
if (lst.Contains(ctrl))
{
int startId = lst.IndexOf(ctrl);
int cnt = startId;
//Debug.Log ("remove cnt:" + cnt);
_chainObjs = lst;
lst.RemoveRange(0, cnt);
bDetected = true;
break;
}
lst.Add(ctrl);
}
ringObjs = lst;
return(bDetected);
}
public void ClearMovePwr()
{
if (_TgtObj != null)
{
MiroModelV1 model =
CellObjCtrlUtils.GetMiroModelFromCell(this);
model.ClearMovePwr();
}
}
public void IncMovePwr()
{
if (_TgtObj != null)
{
MiroModelV1 model =
CellObjCtrlUtils.GetMiroModelFromCell(this);
model.MovePwrInc1();
Debug.Log(model + " inc move power");
}
}
void OnMouseDrag()
{
if (!MiroPlayingStatus.bPlaying)
{
return;
}
if (CheckBlock())
{
return;
}
if (enabled)
{
_bDragging = true;
//Debug.Log (_cctrl.name + " OnMouseDrag" + " rotate");
Vector3 hitDir = GetHitDir();
int rightDir = _cctrl.GetDir();
float minAngle = 100000.0f;
for (int dir = 0; dir < 6; dir++)
{
if (_banDirs.Contains(dir))
{
continue;
}
CellObjCtrl nbCtrl =
CellObjCtrlUtils.GetNbCellObjCtrlInAbsDir(_cctrl, dir);
if (nbCtrl == null)
{
continue;
}
Vector3 nbDir = nbCtrl.transform.position - _cctrl.transform.position;
nbDir.Normalize();
float angle = Vector3.Angle(hitDir, nbDir);
if (angle < minAngle)
{
minAngle = angle;
rightDir = dir;
}
}
if (rightDir != _cctrl.GetDir())
{
_cctrl.SetDir(rightDir);
_cctrl.ChangeDir();
//print ("ChangeDir" + rightDir);
_RightDir = rightDir;
_DirChanged.Invoke(rightDir);
}
}
}
public static bool DetectRingFrom(CellObjCtrl cctrl, ref List <CellObjCtrl> ringObjs)
{
bool bRing = false;
bool bCtrlling = CellObjCtrlUtils.IsControllingObj(cctrl);
if (!bCtrlling)
{
return(false);
}
ringObjs.Add(cctrl);
CellObjCtrl ctrlNxt = CellObjCtrlUtils.GetFwdCellObjCtrl(cctrl);
ringObjs.Add(ctrlNxt);
int count = 0;
bool bReturn = false;
while (CellObjCtrlUtils.IsControllingSameCampS(cctrl, ctrlNxt))
{
ctrlNxt = CellObjCtrlUtils.GetFwdCellObjCtrl(ctrlNxt);
if (ctrlNxt == cctrl)
{
bReturn = true;
break;
}
if (ringObjs.Contains(ctrlNxt))
{
int id = ringObjs.IndexOf(ctrlNxt);
ringObjs.RemoveRange(0, id + 1);
ringObjs.Add(ctrlNxt);
bReturn = true;
break;
}
ringObjs.Add(ctrlNxt);
count++;
if (count > 100)
{
break;
}
}
if (bReturn && ringObjs.Count >= 3)
{
bRing = true;
}
return(bRing);
}
void ExhaustRotLeftPower()
{
if (_bExhaustRotPwr)
{
MiroModelV1 model = CellObjCtrlUtils.GetMiroModelFromCell(this);
if (model != null)
{
model.AddRotLeftPwr(-1);
}
}
}
void DeConfigAbsorbing()
{
MiroModelV1 modelMe = CellObjCtrlUtils.GetMiroModelFromCell(_cellCtrl);
if (modelMe == null)
{
return;
}
modelMe.ReleaseAbsorbing();
}
void ExhaustMovePower()
{
if (_bExhaustMovePwr)
{
MiroModelV1 model = CellObjCtrlUtils.GetMiroModelFromCell(this);
if (model != null)
{
model.AddMovePwr(-1);
print("model.AddMovePwr (-1);");
}
}
}
public void UpdateRotation()
{
if (_movFwdUI._bON)
{
MiroModelV1 model =
CellObjCtrlUtils.GetMiroModelFromCell(_cctrl);
if (model != null)
{
transform.rotation = model.transform.rotation;
}
}
}
void TryToAid()
{
TryAid(_cellCtrl);
bool bFaceToFace = CellObjCtrlUtils.IsFaceToFace(_cellCtrl);
if (bFaceToFace)
{
CellObjCtrl fwdCtrl = CellObjCtrlUtils.GetFwdCellObjCtrl(_cellCtrl);
TryAid(fwdCtrl);
}
}
public void ReadyToUpdate(CCRing ccr)
{
//print ("ReadyToUpdate!" + ccr);
MiroModelV1 miro = CellObjCtrlUtils.GetMiroModelFromCell(ccr._cellCtrl);
_miros.Add(miro);
_ctrls[ccr._cellCtrl] = false;
if (_miros.Count == _mgr._MiroObjs.Count)
{
PlaceRing();
}
}
public MiroV1ModelSetting GetMiroModelSettingAt(Hex hex)
{
GameObject cellObj = GetCellObjAt(hex);
if (cellObj == null)
{
return(null);
}
CellObjCtrl cctrl = cellObj.GetComponent <CellObjCtrl> ();
MiroV1ModelSetting setting = CellObjCtrlUtils.GetModelSettingFromCtrl(cctrl);
return(setting);
}
public static bool IsNbAttacking(CellObjCtrl cctrl, int relativeDir)
{
CellObjCtrl nbCtrl = CellObjCtrlUtils.GetNbCellObjCtrl(cctrl, relativeDir);
if (nbCtrl == null)
{
return(false);
}
bool bNbAtt = ShouldAttacking(nbCtrl);
return(bNbAtt);
}
// absorbing configuration
void ConfigAbsorbing()
{
//int bwdDir = _cellCtrl.GetBwdDir ();
MiroModelV1 modelMe = CellObjCtrlUtils.GetMiroModelFromCell(_cellCtrl);
CellObjCtrl fwdCtrl = CellObjCtrlUtils.GetFwdCellObjCtrl(_cellCtrl);
MiroModelV1 modelFwd = CellObjCtrlUtils.GetMiroModelFromCell(fwdCtrl);
ConfigureHole2(modelMe, true);
ConfigureHole2(modelFwd, true);
MiroV1PlacementMgr.ConfigAbsorbingForTF(_cellCtrl.transform);
MiroV1PlacementMgr.ConfigAbsorbingForTF(fwdCtrl.transform);
}
public void MoveInDir(int dir)
{
/*
* if (_TgtObj == null) {
* return;
* }
*
* HexCoord hc = GetComponent<HexCoord> ();
* Transform tf = hc._Neighbors[dir];
* if (tf == null) {
* return;
* }
*
* CellObjCtrl nxtCellObjCtrl =
* tf.gameObject.GetComponent<CellObjCtrl> ();
* if (nxtCellObjCtrl._TgtObj != null ||
* nxtCellObjCtrl._bBlocked) {
* return;
* }*/
bool bCanMove = CanMove(_Dir);
if (!bCanMove)
{
return;
}
CellObjCtrl nxtCellObjCtrl =
CellObjCtrlUtils.GetNbCellObjCtrl(this, 0);
LerpMoveTo lerpMoveTo = _TgtObj.GetComponent <LerpMoveTo> ();
if (lerpMoveTo == null)
{
lerpMoveTo = _TgtObj.AddComponent <LerpMoveTo> ();
}
lerpMoveTo.enabled = true;
Transform tf = nxtCellObjCtrl.transform;
lerpMoveTo._TgtTF = tf;
nxtCellObjCtrl.SetTargetObj(_TgtObj);
_TgtObj = null;
nxtCellObjCtrl.SetDir(_Dir);
nxtCellObjCtrl.PointToCurrentDir();
InvokeTgtObjChanged();
}
void UpdateSituDict()
{
foreach (GameObject ctrlObj in _gridCtrl._Cells)
{
CellObjCtrl ctrl = ctrlObj.GetComponent <CellObjCtrl> ();
MiroV1ModelSetting setting = CellObjCtrlUtils.GetModelSettingFromCtrl(ctrl);
string cname = "";
if (setting != null)
{
cname = setting._CampName;
}
_ChessBoardSitu [ctrl] = cname;
}
}
