artace.ru - творческий сектор

Название: Шаг 3.3: Взаимодействие игровых объектов [Версия для печати]
Автор: Astraliya    Время: 2024-10-16 17:54
Название: Шаг 3.3: Взаимодействие игровых объектов
Добро пожаловать в обсуждение статьи "Шаг 3.3: Взаимодействие игровых объектов"!# l2 p: U( F/ Q: O' ?$ w
6 E' X+ k8 F% |& Y
) {9 @( L. C7 |; q8 p! s
Здесь вы можете задавать любые вопросы, связанные с реализацией взаимодействий между игровыми объектами, такими как игроки, NPC и монстры, в серверной разработке Lineage 2 на Java. Обсудим, как создать динамическое взаимодействие в игровом мире, как правильно использовать события и триггеры, и как улучшить боевые и диалоговые системы.
. f) D! g: U1 Y4 {Задавайте вопросы, делитесь опытом, предложениями и идеями — ваше участие поможет углубить наши знания и сделать разработку серверов еще более интересной!
# V! T+ f! X: p6 pАстралия ?4 v0 t0 V9 O5 h0 d7 s8 l
. K1 O2 W6 X; m) b$ H
Автор: AlexCoder    Время: 2024-10-16 18:31
День добрый!3 D4 Z% m7 G5 }! R7 s9 i
В статье описано взаимодействие игрока с NPC и монстрами через простые методы. Как лучше всего реализовать более сложные взаимодействия, например, если нужно добавить несколько фаз боя с разными состояниями монстра? Есть ли оптимальный способ управления состояниями объектов, чтобы не перегружать логику боевых сценариев?
( O2 t  ?4 Q5 X' @; U" B* t( t6 j5 u: Y0 c
Автор: AlexCoder    Время: 2024-10-16 20:53
Последний раз это сообщение было отредактировано AlexCoder в 2024-10-16 20:54 ( h* U6 F, K; g9 {" Z( r- p$ `
AlexCoder опубликовал в 2024-10-16 18:31
9 E5 q9 k) s! sДень добрый!
" R4 S& s7 N! `3 e' MВ статье описано взаимодействие игрока с N ...

; o) k7 m' B/ t* u; R1 I( dДля управления сложными взаимодействиями, такими как несколько фаз боя с разными состояниями монстра, лучший подход — использовать шаблон проектирования "Состояние" (State Pattern). ' Q$ N- Q) x& j  ~; X

  `2 P1 ?: q+ m0 E3 qЭтот шаблон позволяет разделить логику поведения объекта на разные состояния и управлять ими более гибко, избегая перегрузки основного класса монстра.* Q* f4 }! _* v: R
$ p+ \- e7 c" j+ [' A& l
Шаг 1: Создание интерфейса для состояний монстраПервый шаг — создать интерфейс, который будет представлять разные состояния монстра. Этот интерфейс определяет метод, который будет вызываться в зависимости от текущего состояния.
: `8 y. E) V9 a0 j) k  D+ N  U& q7 f; Y$ n
  1. <font color="Green">// Пакет для состояний монстра</font>) ?2 y" o0 l3 s* q) X; j4 F
  2. package org.l2jmobius.gameserver.model.actor.state;
    ; D; W. ?* f1 g1 Y
  3. <font color="Green">
    # f' @0 a) z! S/ Q& t, ~
  4. // Интерфейс, представляющий состояния монстра</font>6 b# z4 V7 ?' l0 y
  5. public interface MonsterState {$ D; Z( h: X# b: Y4 x
  6.     void handleState(Monster monster);
    " L* @2 |$ K1 |' u* D- [, U
  7. }
    , |5 l! _  @7 d$ W8 r0 c) {
Скопировать код
( \* J5 g! g- j2 n! w: l" M
Шаг 2: Реализация различных состоянийТеперь создадим классы для каждого состояния: например, InitialState, AggressiveState и FinalState. Эти состояния будут реализовывать интерфейс MonsterState и определять поведение монстра на разных этапах боя.
0 H& t9 _) a0 P- V, m) H% o: n2 J- d& B! X' n1 O& ^; N
Класс для начального состояния монстра:$ q; N  b/ \: s. I  o4 C! W
  1. <font color="Green">// Пакет org.l2jmobius.gameserver.model.actor.state</font>
    $ r; t/ k6 Q6 h% J0 R. w
  2. package org.l2jmobius.gameserver.model.actor.state;" l6 V/ C1 H2 F: C) Y0 Q

  3.   K) |* ?2 l% \8 b7 [/ [
  4. import org.l2jmobius.gameserver.model.actor.Monster;
    & L3 S% o+ Q) d3 e& V

  5. 9 o7 a# w, s; a- r9 W
  6. public class InitialState implements MonsterState {
    ' l& K- G) K# r1 P- L1 H
  7.     @Override8 C  V0 ~) l  A
  8.     public void handleState(Monster monster) {& n: b* r! }/ p8 S/ X: h  m& D
  9.         // Начальная фаза боя; q7 H7 p; e! X% V
  10.         System.out.println(monster.getName() + " начинает бой с обычной атакой.");
    - Z4 j* G5 V# ?( H
  11.     }
      E, B1 T* t- j9 E5 j
  12. }
    ( j5 v# \! T1 r; g
Скопировать код
" b+ H( c( a% W- J
( g1 {4 Z. ^3 K2 Y/ K0 i; `% @5 ?) K
! W6 J8 [* _+ Q6 j* H5 x, x) g
9 |2 I, _6 V- O
) C& k0 N% S; w8 [$ Z, ?! I
- i) r# j7 g# L0 V, B
1 W9 h2 [& V( V( P( L' E
Автор: Astraliya    Время: 2024-10-16 21:04
Для управления сложными взаимодействиями, такими как несколько фаз боя с разными состояниями монстра, лучший подход — использовать шаблон проектирования "Состояние" (State Pattern).
6 r' `4 N: a- {8 W% K+ I6 T$ W+ o& [. f
Этот шаблон позволяет разделить логику поведения объекта на разные состояния и управлять ими более гибко, избегая перегрузки основного класса монстра.
' s6 J8 M7 c- K$ [8 x6 J
0 S* r' B& ]4 R4 |6 o9 E1 N3 fШаг 1: Создание интерфейса для состояний монстраПервый шаг — создать интерфейс, который будет представлять разные состояния монстра. Этот интерфейс определяет метод, который будет вызываться в зависимости от текущего состояния.3 Q! u8 R! x, [

7 `8 \5 H' P; c  N% Q
  1. // Пакет для состояний монстра
    & A& `( u  L, J) R8 w& K
  2. package org.l2jmobius.gameserver.model.actor.state;9 w+ E7 H4 `0 k1 t5 _$ P

  3. $ {$ Z2 B" x/ j+ f- W7 |/ V
  4. // Интерфейс, представляющий состояния монстра
    5 k; W  f: n0 Z' _+ F/ S9 N1 n
  5. public interface MonsterState {6 C: ~) L8 z/ g9 w0 o8 k* O
  6.     void handleState(Monster monster);3 V3 Q' M& |" t, ?( w. E+ A& i7 y2 P; c  c
  7. }+ b$ T. |# H' b4 R9 J
Скопировать код
" W9 v1 X( L4 V' t) G
Шаг 2: Реализация различных состоянийТеперь создадим классы для каждого состояния: например, InitialState, AggressiveState и FinalState.
; K; e/ B" W- v) w7 H7 U) T
# t0 [" ^/ \8 o3 w1 h' t& ]Эти состояния будут реализовывать интерфейс MonsterState и определять поведение монстра на разных этапах боя.
4 H2 Y/ Q8 [9 F, I5 A+ a8 D
) H: T/ M) I& \6 CКласс для начального состояния монстра:
4 \  g# j" R- K# ]9 S, O2 p3 F
  1. // Пакет org.l2jmobius.gameserver.model.actor.state9 i+ G. s& ]4 N8 y
  2. package org.l2jmobius.gameserver.model.actor.state;6 V+ c' f: K) g6 b7 @

  3. $ V% G( K  y$ V+ W
  4. import org.l2jmobius.gameserver.model.actor.Monster;% B# ~. V' S- ?/ p" C

  5. 1 W1 Y# f3 E" S2 {: n: J& V
  6. public class InitialState implements MonsterState {+ g( J. z9 r1 O) U4 B, F  b; v0 j8 T
  7.     @Override
    . a7 ?: E1 ]( |
  8.     public void handleState(Monster monster) {0 A/ A* b1 w$ S" V/ y
  9.         // Начальная фаза боя6 T. L8 o6 }7 O+ P' [/ R6 g
  10.         System.out.println(monster.getName() + " начинает бой с обычной атакой.");
    8 F3 @$ L( ]4 `5 b
  11.     }
    # R9 V  m* l6 C1 N. Z. M
  12. }# H3 K% S6 {0 T  M* e& S0 k5 `
Скопировать код
Класс для агрессивного состояния монстра:
! \5 n, s# D3 J( P2 W
  1. // Пакет org.l2jmobius.gameserver.model.actor.state
    " `: m, b- I) w4 F1 O
  2. package org.l2jmobius.gameserver.model.actor.state;& x' Z' n+ p, s1 I, W5 M
  3. 8 P) R" Y, I# S  O7 t
  4. import org.l2jmobius.gameserver.model.actor.Monster;* m* O0 S/ w: o8 m; ]

  5.   J2 Y% z- C/ @1 S
  6. public class AggressiveState implements MonsterState {3 B& N! w2 M; \9 q4 e9 R" I0 T: r
  7.     @Override
    & ?0 G/ p2 {0 J1 K7 i
  8.     public void handleState(Monster monster) {
    . ^6 y1 b4 I7 [7 n
  9.         // Агрессивная фаза боя0 s$ W0 r: U: G
  10.         System.out.println(monster.getName() + " становится агрессивным! Атаки усиливаются.");/ [: j* r# M) K' ^- [. y3 U# i
  11.         monster.setAttackPower(monster.getAttackPower() * 1.5); // Увеличиваем силу атаки3 N, O) F7 X. G: o( I& L
  12.     }
    ) c5 d: @4 a8 @+ t) {& v9 w
  13. }
    4 t+ g" x' I- W7 r
Скопировать код
Класс для финального состояния монстра:: N. v# F, M9 k/ m. i1 e
  1. // Пакет org.l2jmobius.gameserver.model.actor.state! L6 F6 M6 v1 }- |/ O4 d, N
  2. package org.l2jmobius.gameserver.model.actor.state;
    . }  P" o# b3 @0 S6 H3 a

  3. ; Y+ y" \) x, S. W" H
  4. import org.l2jmobius.gameserver.model.actor.Monster;* i  ?1 x  A3 G# O1 ^: i

  5. 4 [2 T6 S8 Y5 D' D' s
  6. public class FinalState implements MonsterState {/ O7 E# T  w6 _+ N
  7.     @Override
    6 m( }4 z( v- G3 B& q3 W
  8.     public void handleState(Monster monster) {
    : a, _* ~' e* N. w* F0 j( f' ]. e
  9.         // Финальная фаза боя
    3 b8 C7 M1 h" r7 v0 A  g
  10.         System.out.println(monster.getName() + " готовится к финальной атаке!");
    7 w: `1 q& K4 \
  11.         monster.setAttackPower(monster.getAttackPower() * 2); // Максимальная сила атаки2 X8 r  R+ g+ J6 \3 ]
  12.     }) j5 I* l0 \3 @3 M# Z2 B7 q/ l# N
  13. }9 k+ }- X! w1 h3 W0 M: a
Скопировать код

) k' J0 I4 X( }4 cШаг 3: Изменение класса MonsterЧтобы монстр мог переключаться между состояниями, нам нужно обновить класс Monster. В этой сборке L2J_Mobius, классы для игровых объектов, таких как монстры, находятся в пакете org.l2jmobius.gameserver.model.actor.
6 y) R. t/ W; ?2 T% B6 Y7 D3 f
  1. // Пакет org.l2jmobius.gameserver.model.actor" x' e# H) ~9 C# }
  2. package org.l2jmobius.gameserver.model.actor;7 _5 f2 B4 {9 g6 [+ N7 b- a' R

  3. 3 o/ h) Q5 N# B4 W; C! S
  4. import org.l2jmobius.gameserver.model.actor.state.MonsterState;
    5 Z0 W$ _- i% n! s9 L# Q' ?9 i
  5. import org.l2jmobius.gameserver.model.actor.state.InitialState;  z' g, ?! P/ A2 o0 D" l

  6. $ A; F+ W6 G. [4 D* F% V
  7. public class Monster extends Creature {
    # B% r! Y' J9 ^% S
  8.     private String name;8 q9 f1 q5 ^7 X; r4 Q  I. t% x. b
  9.     private double attackPower;
    0 c1 t6 l2 k" }: `8 [, C
  10.     private MonsterState state; // Текущее состояние монстра
    3 u2 e! Q, B/ [( M$ Z  ~+ i/ x: v2 i
  11. . G2 o# }8 B% J' j* i: U
  12.     // Конструктор монстра
    . ~* I4 B; R8 o3 [
  13.     public Monster(String name, double attackPower) {! g! d$ P+ C/ j
  14.         this.name = name;
    ! U0 e0 S6 I" S$ d
  15.         this.attackPower = attackPower;) R# Y1 \! _8 }9 T( R( t1 }
  16.         this.state = new InitialState(); // Устанавливаем начальное состояние# k) j& ^! m& b* F8 g# \
  17.     }( G; D: \* P) N+ N
  18. ' b. E. ^+ U; b# }
  19.     // Метод для смены состояния
    5 r! O: M# y% ^) `% _$ c/ U" l/ ]& w
  20.     public void setState(MonsterState newState) {
    * F* L/ w3 Q/ B! ]  q' L
  21.         this.state = newState;
    $ K% a' \9 A7 h' f( J1 T
  22.     }2 L2 l* U) I* b2 x0 t

  23. ) o8 z+ Z1 u0 @( U8 g) q  p8 S
  24.     // Выполнение действий на основе текущего состояния
    0 K/ P  G8 z' U3 u# Q5 g
  25.     public void executeState() {
    1 I+ W( g3 P) @) m0 `4 G, c
  26.         state.handleState(this);0 @) W, L+ u$ d' _
  27.     }
    8 V+ M* U6 _% Y3 d: T" N7 Z
  28. 2 P) i6 v$ @5 N0 {
  29.     // Геттеры и сеттеры* v: [+ D. O; y1 h3 ?# F
  30.     public String getName() {
      R! R" a* ~3 A! w- R1 e
  31.         return name;
    ( b0 g# h6 d% L. Q
  32.     }( I+ V/ ]. R; M& |8 [- W4 m) n

  33. 3 H- `. k' s0 y
  34.     public double getAttackPower() {- ?1 K- |2 t2 R+ i- Y! k
  35.         return attackPower;
    8 N6 i6 b* @$ J- s2 ]& `8 N
  36.     }
    ( c( B; |0 ~0 r: ~1 X5 U

  37. $ M( Z0 [1 o( S& i* k
  38.     public void setAttackPower(double attackPower) {
    " ~  L3 p% V( j' ~% N
  39.         this.attackPower = attackPower;/ d' O  j9 y* k3 h& |
  40.     }7 k# i4 |0 _/ a3 _8 s
  41. }
    % d* _) E. p8 `& p5 o
Скопировать код
. q4 R& @  G% V2 C5 a  w9 K6 X1 j$ o
Шаг 4: Симуляция боя с фазамиТеперь мы можем протестировать логику боя с переключением состояний монстра./ x# S0 Y# E$ a
% J! h; v9 t0 Z( P
  1. // Пакет org.l2jmobius.gameserver.model.battle# F  k6 Z! I$ S0 f
  2. package org.l2jmobius.gameserver.model.battle;
    3 ^: _" }" \/ u  {9 }
  3. ; W9 L: Y+ }6 w% L
  4. import org.l2jmobius.gameserver.model.actor.Monster;
    6 B* }! t- |( A  @/ N6 ~  \3 D
  5. import org.l2jmobius.gameserver.model.actor.state.AggressiveState;0 \6 A" c  t8 J. C2 x
  6. import org.l2jmobius.gameserver.model.actor.state.FinalState;1 I0 ?) F2 x; W/ R8 T1 \2 ]
  7. " o+ a: a  X( P+ C& T
  8. public class BattleSimulation {
    ( C3 P  K. V" x* j# g% f
  9.     public static void main(String[] args) {8 \; P8 c6 j7 D6 k
  10.         // Создаем монстра с начальной атакой
    $ ~7 b' @' x$ J% Z& k# A9 d
  11.         Monster monster = new Monster("Дракон", 100);
    $ r# h7 q9 _; J$ a: k; h
  12. ) g+ H5 L4 Z. O
  13.         // Начальная фаза' E9 r% g( I* c( f
  14.         monster.executeState();
    1 v4 ]6 F# e0 R. H9 ]7 A
  15. ) g$ h" M7 \$ N; ]
  16.         // Переход в агрессивную фазу
    7 [. \, n9 m' j8 k- |* q
  17.         monster.setState(new AggressiveState());5 e% J. t; i6 U5 B9 ^# b9 I
  18.         monster.executeState();
    ; `. D% E/ k& p/ w
  19. ; t6 U  P) i+ k* ^
  20.         // Финальная фаза
    . v& _  K4 c1 f2 \  b5 r: P5 E; A
  21.         monster.setState(new FinalState());
    6 S9 w* M! s) g  M  T% G
  22.         monster.executeState();1 y1 x8 K5 j. e" {7 g3 e
  23.     }* x% B) j" r, A' Q; _  O9 P
  24. }! p' R3 v9 y# f( i( s) a. ?5 d3 P5 M4 q
Скопировать код

  x: s/ a* r7 ]: i% q% zКомментарии по структуре пакетов и классов:( l( B8 h2 `1 Z- r- P
ЗаключениеШаблон "Состояние" позволяет легко управлять фазами боя и не перегружать основной класс монстра. Это делает логику боевых сценариев более гибкой и масштабируемой. В будущем, если появятся новые фазы или состояния, их можно будет легко добавить, не изменяя основной код.$ ?- |8 o9 r" r6 V/ u" I
Если появятся дополнительные вопросы по реализации или структуре классов, буду рада помочь!
$ x% S5 p) M* c& |. l, h7 c' c. l9 }9 [
8 C  m4 L8 n! o
( J$ S4 O$ @* F; _& M# a4 _$ u
; k+ i9 n9 v) h, \  y$ o
0 L1 w! d1 p! u* Q9 ^$ F- |
: e) |4 `9 y3 A' G3 Z5 a
) T  w) S! f7 P3 L2 @4 H9 R8 _( @0 t

! r1 r" N0 N0 r! L8 j  F$ \4 x6 t1 ~6 ]/ o

/ Z' \. c# O4 z3 D% ^& [& l; R, L% j7 I  ^8 m1 }" ~0 P( U/ p1 k8 ~

. i7 L. p% `' V7 g) x  l$ M4 Z
$ G3 w6 \/ k7 Z
. L0 O4 L, b! H6 C" ]1 U3 R7 K( e
Автор: AlexCoder    Время: 2024-10-16 21:21
Astraliya опубликовал в 2024-10-16 21:04
1 s- J3 O: S  {; J# L; g7 PДля управления сложными взаимодействиями, такими как  ...

) f) n; U5 v& v6 }! j& }Отличный подход! Использование шаблона "Состояние" действительно помогает сделать код более чистым и управляемым. Я задумался: если мы добавим несколько фаз в бою с различными типами атак (например, магические и физические атаки), можно ли расширить этот паттерн, чтобы каждая фаза также учитывала тип атаки? Например, чтобы в агрессивной фазе монстр мог случайным образом чередовать типы атак. Как лучше организовать это в рамках данного паттерна?
Автор: Astraliya    Время: 2024-10-16 21:33
AlexCoder опубликовал в 2024-10-16 21:21
. p+ ^4 X3 K3 P$ h. n$ O9 rОтличный подход! Использование шаблона "Состояние" де ...

" }9 }* r8 ~* L' |2 W! Q; M0 Q4 |Хороший вопрос! Да, шаблон "Состояние" можно легко расширить, чтобы учесть различные типы атак. В этом случае можно добавить логику для чередования атак (магических и физических) в каждом состоянии.+ X8 D& g$ x5 D5 r
9 a* v3 u" q4 Y1 C- K+ U
Шаг 1: Добавление типа атакиДля этого давайте создадим перечисление (enum) для типов атак и добавим его в наши состояния. Это позволит монстру случайным образом выбирать тип атаки во время боя.
! \, o. E  W: u. b0 t3 j
9 d" q2 p" x. b+ ]2 F
  1. // Пакет org.l2jmobius.gameserver.model.actor) {- M) [3 H7 J% c/ N7 p# `
  2. package org.l2jmobius.gameserver.model.actor;
    " a: ?( ]2 V" D) g. |5 z! l

  3. ( H9 A: b  X, @5 I' N) ]
  4. // Перечисление для типов атак( R. a4 J9 f' j
  5. public enum AttackType {
    4 ]2 ]+ t4 B0 {) z: G  i% P
  6.     PHYSICAL, MAGICAL;" ]7 ~8 G) I6 O/ |+ v6 T; H
  7. }( T. z. @6 e2 j  ]1 R6 J
Скопировать код
Шаг 2: Обновление состояний для поддержки разных атакТеперь обновим состояния монстра, чтобы в каждом из них можно было чередовать типы атак.
* i# N3 l# R, v7 b5 PОбновленный класс для агрессивного состояния монстра:
5 e7 N8 n$ i7 X# d& R  ]: V) b$ j" y, N1 m
  1. // Пакет org.l2jmobius.gameserver.model.actor.state" w2 L+ ]  [8 q  K1 Z  n0 B1 H
  2. package org.l2jmobius.gameserver.model.actor.state;
    ) n* I1 H# `: l: f5 O4 C$ g+ Z# z
  3. 3 X5 g* F3 Z3 s. F" B7 v
  4. import org.l2jmobius.gameserver.model.actor.Monster;
    6 `* `* M! N) t4 I
  5. import org.l2jmobius.gameserver.model.actor.AttackType;: a  |- E, r2 R5 i

  6. 9 `4 }$ Q4 P0 p) ]1 e) ?* Z9 o
  7. import java.util.Random;
    5 j1 Z/ T6 t' |% t4 v$ ]9 O: A, \

  8. 9 g2 K4 _1 f9 D3 h9 P
  9. public class AggressiveState implements MonsterState {6 ]3 w$ [5 O0 f  K
  10.     private Random random = new Random();
    4 P3 N8 H/ H: h2 E

  11. + v) n+ U; }& J* R
  12.     @Override" ^) \" I+ x3 \' U
  13.     public void handleState(Monster monster) {
    6 q$ w/ d6 _: n: f# l1 N1 S
  14.         // Выбираем случайный тип атаки: физическая или магическая
    ! _) P, c( {9 f  }
  15.         AttackType attackType = random.nextBoolean() ? AttackType.PHYSICAL : AttackType.MAGICAL;
    : g0 p4 b- y1 K4 d+ @" l  K/ N/ N

  16. 5 ]8 [* K4 I* P" `7 E- D
  17.         // Логика для агрессивной фазы боя
    * O7 E7 L# U& x1 J9 {) o
  18.         System.out.println(monster.getName() + " становится агрессивным и использует "
    ' [% X6 Y' {5 s' D  g( \
  19.             + (attackType == AttackType.PHYSICAL ? "физическую" : "магическую") + " атаку!");; \( Q! c9 M" v
  20.         : m$ P; g" _" O$ s& @! ]+ R
  21.         // Увеличиваем силу атаки в зависимости от типа атаки1 p* ?( N7 p& Q' Z
  22.         double multiplier = (attackType == AttackType.PHYSICAL) ? 1.5 : 1.2;- F+ `. x' m& P- }% v
  23.         monster.setAttackPower(monster.getAttackPower() * multiplier);
    9 k; |# T0 r3 a7 r+ G5 i
  24.     }
    % @7 Y6 _- W. n, l) c6 A2 q
  25. }5 K; c: r. r" h- O* M9 h* _6 j
Скопировать код
Шаг 3: Модификация класса MonsterТеперь класс Monster будет использовать состояние с логикой выбора типа атаки, b+ f+ |0 Z- Q

9 s0 t) i' [- D1 g3 d9 p
  1. // Пакет org.l2jmobius.gameserver.model.actor" G; M  R( U  Q9 o& ]4 r2 x
  2. package org.l2jmobius.gameserver.model.actor;; _, q6 B  \! G& t3 }
  3. . S# j  [' U' v3 w+ g6 d" z% Q
  4. import org.l2jmobius.gameserver.model.actor.state.MonsterState;4 v5 [, h  Q  `7 J$ j# t! K: {
  5. import org.l2jmobius.gameserver.model.actor.state.InitialState;
    * P# @) m+ a! D9 |. ~( o$ y
  6. ) r9 Z4 C3 c+ S. K3 F4 J
  7. public class Monster extends Creature {
    4 s* I8 Q- @. B5 T1 g" k% z
  8.     private String name;
    4 S& d4 W5 r' e8 L( y* M; n# W
  9.     private double attackPower;0 Y" s6 L, ]1 \% x/ j2 D
  10.     private MonsterState state; // Текущее состояние монстра- _  }0 h/ U  v& w6 j  S3 a2 ]
  11. - \  D! a9 x2 C* J/ z. Q7 H7 D& J
  12.     // Конструктор монстра
    ! i6 G& g; \( O6 I
  13.     public Monster(String name, double attackPower) {
    4 M5 G& o! v5 R$ U3 w( Z1 t& P7 f
  14.         this.name = name;$ c' J0 r8 P5 P* W. a. ^  j
  15.         this.attackPower = attackPower;
    . z! e* H5 z# c, Z5 H. B
  16.         this.state = new InitialState(); // Начальное состояние по умолчанию8 w' ^1 K1 [3 T1 E0 x0 e1 L
  17.     }
    2 {( K7 \% n" r

  18. 6 v. Y7 G# Q; i- n% Y$ f
  19.     // Метод для смены состояния, D. `4 o* B7 ]0 a
  20.     public void setState(MonsterState newState) {, g2 [# B; _7 a) W* c! `( `
  21.         this.state = newState;
    ) [4 C! `9 U% ]% q0 s$ ]6 E; Q
  22.     }
    9 b1 r3 D: J4 t$ [4 ?
  23. ' C! `6 W. \& A: c
  24.     // Выполнение действий на основе текущего состояния
    0 C8 U5 Z3 k( R
  25.     public void executeState() {
    , D! t$ _; t6 ~7 p$ q/ ?% [! h
  26.         state.handleState(this);7 H5 q% ~. a1 r5 M6 y
  27.     }: J. S3 U6 ]- U, N

  28. # A2 D( U4 g0 |, j" E
  29.     // Геттеры и сеттеры/ G! l1 M2 g# T  ~0 o" s
  30.     public String getName() {
    : _3 u% O8 p* M, G9 n
  31.         return name;# B' C/ I, R$ t1 e$ b' Y/ Z/ B
  32.     }
    : {( N9 X1 F. _2 j

  33. & M0 U6 ]  ]9 z. g" d, T
  34.     public double getAttackPower() {7 I. O. b, W' G6 D/ d7 z. i
  35.         return attackPower;
    2 _: {! j. U9 g: p1 S% L6 x+ W
  36.     }
    8 t4 G/ G6 p4 ~  U' }- P
  37. 7 t6 p, w* A" b: t
  38.     public void setAttackPower(double attackPower) {
    - V! F+ \5 S, K5 R  M  w
  39.         this.attackPower = attackPower;
    : r% C2 _% {' S! H' L) N8 k
  40.     }1 @, f1 @+ I! l' V- [: r
  41. }/ p6 J  b+ G/ q. I# Z: g7 g( m
Скопировать код
Шаг 4: Тестирование нового поведенияТеперь давайте посмотрим, как монстр будет чередовать типы атак в агрессивной фазе.4 K- @+ r( `' T1 X

' R6 o& B* Z- o) s# ]
  1. // Пакет org.l2jmobius.gameserver.model.battle  B' R9 L1 c/ j. F) G, h" E
  2. package org.l2jmobius.gameserver.model.battle;
    4 e* ~/ f8 v6 v% x0 n0 [

  3. 0 ^! x  a4 ?! G0 |- X( Z
  4. import org.l2jmobius.gameserver.model.actor.Monster;
    & _( Q# H7 J9 v) v( ?
  5. import org.l2jmobius.gameserver.model.actor.state.AggressiveState;- X) l4 S- W. z+ r5 e
  6. / f" b: Z( v- m) U  ?  y  a) R) J! }
  7. public class BattleSimulation {
    8 U0 A% [. ]+ V: C  \4 E
  8.     public static void main(String[] args) {/ @- a7 ~' L# \
  9.         // Создаем монстра
    6 [- C, e' b5 N+ f, C
  10.         Monster monster = new Monster("Дракон", 100);
    3 \7 y. A$ [" a# ^7 d9 P1 x
  11. ' u$ y( c- n9 T( T9 F; f. D
  12.         // Переключаем монстра в агрессивное состояние с разными типами атак/ d7 {4 {! F0 U+ j% U
  13.         monster.setState(new AggressiveState());
    & J* C" e& i* V& c' C
  14.         monster.executeState();( \+ ^' b2 e4 L* ~
  15.         monster.executeState(); // Повторяем, чтобы увидеть чередование атак5 y( f) p# q1 ^
  16.     }* i$ c3 L! J( n* I) ~' _$ G5 a5 [
  17. }4 A$ }  {) K1 C1 P
Скопировать код
ЗаключениеВ результате, с помощью перечисления AttackType, мы можем легко добавлять и чередовать типы атак в зависимости от состояния. Это гибкий способ управления сложными взаимодействиями в бою, не перегружая основной код. Выбор типа атаки можно ещё больше расширить, добавив, например, урон или специальные способности, в зависимости от типа атаки.6 x  n) a3 k5 D# `5 `0 \& L/ R
Если у тебя есть еще идеи или предложения по улучшению, всегда рад обсудить!
' P' a, B; M; T5 `3 ]% j" `# q4 l, [
/ y! e. k7 z& {/ _
9 M$ u. m  Y7 J5 y, K0 g' B




Добро пожаловать artace.ru - творческий сектор (https://artace.ru/) Powered by Discuz! X3.5