есть кнопка , есть класс  для выбора игроком цвета
 и есть класс игрок .
При нажатии кнопки должен выходить диалог выбора цвета  для игрока .
Я думала что достаточно при нажатии кнопки 

 создать  игрока из конструктора класса Игрок  который уже выберет себе цвет но не знаю как этот конструктор прописать  что-бы он выбирал цвет .
Мой конструктор видимо в принципе ошибочный.Он ничего не выбирает поэтому я его здесь и не отображаю . 

Если цвет выбирается в момент создания игрока, то:


В конструкторе класса Игрок:


Добавлено @ 18:59
Если цвет хочется менять во время игры, то:
1. Создаем кнопки или пункты меню "Поменять цвет Игрока1" "Поменять цвет Игрока2"
2. Клеим их к основному окну
3. В класс Игрок добавляем метод смены цвета:

4. В основном окне отслеживаем нажатие кнопок (или выбор пункта меню) и вызываем метод ChangeColor() соответствующего игрока.


ЗЫ
С Праздником!

Это сообщение отредактировал(а) Rpahut - 31.12.2008, 19:03

C Наступившим ...и ещё с наступающими !
получился у меня такой синтакс на кнопке


такой ColorChooser


проблема сейчас с игроком


на строчке
 this.playerColor = this.cchooser.ShowChooser(Color playerColor ); 
компайлер ругается что ему нужна ещё  ")" 
Я пробовала различные варианты написания , но ему всё равно нужна ещё одна скобка.

И еще:

почему-то компайлер хочет ещё одну круглую скобку. Видимо ему что-то другое не нравится в этом варианте конструктора 
но пишет он что нужна ещё одна круглая скобка в строчке playerColor = cchooser.ShowChooser(Color playerColor );
Я уже видела   "лишнии" с моей точки зрения  круглые скобки в примерах с Java кодом , но как и почему их ставят - не знаю. Они бывают не парные !!! и откуда они берутся не понятно . В данном случае я попробовала поставить лишнию скобку - компайлер  всё равно пишет что скобки не хватает .Значит дело не в ней а в чём то другом ...

Ваша ошибка тут:
playerColor = cchooser.ShowChooser(  Color   playerColor);


Скобки, кавычки и прочие знаки, используемые для отделения части текста, всегда парные - одна указывает начало куска, вторая конец.
При большом нагромождении скобок бывает трудно определить на глаз, все ли в коде правильно. Небольшие куски кода часто пишутся "из головы" и не проверяются на корректность - так что там могут быть и ошибки.

Вы правы .. Это конечно объест класса Color но в данном случае он используется как аргумент ... Перестраховалась я   
Теперь всё скомпилировалось но при нажатии на кнопку компайлер как ни странно  находит кучу exceptions типа java.lang.NullPointerException .

 Нам показывали exceptions которые возникают при вводе данных . А  здесь мы пока ещё ничего не  вводили .. Я что-то неправильно импортировала ?

Видимо ошибка вот тут



т.е. в 16 строке в файле Player.java. Судя по всему, член класса



нигде не инициализируется, т.е. ему ничего не присваивается, поэтому происходит java.lang.NullPointerException  

private  ColorChooser cchooser  был инициализирован но ему действительно ничего не присваивалось
 
Надо   было  видимо создать обьект класса 
ColorChooser cchooser = new ColorChooser (); Только что ему присваивать как цвет если сразу у двух игроков есть предустановленные цвета  . .. null видимо ..

Ничего присваивать оказалось не нужно .Просто оставить пустые  скобочки и всё работает ! 

Это сообщение отредактировал(а) Qawra - 5.1.2009, 13:55

Qawra, 

это и значит, что "ничего не присваивалось"   по крайней мере, в твоем коде я не нашел.

ничего не понял, ну да ладно.



также, вызывает сомнение этот код. Что ты им хотела сказать? 

Здесь если cchooser.ShowChooser(playerColor) возвращает null, игроку присваивается цвет по умолчанию.


И это при том, что в яве указателей нету  ...

ColorChooser не нужно делать членом класса, потому как после выполнения конструктора класса Player он уже не будет нужен.
Лучше создать его там где он используется:

 да.. так оно тоже работает . А когда мы отключаем 
//this.playerColor = color;  то как  быть с  цветом для игрока заданным по умолчанию ? Мы ведь с ним теперь не работаем в конструкторе .
Я правда не могу это сейчас практически проверить .
Попробовать нарисовать точки без выбора цвета игрока  пока нечем .Нужен отдельный класс Points где точки будут рисоваться по очереди цветами игроков и только в углах клеток решётки . Вызывается решётка кодом на кнопке 
есть по умолчанию  два цвета для игроков red и blue  . Но ведь если игрок не станет выбирать цвет то он не запустит  конструктор и цвета по умолчанию тоже не будет .. Хотелось бы написать  Но тогда игроку никогда не выбрать себе цвет 
Как при нажатии кнопки старт проверить что были нажаты firstPlayerButton и
secondPlayerButton ? 

Цвет по умолчанию мы передаем в ColorChooser:
playerColor = cchooser.ShowChooser(color);
так что либо пользователь изменит и выберет цвет - тогда его мы присвоим игроку,
либо пользователь откажется от выбора - тогда срабатывает проверка на null и цвет по умолчанию записывается в playerColor.

Конструктор вызывается автоматически при создании экземпляра объекта.

Вручную конструкторы вызывать не стоит. Они существуют для инициализации объектов при создании - в случае класса Player для инициализации его переменных playerColor и orderOfPlayers.


Так у вас при нажатии кнопки Старт создаются оба игрока, т.е. для каждого из них будет выполнен конструктор, а значит два раза на экране появится ColorChooser с предложением поменять цвет. Вполне приемлимый вариант, только firstPlayerButton и secondPlayerButton в таком случае можно убрать.

Если вы желаете выбирать цвет для игроков перед началом игры, нужно:
1. При нажатии кнопок firstPlayerButton и secondPlayerButton показывать ColorChooser, запоминать выбранный цвет.
2. При нажатии кнопки Start создавать Игроков и передавать им (их конструкторам) цвета.
3. В конструкторе класса Player в таком случае ColorChooser показывать не нужно, просто записываем полученный цвет в playerColor.

что бы изменить код на кнопках мне пришлось дополнительно  декларировать в этом классе  две переменные  Код на кнопках теперь выглядит так 
Класс  Player совсем укоротился и выглядит так 


переменную private Color playerColor; пришлось прописать дважды в двух разных классах , иначе не компелировалось . А что будет если игрок сразу нажмёт кнопку старт ? У него не будет предустановленного цвета ? Может быть приравнять в начале класса private Color playerColor = Color.white ;
и на кнопке старт сделать проверку playerColor.Если он всё ещё white значит игроки отказываются выбирать цвет и мы им назначим цвет по умолчанию прямо здесь на кнопке старт ... сейчас  пытаюсь сообразить как построить класс Points  что-бы проверить каким цветом будет рисоваться .
Пока только сам процесс рисования скомпоновался. 

Там самый ужас что надо ставить точки только в углах решётки . Причем нужен небольшой зазор в координатах иначе человек должен будет " целится"
в определённый пиксель..
Решётка в двух классах выглядит так 

Это сообщение отредактировал(а) Qawra - 6.1.2009, 16:37

Извините что вопрос про решётку не выделила в отдельную тему   

Это сообщение отредактировал(а) Qawra - 6.1.2009, 16:43

Qawra, я переименую тему в "Разработка игры "Территория", обащайтесь на здоровье.

Да уж с темами кавардак...

Давайте что-ли сначала выбор цвета добьем.
Итак, мы желаем чтобы пользователь мог выбрать цвета игроков, до того как будут созданы сами игроки. Поскольку игроков еще нет, сохранить цвет в них мы не можем, стало быть нам понадобятся переменные для хранения цвета, и их нужно будет две, потому что игроков двое и каждый из них должен иметь свой цвет. Одной переменной playerColor тут не обойтись.


Да. Сам по себе он не появится. 


Вначале - это в конструкторе. И, если у нас будет две переменные, можно будет в каждую из них положить свой цвет - например красный и синий. Потом, когда создаем игроков, передаем каждому его цвет. И ничего уже проверять не нужно будет - независимо от того, станет пользователь менять цвет или нет, игроки все равно будут разноцветные.

Дополнительно, хотя и не обязательно:
1. Вставьте проверку на null в метод ShowChooser():

Вместо того чтобы всякий раз проверять что там нам вернулось, так можно быть уверенным что вернется то что нужно.
Сам метод стоит переименовать, чтобы название соответствовало тому, что он делает с точки зрения программы - например ChangeColor или что-то в таком духе.

2. private  ColorChooser cchooser = new ColorChooser ();
Не нужно делать ColorChooser членом класса. Он не хранит внутри никаких данных, которые были бы нужны классу, и его можно создать когда он понадобится, например в методе где обрабатываются кнопки, а после использования выкинуть и забыть.

Так, что еще...


Тут зависит от того, как будет игра построена, но хранить orderOfPlayers внутри класса Игрок скорее всего не понадобится. Как раз должен быть вышестоящий класс, заведующий порядком ходов. В любом случае у нас уже есть переменные first и second, ясно что first это first, а second соответственно second.

Теперь решетка.
Ну, помимо размера тут нам понадобится еще знать размер клетки. Вместо того чтобы самим считать и указывать размер Grids, мы дадим ему количество клеток по горизонтали и вертикали, плюс размер клетки. Тогда размер канваса можно будет посчитать:
width = rows*cellSize; и height = cols*cellSize;
Переменные width и height удобно сделать членами класса GridsCanvas и вычислять их значения в конструкторе. После вычисления размеров конструктор GridsCanvas должен сам вызывать SetSize(). 

Чем больше автоматики, тем меньше ручной работы. Так GridCanvas сам посчитает, сколько нужно места для отображения всех точек, у нас просто нет возможности сделать его слишком большим или слишком маленьким. Кроме того, у вас вычисляются rowHt и rowWid, вместо них можно использовать cellSize (эту переменную, кстати, тоже надо вписать в члены класса).

Касательно явы - возможно придется в GridCanvas переделать метод getPreferredSize() для того чтобы pack() сработал правильно. Еще хорошо бы вокруг канваса оставить пустое пространство, иначе крайние точки окажутся на самом краю окна и тыкать в них будет неудобно.

Еще момент, который кажется остался не понятым - мы не работаем с клетками, мы работаем с точками. Клетки чертятся по точкам, а не точки в углах клеток. Вообще сетку мы рисуем для красоты, работать все будет и без нее.

Дальше - т.к. каждый объект должен заниматься своим делом, расположение точек на канвасе мы оставим канвасу, а рисование точек - точкам. Поэтому класс Точка не будет знать свои координаты на канвасе. Вместо этого Точка будет рисовать всегда в координате [0, 0]

но!
Перед тем как просить точку нарисоваться, канвас будет вызывать Graphics.translate():

так что когда точка станет рисовать Oval, координаты [0, 0] будут именно там, где должна отобразиться точка.
В принцип работы translate() можно не вникать. Главное это после отрисовки точки вернуть все как было:

иначе [0, 0] будет сдвигаться все дальше и дальше по мере рисования точек и улетит совсем. Не говоря уже о том, что точки будут появляться совсем не там где нам нужно.

Все вместе:
Если в классе Точка есть

тогда в GridsCanvas.paint() пишем так:


Как считать координаты точки, зависит от того, как мы их храним. Я делал двумерный массив Точек размером [rows][cols], в цикле рисования поля у меня были переменные x и y, соответсвенно координаты точки [x][y] = [x*cellSize, y*cellSize].
Точки создаются все сразу, при создании игрового поля, и существуют уже до того как игроки их поставят. Вобще игроки у нас не ставят точки, они их просто помечают как свои... Точка, если она не помечена, либо не рисуется совсем, либо рисуется с меньшим радиусом, либо как-нибудь так рисуется чтобы ее можно было отличить от помеченной - ну это потом можно будет метод paint() точки дорабатывать по мере надобности.

По порядку  и старательно :
1.  рисуем две независимые переменные хранящие предустановленный цвет игроков.
на кнопках теперь будет 
 а вот с Color Chooser теперь непонятно..Что передавать в качестве аргумента если переменные хранящие цвет теперь имеют разные названия ?
 получается нам нужна ещё одна переменная хранящая цвет или мы можем прописать метод дважды ChangeColor1 и ChangeColor2 ? 

2 . без строчки private  ColorChooser cchooser = new ColorChooser (); не компелируется ( не может найти cchooser )

3.  В конструкторе Player опять проблема с именем переменной хранящей цвет .
 делать второй конструктор как то неудобно .Значит надо подумать о переменной хранящей цвет ..Не избежать её !

 с решёткой .....я рассматриваю свой GridsCanvas и его конструктор 
 получается что метод public void paint(Graphics g) надо вызвать внутри конструктора . Там же вызвать метод SetSize(). Его видимо надо найти в sun tutorials .
О методе  getPreferredSize() я не знала я просто хотела наложить решётку на новую JFrame . Надеюсь то тогда целиться в точки будет удобнее .

Начиная с фразы "Клетки чертятся по точкам, а не точки в углах клеток. Вообще сетку мы рисуем для красоты, работать все будет и без нее."
я впала в процесс осмысления который видимо затянется до утра ...
Завтра я постараюсь нарисовать что я поняла  

Ну, вернемся к основам...
cchooser.ChangeColor(firstDefaultColor);
Когда мы вызываем метод, мы передаем ему аргументы. В данном случае у нас вписана переменная firstDefaultColor, в которой хранится Color.blue. Фишка в том, что мы не передаем саму переменную, мы не можем никак передать переменную - мы передаем значение которое хранится в переменной. Т.е. ChangeColor(firstDefaultColor) это то же самое что ChangeColor(СинийЦвет).

Внутри метода мы принимаем параметр
public Color ChangeColor(Color ?"?"?) {
не важно как он называется здесь, Ява просто засунет в эту переменную значение, которое мы передали(СинийЦвет). И Ява не запутается что куда класть, потому что метод принимает цвет, и мы передаем цвет, и там это первый параметр(и единственный), и тут первый параметр... Короче, компилятор ориентируется по типу и порядку аргументов, а не по их имени. Для самого метода этот параметр вообще выглядит как переменная, в которой как-то сам собой оказался синий цвет.
Программисту в отличии от компилятора проще ориентироваться по имени. Удобно называть параметр defaultColor, потому что это и есть по сути цвет по умолчанию, хотя вы можете выбрать название на свой вкус.



А попробуйте сами его найти  
Его надо создать. Кажется, я писал об этом. Всякий объект перед тем как его можно будет использовать, должен быть создан. Но не нужно вписывать его как член класса, а нужно его прямо там создать где он используется, в методе где обрабатываются нажатия кнопок. Потому что он используется только там, потому что не хранит никакой нужной нам информации; нет никакой причины делать его членом класса. Вы же не выписываете все используемые в классе переменные в члены класса.


А вот и нет. Тут то же что и с ChangeColor() - имя менять не нужно. Будет работать как есть.

Все. Когда с выбором цвета будет покончено, тогда перейдем к игровому полю.

Я решилась оставить только две переменные хранящие цвет 


На кнопках результат такого сокращения выглядит как то странно  , но с точки компайлера возможно это вполне разумно 
 то есть цвет либо останется либо измениться но он всё равно будет ..
При выборе цвета у меня получилось 
 не знаю как это будет работать . Идея была оставить игроку одно название цвета независимо от того сам он его выбрал или цвет был задан  по умолчанию.  Смущают правда  два идентичных return ... 
Конструктор для игрока предполагает  дополнительную переменную playerColor
 Что мы с ней потом  будем делать ? 

Работать это будет очень интересно:


Нам же нужно, чтобы возвращался:
1. цвет выбранный пользователем, если он его выбрал; 
2. а если не выбрал - то цвет по умолчанию (нам обязательно нужно вернуть обратно какой-то цвет, ради этого и существует метод; если пользователь не хочет выбирать цвет, нам придется вернуть цвет по умолчанию - потому что другого у нас просто нет).
Записываем это дело по-русски:


дальше переводим:


а теперь просто записываем то же самое на Яве:

============================================

Не надо так париться с именами. 
Когда мы возвращаем значение, мы возвращаем значение, т.е. то, что лежит внутри переменной. Мы пишем имя переменной, чтобы Ява знала, из какой переменной взять значение. Сама переменная не передается и не возвращается.


Или вот еще пример:

А ведь внутри метода showDialog тоже есть строчка
return ...;
И мы даже не знаем, какое там имя используется. Нам и не нужно этого знать. Достаточно того что мы знаем какого типа значение возвращает метод - так мы можем создать подходящую переменную чтобы в нее положить значение:



Вобщем смысл всего этого:
1. Когда пишете какой-нибудь метод, позаботьтесь о том чтобы он делал то, что от него требуется. Определите, какая информация ему потребуется для работы - это и будут входные параметры. Как вы их назовете не важно, главное чтобы вы сами не путались в них.
2. Когда вызываете метод, передавайте значения, которые требуются ему для работы. Не важно как называются переменные, в которых эти значения лежат.
3. Если вы хотите чтобы метод возвращал вам что-то, нужна переменная соответствующего типа. С любым именем.
4. Перепишите метод ChangeColor(). Переименуйте параметр конструктора класса Игрок из firstDefautColor в color; конструктор будет работать и так, но у препода могут возникнуть вопросы.

Спасибо за такой подробный перевод с Java на русский .
 В рамках нашего курса , программированию посвящено  только два часа в неделю поэтому многие вещи просто  не досказаны. Например, нам говорили то что компайлер различает конструкторы только по типу аргументов , но примеры всегда были с одинаковыми названиями этих самых аргументов в конструкторе  и  как членов класса ... 
Теперь у меня получилось  так : 
  и  

Для того что бы начать рисовать точки нам нужно их предварительно создать и сохранить ещё до начала игры.  Это правда что хранить их лучше в Vector  а не в Array ? О векторах мы знаем только то что это dynamic array (мы проходили это в топике data structures). Теоретически ,  если  точки это обьекты то когда они созданы память под них уже выделена . Количество их во время игры тоже не измениться ... Какой выигрыш от использования векторов ? Мы ещё ни разу не обращались к ним на программировании . 

Можно написать с использованием векторов, но реальной причины для этого я не вижу. Вектора понадобятся нам позже, а точки поля мы будем хранить в двумерном массиве.
Массив этот должен быть членом класса Поле (или GridCanvas? или полем у вас будет другой класс?). Пара слов об инициализации массива:
если массив мы определим так

то у нас ничего не получится, потому что, во-первых, эта строчка выполнится до конструктора класса Поле, а значит в переменных rows и cols будут еще лежать нули(получится points[0][0], массив нулевого размера). Во-вторых, никаких Точек эта строчка не создает, независимо от размеров, а создает она массив. Мы определили массив, мы его и получили, и ничего больше.

Поэтому мы напишем так:

и в конструкторе класса Поле:


Вот так мы создаем массив точек. Этот кусок кстати разумно выложить из конструктора в отдельный метод, потому что каждый раз начиная новую игру мы будем (пере)создавать массив.
===================================================

Когда точки созданы, можно попробовать их отрисовать. Так как DrawablePoint у нас extends Component, то по идее можно добавлять точки к GridsCanvas(метод add()) и они будут автоматически перерисовываться при перерисовке самого поля(т.е. автоматически будет вызываться метод paint() точек). Вот этого я делать не пробовал, вобще это больше по яве - а значит не совсем ко мне. У меня метод paint после нескольких попыток стал вызываться, но точек все равно не видно   

Ладно.
Раз уж мы используем SWING для GUI, давайте обойдемся без класса Component (он из AWT). Поле наше будет extends JPanel, точка вообще ничего не extends.
У поля должен быть метод void paintComponent(Graphics g); в нем нужно разместить код рисования сетки + в цикле для каждой Точки из массива вызывать метод paint(g). Разумеется в классе Точка нужно написать метод paint(Graphics g).
Дальше возможны два варианта - 
1. Если в классе Точка хранятся ее координаты, в методе Точка.paint() можно просто рисовать овал на этих координатах.
2. Если в классе Точка нет координат - тогда использовать метод translate() как я писал раньше.

Работать с полем я хотела в отдельном классе потому что иначе я запутаюсь 
Назовём его BattleField .
  были уже инициализированы в GridCanvas
 и использовались в Grids
 Поэтому я надеюсь  мы можем их просто использовать в новом классе 

 Я правильно поняла что параметрами для заранее созданной точки могут быть только координаты ? У неё ведь ещё  нет владельца . Да и рисовать её нам пока не надо . Я краем уха в лаборатории  слышала  
что когда рисуется решётка и точки  - результат зависит от  порядка  действий . Решётка может  зарисовывать точки . А что ещё  мы будем делать в конструкторе поля ?

Добавлено @ 23:39
класс Точка в наброске пока выглядит так 
 
пришлось снова прописать public Color color ;  потому что со словом this. иначе не компелируется

Это сообщение отредактировал(а) Qawra - 9.1.2009, 23:45

Переделайте
1:


2:


3:


Имеет смысл все-таки объединить классы GridsCanvas и BattleField. Два класса там во всяком случае не нужны.
Чтобы вы не путались, попробую обрисовать как это все должно выглядеть:
GridsCanvas(или BattleField) будет создавать, хранить точки и рисовать их на экран
Grids будет окном игры; окно нужно чтобы GridsCanvas можно было отобразить на экране

В классе Grids в качестве члена класса вписываем GridsCanvas. В конструкторе Grids, когда известны размеры поля, создаем(инициализируем, передаем размеры) GridsCanvas.
В классе GridsCanvas в члены класса вписываем массив points[][], в конструкторе инициализируем этот массив, точно так, как это сейчас сделано в BattleField.
Теперь чтобы создать поле в окне со всеми точками достаточно создать Grids с правильными параметрами; когда создается Grids, будет создан и GridsCanvas, а он в свою очередь создаст точки.
Касательно параметров конструктора Grids:

title - не нужен; заголовок каждый раз будет тот же(или нет?), можно вписать в конструктор:

w, h - не нужны; размер окна должен вычисляться в зависимости от размера поля
rows, cols - это все что нам нужно

=======================
Когда Ява решит отобразить окно, она вызовет метод GridsCanvas.paintComponent(); этот метод должен рисовать игровое поле. Пока он рисует только сетку, но должен еще и рисовать все точки на поле. Чтобы точки могли рисоваться, во-первых у них должен быть метод paint(Graphics g), во-вторых этот метод должен рисовать точку(при помощи drawOval() скорее всего), и наконец нужно чтобы при рисовании поля вызывался этот метод у каждой точки. Т.е. в GridsCanvas.paintComponent() нужно добавить цикл, в котором для каждой точки вызывается paint(g).


Да. Но если уж вы передаете координаты "points[x][y] = new DrawablePoint(x, y);", то конструктор точки должен принимать координаты - "DrawablePoint(int xcoord, int ycoord)" - и сохранять их внутри класса.

Кстати, мы работать теперь будем с двумя разными координатными системами - у нас есть координаты точки на поле, и координаты точки на экране. Координаты на поле [3][2] означают точку в третьем столбце и второй строчке. Координаты на экране будут другими, потому что нам нужно расстояние между точками. Расстояние между точками это размер клетки, cellSize; тогда экранные координаты точки:
xscreen = xfield * cellSize;
yscreen = yfield * cellSize;

Можно в GridsCanvas добавить private-метод для перевода координат на поле в экранные:

Использовать его можно например так:


============================
Тока сейчас заметил - у вас опять написаны параметры вместе с типом!

============================
По возможности вносите изменения небольшими кусками и компилируйте код - Ява покажет где у вас ошибки.
В помощь - поправленный класс Grids:


Это сообщение отредактировал(а) Rpahut - 10.1.2009, 22:46

Когда я поменяла в class GridsCanvas extends Canvas на extends  JPanel решётка перестала выходить нормально. Появляется  окошко очень узкое и нерастягивающееся. Так что Canvas я пока оставила .Природа его не известна но на решётку он действует положительно .
Пытаюсь изменить свой класс Grid но пока от этого становиться только хуже. Окошко выходит но решётки на нём нет .
w, h  я пока хочу оставить потому окошко будет иметь постоянные размеры. У нас в школе разрешение мониторов  компьютером 800/600 и  я не  буду вводить функцию изменения размеров поля . Оно и так занимает весь экран .
Параметры у меня действительно написаны вместе с типом потому что иначе не комперировалось 
в строчке private void   drawCircle (  x,   y,  radius, Graphics g) компайлер требует идентифаер ..

Ну нерастягивающееся оно потому что в коде так написано.
А что касается размера, то когда вы в Grids вызываете pack(), Ява спрашивает у GridsCanvas через метод getPreferredSize(), какой бы ей хотелось иметь размер. Чтобы Ява знала, какой нам нужен размер, сначала надо вызвать setPreferredSize() с указанным размером.
Так же нужно вызвать setVisible(true) в конструкторе GridsCanvas, потому как по умолчанию элементы спрятаны и отображаться не будут.


Пока GridsCanvas не будет правильно оформлен, окно будет пустым или очень маленьким, это нормально; главное чтобы оно отображалось на экране и нормально закрывалось при нажатии [Х]. Это будет озачать что Grids работает.


Если размер постоянный, то передавать его через параметры совсем уж не нужно. Можно просто вписать его в класс. То же самое касается количества точек - если настройки не будет, все можно вписывать внутрь класса Grids. 


Вот такое у меня хоть убейте не компилируется:

В заголовке метода типы должны указываться. Без них никак. Я уже писал о том что типы нужны компилятору.
Я имел ввиду кусок, в котором инициализируется массив точек:

Разве BlueJ не ругается на эту строчку?
======================================

ОК, давайте по порядку.
Класс Grids
Можно скопировать код который я выкладывал. Если конструктор Grids не принимает параметров-размеров, скобки у него оставляем пустыми, но добавляем в него переменные:

Тут у нас гадкая неопределенность - мы можем либо задать размер окна, размер клетки и вычислить сколько точек поместится в окне; либо мы можем задать опять размер окна, желаемое количество клеток, и из них посчитать размер клетки. Второй вариант мне не нравится, потому как размер клетки все-таки важнее количества точек, от него зависит насколько удобно будет тыкать в точки и как они будут выглядеть. Поэтому я прикинул и вписал клетку размером 15 пикселей и поле размером 35х35 клеток, потом если что эти цифры можно будет поменять.
Что еще нужно обязательно сделать в конструкторе - это создать GridsCanvas, передать ему размеры поля и клетки, добавить его...; все это есть в коде. 


Класс GridsCanvas
Обязательно extends JPanel, иначе работать не будет.
int rows, cols и cellSize делаем членами класса, мы будем часто пользоваться ими. В конструкторе помещаем в эти переменные конкретные значения, которые конструктор принимает как параметры.
Обязательно вызываем в конструкторе setVisible(true) и setPreferredSize(new Dimension(panelWidth, panelHeight)), иначе панель либо не будет отображаться совсем, либо будет слишком маленькой. Вместо panelWidth и panelHeight естественно нужно указать размер панели достаточный чтобы вместить все точки:
panelWidth = cols*cellSize;
panelHeight = rows*cellSize;

Еще один метод, необходимый в GridsCanvas - это


Класс DrawablePoint



Еще нужно добавить метод

Когда все это заработает, в метод GridsCanvas.paintComponent() можно будет добавить цикл, перебирающий все точки и вызывающий для каждой ее метод paint() - так наши точки будут рисоваться на экран.

Эту строчку я не могу найти   

Судя по всему я её успела отредактировать как

Класс Grids я скомпелировала так 


Где-то закралась ошибка потому что окошко выходит без решётки и не по центру экрана . Закрывается нормально но есть Terminal window с текстом

На кнопке старт я изменила вызов конструктора с  new Grids("Points", 800, 800, 20, 20).setVisible(true);    на new Grids( );

DrawablePoints выглядят теперь так 
И остался ещё класс BattleField который нам не нужен но там прописан метод
 который теперь надо вызывать прописать в GridCanvas/

Эта плоха. Быть она должна.

Вот после этой строчки у вас был там цикл инициализации массива в котором я видел ошибку... Если вы ее уже поправили - тогда ладно.


Одно замечание:
canvas.setSize(rows*sellSize , cols*sellSize);
можно убрать. Для JPanel размер устанавливается через setPreferredSize(), и делать это нужно в конструкторе GridsCanvas.


Видимо ему не нравится extends класса GridsCanvas. Пока там не будет extends JPanel ошибка так и останется.


Норм. 

Метод makePoints() нужно перенести из BattleField в GridsCanvas. Класс BattleField можно после этого убрать совсем.

Нашла ! Эта строчка была в классе BattleField который мы уже не используем .Там мы инициализировали массив точек в методе  makePoints
 Теперь мы  уже не можем это делать потому что класс DrawablePoint  в настоящий момент не содержит такого конструктора . Там теперь конструктор 
 

нужно видимо ввести  соординаты x,y как аргументы  , либо  сделать два разных конструктора DrawablePoint  . Один только с цветом а второй только с координатами .

class GridsCanvas extends JFrame  было ещё вчера .. Сегодня ошибка повторилась . 
"adding a window to a container" может означать что мы добавляем add(canvas); неправильно с точки зрения компайлера ..?

extends JPanel. JFrame - это окно, нельзя добавить окно в окно.

Конструктор точки пусть остается как есть. Цикл инициализации массива нужно модифицировать - передавать точке вместо координат цвет. Кроме того x и y мы будем передавать точке во время отрисовки.

C extends JPanel всё получилось замечательно.Сообщение о ошибке изчезло и решётка вышла нормально . 

Ну вот, дальше собственно берем цикл

и вставляем его в GridsCanvas в метод paintComponent(). Точки должны рисоваться цветом, который вы передаете им при создании.
И не удивляйтесь если точки окажутся неправильно расположены на сетке.

Я изменила цикл инициализации массива   и вызвала paint() для каждой точки 
 на строчке  компайлер не может найти переменную cellSize которая является public членом того же класса. ..
 

Это сообщение отредактировал(а) Qawra - 13.1.2009, 18:34

Qawra, 
[


опечатка. должно быть cellSize

Угу.
И переменные rowHt и rowWid в методе paintComponent() это тот же cellSize, так что от них можно избавиться.

В остальных местах где эти переменные используются меняем их на cellSize.

Кстати, переменные-члены класса у нас везде должны быть private, потому что пользуется ими только сам класс. Да и вообще разумно спрятать переменные класса от остальной программы.

Если отключить  то надо как-то модифицировать  paintComponent потому что
без них ничего нарисовать в данный момент нельзя.
  

и дальше в том же духе

скомпелировалось так  без rows и cols в аргументах drawLine не компелировалось поэтому я их там прописала. Как вы и предупреждали  рисует косые линии  там где предполагается решётка. Есть сообщение о NullPointerException в 34 строкe:
 Array у нас инициализирован как private  член класса  

Вот этого я не ожидал   


А почему именно их?

Давайте разберемся:
Лини рисуются при помощи drawLine() + Линии рисуются неправильно = Неправильно используется метод drawLine()

drawLine() принимает четыре аргумента:
drawLine(x1, y1, x2, y2)
x1 и y1 это координаты начала линии, x2 и y2 - координаты ее конца. Нам, чтобы начертить сетку, нужно нарисовать вертикальные и горизонтальные линии на поле

У горизонтальных линий y1 и y2 должны быть одинаковые, иначе они не будут горизонтальными. Вообще любая точка на горизонтальной прямой имеет ту же координату Y. У вертикальных линий должны быть одинаковые x1 и x2.
Дальше - первую горизонтальную линию нам надо начертить в самом верху поля, все остальные - ниже предыдущей на cellSize. Т.е. координата Y кратна cellSize и равна cellSize*номерСтроки; у нас в цикле уже есть переменная i которая считает строки и содержит номер текущей строки. Записываем:

Теперь x1 и x2. Каждая линия должна идти от одного края поля до другого, для этого один икс должен быть равен нулю(у левого края поля x=0), а другой равен ширине поля (т.е. cols*cellSize); вписываем иксы:


Аналогично для вертикальных линий:
X начала и конца каждой линии одинаковый.
X кратен cellSize и равен cellSize*номерСтолбца (вместо номера столбца опять используем переменную i).
Y начала линии - ноль.
Y конца линии - расстояние от верха до низа поля = высота поля = количествоСтрок*cellSize

===========================

В этой строке:

такое исключение может возникнуть, только если points[x][y] не содержит точки.
Скорее всего что-то случилось с циклом инициализации массива points.
Вообще с этим массивом мы много чего делаем, напомню самые важные моменты:

Когда мы создаем массив, в его ячейки раскладывается значение null. Если не инициализировать массив, null так там и останется. Если после этого попытаться что-то сделать с элементом в массиве, например

возникает NullPointerException.

Когда инициализация у вас будет работать как надо, на экране сразу появятся точки.

Зашла в интернет утром перед школой и убегаю ..В школе попробую переделать . У меня часовой пояс на два часа раньше чем московкий .Поэтому я иногда не успеваю 

Решётка теперь рисуется нормально.
Цикл инициализации массива points ...
Мне кажется чего - то нехватает в классе  DrawablePoint ..
Но начнём по порядку :
В классе GridsCanvas если мы инициализируем как член класса 
 а затем указываем его размер  компайлер на этой строчке требует идентифайер . Если сделать всё в одну строчку  то это компелируется и мы переходим к созданию и раскладыванию точек по ячейкам .У нас есть для этого  метод makePoints но конструктору к которому он нас отсылает  нужен аргумент color.
Если мы передадим цвет при создании точек (не знаю правда какой реально  это цвет с точки зрения компайлера ..наверно firstPlayerColor..) то сообщение об ошибке изчезает 

    

Осталась нарисовать точки...Для этого нам нужны аргументы. В классе  DrawablePoint у нас прописано почему- то даже два метода
 
когда я пытаюсь нарисовать точки как  класс компелируется но при запуске программы выходит NullPointerException на этой строчке. Я думаю  нам надо переделать метод для рисования . Может быть проблема в Graphics g ..

Эту строчку можно было хотя бы скопировать у меня. Зачем там квадратные скобки (points [][]...  )?? Мы просто должны указать имя переменной, в которую хотим положить new DrawablePoint[cols][rows]:

У BlueJ конечно кривые сообщения об ошибках, но если он ругается на эту строчку, значит ошибку стоит искать именно в ней. Зачем исправлять объявление массива, к которому у Явы нет никаких претензий?


...то массив будет нулевого размера, потому что эта строка выполняется до конструктора класса, и в переменных cols и rows еще лежат нули. Дальше вы еще пытаетесь с этим массивом что-то делать - отсюда и все ошибки.
Так делать не надо!


Метод drawCircle() вы добавили сами ;). Пусть он пока остается, только сделайте его private. Для отрисовки точки используйте ее метод paint().


Читайте все что я пишу внимательнее. Мы по несколько раз на одни и те же грабли наступаем.

Я поняла ..у меня даже точки прорисовались ...правда они пока выглядят пустыми кружками .Надо наверно одновременно с рисованием вызывать метод закрашивающий кружки . Цвет у них по умолчанию чёрный.
 сначала они прорисовались на самом краю решётки , там где координаты x=0 и y=0 . Но потом я для симметрии приравняла начальные x и y к 1 и точки встали симметрично , не касаясь краёв решётки .  Можно наверно даже так оставить ( не накладывать решётку на новую JFrame ).

Попыталась я закрасить кружочки добавив строчку  скомпелировалось , но видимого результата от неё нет  .
пытаюсь добавить MouseListener к решётке 
 компайлер не может найти метод setLocation ..Туманно пока представляю что ему надо в этом случае импортировать  или  имплементировать . Всё что можно было представить я уже импортировала  
 почему-то он не видит public void mouseClicked который прописан в кострукторе . Поэтому мне пришлось прописать public void mouseClicked ещё раз  в конце класса  .

 

Это сообщение отредактировал(а) Qawra - 17.1.2009, 00:24

Это замечательно!  Можно двигаться дальше.

Рекомендации по движению дальше:
1. Сначала прочитайте, не вникая сильно, что я тут понаписал, постарайтесь уловить суть идеи.
2. Начните читать с начала, подробнее разбирая каждый пункт. Вносите изменения в код по мере продвижения.
3. Добавляйте в свой код комментарии, особенно касательно новых для вас вещей - так лучше усваивается.
4. Спрашивайте, если что непонятно.

______________________________________
Так, мы убедились что GridsCanvas и точки рисуются, так что пока отложим доработки (мы еще доработаем рисование сетки и точки). Есть более важная весчь - это обработка мыши, чтобы можно было щелкать по точкам.
Для того чтобы ловить события мыши, мы добавим implements MouseListener в класс Grids, и в него же впишем метод:


Пояснение:
implements MouseListener значит что класс, к которому это приписано, желает получать сообщения о том, что происходит с мышью.
Ява будет передавать классу сообщения о мыши, но чтобы их получать, в классе должны иметься определенные методы:
public void mouseEntered(MouseEvent e) // вызывается, когда мышка входит в пределы действия компонента
public void mouseExited(MouseEvent e) // наоборот
public void mouseDragged(MouseEvent e) // кнопка нажата и мышка двигается
public void mouseClicked(MouseEvent e) // пользователь щелкнул кнопкой мыши
Все эти методы должны присутствовать в классе Grids, иначе Ява не станет с ним работать; но нас интересует только где пользователь щелкнет кнопкой, поэтому мы впишем код только в mouseClicked(), а остальные методы оставим пустыми.

Еще нужно указать, какой именно компонент нас интересует. Для этого в конструктор Grids вставляем:


Теперь с другой стороны - когда щелкается кнопка мыши, это значит что игрок пытается сделать ход. Поскольку игроков у нас двое, нужно знать не только координаты где произошел щелчок, но и чей (какого из игроков) сейчас ход.
Поэтому добавляем в Grids переменную

а в конструкторе Grids присваиваем ей значение:

Теперь чтобы узнать чей ход можно написать

По ходу игры значение этой переменной будет меняться, и соответственно будут "переключаться" игроки - один ходит, второй отдыхает.

--------------------
Теперь мы можем узнать где и какой игрок щелкнул мышкой. Дальше, допустим, мы хотим чтобы точка, в которую щелкнули, красилась цветом игрока, который щелкнул (это займет много текста).
Точками управляет класс GridsCanvas (массив points находится в нем, значит он за них и отвечает), поэтому информацию о щелчке нужно сначала передать ему. Для этого можно добавить в GridsCanvas метод, принимающий соответствующие параметры, например такой:

Класс GridsCanvas уже может рассчитать в какую точку попал щелчок(если вообще попал) и передать цвет этой точке. Но, опять, чтобы точка могла принять цвет, у нее должен быть метод по типу такого:

Как рассчитать, в какую Точку попадают координаты щелчка:
если чтобы определить экранные координаты точки, мы умножали ее координаты-на-поле на cellSize
то здесь нам нужно наоборот, определить координаты-на-поле, поэтому делим экранные координаты на cellSize

--------------отступление--------------------
Настоятельно рекомендую поместить код преобразования координат экран->поле и поле->экран в отдельные методы класса GridsCanvas:


Это важно, потому что дальше код преобразования координат у нас поменяется немного, может быть несколько раз, и вам придется либо везде менять x*cellSize на новую формулу, либо можно будет просто подправить метод field2screen().
--------------------------------------------------

Так...
Метод DrawablePoint.setNewColor() я выше описал, теперь GridsCanvas.mouseWasClicked().

Довольно просто.
Можете потом пощелкать в окне в стороне от сетки и посмотреть что получится =)

Теперь метод mouseClicked(), с которого все и началось.

Тут, как видно, нам еще нехватает метода Player.getColor(), который возвращал бы цвет игрока, но его я думаю вы напишете без подсказок.

--------------------------------------------
И все вместе с высоты птичьего полета:
1. Пользователь щелкает в окне
2. Ява вызывает Canvas.mouseClicked()
3. mouseClicked() передает информацию в GridsCanvas.mouseWasClicked()
4. mouseWasClicked() устанавливает новый цвет точки

PS Да чуть не забыл - в DrawablePoint.paint() нужно вставить строчку g.setColor(color); чтобы кружок рисовался цветом точки!!!

Это сообщение отредактировал(а) Rpahut - 17.1.2009, 00:38

в Grids пришлось прописать как членов класса  две переменные Player first  и Player second  
которые  создаются при нажатии на кнопки в стартовом окошке
 

Я создала метод setNewColor в классе DrawablePoint .
Но " пощелкать в окне в стороне от сетки " мне не удалось .У меня там   пока только решётка и ничего больше нет  
Класс Player скомпелировался 
 В методе getColor я передаю аргумент currentPlayer что-бы вернуть цвет игрока .Тут возникает проблема с Grids. mouseClicked который собственно и использует этот метод. canvas.mouseWasClicked(screenX, screenY, currentPlayer.getColor(currentPlayer )) ; компелируется но вызывает ошибку NullPointerException  когда я щёлкаю мышкой по решётке  . В классе Grids 


Сначала я поместила  но теперь думаю они должны быть частью отдельного метода .Поэтому я их из конструктора убрала и не знаю что с ними делать .




Это сообщение отредактировал(а) Qawra - 17.1.2009, 16:16

Блин какая путаница с классами.
Я как-то позабыл, что игроки у нас создаются в стартовом окне.
Ну ничего, это можно поправить - вы правильно прописали игроков, осталось только убрать эти переменные из стартового окна. А то так у нас четверо игроков - двое прописаны там и двое тут.
Еще нужно немного исправить программу. Привожу код:


Когда это добавите, ошибка nullPointerException должна пропасть.

________________________________

Ну, Player.getColor() на самом деле гораздо проще:

Смысл именно в том чтобы получить от игрока его цвет.
first.getColor() - возвращает цвет первого игрока
second.getColor() - возвращает цвет второго игрока
currentPlayer.getColor() - возвращает цвет того игрока, который сейчас ходит

_______________________________

=) Эти строки используются в Grids.mouseClicked(), немного в другом виде правда. Отдельно я их писал в качестве примера.