Вакуумный транзистор сможет преодолеть рубеж 1 ТГц

Лампы: перерождение

Как смотреть фильмы в оригинале, если английский слабоват? Решение!

Как минимум этим он плох.

Как смотреть фильмы в оригинале, если английский слабоват? Решение!

Оно-то эффективно, но нудно. Да и «спойлеры».

Как смотреть фильмы в оригинале, если английский слабоват? Решение!

Обязательно попробую.
Пробовал и смотреть по несколько раз и читать перед просмотром сабы — быстро надоедало.
В итоге разделил сериалы на 3 категории — смотрю в переводе, с русскими сабами, с оригинальными сабами.

Готовится к выходу постановление о снижении почтового лимита до €150

Позволю себе спросить: как наполнение карманов реселлеров влияет на

обеспечения достойной жизни и свободного развития всех граждан.

Готовится к выходу постановление о снижении почтового лимита до €150

Инвестировать в отечественного производителя?
Налоговые каникулы для отечественного производителя?
Упростить процедуру регистрации?
Запретить ввоз изза рубежа!

Выбор, кстати, весьма логичен. Последний вариант требует наименьшее количество телодвижений со стороны властьпредержащих.

Магистратура или работать?

Я в свое время выбрал специалитет (на Украине еще есть, обещают отменить как минимум с тех пор как я поступал 5 лет назад.)
Все же уже не бакалавр, но и еще не магистр.

И да, у нас специалитет 1 год, а магистратура — 1,5 года.

Бесплатная копия Battlefield 3

Как игрок в Батлфилд с 2010 могу сказать что серия из «игрокоориентированной» превращается в «баблоориентированную», особенно с открытием предзаказа на новый батлфилд.

Как молодым специалистам устроиться в IT-компанию

Вот-вот. Изя в данном случае не подходит по причине «overcvalified» И даже если он согласится на 100 рублей, то скоро ему наскучит забивать только 2 гвоздя в час (он же может 5!) и начнет разрушать трудовую дисциплину (пойдет змея воздушного запускать) и в конце-концов займется поисками другой работы, где требуется забивать 6 гвоздей в час (а это уже стимул к обучению). И зачем мне, спрашивается, брать Изю, который будет отвлекать других моих работников своим воздушным змеем и в конце-концов уйдет, если можно взять Петю, который все время будет работать и с меньшей вероятностью уйдет из моей компании при прочих равных условиях.

Как молодым специалистам устроиться в IT-компанию

Неплохо программируете? Попробуйте себя в фрилансе. Не скажу за все платформы, но на андроиде сейчас можно найти заказ уровнем от «чуть сложнее хэлло-ворлд» до сложных клиент-серверных систем.

А вообще соглашусь с предыдущими ораторами: отдыхайте, создавайте свое, учавствуйте в OS, освойте линукс в конце-концов (если еще нет).

В Дубае за отметку людей на фотографиях в Facebook можно попасть в тюрьму

В ВК есть такое. Моя страница -> Фотографии со мной.

В Дубае за отметку людей на фотографиях в Facebook можно попасть в тюрьму

А не пробовали настраивать ленту? Незнаю как в ФБ, но в ВК лента отлично настраивается.

Пишем игру для Android используя Canvas

Заголовок

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){<br

Советское культурное и научное наследие освобождается от оков копирайта. Расширение режима «общественного достояния»

Луч света в темном царстве.

Продажа приложений в Google Play из Украины

а что не так с законами?

Как нам выстроить информационную защиту России

Железный занавес 2.0

99 удивительных фактов о бизнесе будущего

Дали бы пояснения, что такое поколение Y, поколение Миллениум, я так полагаю, люди родившиеся в 3 тысячелетии.

Еврокомиссия: «Фритуплей? Тогда никаких встроенных покупок!»

Google play

Что общего у gamedev-а с космонавтикой или работа с итераторами в PHP

Абсолютное несоответствие заголовка и содержания.

В Лондоне закончили строительство самого большого в мире моста с солнечными панелями

900 тысяч кВт электроэнергии в год

Который раз вижу такое на хабре и который раз мне хочется подарить учебник по физике.
кВт — это мощность, определяется как отношение вырабатываемой энергии к времени, за которое она вырабатывается. Данная фраза имеет такой же смысл как и 42 км/ч в год

Посмотрел оригинал — там

900,000 kWh of electricity each year

что означает 900 МВт • ч электроэнергии в год.