Top.Mail.Ru

[Руководство по Java для L2J] Шаг 3.3: Взаимодействие игровых объектов

[Скопировать ссылку]
Astraliya Опубликовано 2024-10-16 17:54:29 | Показать все сообщения |Режим чтения Распечатать Назад Вперед

Зарегистрируйтесь сейчас чтобы найти еще больше друзей, и получить полноценный доступ ко всем функциям сайта!

Для просмотра Вам необходимо авторизоваться Если Вы еще не зарегистрированы, перейдите по ссылке:Зарегистрироваться

x
Добро пожаловать в обсуждение статьи "Шаг 3.3: Взаимодействие игровых объектов"!
" B4 Y3 w, M1 [& a' h
% F1 f; P( s+ c, K5 H4 J4 J
; F' B9 r* `% |% t6 v
Здесь вы можете задавать любые вопросы, связанные с реализацией взаимодействий между игровыми объектами, такими как игроки, NPC и монстры, в серверной разработке Lineage 2 на Java. Обсудим, как создать динамическое взаимодействие в игровом мире, как правильно использовать события и триггеры, и как улучшить боевые и диалоговые системы.
) g3 }4 r* s( V2 pЗадавайте вопросы, делитесь опытом, предложениями и идеями — ваше участие поможет углубить наши знания и сделать разработку серверов еще более интересной!) c  N0 h0 n" K$ z9 i+ k7 d( \
Астралия ?. S: d( U& H6 y! h0 a5 s8 O9 y
. K0 [  q  j. y) q+ Y: l4 P( ?7 j

Сообщений в теме:5

AlexCoder Опубликовано 2024-10-16 18:31:29 | Показать все сообщения
День добрый!
% r3 ^/ e. v$ a- k! lВ статье описано взаимодействие игрока с NPC и монстрами через простые методы. Как лучше всего реализовать более сложные взаимодействия, например, если нужно добавить несколько фаз боя с разными состояниями монстра? Есть ли оптимальный способ управления состояниями объектов, чтобы не перегружать логику боевых сценариев?
; H* I. j: H' X" t' g3 v) p3 m2 Q4 R
; T4 ]2 d7 u/ e/ T
AlexCoder Опубликовано 2024-10-16 20:53:49 | Показать все сообщения
Последний раз это сообщение было отредактировано AlexCoder в 2024-10-16 20:54
: z, t& ]6 B) I2 `6 U& A
AlexCoder опубликовал в 2024-10-16 18:315 v! H. |2 u; N. `+ r
День добрый!
5 G0 E" [# m# E% s% X/ e6 o. D: uВ статье описано взаимодействие игрока с N ...
: k* j+ N7 h! s8 z( A
Для управления сложными взаимодействиями, такими как несколько фаз боя с разными состояниями монстра, лучший подход — использовать шаблон проектирования "Состояние" (State Pattern). $ O  b' W0 Q% {# c6 V

' {! O& e* ^5 Y% a6 o2 B# oЭтот шаблон позволяет разделить логику поведения объекта на разные состояния и управлять ими более гибко, избегая перегрузки основного класса монстра.$ l- q, Q# o' W0 W# q8 U
: T5 z# k# W( x* n6 o; M7 [
Шаг 1: Создание интерфейса для состояний монстраПервый шаг — создать интерфейс, который будет представлять разные состояния монстра. Этот интерфейс определяет метод, который будет вызываться в зависимости от текущего состояния.
/ U( C% e7 s# t
( q' K4 M  v! F& k& Q1 J
  1. <font color="Green">// Пакет для состояний монстра</font>
    ) H3 \( s! x9 H* O) H
  2. package org.l2jmobius.gameserver.model.actor.state;. `8 l5 y. i9 U! q1 ]
  3. <font color="Green">
      y: k  e/ u( O  l9 i# Q, l
  4. // Интерфейс, представляющий состояния монстра</font>" U! Y1 u; t4 @0 [" D5 q% v
  5. public interface MonsterState {# q( e) j) H. n2 Q
  6.     void handleState(Monster monster);8 z2 P9 D9 m) {" o" b
  7. }
    % W5 P$ R7 B0 g- I# a5 Q% o+ [: g( v
Скопировать код

9 a, B9 n8 s% V, I6 H  p! _Шаг 2: Реализация различных состоянийТеперь создадим классы для каждого состояния: например, InitialState, AggressiveState и FinalState. Эти состояния будут реализовывать интерфейс MonsterState и определять поведение монстра на разных этапах боя.. [4 i% z' w/ d; @
2 w: d* A  D5 k3 A, R( E
Класс для начального состояния монстра:$ y' P' ?% v5 n1 _. _3 j) e
  1. <font color="Green">// Пакет org.l2jmobius.gameserver.model.actor.state</font>
    & m& X$ b+ u" h  x, q1 s
  2. package org.l2jmobius.gameserver.model.actor.state;
    + q0 g+ A$ s; m8 [' s
  3. " z5 X5 Q5 |9 r5 f- Z) a
  4. import org.l2jmobius.gameserver.model.actor.Monster;1 T0 O0 ]' @8 J/ {3 g1 Y

  5. & n* ^% ~8 o" l( ]5 j& l
  6. public class InitialState implements MonsterState {' ~0 V) [( ]; Q; [
  7.     @Override
    8 U) [. T: n. ^( B9 D
  8.     public void handleState(Monster monster) {6 t! ?9 s  ^$ N. y" v6 u+ r) a
  9.         // Начальная фаза боя3 x8 C* G& L: b6 }
  10.         System.out.println(monster.getName() + " начинает бой с обычной атакой.");
    5 ^5 M: I+ M- |& ~5 W
  11.     }
    8 O* x2 ], ~: t
  12. }8 M  r! E& ~$ M3 L, U# i
Скопировать код

' j% ~. }& X7 j5 l7 m/ g. S3 g/ j
- m+ ]$ N. w8 V' I1 `, a' B/ E4 `. V. e5 p. }

- K+ M( V# R) w/ m6 m0 l- F) y' ]4 Z/ L4 \0 w5 r1 i* ]2 i

' R2 z% r" Z' h. L0 Z7 L. {  C/ A! Z2 ~$ y. x& C* P$ b
 Автор| Astraliya Опубликовано 2024-10-16 21:04:54 | Показать все сообщения
Для управления сложными взаимодействиями, такими как несколько фаз боя с разными состояниями монстра, лучший подход — использовать шаблон проектирования "Состояние" (State Pattern).
) ~) W$ ~' r: C/ s
. v3 K' v9 q9 W/ t9 U/ @% f* HЭтот шаблон позволяет разделить логику поведения объекта на разные состояния и управлять ими более гибко, избегая перегрузки основного класса монстра.
" P) W; f5 N# r6 A: T  x# |! v! c" [$ j5 E% t3 D1 s, C! K/ Z- o
Шаг 1: Создание интерфейса для состояний монстраПервый шаг — создать интерфейс, который будет представлять разные состояния монстра. Этот интерфейс определяет метод, который будет вызываться в зависимости от текущего состояния.: ~( A  J2 P/ M; [5 G5 ]  r

" L: \$ H1 q7 C4 L# {" Q5 C2 @
  1. // Пакет для состояний монстра
    : \; p2 K' r* V
  2. package org.l2jmobius.gameserver.model.actor.state;
    ( Q. A& {  \4 ^. a3 Z; X' Q

  3. 3 _0 v' u; @5 I8 P3 z
  4. // Интерфейс, представляющий состояния монстра
    ; L3 ^0 m6 N0 n  S
  5. public interface MonsterState {# ?: E3 {+ S  d8 Y1 z: i
  6.     void handleState(Monster monster);: `- ]  l- _4 n* s: @5 N% |5 H( Q" f
  7. }) L3 l8 z, W: a- @& U, J: I
Скопировать код
; n" T) }7 G9 d, q" i
Шаг 2: Реализация различных состоянийТеперь создадим классы для каждого состояния: например, InitialState, AggressiveState и FinalState.
/ h% b2 o( r/ x' S! L$ e
! Q0 W" O+ z& E+ d" ^3 @! \( ]6 EЭти состояния будут реализовывать интерфейс MonsterState и определять поведение монстра на разных этапах боя.
" P2 D" u  L( {9 b8 A" ]% w" }7 y, z: ^$ M
Класс для начального состояния монстра:: X8 W, i2 E2 x: R3 X0 L( R
  1. // Пакет org.l2jmobius.gameserver.model.actor.state8 I# K5 T% c, i* q! O
  2. package org.l2jmobius.gameserver.model.actor.state;4 }* E3 q! ^' [/ Q! ]
  3. 2 X, }5 T* `7 X7 W" v1 z
  4. import org.l2jmobius.gameserver.model.actor.Monster;
    - f+ Q  M! w  d% Z! G
  5. . |  K6 j# J6 _. R0 F
  6. public class InitialState implements MonsterState {4 ]8 @' |0 H8 d$ Q# J" O' ]. s
  7.     @Override
    ! b5 b) S: W0 p+ s  _) k, D( e. e
  8.     public void handleState(Monster monster) {- ^. {9 _% \" M- B4 F/ t: S/ z
  9.         // Начальная фаза боя
    % h- Q/ R. E8 T$ ~
  10.         System.out.println(monster.getName() + " начинает бой с обычной атакой.");! l1 r9 e# F$ x
  11.     }$ h* {9 e) j& O4 r* n9 p
  12. }
    1 E. n% d; b  D2 B' W/ j0 z
Скопировать код
Класс для агрессивного состояния монстра:$ N: @4 n8 a, R* t# O
  1. // Пакет org.l2jmobius.gameserver.model.actor.state
    2 ~( q6 `, z: L+ {* v4 f1 Y# X
  2. package org.l2jmobius.gameserver.model.actor.state;  }/ T" ^  G; o' P& t; ~' ]0 Z' p

  3. 7 |! m+ X% A+ ^7 W4 \
  4. import org.l2jmobius.gameserver.model.actor.Monster;
    5 S2 h) w2 {5 ]. C4 _
  5. ! G1 A5 z$ E6 j/ w" k& s
  6. public class AggressiveState implements MonsterState {
    5 v% Y2 b# ~6 F5 q  w
  7.     @Override4 Y$ V! d7 i$ b# R, }6 k0 c
  8.     public void handleState(Monster monster) {5 d5 j, }+ X) t: G" H% e
  9.         // Агрессивная фаза боя, e) V$ u& c. Z
  10.         System.out.println(monster.getName() + " становится агрессивным! Атаки усиливаются.");
    5 a* ~# O. Z1 D  j2 Z3 U% M4 p
  11.         monster.setAttackPower(monster.getAttackPower() * 1.5); // Увеличиваем силу атаки
      X& G, }7 x0 B0 T
  12.     }7 }- q/ A8 x7 K% q, U) [
  13. }- ]; x. L* {: X4 ~7 F
Скопировать код
Класс для финального состояния монстра:! A% b5 e5 P5 T8 A5 i$ Q  L. N
  1. // Пакет org.l2jmobius.gameserver.model.actor.state
    $ C6 j" I. i( L* h2 w7 R8 {. E
  2. package org.l2jmobius.gameserver.model.actor.state;/ m9 P8 V7 R8 q) \5 R
  3. 8 i; S5 R+ N. M/ ^$ T6 w+ a
  4. import org.l2jmobius.gameserver.model.actor.Monster;
    : l! ?: Y) x6 Z7 Y; o* |

  5. ) v- h; k! T" I& k" F- ~9 ]
  6. public class FinalState implements MonsterState {
    + j5 ]5 a9 c7 J: M. L) }* O3 z
  7.     @Override( C4 f! r( l3 V) ~& V
  8.     public void handleState(Monster monster) {
    2 S& X# G2 E$ t* w  }$ P
  9.         // Финальная фаза боя
    $ H, C9 W. m. B
  10.         System.out.println(monster.getName() + " готовится к финальной атаке!");" K+ n1 V) x& J
  11.         monster.setAttackPower(monster.getAttackPower() * 2); // Максимальная сила атаки
    3 J1 O2 k. |0 k- f# P& T
  12.     }
    - X$ y; [! Q3 P$ p8 H
  13. }
    8 ~! W; Q/ C7 P, e
Скопировать код
: g. F$ m: @6 M, [4 W! m
Шаг 3: Изменение класса MonsterЧтобы монстр мог переключаться между состояниями, нам нужно обновить класс Monster. В этой сборке L2J_Mobius, классы для игровых объектов, таких как монстры, находятся в пакете org.l2jmobius.gameserver.model.actor.
0 P9 W3 y- P0 L$ I! M% b  Q; A
  1. // Пакет org.l2jmobius.gameserver.model.actor
    + ?. a+ q# e7 @) R: H' p. y
  2. package org.l2jmobius.gameserver.model.actor;
      v7 ?4 r* H  d2 R- Y0 X5 d
  3. ! Q1 c2 S+ G& E* t
  4. import org.l2jmobius.gameserver.model.actor.state.MonsterState;$ u$ R  a- C+ X' N
  5. import org.l2jmobius.gameserver.model.actor.state.InitialState;# w2 |( s) O, E* p- R
  6. + X$ \5 g/ `$ ]
  7. public class Monster extends Creature {
    / B: l4 g9 X5 m0 B$ E
  8.     private String name;
    - {# U5 m% H% O. z* u0 w- Y
  9.     private double attackPower;5 \5 v4 r% o0 f) r! _
  10.     private MonsterState state; // Текущее состояние монстра
    , I$ r7 @9 y3 m+ @+ Y% i

  11. 7 A$ J; v% _& A1 h
  12.     // Конструктор монстра- n8 |6 p6 S7 G
  13.     public Monster(String name, double attackPower) {
    8 ~; |+ X* N" j
  14.         this.name = name;
    7 Z$ K; x$ Q! _. h) Q/ _
  15.         this.attackPower = attackPower;
    7 \- V: R  j9 `. G8 r
  16.         this.state = new InitialState(); // Устанавливаем начальное состояние" a3 A  l1 \# M, E. Y, c0 L% s
  17.     }
      _& e3 ^- Z' a; K  o

  18. ) [$ ?3 ^# V/ |: R; E8 y  {
  19.     // Метод для смены состояния  K+ P1 Z+ T; A" h
  20.     public void setState(MonsterState newState) {
    ! S4 H0 s9 w( a: [2 k+ r2 Y
  21.         this.state = newState;  h) y. S+ O+ o% {$ ~" g5 n& I
  22.     }+ x4 |2 d, }: E3 H1 l% q8 L
  23. # I- G" Y- p) x
  24.     // Выполнение действий на основе текущего состояния
    5 K; `, F* f( K& p8 |
  25.     public void executeState() {$ i( p% s- f4 L1 W
  26.         state.handleState(this);$ S; d* `! {6 ]) M4 C6 M3 r$ W
  27.     }
    : _( N0 C5 Y8 ]$ ^& j3 W
  28. : b/ Z6 g3 \7 o+ A! ]
  29.     // Геттеры и сеттеры
    + `/ j1 I5 G7 E9 ?3 d$ H% L
  30.     public String getName() {
    ! M+ V; O) p' f$ h; a. X5 v) z
  31.         return name;% W4 o, R/ @" C8 x; i
  32.     }% _0 E* t9 l* m& ~) B

  33. $ U* d! b9 L6 Z  P
  34.     public double getAttackPower() {/ V7 L$ f' U: n- C" f7 Z
  35.         return attackPower;
    - p/ }2 a7 D% z+ o# E! O* Y) K
  36.     }
      R% n# t3 ~( [0 E0 x" B

  37. ) y5 e9 O/ p9 @
  38.     public void setAttackPower(double attackPower) {1 ]0 _  z" R7 U! Y9 [* T4 _' [
  39.         this.attackPower = attackPower;
    1 q5 H6 L- R* Z% m$ [
  40.     }6 h$ E+ b6 P/ r" d1 N; u
  41. }. W. M/ t- X/ n8 G! f
Скопировать код
) L9 N. S# L/ h/ n
Шаг 4: Симуляция боя с фазамиТеперь мы можем протестировать логику боя с переключением состояний монстра., |5 o, t1 K3 s  u" b6 j" s

1 B9 ?! L! V  N- P, ]& |+ W% j
  1. // Пакет org.l2jmobius.gameserver.model.battle1 z$ X2 G% a5 N* {" s  |# I* h
  2. package org.l2jmobius.gameserver.model.battle;
    8 p9 e) s$ s! R) {
  3. : C0 }' H3 y( G' v5 a
  4. import org.l2jmobius.gameserver.model.actor.Monster;5 Y+ y& X- Q4 J$ k$ m1 X( m
  5. import org.l2jmobius.gameserver.model.actor.state.AggressiveState;
    % b* p' L* J! g& f0 ~4 n5 r
  6. import org.l2jmobius.gameserver.model.actor.state.FinalState;5 T9 ?* e& K* M! T# X- }+ a& X

  7. , ~! O1 u' |- q- r/ Y. o
  8. public class BattleSimulation {% z! d, b+ j7 t. i( h- F
  9.     public static void main(String[] args) {
    4 Y' C& r5 `2 a& `( G
  10.         // Создаем монстра с начальной атакой
    & w  y* D0 C9 e4 N/ W
  11.         Monster monster = new Monster("Дракон", 100);
    7 X+ o- l2 ]) o) X0 m3 I$ j& B- w( M
  12. ! B$ a2 E; p# D. e
  13.         // Начальная фаза+ r7 J0 E% O# I3 ^! V9 A* J* ]
  14.         monster.executeState();* S) _% \( L% C: W/ H; z
  15. ' T& Z" k! v3 }" ^  r, _; d& v( ~9 U
  16.         // Переход в агрессивную фазу
    & @% _: d3 W( e- K! Z
  17.         monster.setState(new AggressiveState());( R+ d7 g. u8 \* p* y! }8 w
  18.         monster.executeState();% c4 ]- c+ x0 _$ _! O' a' k+ w+ K; C

  19. * t7 R0 @2 B+ X4 G  ^
  20.         // Финальная фаза* w7 c& _3 ?2 V: Z, R6 V
  21.         monster.setState(new FinalState());4 I8 [) G, r$ L/ L
  22.         monster.executeState();" e8 E% D+ ^* H9 {; k" O$ L
  23.     }
    0 j: z9 i& ?' E8 L% c
  24. }( E/ [7 y( T0 p  L1 T) R2 p
Скопировать код
0 A4 q0 F; E' k: G* F
Комментарии по структуре пакетов и классов:$ F6 [0 n+ n+ O) e- |+ I! i
  • Пакет org.l2jmobius.gameserver.model.actor: содержит основные игровые сущности, такие как Monster.
  • Пакет org.l2jmobius.gameserver.model.actor.state: отвечает за реализацию состояний для объектов, таких как монстры.
  • Пакет org.l2jmobius.gameserver.model.battle: может содержать примеры взаимодействий, такие как симуляция боевых сценариев.5 ]4 V8 D( P; Q
ЗаключениеШаблон "Состояние" позволяет легко управлять фазами боя и не перегружать основной класс монстра. Это делает логику боевых сценариев более гибкой и масштабируемой. В будущем, если появятся новые фазы или состояния, их можно будет легко добавить, не изменяя основной код.
# S9 @: o: A' U9 j) `# f) RЕсли появятся дополнительные вопросы по реализации или структуре классов, буду рада помочь!  _1 r' v5 u& r% m6 y' S

! E* G$ \: h, c: i: q  Q
! z/ B# M( D9 s% @6 x6 h7 y
" \2 j) H$ g# s- c# p) t$ G; ^
7 \6 h3 s5 @7 L# P1 A; f1 B
" N& S' b: S7 g1 U' r1 r6 d4 w% ^& [

* b: B  Z& W2 i/ }" X1 m2 Z+ u4 e! b! @, X

7 c2 {& B/ }7 m2 C& e) C9 I' e$ C
. x: G( v/ Y" i# ~# i

) X* Q# v0 [8 ^& A& L9 o* m4 Q0 }: ^) H. p8 ?6 \

6 u/ _7 o5 [9 @
AlexCoder Опубликовано 2024-10-16 21:21:15 | Показать все сообщения
Astraliya опубликовал в 2024-10-16 21:04
' o2 F/ l) I1 M" p! P/ U5 N  eДля управления сложными взаимодействиями, такими как  ...
: O; [( y2 G: ]' ^8 t
Отличный подход! Использование шаблона "Состояние" действительно помогает сделать код более чистым и управляемым. Я задумался: если мы добавим несколько фаз в бою с различными типами атак (например, магические и физические атаки), можно ли расширить этот паттерн, чтобы каждая фаза также учитывала тип атаки? Например, чтобы в агрессивной фазе монстр мог случайным образом чередовать типы атак. Как лучше организовать это в рамках данного паттерна?
 Автор| Astraliya Опубликовано 2024-10-16 21:33:48 | Показать все сообщения
AlexCoder опубликовал в 2024-10-16 21:21! u7 b* j6 C1 o9 ^
Отличный подход! Использование шаблона "Состояние" де ...
9 j  o; ?# a- `4 N( o* f, m8 t: _
Хороший вопрос! Да, шаблон "Состояние" можно легко расширить, чтобы учесть различные типы атак. В этом случае можно добавить логику для чередования атак (магических и физических) в каждом состоянии.. a  j! Q" ~; |$ z0 f  Y

, a1 k2 R  m0 u% LШаг 1: Добавление типа атакиДля этого давайте создадим перечисление (enum) для типов атак и добавим его в наши состояния. Это позволит монстру случайным образом выбирать тип атаки во время боя.
# _% |  w! V) Q. |; Z5 y
" K$ X' \  r/ i2 }' D, y  L/ Q6 j
  1. // Пакет org.l2jmobius.gameserver.model.actor
    * Z1 L7 }3 U# K3 {5 }
  2. package org.l2jmobius.gameserver.model.actor;
    $ v6 U& I( i: a7 _% q! G
  3. # W* B) k, z, y. V+ R. ^
  4. // Перечисление для типов атак
    ' t3 d. L, i! M  Z4 Q9 j
  5. public enum AttackType {
    % E8 v1 a9 i6 J, r+ J
  6.     PHYSICAL, MAGICAL;) X) B* w1 ?: m: J& A: A  j- K
  7. }7 c, L2 g4 M9 C$ n2 t8 o
Скопировать код
Шаг 2: Обновление состояний для поддержки разных атакТеперь обновим состояния монстра, чтобы в каждом из них можно было чередовать типы атак.
- W( X6 D2 T. |- C4 @Обновленный класс для агрессивного состояния монстра:( @* m( ?3 K# K1 g( ?! W
7 O0 D8 ^' Q  b" m
  1. // Пакет org.l2jmobius.gameserver.model.actor.state
    : v$ v$ i. r/ T& A
  2. package org.l2jmobius.gameserver.model.actor.state;
    ! x/ b8 j! O" a6 n( @- R
  3. " `8 N0 A# n: c" N( R( A( s
  4. import org.l2jmobius.gameserver.model.actor.Monster;6 v% w1 s2 _6 f
  5. import org.l2jmobius.gameserver.model.actor.AttackType;
    5 S0 t6 W0 [; M6 X- h
  6. ! P! q4 U+ q# g4 k) f
  7. import java.util.Random;
    / O' V$ h. Y5 {+ j

  8. ' J4 \. l2 ]+ H$ k: F& w
  9. public class AggressiveState implements MonsterState {
    1 |8 s3 v' f2 I# o
  10.     private Random random = new Random();
    + }4 f* i8 v# f  s( p* ?
  11. 1 O2 p' K, c" h4 |" C
  12.     @Override
    2 x; \6 u) F1 _9 @
  13.     public void handleState(Monster monster) {; s, [5 ]3 H4 ?$ I7 J* p" x6 V
  14.         // Выбираем случайный тип атаки: физическая или магическая0 R" r  J# I9 H: [' u/ r3 N: y8 \
  15.         AttackType attackType = random.nextBoolean() ? AttackType.PHYSICAL : AttackType.MAGICAL;5 R* e) S- D8 b" ]) g+ W, r% i

  16. 4 [" Y$ C- Q8 Q1 f4 Y
  17.         // Логика для агрессивной фазы боя7 I- w0 N+ u; x
  18.         System.out.println(monster.getName() + " становится агрессивным и использует "
      Y. R  X) ?/ Y% K9 _/ Y
  19.             + (attackType == AttackType.PHYSICAL ? "физическую" : "магическую") + " атаку!");" o) {, N" Z5 V' w2 Q
  20.         % X" a/ s+ V) \0 n9 H+ b
  21.         // Увеличиваем силу атаки в зависимости от типа атаки
    ; d( U  I! x+ b8 g4 }# f* H5 D
  22.         double multiplier = (attackType == AttackType.PHYSICAL) ? 1.5 : 1.2;; v: a# W* N7 b0 f* q4 J4 o: \5 [- V
  23.         monster.setAttackPower(monster.getAttackPower() * multiplier);
    - |9 {& R1 t3 q) E# `1 Z1 n8 R9 c
  24.     }
    - e5 Y6 O  V* m3 v4 h
  25. }, ^4 |, N3 C4 g8 r# e2 d
Скопировать код
Шаг 3: Модификация класса MonsterТеперь класс Monster будет использовать состояние с логикой выбора типа атаки
# e& D- q, X+ e$ v: E4 x2 z+ w% a& P7 {1 C7 B7 Y2 z
  1. // Пакет org.l2jmobius.gameserver.model.actor
    # r# b7 \9 o$ n' N$ u( s
  2. package org.l2jmobius.gameserver.model.actor;% ^: r: g4 X$ d( o
  3. / p$ r& L4 y6 {4 ]9 }1 A- a
  4. import org.l2jmobius.gameserver.model.actor.state.MonsterState;
    7 X7 `: j6 B9 x1 O( Y
  5. import org.l2jmobius.gameserver.model.actor.state.InitialState;. F3 `4 q6 R4 ~/ z
  6. " U  P$ u, M4 n4 u$ [
  7. public class Monster extends Creature {' X% B, v% |( |/ I1 ^0 J
  8.     private String name;+ d) l. g: {6 m. @
  9.     private double attackPower;
    7 o8 Z# s5 {* a  ]$ u" y/ q, e
  10.     private MonsterState state; // Текущее состояние монстра
    & D) T9 c* ]2 Z/ [

  11. % i7 t+ g7 X  J# x
  12.     // Конструктор монстра7 M- m- @  p2 J8 T' `
  13.     public Monster(String name, double attackPower) {! [1 W/ F+ u0 W* i; E4 C
  14.         this.name = name;
    $ E( f6 F( i4 |3 N8 d
  15.         this.attackPower = attackPower;, [. p: X; ]" q7 J3 {# Z
  16.         this.state = new InitialState(); // Начальное состояние по умолчанию
    6 s" Z6 r) P5 H
  17.     }( D  D0 i" q* G, ^
  18. - }& b$ [. ?5 m) C3 V1 M
  19.     // Метод для смены состояния
    6 b2 P) P; P) F4 C9 J
  20.     public void setState(MonsterState newState) {% C# U5 r3 t: B! c1 S
  21.         this.state = newState;5 H7 _/ l5 f" L9 B
  22.     }* `) b  Q; `9 }/ ]% P4 {0 X8 C( _
  23. ' I* N7 v$ a+ J4 @
  24.     // Выполнение действий на основе текущего состояния8 f4 O5 {( o  ]  a( n
  25.     public void executeState() {; Q: Q2 n5 I4 e. N/ l6 z
  26.         state.handleState(this);
    2 Y3 a( x4 O$ C" T5 f6 u. @
  27.     }3 v; \/ S: A4 _/ ]2 D
  28. : l7 R3 E+ l, S. U- |
  29.     // Геттеры и сеттеры" A7 J7 M  i+ H5 r+ O5 [% K
  30.     public String getName() {
    ) h2 J4 |; n: `- [) I- k4 O
  31.         return name;6 p# h- A! a0 G$ ^* L
  32.     }
    + y1 Q; i8 Q) a2 s7 ^3 l0 H

  33. : B% [5 a2 x* H4 {( A# ]4 e9 G5 j! @
  34.     public double getAttackPower() {" b" X$ @# S; Z% T" U& p" ~
  35.         return attackPower;" F1 o: k& r& l2 D" E
  36.     }% z+ _3 W$ @3 A6 \, _

  37. / ]- C: S. X5 z0 {
  38.     public void setAttackPower(double attackPower) {
    - l1 F% T4 K$ ^6 I
  39.         this.attackPower = attackPower;
    ! v( s) z4 j0 M0 b4 T
  40.     }+ w/ ^: T8 B  S) x. M. D
  41. }
      I  |& M0 S6 L) \( |5 ?5 C/ @& V
Скопировать код
Шаг 4: Тестирование нового поведенияТеперь давайте посмотрим, как монстр будет чередовать типы атак в агрессивной фазе.0 g, w$ \! r5 E, T6 n9 h) u

' J7 y8 v# ?2 H" E
  1. // Пакет org.l2jmobius.gameserver.model.battle
    0 a& A8 i9 w$ L( I, u
  2. package org.l2jmobius.gameserver.model.battle;
    $ K! @. I; E( V; f

  3. ! n6 w0 O; V$ Q4 o
  4. import org.l2jmobius.gameserver.model.actor.Monster;
    ' Y  V1 T; Y7 b& y: I8 s) P# y
  5. import org.l2jmobius.gameserver.model.actor.state.AggressiveState;
    , Q/ M' a# ?- z% N9 C& C$ y/ C7 b
  6. * p+ |# ?& [# E5 W: |  c5 k5 [: E
  7. public class BattleSimulation {
    0 y1 d( e3 l2 B$ O0 X. Q
  8.     public static void main(String[] args) {
    - n9 ~" r7 u2 |4 M0 d9 O, F' T
  9.         // Создаем монстра1 \9 R& V9 K' O/ G0 i, M
  10.         Monster monster = new Monster("Дракон", 100);
    + ]: _* W" U5 J0 p3 n
  11. # p. _  o2 d3 l+ [0 O
  12.         // Переключаем монстра в агрессивное состояние с разными типами атак& p4 X: Y3 j$ M. V! b' H/ r2 f
  13.         monster.setState(new AggressiveState());
    - H9 Y$ s2 |# _5 D5 h6 g
  14.         monster.executeState();
    * C% ~5 ^6 O8 o, P& |5 v
  15.         monster.executeState(); // Повторяем, чтобы увидеть чередование атак
    % W+ @$ C" [6 q2 H
  16.     }
    " R. |* N7 h1 N: S: T. [4 B
  17. }0 |. g  B( V( I7 @0 \+ q# O- z
Скопировать код
ЗаключениеВ результате, с помощью перечисления AttackType, мы можем легко добавлять и чередовать типы атак в зависимости от состояния. Это гибкий способ управления сложными взаимодействиями в бою, не перегружая основной код. Выбор типа атаки можно ещё больше расширить, добавив, например, урон или специальные способности, в зависимости от типа атаки.
0 b9 K9 T1 d' Z' ^Если у тебя есть еще идеи или предложения по улучшению, всегда рад обсудить!6 N7 A0 `. Y1 E) Y0 O  e: f, B
7 `" O1 Q6 V/ M: d- a  i

# q& ]5 h( I- N2 H& M) F  m7 H; X" G; Q" K  W# |) @. k
Чтобы ответить, вам надо авторизироваться в системе Вход | Зарегистрироваться

Правил начисления баллов

  • Выдающийся вклад

    Прилагайте постоянные усилия для процветания форума в течение длительного времени или много раз выдвигайте конструктивные предложения.
  • Авторитет сайта

    Участники, внесшие выдающийся вклад в работу форума

подписок0

подписчиков0

постов9

Опубликовать
Сектор творческих людей
Горячая линия

638638758

С понедельника по воскресенье с 9:00 до 23:00

Обратной связь

admin@artace.ru Онлайн

QR-код

Powered by Discuz! X3.5© 2001-2021 Comsenz Inc.