Хабр Курсы для всех
РЕКЛАМА
Практикум, Хекслет, SkyPro, авторские курсы — собрали всех и попросили скидки. Осталось выбрать!
Хабр доступен 24/7 благодаря поддержке друзей
Комментарии 7
>> Прошу большими камнями не кидаться. Осознаю низкое качество кода и обещаю стремиться избегать говнокода. Спасибо за внимание.
>> P.S. Это моя первая статья на хабре.
Все когда-то с этого начинали. Ну, за исключением Ализароподобных, у которых, с рождения новости в крови… А так, you're welcome… :)
>> P.S. Это моя первая статья на хабре.
Все когда-то с этого начинали. Ну, за исключением Ализароподобных, у которых, с рождения новости в крови… А так, you're welcome… :)
Для игры лучше использовать SurfaceView, тогда весь вывод на экран можно вынести в отдельный поток.
А зачем? Есть же вполне устоявшийся вариант game loop'a со смещением, который зачастую (если умеем грамотно воспользоваться этим смещением) будет работать лучше.
Я про последнюю реализацию туточки.
Я про последнюю реализацию туточки.
идея игры очень напоминает одну из моих любимых игр — гексагон
помню, еще на вин98 через дос играл в нее :)
недавно, вот попалась флеш-реализация — vk.com/app1922887
помню, еще на вин98 через дос играл в нее :)
недавно, вот попалась флеш-реализация — vk.com/app1922887
>> Название забылось, а поиски на нескольких тематических форумах ни к чему не привели
Она? play.google.com/store/apps/details?id=uk.co.stevebosman.criticalmass.android
Она? play.google.com/store/apps/details?id=uk.co.stevebosman.criticalmass.android
Заголовок
private final GameView view;
private final GameActivity activity;
private int moveNumber=0, currentPlayer=0;
private final int COUNT_OF_PLAYERS, BOARD_WIDTH, BOARD_HEIGHT;
private final Cell[][] cells;
private final int[] colors={0xff1d76fc, 0xfffb1d76, 0xff76fb1d, 0xffa21cfb};//цвета атомов
private final Handler mHandler;
public GameLogic(GameView view, GameActivity activity) {
this.view = view;
this.activity=activity;
mHandler=new Handler();
//инициализируем игровые параметры (количество игроков, размер доски)
this.COUNT_OF_PLAYERS=2;
this.BOARD_HEIGHT=10;
this.BOARD_WIDTH=10;
cells=new Cell[BOARD_WIDTH][BOARD_HEIGHT];
for(int x=0; x<BOARD_WIDTH; x++){
for(int y=0; y<BOARD_HEIGHT; y++){
if((x==0 || x==BOARD_WIDTH-1) && (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(2);//угловые ячейки имеют емкость 2
}else
if((x==0 || x==BOARD_WIDTH-1) || (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(3);//краевые, но не угловые — 3
}else{
cells[x][y]=new Cell(4);//остальные — 4
}
}
}
}
//вызывается из вьюхи по одиночному тапу
public void addAtom(final int cellX, final int cellY) {
//получаем ячейку, в которую добавляем атом, если ее нет в массиве — выходим из функции.
final Cell currentCell;
try{
currentCell=cells[cellX][cellY];
}catch (IndexOutOfBoundsException ex){
return;
}
//если в ячейке уже есть атомы этого игрока
if(currentCell.getPlayer()==currentPlayer){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
//если ячейка заполнена
if(currentCell.isFilled()){
final List nearby=new ArrayList(4);//лист соседних ячеек
selfAddCell(cellX, cellY-1, nearby);
selfAddCell(cellX, cellY+1, nearby);
selfAddCell(cellX-1, cellY, nearby);
selfAddCell(cellX+1, cellY, nearby);
for(Cell nearbyCell:nearby){
nearbyCell.setPlayer(currentPlayer);//соседним ячейкам устанавливаем нового владельца
}
delayedAddAtom(cellX, cellY-1);
delayedAddAtom(cellX, cellY+1);
delayedAddAtom(cellX-1, cellY);
delayedAddAtom(cellX+1, cellY);
//через секунду произойдет вызов метода run()
mHandler.postDelayed(new Runnable() {
Override
public void run() {
//текущая ячейка становится нейтральной (ничейной)
currentCell.setPlayer(-1);
//и пустой
currentCell.resetCount();
view.drawAtoms(cellX, cellY, 0x000000, 0);
}
}, 1000);
return;
}
}else if(currentCell.getPlayer()==-1){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
currentCell.setPlayer(currentPlayer);
}else{
return;
}
}
//через секунду соседние ячйки получат по атому
private void delayedAddAtom(final int cellX, final int cellY){
mHandler.postDelayed(new Runnable() {
Override
public void run() {
addAtom(cellX, cellY);
}
}, 1000);
}
//добавляем в лист target существующие ячейки
private void selfAddCell(int cellX, int cellY, List target){
try{
target.add(cells[cellX][cellY]);
}catch (IndexOutOfBoundsException ignore){}
}
private final GameView view;
private final GameActivity activity;
private int moveNumber=0, currentPlayer=0;
private final int COUNT_OF_PLAYERS, BOARD_WIDTH, BOARD_HEIGHT;
private final Cell[][] cells;
private final int[] colors={0xff1d76fc, 0xfffb1d76, 0xff76fb1d, 0xffa21cfb};//цвета атомов
private final Handler mHandler;
public GameLogic(GameView view, GameActivity activity) {
this.view = view;
this.activity=activity;
mHandler=new Handler();
//инициализируем игровые параметры (количество игроков, размер доски)
this.COUNT_OF_PLAYERS=2;
this.BOARD_HEIGHT=10;
this.BOARD_WIDTH=10;
cells=new Cell[BOARD_WIDTH][BOARD_HEIGHT];
for(int x=0; x<BOARD_WIDTH; x++){
for(int y=0; y<BOARD_HEIGHT; y++){
if((x==0 || x==BOARD_WIDTH-1) && (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(2);//угловые ячейки имеют емкость 2
}else
if((x==0 || x==BOARD_WIDTH-1) || (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(3);//краевые, но не угловые — 3
}else{
cells[x][y]=new Cell(4);//остальные — 4
}
}
}
}
//вызывается из вьюхи по одиночному тапу
public void addAtom(final int cellX, final int cellY) {
//получаем ячейку, в которую добавляем атом, если ее нет в массиве — выходим из функции.
final Cell currentCell;
try{
currentCell=cells[cellX][cellY];
}catch (IndexOutOfBoundsException ex){
return;
}
//если в ячейке уже есть атомы этого игрока
if(currentCell.getPlayer()==currentPlayer){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
//если ячейка заполнена
if(currentCell.isFilled()){
final List nearby=new ArrayList(4);//лист соседних ячеек
selfAddCell(cellX, cellY-1, nearby);
selfAddCell(cellX, cellY+1, nearby);
selfAddCell(cellX-1, cellY, nearby);
selfAddCell(cellX+1, cellY, nearby);
for(Cell nearbyCell:nearby){
nearbyCell.setPlayer(currentPlayer);//соседним ячейкам устанавливаем нового владельца
}
delayedAddAtom(cellX, cellY-1);
delayedAddAtom(cellX, cellY+1);
delayedAddAtom(cellX-1, cellY);
delayedAddAtom(cellX+1, cellY);
//через секунду произойдет вызов метода run()
mHandler.postDelayed(new Runnable() {
Override
public void run() {
//текущая ячейка становится нейтральной (ничейной)
currentCell.setPlayer(-1);
//и пустой
currentCell.resetCount();
view.drawAtoms(cellX, cellY, 0x000000, 0);
}
}, 1000);
return;
}
}else if(currentCell.getPlayer()==-1){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
currentCell.setPlayer(currentPlayer);
}else{
return;
}
}
//через секунду соседние ячйки получат по атому
private void delayedAddAtom(final int cellX, final int cellY){
mHandler.postDelayed(new Runnable() {
Override
public void run() {
addAtom(cellX, cellY);
}
}, 1000);
}
//добавляем в лист target существующие ячейки
private void selfAddCell(int cellX, int cellY, List target){
try{
target.add(cells[cellX][cellY]);
}catch (IndexOutOfBoundsException ignore){}
}
private final GameView view;
private final GameActivity activity;
private int moveNumber=0, currentPlayer=0;
private final int COUNT_OF_PLAYERS, BOARD_WIDTH, BOARD_HEIGHT;
private final Cell[][] cells;
private final int[] colors={0xff1d76fc, 0xfffb1d76, 0xff76fb1d, 0xffa21cfb};//цвета атомов
private final Handler mHandler;
public GameLogic(GameView view, GameActivity activity) {
this.view = view;
this.activity=activity;
mHandler=new Handler();
//инициализируем игровые параметры (количество игроков, размер доски)
this.COUNT_OF_PLAYERS=2;
this.BOARD_HEIGHT=10;
this.BOARD_WIDTH=10;
cells=new Cell[BOARD_WIDTH][BOARD_HEIGHT];
for(int x=0; x<BOARD_WIDTH; x++){
for(int y=0; y<BOARD_HEIGHT; y++){
if((x==0 || x==BOARD_WIDTH-1) && (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(2);//угловые ячейки имеют емкость 2
}else
if((x==0 || x==BOARD_WIDTH-1) || (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(3);//краевые, но не угловые — 3
}else{
cells[x][y]=new Cell(4);//остальные — 4
}
}
}
}
//вызывается из вьюхи по одиночному тапу
public void addAtom(final int cellX, final int cellY) {
//получаем ячейку, в которую добавляем атом, если ее нет в массиве — выходим из функции.
final Cell currentCell;
try{
currentCell=cells[cellX][cellY];
}catch (IndexOutOfBoundsException ex){
return;
}
//если в ячейке уже есть атомы этого игрока
if(currentCell.getPlayer()==currentPlayer){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
//если ячейка заполнена
if(currentCell.isFilled()){
final List nearby=new ArrayList(4);//лист соседних ячеек
selfAddCell(cellX, cellY-1, nearby);
selfAddCell(cellX, cellY+1, nearby);
selfAddCell(cellX-1, cellY, nearby);
selfAddCell(cellX+1, cellY, nearby);
for(Cell nearbyCell:nearby){
nearbyCell.setPlayer(currentPlayer);//соседним ячейкам устанавливаем нового владельца
}
delayedAddAtom(cellX, cellY-1);
delayedAddAtom(cellX, cellY+1);
delayedAddAtom(cellX-1, cellY);
delayedAddAtom(cellX+1, cellY);
//через секунду произойдет вызов метода run()
mHandler.postDelayed(new Runnable() {
Override
public void run() {
//текущая ячейка становится нейтральной (ничейной)
currentCell.setPlayer(-1);
//и пустой
currentCell.resetCount();
view.drawAtoms(cellX, cellY, 0x000000, 0);
}
}, 1000);
return;
}
}else if(currentCell.getPlayer()==-1){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
currentCell.setPlayer(currentPlayer);
}else{
return;
}
}
//через секунду соседние ячйки получат по атому
private void delayedAddAtom(final int cellX, final int cellY){
mHandler.postDelayed(new Runnable() {
Override
public void run() {
addAtom(cellX, cellY);
}
}, 1000);
}
//добавляем в лист target существующие ячейки
private void selfAddCell(int cellX, int cellY, List target){
try{
target.add(cells[cellX][cellY]);
}catch (IndexOutOfBoundsException ignore){}
}
private final GameView view;
private final GameActivity activity;
private int moveNumber=0, currentPlayer=0;
private final int COUNT_OF_PLAYERS, BOARD_WIDTH, BOARD_HEIGHT;
private final Cell[][] cells;
private final int[] colors={0xff1d76fc, 0xfffb1d76, 0xff76fb1d, 0xffa21cfb};//цвета атомов
private final Handler mHandler;
public GameLogic(GameView view, GameActivity activity) {
this.view = view;
this.activity=activity;
mHandler=new Handler();
//инициализируем игровые параметры (количество игроков, размер доски)
this.COUNT_OF_PLAYERS=2;
this.BOARD_HEIGHT=10;
this.BOARD_WIDTH=10;
cells=new Cell[BOARD_WIDTH][BOARD_HEIGHT];
for(int x=0; x<BOARD_WIDTH; x++){
for(int y=0; y<BOARD_HEIGHT; y++){
if((x==0 || x==BOARD_WIDTH-1) && (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(2);//угловые ячейки имеют емкость 2
}else
if((x==0 || x==BOARD_WIDTH-1) || (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(3);//краевые, но не угловые — 3
}else{
cells[x][y]=new Cell(4);//остальные — 4
}
}
}
}
//вызывается из вьюхи по одиночному тапу
public void addAtom(final int cellX, final int cellY) {
//получаем ячейку, в которую добавляем атом, если ее нет в массиве — выходим из функции.
final Cell currentCell;
try{
currentCell=cells[cellX][cellY];
}catch (IndexOutOfBoundsException ex){
return;
}
//если в ячейке уже есть атомы этого игрока
if(currentCell.getPlayer()==currentPlayer){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
//если ячейка заполнена
if(currentCell.isFilled()){
final List nearby=new ArrayList(4);//лист соседних ячеек
selfAddCell(cellX, cellY-1, nearby);
selfAddCell(cellX, cellY+1, nearby);
selfAddCell(cellX-1, cellY, nearby);
selfAddCell(cellX+1, cellY, nearby);
for(Cell nearbyCell:nearby){
nearbyCell.setPlayer(currentPlayer);//соседним ячейкам устанавливаем нового владельца
}
delayedAddAtom(cellX, cellY-1);
delayedAddAtom(cellX, cellY+1);
delayedAddAtom(cellX-1, cellY);
delayedAddAtom(cellX+1, cellY);
//через секунду произойдет вызов метода run()
mHandler.postDelayed(new Runnable() {
Override
public void run() {
//текущая ячейка становится нейтральной (ничейной)
currentCell.setPlayer(-1);
//и пустой
currentCell.resetCount();
view.drawAtoms(cellX, cellY, 0x000000, 0);
}
}, 1000);
return;
}
}else if(currentCell.getPlayer()==-1){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
currentCell.setPlayer(currentPlayer);
}else{
return;
}
}
//через секунду соседние ячйки получат по атому
private void delayedAddAtom(final int cellX, final int cellY){
mHandler.postDelayed(new Runnable() {
Override
public void run() {
addAtom(cellX, cellY);
}
}, 1000);
}
//добавляем в лист target существующие ячейки
private void selfAddCell(int cellX, int cellY, List target){
try{
target.add(cells[cellX][cellY]);
}catch (IndexOutOfBoundsException ignore){}
}
private final GameView view;
private final GameActivity activity;
private int moveNumber=0, currentPlayer=0;
private final int COUNT_OF_PLAYERS, BOARD_WIDTH, BOARD_HEIGHT;
private final Cell[][] cells;
private final int[] colors={0xff1d76fc, 0xfffb1d76, 0xff76fb1d, 0xffa21cfb};//цвета атомов
private final Handler mHandler;
public GameLogic(GameView view, GameActivity activity) {
this.view = view;
this.activity=activity;
mHandler=new Handler();
//инициализируем игровые параметры (количество игроков, размер доски)
this.COUNT_OF_PLAYERS=2;
this.BOARD_HEIGHT=10;
this.BOARD_WIDTH=10;
cells=new Cell[BOARD_WIDTH][BOARD_HEIGHT];
for(int x=0; x<BOARD_WIDTH; x++){
for(int y=0; y<BOARD_HEIGHT; y++){
if((x==0 || x==BOARD_WIDTH-1) && (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(2);//угловые ячейки имеют емкость 2
}else
if((x==0 || x==BOARD_WIDTH-1) || (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(3);//краевые, но не угловые — 3
}else{
cells[x][y]=new Cell(4);//остальные — 4
}
}
}
}
//вызывается из вьюхи по одиночному тапу
public void addAtom(final int cellX, final int cellY) {
//получаем ячейку, в которую добавляем атом, если ее нет в массиве — выходим из функции.
final Cell currentCell;
try{
currentCell=cells[cellX][cellY];
}catch (IndexOutOfBoundsException ex){
return;
}
//если в ячейке уже есть атомы этого игрока
if(currentCell.getPlayer()==currentPlayer){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
//если ячейка заполнена
if(currentCell.isFilled()){
final List nearby=new ArrayList(4);//лист соседних ячеек
selfAddCell(cellX, cellY-1, nearby);
selfAddCell(cellX, cellY+1, nearby);
selfAddCell(cellX-1, cellY, nearby);
selfAddCell(cellX+1, cellY, nearby);
for(Cell nearbyCell:nearby){
nearbyCell.setPlayer(currentPlayer);//соседним ячейкам устанавливаем нового владельца
}
delayedAddAtom(cellX, cellY-1);
delayedAddAtom(cellX, cellY+1);
delayedAddAtom(cellX-1, cellY);
delayedAddAtom(cellX+1, cellY);
//через секунду произойдет вызов метода run()
mHandler.postDelayed(new Runnable() {
Override
public void run() {
//текущая ячейка становится нейтральной (ничейной)
currentCell.setPlayer(-1);
//и пустой
currentCell.resetCount();
view.drawAtoms(cellX, cellY, 0x000000, 0);
}
}, 1000);
return;
}
}else if(currentCell.getPlayer()==-1){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
currentCell.setPlayer(currentPlayer);
}else{
return;
}
}
//через секунду соседние ячйки получат по атому
private void delayedAddAtom(final int cellX, final int cellY){
mHandler.postDelayed(new Runnable() {
Override
public void run() {
addAtom(cellX, cellY);
}
}, 1000);
}
//добавляем в лист target существующие ячейки
private void selfAddCell(int cellX, int cellY, List target){
try{
target.add(cells[cellX][cellY]);
}catch (IndexOutOfBoundsException ignore){}
}
private final GameView view;
private final GameActivity activity;
private int moveNumber=0, currentPlayer=0;
private final int COUNT_OF_PLAYERS, BOARD_WIDTH, BOARD_HEIGHT;
private final Cell[][] cells;
private final int[] colors={0xff1d76fc, 0xfffb1d76, 0xff76fb1d, 0xffa21cfb};//цвета атомов
private final Handler mHandler;
public GameLogic(GameView view, GameActivity activity) {
this.view = view;
this.activity=activity;
mHandler=new Handler();
//инициализируем игровые параметры (количество игроков, размер доски)
this.COUNT_OF_PLAYERS=2;
this.BOARD_HEIGHT=10;
this.BOARD_WIDTH=10;
cells=new Cell[BOARD_WIDTH][BOARD_HEIGHT];
for(int x=0; x<BOARD_WIDTH; x++){
for(int y=0; y<BOARD_HEIGHT; y++){
if((x==0 || x==BOARD_WIDTH-1) && (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(2);//угловые ячейки имеют емкость 2
}else
if((x==0 || x==BOARD_WIDTH-1) || (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(3);//краевые, но не угловые — 3
}else{
cells[x][y]=new Cell(4);//остальные — 4
}
}
}
}
//вызывается из вьюхи по одиночному тапу
public void addAtom(final int cellX, final int cellY) {
//получаем ячейку, в которую добавляем атом, если ее нет в массиве — выходим из функции.
final Cell currentCell;
try{
currentCell=cells[cellX][cellY];
}catch (IndexOutOfBoundsException ex){
return;
}
//если в ячейке уже есть атомы этого игрока
if(currentCell.getPlayer()==currentPlayer){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
//если ячейка заполнена
if(currentCell.isFilled()){
final List nearby=new ArrayList(4);//лист соседних ячеек
selfAddCell(cellX, cellY-1, nearby);
selfAddCell(cellX, cellY+1, nearby);
selfAddCell(cellX-1, cellY, nearby);
selfAddCell(cellX+1, cellY, nearby);
for(Cell nearbyCell:nearby){
nearbyCell.setPlayer(currentPlayer);//соседним ячейкам устанавливаем нового владельца
}
delayedAddAtom(cellX, cellY-1);
delayedAddAtom(cellX, cellY+1);
delayedAddAtom(cellX-1, cellY);
delayedAddAtom(cellX+1, cellY);
//через секунду произойдет вызов метода run()
mHandler.postDelayed(new Runnable() {
Override
public void run() {
//текущая ячейка становится нейтральной (ничейной)
currentCell.setPlayer(-1);
//и пустой
currentCell.resetCount();
view.drawAtoms(cellX, cellY, 0x000000, 0);
}
}, 1000);
return;
}
}else if(currentCell.getPlayer()==-1){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
currentCell.setPlayer(currentPlayer);
}else{
return;
}
}
//через секунду соседние ячйки получат по атому
private void delayedAddAtom(final int cellX, final int cellY){
mHandler.postDelayed(new Runnable() {
Override
public void run() {
addAtom(cellX, cellY);
}
}, 1000);
}
//добавляем в лист target существующие ячейки
private void selfAddCell(int cellX, int cellY, List target){
try{
target.add(cells[cellX][cellY]);
}catch (IndexOutOfBoundsException ignore){}
}
private final GameView view;
private final GameActivity activity;
private int moveNumber=0, currentPlayer=0;
private final int COUNT_OF_PLAYERS, BOARD_WIDTH, BOARD_HEIGHT;
private final Cell[][] cells;
private final int[] colors={0xff1d76fc, 0xfffb1d76, 0xff76fb1d, 0xffa21cfb};//цвета атомов
private final Handler mHandler;
public GameLogic(GameView view, GameActivity activity) {
this.view = view;
this.activity=activity;
mHandler=new Handler();
//инициализируем игровые параметры (количество игроков, размер доски)
this.COUNT_OF_PLAYERS=2;
this.BOARD_HEIGHT=10;
this.BOARD_WIDTH=10;
cells=new Cell[BOARD_WIDTH][BOARD_HEIGHT];
for(int x=0; x<BOARD_WIDTH; x++){
for(int y=0; y<BOARD_HEIGHT; y++){
if((x==0 || x==BOARD_WIDTH-1) && (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(2);//угловые ячейки имеют емкость 2
}else
if((x==0 || x==BOARD_WIDTH-1) || (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(3);//краевые, но не угловые — 3
}else{
cells[x][y]=new Cell(4);//остальные — 4
}
}
}
}
//вызывается из вьюхи по одиночному тапу
public void addAtom(final int cellX, final int cellY) {
//получаем ячейку, в которую добавляем атом, если ее нет в массиве — выходим из функции.
final Cell currentCell;
try{
currentCell=cells[cellX][cellY];
}catch (IndexOutOfBoundsException ex){
return;
}
//если в ячейке уже есть атомы этого игрока
if(currentCell.getPlayer()==currentPlayer){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
//если ячейка заполнена
if(currentCell.isFilled()){
final List nearby=new ArrayList(4);//лист соседних ячеек
selfAddCell(cellX, cellY-1, nearby);
selfAddCell(cellX, cellY+1, nearby);
selfAddCell(cellX-1, cellY, nearby);
selfAddCell(cellX+1, cellY, nearby);
for(Cell nearbyCell:nearby){
nearbyCell.setPlayer(currentPlayer);//соседним ячейкам устанавливаем нового владельца
}
delayedAddAtom(cellX, cellY-1);
delayedAddAtom(cellX, cellY+1);
delayedAddAtom(cellX-1, cellY);
delayedAddAtom(cellX+1, cellY);
//через секунду произойдет вызов метода run()
mHandler.postDelayed(new Runnable() {
Override
public void run() {
//текущая ячейка становится нейтральной (ничейной)
currentCell.setPlayer(-1);
//и пустой
currentCell.resetCount();
view.drawAtoms(cellX, cellY, 0x000000, 0);
}
}, 1000);
return;
}
}else if(currentCell.getPlayer()==-1){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
currentCell.setPlayer(currentPlayer);
}else{
return;
}
}
//через секунду соседние ячйки получат по атому
private void delayedAddAtom(final int cellX, final int cellY){
mHandler.postDelayed(new Runnable() {
Override
public void run() {
addAtom(cellX, cellY);
}
}, 1000);
}
//добавляем в лист target существующие ячейки
private void selfAddCell(int cellX, int cellY, List target){
try{
target.add(cells[cellX][cellY]);
}catch (IndexOutOfBoundsException ignore){}
}
private final GameView view;
private final GameActivity activity;
private int moveNumber=0, currentPlayer=0;
private final int COUNT_OF_PLAYERS, BOARD_WIDTH, BOARD_HEIGHT;
private final Cell[][] cells;
private final int[] colors={0xff1d76fc, 0xfffb1d76, 0xff76fb1d, 0xffa21cfb};//цвета атомов
private final Handler mHandler;
public GameLogic(GameView view, GameActivity activity) {
this.view = view;
this.activity=activity;
mHandler=new Handler();
//инициализируем игровые параметры (количество игроков, размер доски)
this.COUNT_OF_PLAYERS=2;
this.BOARD_HEIGHT=10;
this.BOARD_WIDTH=10;
cells=new Cell[BOARD_WIDTH][BOARD_HEIGHT];
for(int x=0; x<BOARD_WIDTH; x++){
for(int y=0; y<BOARD_HEIGHT; y++){
if((x==0 || x==BOARD_WIDTH-1) && (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(2);//угловые ячейки имеют емкость 2
}else
if((x==0 || x==BOARD_WIDTH-1) || (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(3);//краевые, но не угловые — 3
}else{
cells[x][y]=new Cell(4);//остальные — 4
}
}
}
}
//вызывается из вьюхи по одиночному тапу
public void addAtom(final int cellX, final int cellY) {
//получаем ячейку, в которую добавляем атом, если ее нет в массиве — выходим из функции.
final Cell currentCell;
try{
currentCell=cells[cellX][cellY];
}catch (IndexOutOfBoundsException ex){
return;
}
//если в ячейке уже есть атомы этого игрока
if(currentCell.getPlayer()==currentPlayer){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
//если ячейка заполнена
if(currentCell.isFilled()){
final List nearby=new ArrayList(4);//лист соседних ячеек
selfAddCell(cellX, cellY-1, nearby);
selfAddCell(cellX, cellY+1, nearby);
selfAddCell(cellX-1, cellY, nearby);
selfAddCell(cellX+1, cellY, nearby);
for(Cell nearbyCell:nearby){
nearbyCell.setPlayer(currentPlayer);//соседним ячейкам устанавливаем нового владельца
}
delayedAddAtom(cellX, cellY-1);
delayedAddAtom(cellX, cellY+1);
delayedAddAtom(cellX-1, cellY);
delayedAddAtom(cellX+1, cellY);
//через секунду произойдет вызов метода run()
mHandler.postDelayed(new Runnable() {
Override
public void run() {
//текущая ячейка становится нейтральной (ничейной)
currentCell.setPlayer(-1);
//и пустой
currentCell.resetCount();
view.drawAtoms(cellX, cellY, 0x000000, 0);
}
}, 1000);
return;
}
}else if(currentCell.getPlayer()==-1){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
currentCell.setPlayer(currentPlayer);
}else{
return;
}
}
//через секунду соседние ячйки получат по атому
private void delayedAddAtom(final int cellX, final int cellY){
mHandler.postDelayed(new Runnable() {
Override
public void run() {
addAtom(cellX, cellY);
}
}, 1000);
}
//добавляем в лист target существующие ячейки
private void selfAddCell(int cellX, int cellY, List target){
try{
target.add(cells[cellX][cellY]);
}catch (IndexOutOfBoundsException ignore){}
}
private final GameView view;
private final GameActivity activity;
private int moveNumber=0, currentPlayer=0;
private final int COUNT_OF_PLAYERS, BOARD_WIDTH, BOARD_HEIGHT;
private final Cell[][] cells;
private final int[] colors={0xff1d76fc, 0xfffb1d76, 0xff76fb1d, 0xffa21cfb};//цвета атомов
private final Handler mHandler;
public GameLogic(GameView view, GameActivity activity) {
this.view = view;
this.activity=activity;
mHandler=new Handler();
//инициализируем игровые параметры (количество игроков, размер доски)
this.COUNT_OF_PLAYERS=2;
this.BOARD_HEIGHT=10;
this.BOARD_WIDTH=10;
cells=new Cell[BOARD_WIDTH][BOARD_HEIGHT];
for(int x=0; x<BOARD_WIDTH; x++){
for(int y=0; y<BOARD_HEIGHT; y++){
if((x==0 || x==BOARD_WIDTH-1) && (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(2);//угловые ячейки имеют емкость 2
}else
if((x==0 || x==BOARD_WIDTH-1) || (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(3);//краевые, но не угловые — 3
}else{
cells[x][y]=new Cell(4);//остальные — 4
}
}
}
}
//вызывается из вьюхи по одиночному тапу
public void addAtom(final int cellX, final int cellY) {
//получаем ячейку, в которую добавляем атом, если ее нет в массиве — выходим из функции.
final Cell currentCell;
try{
currentCell=cells[cellX][cellY];
}catch (IndexOutOfBoundsException ex){
return;
}
//если в ячейке уже есть атомы этого игрока
if(currentCell.getPlayer()==currentPlayer){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
//если ячейка заполнена
if(currentCell.isFilled()){
final List nearby=new ArrayList(4);//лист соседних ячеек
selfAddCell(cellX, cellY-1, nearby);
selfAddCell(cellX, cellY+1, nearby);
selfAddCell(cellX-1, cellY, nearby);
selfAddCell(cellX+1, cellY, nearby);
for(Cell nearbyCell:nearby){
nearbyCell.setPlayer(currentPlayer);//соседним ячейкам устанавливаем нового владельца
}
delayedAddAtom(cellX, cellY-1);
delayedAddAtom(cellX, cellY+1);
delayedAddAtom(cellX-1, cellY);
delayedAddAtom(cellX+1, cellY);
//через секунду произойдет вызов метода run()
mHandler.postDelayed(new Runnable() {
Override
public void run() {
//текущая ячейка становится нейтральной (ничейной)
currentCell.setPlayer(-1);
//и пустой
currentCell.resetCount();
view.drawAtoms(cellX, cellY, 0x000000, 0);
}
}, 1000);
return;
}
}else if(currentCell.getPlayer()==-1){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
currentCell.setPlayer(currentPlayer);
}else{
return;
}
}
//через секунду соседние ячйки получат по атому
private void delayedAddAtom(final int cellX, final int cellY){
mHandler.postDelayed(new Runnable() {
Override
public void run() {
addAtom(cellX, cellY);
}
}, 1000);
}
//добавляем в лист target существующие ячейки
private void selfAddCell(int cellX, int cellY, List target){
try{
target.add(cells[cellX][cellY]);
}catch (IndexOutOfBoundsException ignore){}
}
private final GameView view;
private final GameActivity activity;
private int moveNumber=0, currentPlayer=0;
private final int COUNT_OF_PLAYERS, BOARD_WIDTH, BOARD_HEIGHT;
private final Cell[][] cells;
private final int[] colors={0xff1d76fc, 0xfffb1d76, 0xff76fb1d, 0xffa21cfb};//цвета атомов
private final Handler mHandler;
public GameLogic(GameView view, GameActivity activity) {
this.view = view;
this.activity=activity;
mHandler=new Handler();
//инициализируем игровые параметры (количество игроков, размер доски)
this.COUNT_OF_PLAYERS=2;
this.BOARD_HEIGHT=10;
this.BOARD_WIDTH=10;
cells=new Cell[BOARD_WIDTH][BOARD_HEIGHT];
for(int x=0; x<BOARD_WIDTH; x++){
for(int y=0; y<BOARD_HEIGHT; y++){
if((x==0 || x==BOARD_WIDTH-1) && (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(2);//угловые ячейки имеют емкость 2
}else
if((x==0 || x==BOARD_WIDTH-1) || (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(3);//краевые, но не угловые — 3
}else{
cells[x][y]=new Cell(4);//остальные — 4
}
}
}
}
//вызывается из вьюхи по одиночному тапу
public void addAtom(final int cellX, final int cellY) {
//получаем ячейку, в которую добавляем атом, если ее нет в массиве — выходим из функции.
final Cell currentCell;
try{
currentCell=cells[cellX][cellY];
}catch (IndexOutOfBoundsException ex){
return;
}
//если в ячейке уже есть атомы этого игрока
if(currentCell.getPlayer()==currentPlayer){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
//если ячейка заполнена
if(currentCell.isFilled()){
final List nearby=new ArrayList(4);//лист соседних ячеек
selfAddCell(cellX, cellY-1, nearby);
selfAddCell(cellX, cellY+1, nearby);
selfAddCell(cellX-1, cellY, nearby);
selfAddCell(cellX+1, cellY, nearby);
for(Cell nearbyCell:nearby){
nearbyCell.setPlayer(currentPlayer);//соседним ячейкам устанавливаем нового владельца
}
delayedAddAtom(cellX, cellY-1);
delayedAddAtom(cellX, cellY+1);
delayedAddAtom(cellX-1, cellY);
delayedAddAtom(cellX+1, cellY);
//через секунду произойдет вызов метода run()
mHandler.postDelayed(new Runnable() {
Override
public void run() {
//текущая ячейка становится нейтральной (ничейной)
currentCell.setPlayer(-1);
//и пустой
currentCell.resetCount();
view.drawAtoms(cellX, cellY, 0x000000, 0);
}
}, 1000);
return;
}
}else if(currentCell.getPlayer()==-1){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
currentCell.setPlayer(currentPlayer);
}else{
return;
}
}
//через секунду соседние ячйки получат по атому
private void delayedAddAtom(final int cellX, final int cellY){
mHandler.postDelayed(new Runnable() {
Override
public void run() {
addAtom(cellX, cellY);
}
}, 1000);
}
//добавляем в лист target существующие ячейки
private void selfAddCell(int cellX, int cellY, List target){
try{
target.add(cells[cellX][cellY]);
}catch (IndexOutOfBoundsException ignore){}
}
private final GameView view;
private final GameActivity activity;
private int moveNumber=0, currentPlayer=0;
private final int COUNT_OF_PLAYERS, BOARD_WIDTH, BOARD_HEIGHT;
private final Cell[][] cells;
private final int[] colors={0xff1d76fc, 0xfffb1d76, 0xff76fb1d, 0xffa21cfb};//цвета атомов
private final Handler mHandler;
public GameLogic(GameView view, GameActivity activity) {
this.view = view;
this.activity=activity;
mHandler=new Handler();
//инициализируем игровые параметры (количество игроков, размер доски)
this.COUNT_OF_PLAYERS=2;
this.BOARD_HEIGHT=10;
this.BOARD_WIDTH=10;
cells=new Cell[BOARD_WIDTH][BOARD_HEIGHT];
for(int x=0; x<BOARD_WIDTH; x++){
for(int y=0; y<BOARD_HEIGHT; y++){
if((x==0 || x==BOARD_WIDTH-1) && (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(2);//угловые ячейки имеют емкость 2
}else
if((x==0 || x==BOARD_WIDTH-1) || (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(3);//краевые, но не угловые — 3
}else{
cells[x][y]=new Cell(4);//остальные — 4
}
}
}
}
//вызывается из вьюхи по одиночному тапу
public void addAtom(final int cellX, final int cellY) {
//получаем ячейку, в которую добавляем атом, если ее нет в массиве — выходим из функции.
final Cell currentCell;
try{
currentCell=cells[cellX][cellY];
}catch (IndexOutOfBoundsException ex){
return;
}
//если в ячейке уже есть атомы этого игрока
if(currentCell.getPlayer()==currentPlayer){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
//если ячейка заполнена
if(currentCell.isFilled()){
final List nearby=new ArrayList(4);//лист соседних ячеек
selfAddCell(cellX, cellY-1, nearby);
selfAddCell(cellX, cellY+1, nearby);
selfAddCell(cellX-1, cellY, nearby);
selfAddCell(cellX+1, cellY, nearby);
for(Cell nearbyCell:nearby){
nearbyCell.setPlayer(currentPlayer);//соседним ячейкам устанавливаем нового владельца
}
delayedAddAtom(cellX, cellY-1);
delayedAddAtom(cellX, cellY+1);
delayedAddAtom(cellX-1, cellY);
delayedAddAtom(cellX+1, cellY);
//через секунду произойдет вызов метода run()
mHandler.postDelayed(new Runnable() {
Override
public void run() {
//текущая ячейка становится нейтральной (ничейной)
currentCell.setPlayer(-1);
//и пустой
currentCell.resetCount();
view.drawAtoms(cellX, cellY, 0x000000, 0);
}
}, 1000);
return;
}
}else if(currentCell.getPlayer()==-1){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
currentCell.setPlayer(currentPlayer);
}else{
return;
}
}
//через секунду соседние ячйки получат по атому
private void delayedAddAtom(final int cellX, final int cellY){
mHandler.postDelayed(new Runnable() {
Override
public void run() {
addAtom(cellX, cellY);
}
}, 1000);
}
//добавляем в лист target существующие ячейки
private void selfAddCell(int cellX, int cellY, List target){
try{
target.add(cells[cellX][cellY]);
}catch (IndexOutOfBoundsException ignore){}
}
private final GameView view;
private final GameActivity activity;
private int moveNumber=0, currentPlayer=0;
private final int COUNT_OF_PLAYERS, BOARD_WIDTH, BOARD_HEIGHT;
private final Cell[][] cells;
private final int[] colors={0xff1d76fc, 0xfffb1d76, 0xff76fb1d, 0xffa21cfb};//цвета атомов
private final Handler mHandler;
public GameLogic(GameView view, GameActivity activity) {
this.view = view;
this.activity=activity;
mHandler=new Handler();
//инициализируем игровые параметры (количество игроков, размер доски)
this.COUNT_OF_PLAYERS=2;
this.BOARD_HEIGHT=10;
this.BOARD_WIDTH=10;
cells=new Cell[BOARD_WIDTH][BOARD_HEIGHT];
for(int x=0; x<BOARD_WIDTH; x++){
for(int y=0; y<BOARD_HEIGHT; y++){
if((x==0 || x==BOARD_WIDTH-1) && (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(2);//угловые ячейки имеют емкость 2
}else
if((x==0 || x==BOARD_WIDTH-1) || (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(3);//краевые, но не угловые — 3
}else{
cells[x][y]=new Cell(4);//остальные — 4
}
}
}
}
//вызывается из вьюхи по одиночному тапу
public void addAtom(final int cellX, final int cellY) {
//получаем ячейку, в которую добавляем атом, если ее нет в массиве — выходим из функции.
final Cell currentCell;
try{
currentCell=cells[cellX][cellY];
}catch (IndexOutOfBoundsException ex){
return;
}
//если в ячейке уже есть атомы этого игрока
if(currentCell.getPlayer()==currentPlayer){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
//если ячейка заполнена
if(currentCell.isFilled()){
final List nearby=new ArrayList(4);//лист соседних ячеек
selfAddCell(cellX, cellY-1, nearby);
selfAddCell(cellX, cellY+1, nearby);
selfAddCell(cellX-1, cellY, nearby);
selfAddCell(cellX+1, cellY, nearby);
for(Cell nearbyCell:nearby){
nearbyCell.setPlayer(currentPlayer);//соседним ячейкам устанавливаем нового владельца
}
delayedAddAtom(cellX, cellY-1);
delayedAddAtom(cellX, cellY+1);
delayedAddAtom(cellX-1, cellY);
delayedAddAtom(cellX+1, cellY);
//через секунду произойдет вызов метода run()
mHandler.postDelayed(new Runnable() {
Override
public void run() {
//текущая ячейка становится нейтральной (ничейной)
currentCell.setPlayer(-1);
//и пустой
currentCell.resetCount();
view.drawAtoms(cellX, cellY, 0x000000, 0);
}
}, 1000);
return;
}
}else if(currentCell.getPlayer()==-1){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
currentCell.setPlayer(currentPlayer);
}else{
return;
}
}
//через секунду соседние ячйки получат по атому
private void delayedAddAtom(final int cellX, final int cellY){
mHandler.postDelayed(new Runnable() {
Override
public void run() {
addAtom(cellX, cellY);
}
}, 1000);
}
//добавляем в лист target существующие ячейки
private void selfAddCell(int cellX, int cellY, List target){
try{
target.add(cells[cellX][cellY]);
}catch (IndexOutOfBoundsException ignore){}
}
private final GameView view;
private final GameActivity activity;
private int moveNumber=0, currentPlayer=0;
private final int COUNT_OF_PLAYERS, BOARD_WIDTH, BOARD_HEIGHT;
private final Cell[][] cells;
private final int[] colors={0xff1d76fc, 0xfffb1d76, 0xff76fb1d, 0xffa21cfb};//цвета атомов
private final Handler mHandler;
public GameLogic(GameView view, GameActivity activity) {
this.view = view;
this.activity=activity;
mHandler=new Handler();
//инициализируем игровые параметры (количество игроков, размер доски)
this.COUNT_OF_PLAYERS=2;
this.BOARD_HEIGHT=10;
this.BOARD_WIDTH=10;
cells=new Cell[BOARD_WIDTH][BOARD_HEIGHT];
for(int x=0; x<BOARD_WIDTH; x++){
for(int y=0; y<BOARD_HEIGHT; y++){
if((x==0 || x==BOARD_WIDTH-1) && (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(2);//угловые ячейки имеют емкость 2
}else
if((x==0 || x==BOARD_WIDTH-1) || (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(3);//краевые, но не угловые — 3
}else{
cells[x][y]=new Cell(4);//остальные — 4
}
}
}
}
//вызывается из вьюхи по одиночному тапу
public void addAtom(final int cellX, final int cellY) {
//получаем ячейку, в которую добавляем атом, если ее нет в массиве — выходим из функции.
final Cell currentCell;
try{
currentCell=cells[cellX][cellY];
}catch (IndexOutOfBoundsException ex){
return;
}
//если в ячейке уже есть атомы этого игрока
if(currentCell.getPlayer()==currentPlayer){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
//если ячейка заполнена
if(currentCell.isFilled()){
final List nearby=new ArrayList(4);//лист соседних ячеек
selfAddCell(cellX, cellY-1, nearby);
selfAddCell(cellX, cellY+1, nearby);
selfAddCell(cellX-1, cellY, nearby);
selfAddCell(cellX+1, cellY, nearby);
for(Cell nearbyCell:nearby){
nearbyCell.setPlayer(currentPlayer);//соседним ячейкам устанавливаем нового владельца
}
delayedAddAtom(cellX, cellY-1);
delayedAddAtom(cellX, cellY+1);
delayedAddAtom(cellX-1, cellY);
delayedAddAtom(cellX+1, cellY);
//через секунду произойдет вызов метода run()
mHandler.postDelayed(new Runnable() {
Override
public void run() {
//текущая ячейка становится нейтральной (ничейной)
currentCell.setPlayer(-1);
//и пустой
currentCell.resetCount();
view.drawAtoms(cellX, cellY, 0x000000, 0);
}
}, 1000);
return;
}
}else if(currentCell.getPlayer()==-1){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
currentCell.setPlayer(currentPlayer);
}else{
return;
}
}
//через секунду соседние ячйки получат по атому
private void delayedAddAtom(final int cellX, final int cellY){
mHandler.postDelayed(new Runnable() {
Override
public void run() {
addAtom(cellX, cellY);
}
}, 1000);
}
//добавляем в лист target существующие ячейки
private void selfAddCell(int cellX, int cellY, List target){
try{
target.add(cells[cellX][cellY]);
}catch (IndexOutOfBoundsException ignore){}
}
private final GameView view;
private final GameActivity activity;
private int moveNumber=0, currentPlayer=0;
private final int COUNT_OF_PLAYERS, BOARD_WIDTH, BOARD_HEIGHT;
private final Cell[][] cells;
private final int[] colors={0xff1d76fc, 0xfffb1d76, 0xff76fb1d, 0xffa21cfb};//цвета атомов
private final Handler mHandler;
public GameLogic(GameView view, GameActivity activity) {
this.view = view;
this.activity=activity;
mHandler=new Handler();
//инициализируем игровые параметры (количество игроков, размер доски)
this.COUNT_OF_PLAYERS=2;
this.BOARD_HEIGHT=10;
this.BOARD_WIDTH=10;
cells=new Cell[BOARD_WIDTH][BOARD_HEIGHT];
for(int x=0; x<BOARD_WIDTH; x++){
for(int y=0; y<BOARD_HEIGHT; y++){
if((x==0 || x==BOARD_WIDTH-1) && (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(2);//угловые ячейки имеют емкость 2
}else
if((x==0 || x==BOARD_WIDTH-1) || (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(3);//краевые, но не угловые — 3
}else{
cells[x][y]=new Cell(4);//остальные — 4
}
}
}
}
//вызывается из вьюхи по одиночному тапу
public void addAtom(final int cellX, final int cellY) {
//получаем ячейку, в которую добавляем атом, если ее нет в массиве — выходим из функции.
final Cell currentCell;
try{
currentCell=cells[cellX][cellY];
}catch (IndexOutOfBoundsException ex){
return;
}
//если в ячейке уже есть атомы этого игрока
if(currentCell.getPlayer()==currentPlayer){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
//если ячейка заполнена
if(currentCell.isFilled()){
final List nearby=new ArrayList(4);//лист соседних ячеек
selfAddCell(cellX, cellY-1, nearby);
selfAddCell(cellX, cellY+1, nearby);
selfAddCell(cellX-1, cellY, nearby);
selfAddCell(cellX+1, cellY, nearby);
for(Cell nearbyCell:nearby){
nearbyCell.setPlayer(currentPlayer);//соседним ячейкам устанавливаем нового владельца
}
delayedAddAtom(cellX, cellY-1);
delayedAddAtom(cellX, cellY+1);
delayedAddAtom(cellX-1, cellY);
delayedAddAtom(cellX+1, cellY);
//через секунду произойдет вызов метода run()
mHandler.postDelayed(new Runnable() {
Override
public void run() {
//текущая ячейка становится нейтральной (ничейной)
currentCell.setPlayer(-1);
//и пустой
currentCell.resetCount();
view.drawAtoms(cellX, cellY, 0x000000, 0);
}
}, 1000);
return;
}
}else if(currentCell.getPlayer()==-1){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
currentCell.setPlayer(currentPlayer);
}else{
return;
}
}
//через секунду соседние ячйки получат по атому
private void delayedAddAtom(final int cellX, final int cellY){
mHandler.postDelayed(new Runnable() {
Override
public void run() {
addAtom(cellX, cellY);
}
}, 1000);
}
//добавляем в лист target существующие ячейки
private void selfAddCell(int cellX, int cellY, List target){
try{
target.add(cells[cellX][cellY]);
}catch (IndexOutOfBoundsException ignore){}
}private final GameView view;
private final GameActivity activity;
private int moveNumber=0, currentPlayer=0;
private final int COUNT_OF_PLAYERS, BOARD_WIDTH, BOARD_HEIGHT;
private final Cell[][] cells;
private final int[] colors={0xff1d76fc, 0xfffb1d76, 0xff76fb1d, 0xffa21cfb};//цвета атомов
private final Handler mHandler;
public GameLogic(GameView view, GameActivity activity) {
this.view = view;
this.activity=activity;
mHandler=new Handler();
//инициализируем игровые параметры (количество игроков, размер доски)
this.COUNT_OF_PLAYERS=2;
this.BOARD_HEIGHT=10;
this.BOARD_WIDTH=10;
cells=new Cell[BOARD_WIDTH][BOARD_HEIGHT];
for(int x=0; x<BOARD_WIDTH; x++){
for(int y=0; y<BOARD_HEIGHT; y++){
if((x==0 || x==BOARD_WIDTH-1) && (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(2);//угловые ячейки имеют емкость 2
}else
if((x==0 || x==BOARD_WIDTH-1) || (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(3);//краевые, но не угловые — 3
}else{
cells[x][y]=new Cell(4);//остальные — 4
}
}
}
}
//вызывается из вьюхи по одиночному тапу
public void addAtom(final int cellX, final int cellY) {
//получаем ячейку, в которую добавляем атом, если ее нет в массиве — выходим из функции.
final Cell currentCell;
try{
currentCell=cells[cellX][cellY];
}catch (IndexOutOfBoundsException ex){
return;
}
//если в ячейке уже есть атомы этого игрока
if(currentCell.getPlayer()==currentPlayer){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
//если ячейка заполнена
if(currentCell.isFilled()){
final List nearby=new ArrayList(4);//лист соседних ячеек
selfAddCell(cellX, cellY-1, nearby);
selfAddCell(cellX, cellY+1, nearby);
selfAddCell(cellX-1, cellY, nearby);
selfAddCell(cellX+1, cellY, nearby);
for(Cell nearbyCell:nearby){
nearbyCell.setPlayer(currentPlayer);//соседним ячейкам устанавливаем нового владельца
}
delayedAddAtom(cellX, cellY-1);
delayedAddAtom(cellX, cellY+1);
delayedAddAtom(cellX-1, cellY);
delayedAddAtom(cellX+1, cellY);
//через секунду произойдет вызов метода run()
mHandler.postDelayed(new Runnable() {
Override
public void run() {
//текущая ячейка становится нейтральной (ничейной)
currentCell.setPlayer(-1);
//и пустой
currentCell.resetCount();
view.drawAtoms(cellX, cellY, 0x000000, 0);
}
}, 1000);
return;
}
}else if(currentCell.getPlayer()==-1){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
currentCell.setPlayer(currentPlayer);
}else{
return;
}
}
//через секунду соседние ячйки получат по атому
private void delayedAddAtom(final int cellX, final int cellY){
mHandler.postDelayed(new Runnable() {
Override
public void run() {
addAtom(cellX, cellY);
}
}, 1000);
}
//добавляем в лист target существующие ячейки
private void selfAddCell(int cellX, int cellY, List target){
try{
target.add(cells[cellX][cellY]);
}catch (IndexOutOfBoundsException ignore){}
}
private final GameView view;
private final GameActivity activity;
private int moveNumber=0, currentPlayer=0;
private final int COUNT_OF_PLAYERS, BOARD_WIDTH, BOARD_HEIGHT;
private final Cell[][] cells;
private final int[] colors={0xff1d76fc, 0xfffb1d76, 0xff76fb1d, 0xffa21cfb};//цвета атомов
private final Handler mHandler;
public GameLogic(GameView view, GameActivity activity) {
this.view = view;
this.activity=activity;
mHandler=new Handler();
//инициализируем игровые параметры (количество игроков, размер доски)
this.COUNT_OF_PLAYERS=2;
this.BOARD_HEIGHT=10;
this.BOARD_WIDTH=10;
cells=new Cell[BOARD_WIDTH][BOARD_HEIGHT];
for(int x=0; x<BOARD_WIDTH; x++){
for(int y=0; y<BOARD_HEIGHT; y++){
if((x==0 || x==BOARD_WIDTH-1) && (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(2);//угловые ячейки имеют емкость 2
}else
if((x==0 || x==BOARD_WIDTH-1) || (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(3);//краевые, но не угловые — 3
}else{
cells[x][y]=new Cell(4);//остальные — 4
}
}
}
}
//вызывается из вьюхи по одиночному тапу
public void addAtom(final int cellX, final int cellY) {
//получаем ячейку, в которую добавляем атом, если ее нет в массиве — выходим из функции.
final Cell currentCell;
try{
currentCell=cells[cellX][cellY];
}catch (IndexOutOfBoundsException ex){
return;
}
//если в ячейке уже есть атомы этого игрока
if(currentCell.getPlayer()==currentPlayer){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
//если ячейка заполнена
if(currentCell.isFilled()){
final List nearby=new ArrayList(4);//лист соседних ячеек
selfAddCell(cellX, cellY-1, nearby);
selfAddCell(cellX, cellY+1, nearby);
selfAddCell(cellX-1, cellY, nearby);
selfAddCell(cellX+1, cellY, nearby);
for(Cell nearbyCell:nearby){
private final GameView view;
private final GameActivity activity;
private int moveNumber=0, currentPlayer=0;
private final int COUNT_OF_PLAYERS, BOARD_WIDTH, BOARD_HEIGHT;
private final Cell[][] cells;
private final int[] colors={0xff1d76fc, 0xfffb1d76, 0xff76fb1d, 0xffa21cfb};//цвета атомов
private final Handler mHandler;
public GameLogic(GameView view, GameActivity activity) {
this.view = view;
this.activity=activity;
mHandler=new Handler();
//инициализируем игровые параметры (количество игроков, размер доски)
this.COUNT_OF_PLAYERS=2;
this.BOARD_HEIGHT=10;
this.BOARD_WIDTH=10;
cells=new Cell[BOARD_WIDTH][BOARD_HEIGHT];
for(int x=0; x<BOARD_WIDTH; x++){
for(int y=0; y<BOARD_HEIGHT; y++){
if((x==0 || x==BOARD_WIDTH-1) && (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(2);//угловые ячейки имеют емкость 2
}else
if((x==0 || x==BOARD_WIDTH-1) || (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(3);//краевые, но не угловые — 3
}else{
cells[x][y]=new Cell(4);//остальные — 4
}
}
}
}
//вызывается из вьюхи по одиночному тапу
public void addAtom(final int cellX, final int cellY) {
//получаем ячейку, в которую добавляем атом, если ее нет в массиве — выходим из функции.
final Cell currentCell;
try{
currentCell=cells[cellX][cellY];
}catch (IndexOutOfBoundsException ex){
return;
}
//если в ячейке уже есть атомы этого игрока
if(currentCell.getPlayer()==currentPlayer){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
//если ячейка заполнена
if(currentCell.isFilled()){
final List nearby=new ArrayList(4);//лист соседних ячеек
selfAddCell(cellX, cellY-1, nearby);
selfAddCell(cellX, cellY+1, nearby);
selfAddCell(cellX-1, cellY, nearby);
selfAddCell(cellX+1, cellY, nearby);
for(Cell nearbyCell:nearby){
nearbyCell.setPlayer(currentPlayer);//соседним ячейкам устанавливаем нового владельца
}
delayedAddAtom(cellX, cellY-1);
delayedAddAtom(cellX, cellY+1);
delayedAddAtom(cellX-1, cellY);
delayedAddAtom(cellX+1, cellY);
//через секунду произойдет вызов метода run()
mHandler.postDelayed(new Runnable() {
Override
public void run() {
//текущая ячейка становится нейтральной (ничейной)
currentCell.setPlayer(-1);
//и пустой
currentCell.resetCount();
view.drawAtoms(cellX, cellY, 0x000000, 0);
}
}, 1000);
return;
}
}else if(currentCell.getPlayer()==-1){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
currentCell.setPlayer(currentPlayer);
}else{
return;
}
}
//через секунду соседние ячйки получат по атому
private void delayedAddAtom(final int cellX, final int cellY){
mHandler.postDelayed(new Runnable() {
Override
public void run() {
addAtom(cellX, cellY);
}
}, 1000);
}
//добавляем в лист target существующие ячейки
private void selfAddCell(int cellX, int cellY, List target){
try{
target.add(cells[cellX][cellY]);
}catch (IndexOutOfBoundsException ignore){}
}
private final GameView view;
private final GameActivity activity;
private int moveNumber=0, currentPlayer=0;
private final int COUNT_OF_PLAYERS, BOARD_WIDTH, BOARD_HEIGHT;
private final Cell[][] cells;
private final int[] colors={0xff1d76fc, 0xfffb1d76, 0xff76fb1d, 0xffa21cfb};//цвета атомов
private final Handler mHandler;
public GameLogic(GameView view, GameActivity activity) {
this.view = view;
this.activity=activity;
mHandler=new Handler();
//инициализируем игровые параметры (количество игроков, размер доски)
this.COUNT_OF_PLAYERS=2;
this.BOARD_HEIGHT=10;
this.BOARD_WIDTH=10;
cells=new Cell[BOARD_WIDTH][BOARD_HEIGHT];
for(int x=0; x<BOARD_WIDTH; x++){
for(int y=0; y<BOARD_HEIGHT; y++){
if((x==0 || x==BOARD_WIDTH-1) && (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(2);//угловые ячейки имеют емкость 2
}else
if((x==0 || x==BOARD_WIDTH-1) || (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(3);//краевые, но не угловые — 3
}else{
cells[x][y]=new Cell(4);//остальные — 4
}
}
}
}
//вызывается из вьюхи по одиночному тапу
public void addAtom(final int cellX, final int cellY) {
//получаем ячейку, в которую добавляем атом, если ее нет в массиве — выходим из функции.
final Cell currentCell;
try{
currentCell=cells[cellX][cellY];
}catch (IndexOutOfBoundsException ex){
return;
}
//если в ячейке уже есть атомы этого игрока
if(currentCell.getPlayer()==currentPlayer){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
//если ячейка заполнена
if(currentCell.isFilled()){
final List nearby=new ArrayList(4);//лист соседних ячеек
selfAddCell(cellX, cellY-1, nearby);
selfAddCell(cellX, cellY+1, nearby);
selfAddCell(cellX-1, cellY, nearby);
selfAddCell(cellX+1, cellY, nearby);
for(Cell nearbyCell:nearby){
nearbyCell.setPlayer(currentPlayer);//соседним ячейкам устанавливаем нового владельца
}
delayedAddAtom(cellX, cellY-1);
delayedAddAtom(cellX, cellY+1);
delayedAddAtom(cellX-1, cellY);
delayedAddAtom(cellX+1, cellY);
//через секунду произойдет вызов метода run()
mHandler.postDelayed(new Runnable() {
Override
public void run() {
//текущая ячейка становится нейтральной (ничейной)
currentCell.setPlayer(-1);
//и пустой
currentCell.resetCount();
view.drawAtoms(cellX, cellY, 0x000000, 0);
}
}, 1000);
return;
}
}else if(currentCell.getPlayer()==-1){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
currentCell.setPlayer(currentPlayer);
}else{
return;
}
}
//через секунду соседние ячйки получат по атому
private void delayedAddAtom(final int cellX, final int cellY){
mHandler.postDelayed(new Runnable() {
Override
public void run() {
addAtom(cellX, cellY);
}
}, 1000);
}
//добавляем в лист target существующие ячейки
private void selfAddCell(int cellX, int cellY, List target){
try{
target.add(cells[cellX][cellY]);
}catch (IndexOutOfBoundsException ignore){}
}
private final GameView view;
private final GameActivity activity;
private int moveNumber=0, currentPlayer=0;
private final int COUNT_OF_PLAYERS, BOARD_WIDTH, BOARD_HEIGHT;
private final Cell[][] cells;
private final int[] colors={0xff1d76fc, 0xfffb1d76, 0xff76fb1d, 0xffa21cfb};//цвета атомов
private final Handler mHandler;
public GameLogic(GameView view, GameActivity activity) {
this.view = view;
this.activity=activity;
mHandler=new Handler();
//инициализируем игровые параметры (количество игроков, размер доски)
this.COUNT_OF_PLAYERS=2;
this.BOARD_HEIGHT=10;
this.BOARD_WIDTH=10;
cells=new Cell[BOARD_WIDTH][BOARD_HEIGHT];
for(int x=0; x<BOARD_WIDTH; x++){
for(int y=0; y<BOARD_HEIGHT; y++){
if((x==0 || x==BOARD_WIDTH-1) && (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(2);//угловые ячейки имеют емкость 2
}else
if((x==0 || x==BOARD_WIDTH-1) || (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(3);//краевые, но не угловые — 3
}else{
cells[x][y]=new Cell(4);//остальные — 4
}
}
}
}
//вызывается из вьюхи по одиночному тапу
public void addAtom(final int cellX, final int cellY) {
//получаем ячейку, в которую добавляем атом, если ее нет в массиве — выходим из функции.
final Cell currentCell;
try{
currentCell=cells[cellX][cellY];
}catch (IndexOutOfBoundsException ex){
return;
}
//если в ячейке уже есть атомы этого игрока
if(currentCell.getPlayer()==currentPlayer){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
//если ячейка заполнена
if(currentCell.isFilled()){
final List nearby=new ArrayList(4);//лист соседних ячеек
selfAddCell(cellX, cellY-1, nearby);
selfAddCell(cellX, cellY+1, nearby);
selfAddCell(cellX-1, cellY, nearby);
selfAddCell(cellX+1, cellY, nearby);
for(Cell nearbyCell:nearby){
nearbyCell.setPlayer(currentPlayer);//соседним ячейкам устанавливаем нового владельца
}
delayedAddAtom(cellX, cellY-1);
delayedAddAtom(cellX, cellY+1);
delayedAddAtom(cellX-1, cellY);
delayedAddAtom(cellX+1, cellY);
//через секунду произойдет вызов метода run()
mHandler.postDelayed(new Runnable() {
Override
public void run() {
//текущая ячейка становится нейтральной (ничейной)
currentCell.setPlayer(-1);
//и пустой
currentCell.resetCount();
view.drawAtoms(cellX, cellY, 0x000000, 0);
}
}, 1000);
return;
}
}else if(currentCell.getPlayer()==-1){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
currentCell.setPlayer(currentPlayer);
}else{
return;
}
}
//через секунду соседние ячйки получат по атому
private void delayedAddAtom(final int cellX, final int cellY){
mHandler.postDelayed(new Runnable() {
Override
public void run() {
addAtom(cellX, cellY);
}
}, 1000);
}
//добавляем в лист target существующие ячейки
private void selfAddCell(int cellX, int cellY, List target){
try{
target.add(cells[cellX][cellY]);
}catch (IndexOutOfBoundsException ignore){}
}
private final GameView view;
private final GameActivity activity;
private int moveNumber=0, currentPlayer=0;
private final int COUNT_OF_PLAYERS, BOARD_WIDTH, BOARD_HEIGHT;
private final Cell[][] cells;
private final int[] colors={0xff1d76fc, 0xfffb1d76, 0xff76fb1d, 0xffa21cfb};//цвета атомов
private final Handler mHandler;
public GameLogic(GameView view, GameActivity activity) {
this.view = view;
this.activity=activity;
mHandler=new Handler();
//инициализируем игровые параметры (количество игроков, размер доски)
this.COUNT_OF_PLAYERS=2;
this.BOARD_HEIGHT=10;
this.BOARD_WIDTH=10;
cells=new Cell[BOARD_WIDTH][BOARD_HEIGHT];
for(int x=0; x<BOARD_WIDTH; x++){
for(int y=0; y<BOARD_HEIGHT; y++){
if((x==0 || x==BOARD_WIDTH-1) && (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(2);//угловые ячейки имеют емкость 2
}else
if((x==0 || x==BOARD_WIDTH-1) || (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(3);//краевые, но не угловые — 3
}else{
cells[x][y]=new Cell(4);//остальные — 4
}
}
}
}
//вызывается из вьюхи по одиночному тапу
public void addAtom(final int cellX, final int cellY) {
//получаем ячейку, в которую добавляем атом, если ее нет в массиве — выходим из функции.
final Cell currentCell;
try{
currentCell=cells[cellX][cellY];
}catch (IndexOutOfBoundsException ex){
return;
}
//если в ячейке уже есть атомы этого игрока
if(currentCell.getPlayer()==currentPlayer){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
//если ячейка заполнена
if(currentCell.isFilled()){
final List nearby=new ArrayList(4);//лист соседних ячеек
selfAddCell(cellX, cellY-1, nearby);
selfAddCell(cellX, cellY+1, nearby);
selfAddCell(cellX-1, cellY, nearby);
selfAddCell(cellX+1, cellY, nearby);
for(Cell nearbyCell:nearby){
nearbyCell.setPlayer(currentPlayer);//соседним ячейкам устанавливаем нового владельца
}
delayedAddAtom(cellX, cellY-1);
delayedAddAtom(cellX, cellY+1);
delayedAddAtom(cellX-1, cellY);
delayedAddAtom(cellX+1, cellY);
//через секунду произойдет вызов метода run()
mHandler.postDelayed(new Runnable() {
Override
public void run() {
//текущая ячейка становится нейтральной (ничейной)
currentCell.setPlayer(-1);
//и пустой
currentCell.resetCount();
view.drawAtoms(cellX, cellY, 0x000000, 0);
}
}, 1000);
return;
}
}else if(currentCell.getPlayer()==-1){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
currentCell.setPlayer(currentPlayer);
}else{
return;
}
}
//через секунду соседние ячйки получат по атому
private void delayedAddAtom(final int cellX, final int cellY){
mHandler.postDelayed(new Runnable() {
Override
public void run() {
addAtom(cellX, cellY);
}
}, 1000);
}
//добавляем в лист target существующие ячейки
private void selfAddCell(int cellX, int cellY, List target){
try{
target.add(cells[cellX][cellY]);
}catch (IndexOutOfBoundsException ignore){}
}
private final GameView view;
private final GameActivity activity;
private int moveNumber=0, currentPlayer=0;
private final int COUNT_OF_PLAYERS, BOARD_WIDTH, BOARD_HEIGHT;
private final Cell[][] cells;
private final int[] colors={0xff1d76fc, 0xfffb1d76, 0xff76fb1d, 0xffa21cfb};//цвета атомов
private final Handler mHandler;
public GameLogic(GameView view, GameActivity activity) {
this.view = view;
this.activity=activity;
mHandler=new Handler();
//инициализируем игровые параметры (количество игроков, размер доски)
this.COUNT_OF_PLAYERS=2;
this.BOARD_HEIGHT=10;
this.BOARD_WIDTH=10;
cells=new Cell[BOARD_WIDTH][BOARD_HEIGHT];
for(int x=0; x<BOARD_WIDTH; x++){
for(int y=0; y<BOARD_HEIGHT; y++){
if((x==0 || x==BOARD_WIDTH-1) && (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(2);//угловые ячейки имеют емкость 2
}else
if((x==0 || x==BOARD_WIDTH-1) || (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(3);//краевые, но не угловые — 3
}else{
cells[x][y]=new Cell(4);//остальные — 4
}
}
}
}
//вызывается из вьюхи по одиночному тапу
public void addAtom(final int cellX, final int cellY) {
//получаем ячейку, в которую добавляем атом, если ее нет в массиве — выходим из функции.
final Cell currentCell;
try{
currentCell=cells[cellX][cellY];
}catch (IndexOutOfBoundsException ex){
return;
}
//если в ячейке уже есть атомы этого игрока
if(currentCell.getPlayer()==currentPlayer){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
//если ячейка заполнена
if(currentCell.isFilled()){
final List nearby=new ArrayList(4);//лист соседних ячеек
selfAddCell(cellX, cellY-1, nearby);
selfAddCell(cellX, cellY+1, nearby);
selfAddCell(cellX-1, cellY, nearby);
selfAddCell(cellX+1, cellY, nearby);
for(Cell nearbyCell:nearby){
nearbyCell.setPlayer(currentPlayer);//соседним ячейкам устанавливаем нового владельца
}
delayedAddAtom(cellX, cellY-1);
delayedAddAtom(cellX, cellY+1);
delayedAddAtom(cellX-1, cellY);
delayedAddAtom(cellX+1, cellY);
//через секунду произойдет вызов метода run()
mHandler.postDelayed(new Runnable() {
Override
public void run() {
//текущая ячейка становится нейтральной (ничейной)
currentCell.setPlayer(-1);
//и пустой
currentCell.resetCount();
view.drawAtoms(cellX, cellY, 0x000000, 0);
}
}, 1000);
return;
}
}else if(currentCell.getPlayer()==-1){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
currentCell.setPlayer(currentPlayer);
}else{
return;
}
}
//через секунду соседние ячйки получат по атому
private void delayedAddAtom(final int cellX, final int cellY){
mHandler.postDelayed(new Runnable() {
Override
public void run() {
addAtom(cellX, cellY);
}
}, 1000);
}
//добавляем в лист target существующие ячейки
private void selfAddCell(int cellX, int cellY, List target){
try{
target.add(cells[cellX][cellY]);
}catch (IndexOutOfBoundsException ignore){}
}
private final GameView view;
private final GameActivity activity;
private int moveNumber=0, currentPlayer=0;
private final int COUNT_OF_PLAYERS, BOARD_WIDTH, BOARD_HEIGHT;
private final Cell[][] cells;
private final int[] colors={0xff1d76fc, 0xfffb1d76, 0xff76fb1d, 0xffa21cfb};//цвета атомов
private final Handler mHandler;
public GameLogic(GameView view, GameActivity activity) {
this.view = view;
this.activity=activity;
mHandler=new Handler();
//инициализируем игровые параметры (количество игроков, размер доски)
this.COUNT_OF_PLAYERS=2;
this.BOARD_HEIGHT=10;
this.BOARD_WIDTH=10;
cells=new Cell[BOARD_WIDTH][BOARD_HEIGHT];
for(int x=0; x<BOARD_WIDTH; x++){
for(int y=0; y<BOARD_HEIGHT; y++){
if((x==0 || x==BOARD_WIDTH-1) && (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(2);//угловые ячейки имеют емкость 2
}else
if((x==0 || x==BOARD_WIDTH-1) || (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(3);//краевые, но не угловые — 3
}else{
cells[x][y]=new Cell(4);//остальные — 4
}
}
}
}
//вызывается из вьюхи по одиночному тапу
public void addAtom(final int cellX, final int cellY) {
//получаем ячейку, в которую добавляем атом, если ее нет в массиве — выходим из функции.
final Cell currentCell;
try{
currentCell=cells[cellX][cellY];
}catch (IndexOutOfBoundsException ex){
return;
}
//если в ячейке уже есть атомы этого игрока
if(currentCell.getPlayer()==currentPlayer){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
//если ячейка заполнена
if(currentCell.isFilled()){
final List nearby=new ArrayList(4);//лист соседних ячеек
selfAddCell(cellX, cellY-1, nearby);
selfAddCell(cellX, cellY+1, nearby);
selfAddCell(cellX-1, cellY, nearby);
selfAddCell(cellX+1, cellY, nearby);
for(Cell nearbyCell:nearby){
nearbyCell.setPlayer(currentPlayer);//соседним ячейкам устанавливаем нового владельца
}
delayedAddAtom(cellX, cellY-1);
delayedAddAtom(cellX, cellY+1);
delayedAddAtom(cellX-1, cellY);
delayedAddAtom(cellX+1, cellY);
//через секунду произойдет вызов метода run()
mHandler.postDelayed(new Runnable() {
Override
public void run() {
//текущая ячейка становится нейтральной (ничейной)
currentCell.setPlayer(-1);
//и пустой
currentCell.resetCount();
view.drawAtoms(cellX, cellY, 0x000000, 0);
}
}, 1000);
return;
}
}else if(currentCell.getPlayer()==-1){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
currentCell.setPlayer(currentPlayer);
}else{
return;
}
}
//через секунду соседние ячйки получат по атому
private void delayedAddAtom(final int cellX, final int cellY){
mHandler.postDelayed(new Runnable() {
Override
public void run() {
addAtom(cellX, cellY);
}
}, 1000);
}
//добавляем в лист target существующие ячейки
private void selfAddCell(int cellX, int cellY, List target){
try{
target.add(cells[cellX][cellY]);
}catch (IndexOutOfBoundsException ignore){}
}
private final GameView view;
private final GameActivity activity;
private int moveNumber=0, currentPlayer=0;
private final int COUNT_OF_PLAYERS, BOARD_WIDTH, BOARD_HEIGHT;
private final Cell[][] cells;
private final int[] colors={0xff1d76fc, 0xfffb1d76, 0xff76fb1d, 0xffa21cfb};//цвета атомов
private final Handler mHandler;
public GameLogic(GameView view, GameActivity activity) {
this.view = view;
this.activity=activity;
mHandler=new Handler();
//инициализируем игровые параметры (количество игроков, размер доски)
this.COUNT_OF_PLAYERS=2;
this.BOARD_HEIGHT=10;
this.BOARD_WIDTH=10;
cells=new Cell[BOARD_WIDTH][BOARD_HEIGHT];
for(int x=0; x<BOARD_WIDTH; x++){
for(int y=0; y<BOARD_HEIGHT; y++){
if((x==0 || x==BOARD_WIDTH-1) && (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(2);//угловые ячейки имеют емкость 2
}else
if((x==0 || x==BOARD_WIDTH-1) || (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(3);//краевые, но не угловые — 3
}else{
cells[x][y]=new Cell(4);//остальные — 4
}
}
}
}
//вызывается из вьюхи по одиночному тапу
public void addAtom(final int cellX, final int cellY) {
//получаем ячейку, в которую добавляем атом, если ее нет в массиве — выходим из функции.
final Cell currentCell;
try{
currentCell=cells[cellX][cellY];
}catch (IndexOutOfBoundsException ex){
return;
}
//если в ячейке уже есть атомы этого игрока
if(currentCell.getPlayer()==currentPlayer){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
//если ячейка заполнена
if(currentCell.isFilled()){
final List nearby=new ArrayList(4);//лист соседних ячеек
selfAddCell(cellX, cellY-1, nearby);
selfAddCell(cellX, cellY+1, nearby);
selfAddCell(cellX-1, cellY, nearby);
selfAddCell(cellX+1, cellY, nearby);
for(Cell nearbyCell:nearby){
nearbyCell.setPlayer(currentPlayer);//соседним ячейкам устанавливаем нового владельца
}
delayedAddAtom(cellX, cellY-1);
delayedAddAtom(cellX, cellY+1);
delayedAddAtom(cellX-1, cellY);
delayedAddAtom(cellX+1, cellY);
//через секунду произойдет вызов метода run()
mHandler.postDelayed(new Runnable() {
Override
public void run() {
//текущая ячейка становится нейтральной (ничейной)
currentCell.setPlayer(-1);
//и пустой
currentCell.resetCount();
view.drawAtoms(cellX, cellY, 0x000000, 0);
}
}, 1000);
return;
}
}else if(currentCell.getPlayer()==-1){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
currentCell.setPlayer(currentPlayer);
}else{
return;
}
}
//через секунду соседние ячйки получат по атому
private void delayedAddAtom(final int cellX, final int cellY){
mHandler.postDelayed(new Runnable() {
Override
public void run() {
addAtom(cellX, cellY);
}
}, 1000);
}
//добавляем в лист target существующие ячейки
private void selfAddCell(int cellX, int cellY, List target){
try{
target.add(cells[cellX][cellY]);
}catch (IndexOutOfBoundsException ignore){}
}
private final GameView view;
private final GameActivity activity;
private int moveNumber=0, currentPlayer=0;
private final int COUNT_OF_PLAYERS, BOARD_WIDTH, BOARD_HEIGHT;
private final Cell[][] cells;
private final int[] colors={0xff1d76fc, 0xfffb1d76, 0xff76fb1d, 0xffa21cfb};//цвета атомов
private final Handler mHandler;
public GameLogic(GameView view, GameActivity activity) {
this.view = view;
this.activity=activity;
mHandler=new Handler();
//инициализируем игровые параметры (количество игроков, размер доски)
this.COUNT_OF_PLAYERS=2;
this.BOARD_HEIGHT=10;
this.BOARD_WIDTH=10;
cells=new Cell[BOARD_WIDTH][BOARD_HEIGHT];
for(int x=0; x<BOARD_WIDTH; x++){
for(int y=0; y<BOARD_HEIGHT; y++){
if((x==0 || x==BOARD_WIDTH-1) && (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(2);//угловые ячейки имеют емкость 2
}else
if((x==0 || x==BOARD_WIDTH-1) || (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(3);//краевые, но не угловые — 3
}else{
cells[x][y]=new Cell(4);//остальные — 4
}
}
}
}
//вызывается из вьюхи по одиночному тапу
public void addAtom(final int cellX, final int cellY) {
//получаем ячейку, в которую добавляем атом, если ее нет в массиве — выходим из функции.
final Cell currentCell;
try{
currentCell=cells[cellX][cellY];
}catch (IndexOutOfBoundsException ex){
return;
}
//если в ячейке уже есть атомы этого игрока
if(currentCell.getPlayer()==currentPlayer){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
//если ячейка заполнена
if(currentCell.isFilled()){
final List nearby=new ArrayList(4);//лист соседних ячеек
selfAddCell(cellX, cellY-1, nearby);
selfAddCell(cellX, cellY+1, nearby);
selfAddCell(cellX-1, cellY, nearby);
selfAddCell(cellX+1, cellY, nearby);
for(Cell nearbyCell:nearby){
nearbyCell.setPlayer(currentPlayer);//соседним ячейкам устанавливаем нового владельца
}
delayedAddAtom(cellX, cellY-1);
delayedAddAtom(cellX, cellY+1);
delayedAddAtom(cellX-1, cellY);
delayedAddAtom(cellX+1, cellY);
//через секунду произойдет вызов метода run()
mHandler.postDelayed(new Runnable() {
Override
public void run() {
//текущая ячейка становится нейтральной (ничейной)
currentCell.setPlayer(-1);
//и пустой
currentCell.resetCount();
view.drawAtoms(cellX, cellY, 0x000000, 0);
}
}, 1000);
return;
}
}else if(currentCell.getPlayer()==-1){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
currentCell.setPlayer(currentPlayer);
}else{
return;
}
}
//через секунду соседние ячйки получат по атому
private void delayedAddAtom(final int cellX, final int cellY){
mHandler.postDelayed(new Runnable() {
Override
public void run() {
addAtom(cellX, cellY);
}
}, 1000);
}
//добавляем в лист target существующие ячейки
private void selfAddCell(int cellX, int cellY, List target){
try{
target.add(cells[cellX][cellY]);
}catch (IndexOutOfBoundsException ignore){}
}
private final GameView view;
private final GameActivity activity;
private int moveNumber=0, currentPlayer=0;
private final int COUNT_OF_PLAYERS, BOARD_WIDTH, BOARD_HEIGHT;
private final Cell[][] cells;
private final int[] colors={0xff1d76fc, 0xfffb1d76, 0xff76fb1d, 0xffa21cfb};//цвета атомов
private final Handler mHandler;
public GameLogic(GameView view, GameActivity activity) {
this.view = view;
this.activity=activity;
mHandler=new Handler();
//инициализируем игровые параметры (количество игроков, размер доски)
this.COUNT_OF_PLAYERS=2;
this.BOARD_HEIGHT=10;
this.BOARD_WIDTH=10;
cells=new Cell[BOARD_WIDTH][BOARD_HEIGHT];
for(int x=0; x<BOARD_WIDTH; x++){
for(int y=0; y<BOARD_HEIGHT; y++){
if((x==0 || x==BOARD_WIDTH-1) && (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(2);//угловые ячейки имеют емкость 2
}else
if((x==0 || x==BOARD_WIDTH-1) || (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(3);//краевые, но не угловые — 3
}else{
cells[x][y]=new Cell(4);//остальные — 4
}
}
}
}
//вызывается из вьюхи по одиночному тапу
public void addAtom(final int cellX, final int cellY) {
//получаем ячейку, в которую добавляем атом, если ее нет в массиве — выходим из функции.
final Cell currentCell;
try{
currentCell=cells[cellX][cellY];
}catch (IndexOutOfBoundsException ex){
return;
}
//если в ячейке уже есть атомы этого игрока
if(currentCell.getPlayer()==currentPlayer){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
//если ячейка заполнена
if(currentCell.isFilled()){
final List nearby=new ArrayList(4);//лист соседних ячеек
selfAddCell(cellX, cellY-1, nearby);
selfAddCell(cellX, cellY+1, nearby);
selfAddCell(cellX-1, cellY, nearby);
selfAddCell(cellX+1, cellY, nearby);
for(Cell nearbyCell:nearby){
nearbyCell.setPlayer(currentPlayer);//соседним ячейкам устанавливаем нового владельца
}
delayedAddAtom(cellX, cellY-1);
delayedAddAtom(cellX, cellY+1);
delayedAddAtom(cellX-1, cellY);
delayedAddAtom(cellX+1, cellY);
//через секунду произойдет вызов метода run()
mHandler.postDelayed(new Runnable() {
Override
public void run() {
//текущая ячейка становится нейтральной (ничейной)
currentCell.setPlayer(-1);
//и пустой
currentCell.resetCount();
view.drawAtoms(cellX, cellY, 0x000000, 0);
}
}, 1000);
return;
}
}else if(currentCell.getPlayer()==-1){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
currentCell.setPlayer(currentPlayer);
}else{
return;
}
}
//через секунду соседние ячйки получат по атому
private void delayedAddAtom(final int cellX, final int cellY){
mHandler.postDelayed(new Runnable() {
Override
public void run() {
addAtom(cellX, cellY);
}
}, 1000);
}
//добавляем в лист target существующие ячейки
private void selfAddCell(int cellX, int cellY, List target){
try{
target.add(cells[cellX][cellY]);
}catch (IndexOutOfBoundsException ignore){}
}
private final GameView view;
private final GameActivity activity;
private int moveNumber=0, currentPlayer=0;
private final int COUNT_OF_PLAYERS, BOARD_WIDTH, BOARD_HEIGHT;
private final Cell[][] cells;
private final int[] colors={0xff1d76fc, 0xfffb1d76, 0xff76fb1d, 0xffa21cfb};//цвета атомов
private final Handler mHandler;
public GameLogic(GameView view, GameActivity activity) {
this.view = view;
this.activity=activity;
mHandler=new Handler();
//инициализируем игровые параметры (количество игроков, размер доски)
this.COUNT_OF_PLAYERS=2;
this.BOARD_HEIGHT=10;
this.BOARD_WIDTH=10;
cells=new Cell[BOARD_WIDTH][BOARD_HEIGHT];
for(int x=0; x<BOARD_WIDTH; x++){
for(int y=0; y<BOARD_HEIGHT; y++){
if((x==0 || x==BOARD_WIDTH-1) && (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(2);//угловые ячейки имеют емкость 2
}else
if((x==0 || x==BOARD_WIDTH-1) || (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(3);//краевые, но не угловые — 3
}else{
cells[x][y]=new Cell(4);//остальные — 4
}
}
}
}
//вызывается из вьюхи по одиночному тапу
public void addAtom(final int cellX, final int cellY) {
//получаем ячейку, в которую добавляем атом, если ее нет в массиве — выходим из функции.
final Cell currentCell;
try{
currentCell=cells[cellX][cellY];
}catch (IndexOutOfBoundsException ex){
return;
}
//если в ячейке уже есть атомы этого игрока
if(currentCell.getPlayer()==currentPlayer){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
//если ячейка заполнена
if(currentCell.isFilled()){
final List nearby=new ArrayList(4);//лист соседних ячеек
selfAddCell(cellX, cellY-1, nearby);
selfAddCell(cellX, cellY+1, nearby);
selfAddCell(cellX-1, cellY, nearby);
selfAddCell(cellX+1, cellY, nearby);
for(Cell nearbyCell:nearby){
nearbyCell.setPlayer(currentPlayer);//соседним ячейкам устанавливаем нового владельца
}
delayedAddAtom(cellX, cellY-1);
delayedAddAtom(cellX, cellY+1);
delayedAddAtom(cellX-1, cellY);
delayedAddAtom(cellX+1, cellY);
//через секунду произойдет вызов метода run()
mHandler.postDelayed(new Runnable() {
Override
public void run() {
//текущая ячейка становится нейтральной (ничейной)
currentCell.setPlayer(-1);
//и пустой
currentCell.resetCount();
view.drawAtoms(cellX, cellY, 0x000000, 0);
}
}, 1000);
return;
}
}else if(currentCell.getPlayer()==-1){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
currentCell.setPlayer(currentPlayer);
}else{
return;
}
}
//через секунду соседние ячйки получат по атому
private void delayedAddAtom(final int cellX, final int cellY){
mHandler.postDelayed(new Runnable() {
Override
public void run() {
addAtom(cellX, cellY);
}
}, 1000);
}
//добавляем в лист target существующие ячейки
private void selfAddCell(int cellX, int cellY, List target){
try{
target.add(cells[cellX][cellY]);
}catch (IndexOutOfBoundsException ignore){}
}
private final GameView view;
private final GameActivity activity;
private int moveNumber=0, currentPlayer=0;
private final int COUNT_OF_PLAYERS, BOARD_WIDTH, BOARD_HEIGHT;
private final Cell[][] cells;
private final int[] colors={0xff1d76fc, 0xfffb1d76, 0xff76fb1d, 0xffa21cfb};//цвета атомов
private final Handler mHandler;
public GameLogic(GameView view, GameActivity activity) {
this.view = view;
this.activity=activity;
mHandler=new Handler();
//инициализируем игровые параметры (количество игроков, размер доски)
this.COUNT_OF_PLAYERS=2;
this.BOARD_HEIGHT=10;
this.BOARD_WIDTH=10;
cells=new Cell[BOARD_WIDTH][BOARD_HEIGHT];
for(int x=0; x<BOARD_WIDTH; x++){
for(int y=0; y<BOARD_HEIGHT; y++){
if((x==0 || x==BOARD_WIDTH-1) && (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(2);//угловые ячейки имеют емкость 2
}else
if((x==0 || x==BOARD_WIDTH-1) || (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(3);//краевые, но не угловые — 3
}else{
cells[x][y]=new Cell(4);//остальные — 4
}
}
}
}
//вызывается из вьюхи по одиночному тапу
public void addAtom(final int cellX, final int cellY) {
//получаем ячейку, в которую добавляем атом, если ее нет в массиве — выходим из функции.
final Cell currentCell;
try{
currentCell=cells[cellX][cellY];
}catch (IndexOutOfBoundsException ex){
return;
}
//если в ячейке уже есть атомы этого игрока
if(currentCell.getPlayer()==currentPlayer){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
//если ячейка заполнена
if(currentCell.isFilled()){
final List nearby=new ArrayList(4);//лист соседних ячеек
selfAddCell(cellX, cellY-1, nearby);
selfAddCell(cellX, cellY+1, nearby);
selfAddCell(cellX-1, cellY, nearby);
selfAddCell(cellX+1, cellY, nearby);
for(Cell nearbyCell:nearby){
nearbyCell.setPlayer(currentPlayer);//соседним ячейкам устанавливаем нового владельца
}
delayedAddAtom(cellX, cellY-1);
delayedAddAtom(cellX, cellY+1);
delayedAddAtom(cellX-1, cellY);
delayedAddAtom(cellX+1, cellY);
//через секунду произойдет вызов метода run()
mHandler.postDelayed(new Runnable() {
Override
public void run() {
//текущая ячейка становится нейтральной (ничейной)
currentCell.setPlayer(-1);
//и пустой
currentCell.resetCount();
view.drawAtoms(cellX, cellY, 0x000000, 0);
}
}, 1000);
return;
}
}else if(currentCell.getPlayer()==-1){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
currentCell.setPlayer(currentPlayer);
}else{
return;
}
}
//через секунду соседние ячйки получат по атому
private void delayedAddAtom(final int cellX, final int cellY){
mHandler.postDelayed(new Runnable() {
Override
public void run() {
addAtom(cellX, cellY);
}
}, 1000);
}
//добавляем в лист target существующие ячейки
private void selfAddCell(int cellX, int cellY, List target){
try{
target.add(cells[cellX][cellY]);
}catch (IndexOutOfBoundsException ignore){}
}
private final GameView view;
private final GameActivity activity;
private int moveNumber=0, currentPlayer=0;
private final int COUNT_OF_PLAYERS, BOARD_WIDTH, BOARD_HEIGHT;
private final Cell[][] cells;
private final int[] colors={0xff1d76fc, 0xfffb1d76, 0xff76fb1d, 0xffa21cfb};//цвета атомов
private final Handler mHandler;
public GameLogic(GameView view, GameActivity activity) {
this.view = view;
this.activity=activity;
mHandler=new Handler();
//инициализируем игровые параметры (количество игроков, размер доски)
this.COUNT_OF_PLAYERS=2;
this.BOARD_HEIGHT=10;
this.BOARD_WIDTH=10;
cells=new Cell[BOARD_WIDTH][BOARD_HEIGHT];
for(int x=0; x<BOARD_WIDTH; x++){
for(int y=0; y<BOARD_HEIGHT; y++){
if((x==0 || x==BOARD_WIDTH-1) && (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(2);//угловые ячейки имеют емкость 2
}else
if((x==0 || x==BOARD_WIDTH-1) || (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(3);//краевые, но не угловые — 3
}else{
cells[x][y]=new Cell(4);//остальные — 4
}
}
}
}
//вызывается из вьюхи по одиночному тапу
public void addAtom(final int cellX, final int cellY) {
//получаем ячейку, в которую добавляем атом, если ее нет в массиве — выходим из функции.
final Cell currentCell;
try{
currentCell=cells[cellX][cellY];
}catch (IndexOutOfBoundsException ex){
return;
}
//если в ячейке уже есть атомы этого игрока
if(currentCell.getPlayer()==currentPlayer){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
//если ячейка заполнена
if(currentCell.isFilled()){
final List nearby=new ArrayList(4);//лист соседних ячеек
selfAddCell(cellX, cellY-1, nearby);
selfAddCell(cellX, cellY+1, nearby);
selfAddCell(cellX-1, cellY, nearby);
selfAddCell(cellX+1, cellY, nearby);
for(Cell nearbyCell:nearby){
nearbyCell.setPlayer(currentPlayer);//соседним ячейкам устанавливаем нового владельца
}
delayedAddAtom(cellX, cellY-1);
delayedAddAtom(cellX, cellY+1);
delayedAddAtom(cellX-1, cellY);
delayedAddAtom(cellX+1, cellY);
//через секунду произойдет вызов метода run()
mHandler.postDelayed(new Runnable() {
Override
public void run() {
//текущая ячейка становится нейтральной (ничейной)
currentCell.setPlayer(-1);
//и пустой
currentCell.resetCount();
view.drawAtoms(cellX, cellY, 0x000000, 0);
}
}, 1000);
return;
}
}else if(currentCell.getPlayer()==-1){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
currentCell.setPlayer(currentPlayer);
}else{
return;
}
}
//через секунду соседние ячйки получат по атому
private void delayedAddAtom(final int cellX, final int cellY){
mHandler.postDelayed(new Runnable() {
Override
public void run() {
addAtom(cellX, cellY);
}
}, 1000);
}
//добавляем в лист target существующие ячейки
private void selfAddCell(int cellX, int cellY, List target){
try{
target.add(cells[cellX][cellY]);
}catch (IndexOutOfBoundsException ignore){}
}
private final GameView view;
private final GameActivity activity;
private int moveNumber=0, currentPlayer=0;
private final int COUNT_OF_PLAYERS, BOARD_WIDTH, BOARD_HEIGHT;
private final Cell[][] cells;
private final int[] colors={0xff1d76fc, 0xfffb1d76, 0xff76fb1d, 0xffa21cfb};//цвета атомов
private final Handler mHandler;
public GameLogic(GameView view, GameActivity activity) {
this.view = view;
this.activity=activity;
mHandler=new Handler();
//инициализируем игровые параметры (количество игроков, размер доски)
this.COUNT_OF_PLAYERS=2;
this.BOARD_HEIGHT=10;
this.BOARD_WIDTH=10;
cells=new Cell[BOARD_WIDTH][BOARD_HEIGHT];
for(int x=0; x<BOARD_WIDTH; x++){
for(int y=0; y<BOARD_HEIGHT; y++){
if((x==0 || x==BOARD_WIDTH-1) && (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(2);//угловые ячейки имеют емкость 2
}else
if((x==0 || x==BOARD_WIDTH-1) || (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(3);//краевые, но не угловые — 3
}else{
cells[x][y]=new Cell(4);//остальные — 4
}
}
}
}
//вызывается из вьюхи по одиночному тапу
public void addAtom(final int cellX, final int cellY) {
//получаем ячейку, в которую добавляем атом, если ее нет в массиве — выходим из функции.
final Cell currentCell;
try{
currentCell=cells[cellX][cellY];
}catch (IndexOutOfBoundsException ex){
return;
}
//если в ячейке уже есть атомы этого игрока
if(currentCell.getPlayer()==currentPlayer){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
//если ячейка заполнена
if(currentCell.isFilled()){
final List nearby=new ArrayList(4);//лист соседних ячеек
selfAddCell(cellX, cellY-1, nearby);
selfAddCell(cellX, cellY+1, nearby);
selfAddCell(cellX-1, cellY, nearby);
selfAddCell(cellX+1, cellY, nearby);
for(Cell nearbyCell:nearby){
nearbyCell.setPlayer(currentPlayer);//соседним ячейкам устанавливаем нового владельца
}
delayedAddAtom(cellX, cellY-1);
delayedAddAtom(cellX, cellY+1);
delayedAddAtom(cellX-1, cellY);
delayedAddAtom(cellX+1, cellY);
//через секунду произойдет вызов метода run()
mHandler.postDelayed(new Runnable() {
Override
public void run() {
//текущая ячейка становится нейтральной (ничейной)
currentCell.setPlayer(-1);
//и пустой
currentCell.resetCount();
view.drawAtoms(cellX, cellY, 0x000000, 0);
}
}, 1000);
return;
}
}else if(currentCell.getPlayer()==-1){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
currentCell.setPlayer(currentPlayer);
}else{
return;
}
}
//через секунду соседние ячйки получат по атому
private void delayedAddAtom(final int cellX, final int cellY){
mHandler.postDelayed(new Runnable() {
Override
public void run() {
addAtom(cellX, cellY);
}
}, 1000);
}
//добавляем в лист target существующие ячейки
private void selfAddCell(int cellX, int cellY, List target){
try{
target.add(cells[cellX][cellY]);
}catch (IndexOutOfBoundsException ignore){}
}
private final GameView view;
private final GameActivity activity;
private int moveNumber=0, currentPlayer=0;
private final int COUNT_OF_PLAYERS, BOARD_WIDTH, BOARD_HEIGHT;
private final Cell[][] cells;
private final int[] colors={0xff1d76fc, 0xfffb1d76, 0xff76fb1d, 0xffa21cfb};//цвета атомов
private final Handler mHandler;
public GameLogic(GameView view, GameActivity activity) {
this.view = view;
this.activity=activity;
mHandler=new Handler();
//инициализируем игровые параметры (количество игроков, размер доски)
this.COUNT_OF_PLAYERS=2;
this.BOARD_HEIGHT=10;
this.BOARD_WIDTH=10;
cells=new Cell[BOARD_WIDTH][BOARD_HEIGHT];
for(int x=0; x<BOARD_WIDTH; x++){
for(int y=0; y<BOARD_HEIGHT; y++){
if((x==0 || x==BOARD_WIDTH-1) && (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(2);//угловые ячейки имеют емкость 2
}else
if((x==0 || x==BOARD_WIDTH-1) || (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(3);//краевые, но не угловые — 3
}else{
cells[x][y]=new Cell(4);//остальные — 4
}
}
}
}
//вызывается из вьюхи по одиночному тапу
public void addAtom(final int cellX, final int cellY) {
//получаем ячейку, в которую добавляем атом, если ее нет в массиве — выходим из функции.
final Cell currentCell;
try{
currentCell=cells[cellX][cellY];
}catch (IndexOutOfBoundsException ex){
return;
}
//если в ячейке уже есть атомы этого игрока
if(currentCell.getPlayer()==currentPlayer){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
//если ячейка заполнена
if(currentCell.isFilled()){
final List nearby=new ArrayList(4);//лист соседних ячеек
selfAddCell(cellX, cellY-1, nearby);
selfAddCell(cellX, cellY+1, nearby);
selfAddCell(cellX-1, cellY, nearby);
selfAddCell(cellX+1, cellY, nearby);
for(Cell nearbyCell:nearby){
nearbyCell.setPlayer(currentPlayer);//соседним ячейкам устанавливаем нового владельца
}
delayedAddAtom(cellX, cellY-1);
delayedAddAtom(cellX, cellY+1);
delayedAddAtom(cellX-1, cellY);
delayedAddAtom(cellX+1, cellY);
//через секунду произойдет вызов метода run()
mHandler.postDelayed(new Runnable() {
Override
public void run() {
//текущая ячейка становится нейтральной (ничейной)
currentCell.setPlayer(-1);
//и пустой
currentCell.resetCount();
view.drawAtoms(cellX, cellY, 0x000000, 0);
}
}, 1000);
return;
}
}else if(currentCell.getPlayer()==-1){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
currentCell.setPlayer(currentPlayer);
}else{
return;
}
}
//через секунду соседние ячйки получат по атому
private void delayedAddAtom(final int cellX, final int cellY){
mHandler.postDelayed(new Runnable() {
Override
public void run() {
addAtom(cellX, cellY);
}
}, 1000);
}
//добавляем в лист target существующие ячейки
private void selfAddCell(int cellX, int cellY, List target){
try{
target.add(cells[cellX][cellY]);
}catch (IndexOutOfBoundsException ignore){}
}private final GameView view;
private final GameActivity activity;
private int moveNumber=0, currentPlayer=0;
private final int COUNT_OF_PLAYERS, BOARD_WIDTH, BOARD_HEIGHT;
private final Cell[][] cells;
private final int[] colors={0xff1d76fc, 0xfffb1d76, 0xff76fb1d, 0xffa21cfb};//цвета атомов
private final Handler mHandler;
public GameLogic(GameView view, GameActivity activity) {
this.view = view;
this.activity=activity;
mHandler=new Handler();
//инициализируем игровые параметры (количество игроков, размер доски)
this.COUNT_OF_PLAYERS=2;
this.BOARD_HEIGHT=10;
this.BOARD_WIDTH=10;
cells=new Cell[BOARD_WIDTH][BOARD_HEIGHT];
for(int x=0; x<BOARD_WIDTH; x++){
for(int y=0; y<BOARD_HEIGHT; y++){
if((x==0 || x==BOARD_WIDTH-1) && (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(2);//угловые ячейки имеют емкость 2
}else
if((x==0 || x==BOARD_WIDTH-1) || (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(3);//краевые, но не угловые — 3
}else{
cells[x][y]=new Cell(4);//остальные — 4
}
}
}
}
//вызывается из вьюхи по одиночному тапу
public void addAtom(final int cellX, final int cellY) {
//получаем ячейку, в которую добавляем атом, если ее нет в массиве — выходим из функции.
final Cell currentCell;
try{
currentCell=cells[cellX][cellY];
}catch (IndexOutOfBoundsException ex){
return;
}
//если в ячейке уже есть атомы этого игрока
if(currentCell.getPlayer()==currentPlayer){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
//если ячейка заполнена
if(currentCell.isFilled()){
final List nearby=new ArrayList(4);//лист соседних ячеек
selfAddCell(cellX, cellY-1, nearby);
selfAddCell(cellX, cellY+1, nearby);
selfAddCell(cellX-1, cellY, nearby);
selfAddCell(cellX+1, cellY, nearby);
for(Cell nearbyCell:nearby){
nearbyCell.setPlayer(currentPlayer);//соседним ячейкам устанавливаем нового владельца
}
delayedAddAtom(cellX, cellY-1);
delayedAddAtom(cellX, cellY+1);
delayedAddAtom(cellX-1, cellY);
delayedAddAtom(cellX+1, cellY);
//через секунду произойдет вызов метода run()
mHandler.postDelayed(new Runnable() {
Override
public void run() {
//текущая ячейка становится нейтральной (ничейной)
currentCell.setPlayer(-1);
//и пустой
currentCell.resetCount();
view.drawAtoms(cellX, cellY, 0x000000, 0);
}
}, 1000);
return;
}
}else if(currentCell.getPlayer()==-1){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
currentCell.setPlayer(currentPlayer);
}else{
return;
}
}
//через секунду соседние ячйки получат по атому
private void delayedAddAtom(final int cellX, final int cellY){
mHandler.postDelayed(new Runnable() {
Override
public void run() {
addAtom(cellX, cellY);
}
}, 1000);
}
//добавляем в лист target существующие ячейки
private void selfAddCell(int cellX, int cellY, List target){
try{
target.add(cells[cellX][cellY]);
}catch (IndexOutOfBoundsException ignore){}
}
private final GameView view;
private final GameActivity activity;
private int moveNumber=0, currentPlayer=0;
private final int COUNT_OF_PLAYERS, BOARD_WIDTH, BOARD_HEIGHT;
private final Cell[][] cells;
private final int[] colors={0xff1d76fc, 0xfffb1d76, 0xff76fb1d, 0xffa21cfb};//цвета атомов
private final Handler mHandler;
public GameLogic(GameView view, GameActivity activity) {
this.view = view;
this.activity=activity;
mHandler=new Handler();
//инициализируем игровые параметры (количество игроков, размер доски)
this.COUNT_OF_PLAYERS=2;
this.BOARD_HEIGHT=10;
this.BOARD_WIDTH=10;
cells=new Cell[BOARD_WIDTH][BOARD_HEIGHT];
for(int x=0; x<BOARD_WIDTH; x++){
for(int y=0; y<BOARD_HEIGHT; y++){
if((x==0 || x==BOARD_WIDTH-1) && (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(2);//угловые ячейки имеют емкость 2
}else
if((x==0 || x==BOARD_WIDTH-1) || (y==0 || y==BOARD_HEIGHT-1)){
cells[x][y]=new Cell(3);//краевые, но не угловые — 3
}else{
cells[x][y]=new Cell(4);//остальные — 4
}
}
}
}
//вызывается из вьюхи по одиночному тапу
public void addAtom(final int cellX, final int cellY) {
//получаем ячейку, в которую добавляем атом, если ее нет в массиве — выходим из функции.
final Cell currentCell;
try{
currentCell=cells[cellX][cellY];
}catch (IndexOutOfBoundsException ex){
return;
}
//если в ячейке уже есть атомы этого игрока
if(currentCell.getPlayer()==currentPlayer){
currentCell.addAtom();
view.drawAtoms(cellX, cellY, colors[currentPlayer], currentCell.getCountOfAtoms());
//если ячейка заполнена
if(currentCell.isFilled()){
final List nearby=new ArrayList(4);//лист соседних ячеек
selfAddCell(cellX, cellY-1, nearby);
selfAddCell(cellX, cellY+1, nearby);
selfAddCell(cellX-1, cellY, nearby);
selfAddCell(cellX+1, cellY, nearby);
for(Cell nearbyCell:nearby){
Зарегистрируйтесь на Хабре, чтобы оставить комментарий
Пишем игру для Android используя Canvas