public void deselectPiece()
{
if(this.selectedPiece != null) {
this.selectedPiece.deselect();
this.selectedPiece = null;
}
}
public void Activate(PieceController p)
{
if(floatingPiece != null){
InventoryAdd(floatingPiece);
}
//p.transform.position = new Vector3(p.transform.position.x,p.transform.position.y,-1f);
floatingPiece = p;
p.SetGridLock(false);
grid.RemovePiece(p);
ewc.transform.rotation = floatingPiece.transform.rotation;
}
public void SelectPiece (PieceController piece)
{
if (m_lastSelectedPiece != null) {
m_lastSelectedPiece.Unselect ();
}
if (piece != null) {
piece.Select ();
}
m_lastSelectedPiece = piece;
}
public void PutThatThingBackWhereItCameFromOrSoHelpMe(PieceController pc, int x, int y)
{
RectTransform prt = (RectTransform)pc.transform;
RectTransform rt = (RectTransform)transform;
UIRectTranslator translate = transform.gameObject.GetComponent <UIRectTranslator>();
Vector3[] corners = new Vector3[4];
rt.GetWorldCorners(corners);
Vector3 gridTopCorner = corners[1]; //new Vector3(gridCorner.x,gridCorner.y+gridLength,gridCorner.z);
Vector3 extents = translate.WorldSize(prt) / 2;
pc.transform.position = gridTopCorner + new Vector3(squareWidth * x + extents.x,
-squareWidth * (y) - extents.y,
pc.transform.position.z);
}
public void DropPiece()
{
if (moving == null)
{
return;
}
if (!newPoint.Equals(moving.point))
{
game.FlipPieces(moving.point, newPoint, true);
}
else
{
game.ResetPiece(moving);
}
moving = null;
}
private static void AddToStreetLightList(Dictionary <int, MapObjectProperties> streetLightList, StreetLightType streetLightType, LightType lightType, Vector2 lightOffset, MapObjectShadowType shadowType, Point objectSize, Point shadowPointLeft, Point shadowPointTop, bool alwaysOn, int elevation)
{
int rowIndex = (int)streetLightType * 4;
for (int i = 0; i < 4; i++)
{
Piece piece = PieceController.GetPiece(10, rowIndex + i);
Light light = GraphicsManager.GetLight(lightType);
Vector2 currentLightOffset = RotateVectorRight(lightOffset, GroundLayerController.tileSize, i);
float radian = RotateRadiansRight(0, i);
Point shadowPointOffset = GetShadowPoint(shadowPointLeft, shadowPointTop, GroundLayerController.tileSize, i, objectSize);
Shadow shadowLeft = new Shadow(ShadowSpriteController.GetShadowSprite(shadowType, ShadowSide.LEFT, i), 0, 0, ShadowSide.LEFT, i, shadowPointOffset);
Shadow shadowRight = new Shadow(ShadowSpriteController.GetShadowSprite(shadowType, ShadowSide.RIGHT, i), 0, 0, ShadowSide.RIGHT, i, shadowPointOffset);
streetLightList.Add(rowIndex + i, new StreetLight(piece, light, currentLightOffset, radian, shadowLeft, shadowRight, shadowPointOffset, alwaysOn, elevation));
}
}
public Grid GenerateGrid(int width, int height)
{
PieceController[,] pieces = new PieceController[width, height];
for (int i = 0; i < width; i++)
{
for (int j = 0; j < height; j++)
{
pieces[i, j] = Instantiate(PrefabManager.GetPrefab(PrefabManager.PrefabType.FloorPiece)
, Vector3.right * (i * _pieceOffset.x) + Vector3.forward * (j * _pieceOffset.z)
, Quaternion.identity).GetComponent <PieceController>();
}
}
return(new Grid(pieces));
}
public void ReproduceState(int index)
{
Init();
History history = History.Instance;
PieceController pc = PieceController.Instance;
for (int i = 0; i <= index; i++)
{
HistoryInfo info = history.Get(i);
Piece piece = pc.GetByIndex(info.PieceId - 1);
piece.Move(info.Position, false);
if (info.IsPromote)
{
piece.Promote();
}
}
}
void PickUpKind()
{
Debug.Log("Select");
isSelected = true;
PieceController controller = PieceController.Instance;
controller.CloseGuideArea();
Piece piece = controller.FindPassivePiece(kind);
if (piece == null)
{
isSelected = false;
return;
}
target = piece;
piece.PickUp();
}
public PieceController CheckEnPassant(Vector2 position)
{
PieceController pieceInfo = null;
if (enPassantMoves.Count > 0)
{
foreach (PieceController info in enPassantMoves)
{
Vector2 pos = new Vector2(info.gridCoordinate.x, info.gridCoordinate.y + (info.isWhite ? -1 : 1));
if (pos == position)
{
pieceInfo = info;
}
}
}
return(pieceInfo);
}
//Determine new position of pieces based of the angle passed(ROM angle)
void MovePiece(float angle, PieceController piece, float offset)
{
//Edit angle based off progression so far
if (StaticClass.PuzzleIncrement == 0.0f)
{
angle -= 2.5f;
}
else if (StaticClass.PuzzleIncrement == 1.0f)
{
//Angle does not change
}
else if (StaticClass.PuzzleIncrement == 2.0f)
{
angle += 2.5f;
}
//Convert angle in radians
angle = angle * (Mathf.Deg2Rad);
//print(angle);
//Calculate z position
float zPos = (Mathf.Abs(piece.transform.position.x)) / Mathf.Tan(angle);
zPos += offset;
print("Zpos: " + zPos);
if (zPos > 5.15f)
{
zPos = 5.2f;
float xPos = (Mathf.Abs(zPos)) * Mathf.Tan(angle);
if (piece.transform.position.x < 0)
{
xPos = -xPos;
}
xPos += offset;
piece.transform.position = new Vector3(xPos, piece.transform.position.y, zPos);
print("x changed loop");
}
else
{
//Change piece position
piece.transform.position = new Vector3(piece.transform.position.x, piece.transform.position.y, zPos);
}
Debug.Log(piece.name);
Debug.Log(piece.transform.position.z);
}
public void DestroyMiniUnit(PieceController _pieceController)
{
try {
if (!miniPieceDictionary.ContainsKey(_pieceController))
{
throw new System.NullReferenceException("Can't Find MiniBuidling");
}
Destroy(miniPieceDictionary[_pieceController].gameObject);
miniPieceDictionary.Remove(_pieceController);
} catch (System.ArgumentNullException ex) {
throw ex;
} catch (System.NullReferenceException ex) {
throw ex;
} catch (System.Exception ex) {
throw ex;
}
}
public void HandleEvent(GameEvent ge)
{
if(ge.type.Equals("piece_tapped")){
PieceController tappedPiece = (PieceController)ge.args[0];
if(tappedPiece.GetGridLock()){
if(floatingPiece != null){
bool success = grid.TryAddPiece(floatingPiece);
if(success){
floatingPiece.SetGridLock(true);
floatingPiece = null;
}
}
Activate (tappedPiece);
}else{
bool success = grid.TryAddPiece(tappedPiece);
if(success){
tappedPiece.SetGridLock(true);
floatingPiece = null;
}
}
}else if(ge.type.Equals("piece_dropped_on_inventory")){
PieceController piece = (PieceController)ge.args[0];
InventoryAdd(piece);
}else if(ge.type.Equals("template_tapped")){
PieceTemplateController tappedPiece = (PieceTemplateController)ge.args[0];
Vector3 loc = (Vector3)ge.args[1];
if(floatingPiece != null){
bool success = grid.TryAddPiece(floatingPiece);
if(success){
floatingPiece.SetGridLock(true);
floatingPiece = null;
}
}
GameObject go = Instantiate (Resources.Load ("Prefabs/ExistingPiece")) as GameObject;
go.transform.SetParent(canvas.transform,false);
go.transform.position = new Vector3(loc.x,loc.y,go.transform.position.z);
PieceController newPiece = go.GetComponent<PieceController>();
newPiece.ConfigureFromJSON(tappedPiece.GetFilename());
newPiece.SetRotation(0);
newPiece.SetMoving(true);
Activate(newPiece);
iwc.RemovePiece(newPiece);
//tappedPiece.SetCount(tappedPiece.GetCount()-1);
}
}
void CreatePiece(Vector2 pos, bool isWhite, PieceTitle.Piece pieceType)
{
GameObject piece = Instantiate(piecePrefab, pieceParent);
piece.name = string.Format("{0}{1}", isWhite ? "White" : "Black", pieceNames[(int)pieceType]);
RectTransform rect = piece.GetComponent <RectTransform>();
Vector2 position = new Vector2((pos.x * gridSpace) + gridOrigin, (pos.y * gridSpace) + gridOrigin);
PieceController pieceController = piece.GetComponent <PieceController>();
pieceController.gridCoordinate = new Vector2(pos.x, pos.y);
pieceController.isWhite = isWhite;
pieceController.piece = pieceType;
pieceController.score = gameScores[(int)pieceType];
piece.GetComponent <Image>().sprite = pieceSprites[(int)pieceType + (System.Enum.GetValues(typeof(PieceTitle.Piece)).Length *(isWhite?0:1))];
rect.sizeDelta = Vector2.one * gridSpace;
rect.localPosition = position;
}
void GrayPieces()
{
string validType = InventoryWindowController.TextStringFromType(towerType);
foreach (Transform childPiece in piecesLayer)
{
PieceController pc = childPiece.GetComponent <PieceController>();
Image i = pc.GetComponent <Image>();
if (pc.validTypes[validType])
{
i.color = new Color(1f, 1f, 1f, 1f);
}
else
{
i.color = new Color(.5f, .5f, .5f, .5f);
}
}
}
public void combine(PieceController owner, PieceController loser)
{
owner.move(loser.model.position);
Player owningPlayer = playerForNumber(owner.model.playerNum);
Player losingPlayer = playerForNumber(loser.model.playerNum);
Debug.Log(owningPlayer);
owningPlayer.pieces.Remove(owner.model);
losingPlayer.pieces.Remove(loser.model);
Piece newPiece = PieceFactory.combine(owner.model, loser.model);
PieceController piece = Instantiate(piecePrefab, Vector3.zero, Quaternion.identity) as PieceController;
piece.transform.parent = transform;
piece.model = newPiece;
piece.board = this;
getTile(piece.model.position).myPiece = piece;
owningPlayer.pieces.Add (newPiece);
Destroy(owner.gameObject);
Destroy(loser.gameObject);
}
public void MovePieceTo( float x, float y ){
//pick available piece
int i = 0;
PieceController toMove = pieces[i];
while( toMove.isInBoard ) {
i++;
if( i < numPieces ) {
toMove = pieces[i];
}
else {
toMove = null;
break;
}
}
if( toMove ) {
toMove.MoveToSpace( x, y );
}
}
public void selectPiece(PieceController pc)
{
if(this.selectedPiece != null) {
if(this.selectedPiece == pc) {
this.selectedPiece.deselect();
}
else if(this.selectedPiece.model.positionIsInRange(this, pc.model.position) && this.selectedPiece.model.canCombineWith(pc.model)) {
int movingPlayer = this.selectedPiece.model.playerNum;
combine(this.selectedPiece, pc);
ai.move(this, movingPlayer == 2);
return;
} else {
this.selectedPiece.deselect();
}
}
this.selectedPiece = pc;
pc.select();
}
public void DeleteConnectedFull()
{
for (int x = 0; x < BoardController.width; x++)
{
for (int y = 0; y < BoardController.height; y++)
{
Grid tempNode = GetGridAtPoint(new Point(x, y));
if (tempNode.value != -1)
{
PieceController tempNodePiece = tempNode.getPiece();
if (tempNodePiece && (tempNodePiece.cntCrossDown >= 2 || tempNodePiece.cntCrossUp >= 2 || tempNodePiece.cntStraight >= 2 || tempNodePiece.cntArea >= 3))
{
DeleteConnectedPoint(tempNode.point);
}
}
}
}
// obstacle 적용
foreach (PieceController pc in hitObstacle)
{
int hitcount = pc.getHitCount() + 1;
pc.setHitCount(hitcount);
if (hitcount == 2)
{
if (pc.value == (int)eStatus.SILVER)
{
GameController.instance.MinusObstacleCountvalue();
}
SetGameScore(pc.value);
blankList.Add(pc);
GetGridAtPoint(pc.point).SetPiece(null);
Destroy(pc.gameObject);
}
}
hitObstacle.Clear();
if (blankList.Count != 0)
{
bUpdateLogic = true;
StartCoroutine(applyGravitybyTick());
}
}
public void HandleEvent(GameEvent ge)
{
Vector3 mousepos = InputWatcher.GetInputPosition();
if (ge.type.Equals("mouse_release"))
{
//Stops the dial from spinning more
spinner = false;
//Only tries to lock if the spinner has a chance of moving
if (clickTime > clickDelay)
{
//Locks position to nearest interval of 60
float rotation = transform.eulerAngles.z;
float lockRot = Mathf.Round(rotation / 90.0f) * 90;
transform.rotation = Quaternion.Euler(0, 0, lockRot);
PieceController pc = EditorController.GetFloatingPiece();
if (pc != null)
{
pc.SetRotation(360 - transform.rotation.eulerAngles.z);
}
}
//resets time
clickTime = 0;
touchDown = false;
}
else if (ge.type.Equals("mouse_click"))
{
//Allows the dial to start spinning
if (spinner == false)
{
float dist = Mathf.Sqrt(((mousepos.x - transform.position.x) * (mousepos.x - transform.position.x))
+ ((mousepos.y - transform.position.y) * (mousepos.y - transform.position.y)));
if (dist > radius)
{
return;
}
originalRot = Mathf.Atan2(mousepos.y - transform.position.y, mousepos.x - transform.position.x);
origz = transform.eulerAngles.z;
//Debug.Log ("new original degrees: " + originalRot);
}
spinner = true;
touchDown = true;
}
}
public PieceController AddPiece(PieceController piece)
{
if (piece.cost <= playerController.Gold && state == GameState.Start)
{
if (playerController.SpendMoney(piece.cost))
{
PieceController _old;
do
{
_old = piece;
piece = UpgradePiece(piece);
} while (_old != piece);
_piecesList.Add(piece);
return(piece);
}
}
return(null);
}
public void FillLine(int line)
{
for (int x = 0; x < gridSizeX; x++)
{
GridUnit curGridUnit = fullGrid[x, line];
if (!curGridUnit.isOccupied)
{
GameObject clonedTile = GameObject.Instantiate(tileClone, transform);
PieceController tileContr = clonedTile.GetComponent <PieceController>();
if (GameEngine.instance.sectAfter20g > 1)
{
tileContr.tiles[0].GetComponent <SpriteRenderer>().sprite = boneblock;
}
tileContr.tiles[0].UpdatePosition(new Vector2Int(x, line));
tileContr.tiles[0].SetTileUp();
PiecesController.instance.piecesInGame.Add(clonedTile);
}
}
}
public void RemovePiece(PieceController p)
{
string fname = p.GetFilename();
for(int i = 0; i < fullList.Count; i++){
InventoryRecord ir = fullList[i];
if(fname.Equals(ir.pieceFileName)){
int oldcount = ir.GetCount();
if(oldcount <= 0){
return;
}else if(oldcount == 1){
ir.SetCount(ir.GetCount()-1);
RefreshList();
}else{
ir.SetCount(ir.GetCount()-1);
}
break;
}
}
}
private void SpawnPiece(GameObject obj, Vector3 pos)
{
GameObject temp = Instantiate(obj, transform);
temp.transform.position = pos;
Piece piece = temp.AddComponent <Piece>();
piece.board = this;
pieces.Add(piece);
temp.AddComponent <Valve.VR.InteractionSystem.Interactable>();
PieceController pc = temp.AddComponent <PieceController>();
pc.piece = piece;
pc.board = this;
MeshCollider col = temp.AddComponent <MeshCollider>();
col.convex = true;
col.isTrigger = true;
}
/// <summary>
/// Загружает префаб фигуры и привязывает его к фигуре BoardState.
/// </summary>
/// <param name="figure">Фигура BoardState.</param>
public void LoadGameObject(Figure figure)
{
// Определяем имя префаба
string figureColor = figure.color.ToString();
string figureType = figure.GetType().ToString().ToLower();
string figureName = $"{figureColor}_{figureType}";
// Создаем объект
GameObject gameObject = Instantiate(Resources.Load($"Pieces/{figureName}")) as GameObject;
gameObject.transform.position = new Vector3(figure.x, figure.y);
gameObject.transform.parent = GameObject.Find("pieces").transform;
// Привязываем объект к фигуре BoardState
PieceController pieceController = gameObject.GetComponent <PieceController>();
pieceController.boardStateFigure = figure;
figure.deletedCallback = pieceController.DeletedCallback;
}
public void AddPiece(PieceController p)
{
string fname = p.GetFilename();
for(int i = 0; i < fullList.Count; i++){
InventoryRecord ir = fullList[i];
if(fname.Equals(ir.pieceFileName)){
//Debug.Log("old count is " + ir.GetCount());
ir.SetCount(ir.GetCount()+1);
//Debug.Log ("new count is " + ir.GetCount());
if(ir.GetCount() == 1){
//Debug.Log ("we just tried refreshing");
RefreshList();
}
break;
}else{
//Debug.Log(fname + " doesn't equal " + ir.pieceFileName);
}
}
}
/// <summary>
/// reset piece state
/// </summary>
public void Reset()
{
if (!gameObject.activeInHierarchy)
{
gameObject.SetActive(true);
}
state = PieceState.Idle;
Target = null;
Health = maxHealth; // Set Default health to Max Health
// fixed origin position
transform.position = originPos; // origin cell position and offset
targetPos = originPos;
lastMove = originPos;
// reset animation
// AnimatorController.Rebind();
// AnimatorController.Update(0f);
AnimatorController.ChangeAnimation(PlayerAnimations.Idle.ToString());
AnimatorController.SetFlipX(Team == 1);
}
public void PlaceOnTop(PieceController piece)
{
if (PieceBelow != null)
{
PieceBelow.PieceOnTop = null;
}
GridPosition = piece.GridPosition;
while (piece.PieceOnTop != null)
{
piece = piece.PieceOnTop;
}
transform.position = piece.transform.position + Vector3.up;
piece.PieceOnTop = this;
PieceBelow = piece;
}
private void AddIndex(int value)
{
if (shiftDown)
{
value *= 4;
}
indexShadow += value;
if (indexShadow < 0)
{
indexShadow = PieceController.GetRowLength(compressedBuilding.pieceRow);
}
if (indexShadow > PieceController.GetRowLength(compressedBuilding.pieceRow))
{
indexShadow = 0;
}
SetSampleShadow();
}
/// <summary>
/// Clears all tiles from a specified line
/// </summary>
/// <param name="lineToClear">Index of the line to be cleared</param>
void ClearLine(int lineToClear)
{
if (lineToClear < 0 || lineToClear > gridSizeY)
{
Debug.LogError("Error: Cannot Clear Line: " + lineToClear);
return;
}
for (int x = 0; x < gridSizeX; x++)
{
PieceController curPC = fullGrid[x, lineToClear].tileOnGridUnit.GetComponent <TileController>().pieceController;
curPC.tiles[fullGrid[x, lineToClear].tileOnGridUnit.GetComponent <TileController>().tileIndex] = null;
Destroy(fullGrid[x, lineToClear].tileOnGridUnit);
if (!curPC.AnyTilesLeft())
{
Destroy(curPC.gameObject);
}
fullGrid[x, lineToClear].tileOnGridUnit = null;
fullGrid[x, lineToClear].isOccupied = false;
}
}
void Awake()
{
if (instance == null)
{
instance = this;
}
if (pieces == null)
{
pieces = new List <Piece>();
}
if (board == null)
{
board = GameObject.Find("Canvas").transform.GetChild(0).GetChild(0).GetComponent <RectTransform>();
}
if (piecePrefab == null)
{
piecePrefab = Resources.Load <GameObject>("piece");
}
settingFiles = new Dictionary <string, TextAsset>();
}
public SwapJob(PieceController piece, PieceController other, float speed, bool revert = false)
{
m_piece = piece;
m_other = other;
m_speed = speed;
m_revert = revert;
if (m_revert)
{
m_tween0 = new LinearTween(piece.transform, piece.transform.position, GameController.Instance.GetPiecePosition(other.Row, other.Col), speed);
m_tween1 = new LinearTween(other.transform, other.transform.position, GameController.Instance.GetPiecePosition(piece.Row, piece.Col), speed);
}
else
{
m_tween0 = new LinearTween(piece.transform, piece.transform.position, GameController.Instance.GetPiecePosition(piece.Row, piece.Col), speed);
m_tween1 = new LinearTween(other.transform, other.transform.position, GameController.Instance.GetPiecePosition(other.Row, other.Col), speed);
}
}
public bool AnimatePieceDrop(PieceController piece)
{
bool animate = false;
Vector3 sourcePos = piece.transform.position;
Vector3 targetPos = Game.GetPiecePosition(piece.Row, piece.Col);
float dist = (sourcePos - targetPos).magnitude;
if (dist > 0.01f)
{
animate = true;
targetPos = new Vector3(sourcePos.x, Mathf.Max(targetPos.y, sourcePos.y - pieceDropSpeed * Time.deltaTime));
}
piece.transform.position = targetPos;
return(animate);
}
private void AddIndex(int value)
{
if (shiftDown)
{
value *= 4;
}
indexBuilding += value;
if (indexBuilding < 0)
{
indexBuilding = PieceController.GetRowLength(compressedBuilding.pieceRow);
}
if (indexBuilding > PieceController.GetRowLength(compressedBuilding.pieceRow))
{
indexBuilding = 0;
}
SetSamplePiece();
}
public void combine(PieceController owner, PieceController loser)
{
owner.move(loser.model.position);
Player owningPlayer = playerForNumber(owner.model.playerNum);
Player losingPlayer = playerForNumber(loser.model.playerNum);
Debug.Log(owningPlayer);
owningPlayer.pieces.Remove(owner.model);
losingPlayer.pieces.Remove(loser.model);
Piece newPiece = PieceFactory.combine(owner.model, loser.model);
PieceController piece = Instantiate(piecePrefab, Vector3.zero, Quaternion.identity) as PieceController;
piece.transform.parent = transform;
piece.model = newPiece;
piece.board = this;
getTile(piece.model.position).myPiece = piece;
owningPlayer.pieces.Add(newPiece);
Destroy(owner.gameObject);
Destroy(loser.gameObject);
}
/// <summary>
/// 一行のタイルをクリアする
/// </summary>
/// <param name="lineToClear">行のインデクス</param>
private void ClearLine(int lineToClear)
{
if (lineToClear < 0 || lineToClear > gridSizeY)
{
Debug.LogError("Error: Cannot Clear Line" + lineToClear);
return;
}
for (int x = 0; x < gridSizeX; x++)
{
PieceController curPC = gameBoardUnits[x, lineToClear].tileOnThisGrid.GetComponent <TileController>().pieceController;
curPC.tiles[gameBoardUnits[x, lineToClear].tileOnThisGrid.GetComponent <TileController>().tileIndex] = null;
Destroy(gameBoardUnits[x, lineToClear].tileOnThisGrid);
if (!curPC.AnyTilesLeft())
{
Destroy(curPC.gameObject);
}
gameBoardUnits[x, lineToClear].tileOnThisGrid = null;
gameBoardUnits[x, lineToClear].isOccupied = false;
}
}
public void CreateAtRandom(Transform parent, Action <PieceController> onCreate)
{
Assert.IsNotNull(_bornPieceList);
if (_bornPieceList == null)
{
return;
}
if (_bornPieceList.Count == 0)
{
return;
}
var index = UnityEngine.Random.Range(0, _bornPieceList.Count - 1);
var prefab = _bornPieceList[index];
PieceController piece = Instantiate(prefab, parent).GetComponent <PieceController>();
_pieceInstanceList.Add(piece);
onCreate(piece);
}
private void FindEnemy(PieceController origin)
{
float minDistance = float.MaxValue;
PieceController target = null;
foreach (var piece in _piecesList)
{
// If target piece alive
if (origin != piece && piece.Alive && piece.Team != origin.Team)
{
// Compare the distance of enemy
var dis = Vector3.Distance(origin.CurrentPosition, piece.TargetPos);
if (dis < minDistance)
{
minDistance = dis;
target = piece;
}
}
}
origin.Target = target;
}
public void RemovePiece(PieceController pc)
{
foreach(PieceRecord pr in allPieces){
if(pr.pc == pc){
allPieces.Remove(pr);
UpdateReadout();
break;
}
}
for(int i = 0; i < GRID_SIZE; i++){
for(int j = 0; j < GRID_SIZE; j++){
Occupancy o = grid[i,j];
if(o.north == pc)
o.north = null;
if(o.east == pc)
o.east = null;
if(o.south == pc)
o.south = null;
if(o.west == pc)
o.west = null;
}
}
}
public void PutThatThingBackWhereItCameFromOrSoHelpMe(PieceController pc,int x, int y)
{
RectTransform prt = (RectTransform)pc.transform;
RectTransform rt = (RectTransform)transform;
UIRectTranslator translate = transform.gameObject.GetComponent<UIRectTranslator>();
Vector3[] corners = new Vector3[4];
rt.GetWorldCorners(corners);
Vector3 gridTopCorner = corners[1];//new Vector3(gridCorner.x,gridCorner.y+gridLength,gridCorner.z);
Vector3 extents = translate.WorldSize(prt)/2;
pc.transform.position = gridTopCorner + new Vector3(squareWidth*x + extents.x,
-squareWidth*(y) - extents.y,
pc.transform.position.z);
pc.transform.SetParent(EditorController.piecesLayer,false);
}
public bool TryAddPiece(PieceController pc)
{
bool fits = PieceFits(pc.gameObject,pc.GetArray());
if(!fits){
Debug.Log ("didn't fit");
return false;
}
int[,] pieceValues = pc.GetArray();
//we've gone through and there've been no collisions
//actually add the piece
allPieces.Add(new PieceRecord(pc,xcounter,ycounter));
UpdateReadout();
for(int i = 0; i < pieceValues.GetLength(0); i++){
for(int j = 0; j < pieceValues.GetLength(1); j++){
Occupancy o = grid[ycounter + i,xcounter + j];
int shapecode = pieceValues[i,j];
if(shapecode == 0){
continue;
}if(shapecode == 1){
o.north = pc;
o.east = pc;
o.south = pc;
o.west = pc;
}if(shapecode == NORTHWEST_CODE){
o.north = pc;
o.west = pc;
}if(shapecode == NORTHEAST_CODE){
o.north = pc;
o.east = pc;
}if(shapecode == SOUTHEAST_CODE){
o.south = pc;
o.east = pc;
}if(shapecode == SOUTHWEST_CODE){
o.south = pc;
o.west = pc;
}
}
}
//SpriteRenderer sr = pc.gameObject.GetComponent<SpriteRenderer>();
PutThatThingBackWhereItCameFromOrSoHelpMe(pc,xcounter,ycounter);
/*RectTransform prt = (RectTransform)pc.transform;
RectTransform rt = (RectTransform)transform;
UIRectTranslator translate = transform.gameObject.GetComponent<UIRectTranslator>();
Vector3[] corners = new Vector3[4];
rt.GetWorldCorners(corners);
Vector3 gridTopCorner = corners[1];//new Vector3(gridCorner.x,gridCorner.y+gridLength,gridCorner.z);
Vector3 extents = translate.WorldSize(prt)/2;
pc.transform.position = new Vector3(xcounter*squareWidth + gridCorner.x + extents.x,
gridCorner.y + gridLength - ((ycounter-1)*squareWidth) - extents.y,
pc.transform.position.z);*/
for(int i = 0; i < GRID_SIZE; i++){
for(int j = 0; j < GRID_SIZE; j++){
overlays[i,j].sprite = blank;
}
}
Debug.Log ("it fit");
return fits;
}
public void Start()
{
grid = GameObject.Find("Grid").GetComponent<GridController>();
ewc = GameObject.Find("SpinWheel").GetComponent<EditorWheelController>();
sr = GameObject.Find("InvScroll").GetComponent<ScrollRect>();
iwc = GameObject.Find("InvContent").GetComponent<InventoryWindowController>();
canvas = GameObject.Find ("Canvas").GetComponent<Canvas>();
//grid.editor = this;
EventManager em = EventManager.Instance();
em.RegisterForEventType("piece_tapped",this);
em.RegisterForEventType("template_tapped",this);
em.RegisterForEventType("piece_dropped_on_inventory",this);
GameObject go = Instantiate (Resources.Load ("Prefabs/ExistingPiece")) as GameObject;
go.transform.SetParent(canvas.transform,false);
go.transform.position = new Vector3(go.transform.position.x-2,go.transform.position.y,go.transform.position.z);
floatingPiece = go.GetComponent<PieceController>();
floatingPiece.ConfigureFromJSON("penetration_normal");
floatingPiece.SetRotation(180);
ewc.transform.rotation = floatingPiece.transform.rotation;
}
public void InventoryAdd(PieceController p)
{
iwc.AddPiece(p);
Destroy (p.gameObject);
}
void Awake()
{
if (instance == null)
instance = this;
if(pieces == null)
pieces = new List<Piece>();
if(board == null)
board = GameObject.Find("Canvas").transform.GetChild(0).GetChild(0).GetComponent<RectTransform>();
if(piecePrefab == null)
piecePrefab = Resources.Load<GameObject>("piece");
settingFiles = new Dictionary<string, TextAsset>();
}
public override void runTileAction (PieceController piece){
shopMenu.playerID = piece.playerID;
shopMenu.ResetShop ();
}
public void HandleEvent(GameEvent ge)
{
if(ge.type.Equals("piece_tapped")){
PieceController tappedPiece = (PieceController)ge.args[0];
if(tappedPiece.GetGridLock()){
if(floatingPiece != null){
bool success = grid.TryAddPiece(floatingPiece);
if(success){
floatingPiece.SetGridLock(true);
floatingPiece = null;
}
}
Activate (tappedPiece);
}else{
bool success = grid.TryAddPiece(tappedPiece);
if(success){
tappedPiece.SetGridLock(true);
floatingPiece = null;
}
}
}else if(ge.type.Equals("piece_dropped_on_inventory")){
PieceController piece = (PieceController)ge.args[0];
InventoryAdd(piece);
}else if(ge.type.Equals("template_tapped")){
PieceTemplateController tappedPiece = (PieceTemplateController)ge.args[0];
Vector3 loc = (Vector3)ge.args[1];
if(floatingPiece != null){
bool success = grid.TryAddPiece(floatingPiece);
if(success){
floatingPiece.SetGridLock(true);
floatingPiece = null;
}
}
GameObject go = Instantiate (Resources.Load ("Prefabs/ExistingPiece")) as GameObject;
go.transform.SetParent(canvas.transform,false);
go.transform.position = new Vector3(loc.x,loc.y,go.transform.position.z);
PieceController newPiece = go.GetComponent<PieceController>();
newPiece.ConfigureFromJSON(tappedPiece.GetFilename());
newPiece.SetRotation(0);
newPiece.SetMoving(true);
Activate(newPiece);
iwc.RemovePiece(newPiece);
//tappedPiece.SetCount(tappedPiece.GetCount()-1);
}else if(ge.type.Equals("alt_click")){
if(floatingPiece == null)
return;
if(!finger1down){
return;
}
Vector3 altClickPos = (Vector3)ge.args[0];
Vector3 firstClickPos = InputWatcher.GetInputPosition();
Vector3 direction = altClickPos-firstClickPos;
twoFingerAngle = Mathf.Atan2 (direction.y,direction.x) *Mathf.Rad2Deg;
pieceAngle = floatingPiece.transform.eulerAngles.z;
floatingPiece.SetTwoFingerMovement(true);
finger2down = true;
}else if(ge.type.Equals("alt_release")){
Debug.Log ("alt release happened");
if(floatingPiece == null)
return;
if(waitingForOtherFingerToReset){
floatingPiece.SetTwoFingerMovement(false);
waitingForOtherFingerToReset = false;
}else{
waitingForOtherFingerToReset = true;
floatingPiece.LockRotation();
}
finger2down = false;
}else if(ge.type.Equals("mouse_click")){
Vector3 pos = (Vector3)ge.args[0];
if(grid.TouchIsOnMe(pos)){
finger1down = true;
}
}else if(ge.type.Equals("mouse_release")){
if(floatingPiece == null)
return;
if(waitingForOtherFingerToReset){
floatingPiece.SetTwoFingerMovement(false);
waitingForOtherFingerToReset = false;
}else{
waitingForOtherFingerToReset = true;
floatingPiece.LockRotation();
}
finger1down = false;
}
}
public PieceRecord(PieceController p, int nx, int ny)
{
pc = p;
x = nx;
y = ny;
}
public abstract void runTileAction (PieceController piece);
