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

Название: Шаг 3.3: Взаимодействие игровых объектов [Версия для печати]
Автор: Astraliya    Время: 2024-10-16 17:54
Название: Шаг 3.3: Взаимодействие игровых объектов
Добро пожаловать в обсуждение статьи "Шаг 3.3: Взаимодействие игровых объектов"!" d. U4 s7 ~. C* J
- J2 J; l1 u- H# Z
! U. c7 [  v# M$ R0 Q* ?
Здесь вы можете задавать любые вопросы, связанные с реализацией взаимодействий между игровыми объектами, такими как игроки, NPC и монстры, в серверной разработке Lineage 2 на Java. Обсудим, как создать динамическое взаимодействие в игровом мире, как правильно использовать события и триггеры, и как улучшить боевые и диалоговые системы.* X) N; G+ e$ }+ i% M* |
Задавайте вопросы, делитесь опытом, предложениями и идеями — ваше участие поможет углубить наши знания и сделать разработку серверов еще более интересной!" y1 T& b; A$ _( o
Астралия ?7 E: N6 B; y/ f  R

% F2 v! \7 r3 v& q7 q& V  N) h1 k: X
Автор: AlexCoder    Время: 2024-10-16 18:31
День добрый!. G+ P& Q8 A6 m1 s& V+ M/ p* B
В статье описано взаимодействие игрока с NPC и монстрами через простые методы. Как лучше всего реализовать более сложные взаимодействия, например, если нужно добавить несколько фаз боя с разными состояниями монстра? Есть ли оптимальный способ управления состояниями объектов, чтобы не перегружать логику боевых сценариев?$ B  q9 q  |9 d% V

( f) o7 O9 o% x" |& _! V$ o
Автор: AlexCoder    Время: 2024-10-16 20:53
Последний раз это сообщение было отредактировано AlexCoder в 2024-10-16 20:54 $ k, I; U9 S3 E& C
AlexCoder опубликовал в 2024-10-16 18:31
5 }( x8 {  ]2 ^. G0 u8 cДень добрый!
# `, k: }% H3 M$ L/ a7 VВ статье описано взаимодействие игрока с N ...

& |% D, f4 r. J3 E5 PДля управления сложными взаимодействиями, такими как несколько фаз боя с разными состояниями монстра, лучший подход — использовать шаблон проектирования "Состояние" (State Pattern). , c3 J, j' F2 s0 L7 Z- g
/ _$ p+ h* _7 e0 E5 A4 x
Этот шаблон позволяет разделить логику поведения объекта на разные состояния и управлять ими более гибко, избегая перегрузки основного класса монстра.
; x7 g$ e5 e* W/ {: k4 W' o/ d4 h. D' W6 A* N% d- W3 t7 k5 B
Шаг 1: Создание интерфейса для состояний монстраПервый шаг — создать интерфейс, который будет представлять разные состояния монстра. Этот интерфейс определяет метод, который будет вызываться в зависимости от текущего состояния.9 E! i4 ?2 p5 o+ b

/ O9 [! W; b1 r* F" }  ?0 h4 K
  1. <font color="Green">// Пакет для состояний монстра</font>( s, p" h" q8 J. d/ p
  2. package org.l2jmobius.gameserver.model.actor.state;
    . _: W+ W" i( ]' l% {+ l1 w
  3. <font color="Green">
    : \0 n8 {. A8 ]( n0 y- c# E4 Q
  4. // Интерфейс, представляющий состояния монстра</font>" Z* D( P1 ~  ~0 A
  5. public interface MonsterState {
    1 @2 i- w5 a( l0 Z( M- E
  6.     void handleState(Monster monster);
    - L! q6 G* n- d
  7. }
    * N$ Q% k2 \+ u0 f
Скопировать код
8 o2 w6 w4 C, ^' g! b
Шаг 2: Реализация различных состоянийТеперь создадим классы для каждого состояния: например, InitialState, AggressiveState и FinalState. Эти состояния будут реализовывать интерфейс MonsterState и определять поведение монстра на разных этапах боя.
; X9 \$ [, r( U( `* o+ y+ P9 O0 d' K) @" L% s0 S! K2 o1 ?
Класс для начального состояния монстра:6 l7 D+ `( i! q8 v* o
  1. <font color="Green">// Пакет org.l2jmobius.gameserver.model.actor.state</font># R' B7 i3 n) S# c, k4 ^
  2. package org.l2jmobius.gameserver.model.actor.state;/ ?& k% U' C4 `! a6 M2 V* Y

  3. 7 b6 _" l' C& p
  4. import org.l2jmobius.gameserver.model.actor.Monster;3 R! {6 d6 M; N9 h( m& |% J
  5. 1 P! S3 q4 D9 a
  6. public class InitialState implements MonsterState {) _1 ^0 [* f; K3 B
  7.     @Override+ t( l$ d) ?) l) L
  8.     public void handleState(Monster monster) {, y* V8 j. o* K, Y8 `; b
  9.         // Начальная фаза боя
      S' Q1 f6 p5 u: _/ ~1 y8 w
  10.         System.out.println(monster.getName() + " начинает бой с обычной атакой.");
    - k7 p, U9 @1 v' V: o2 S2 B
  11.     }4 p; b$ m: E/ \
  12. }/ Q  z2 q9 o3 Y7 i4 z. t# F
Скопировать код
3 o! _  N  H. h

% l7 v6 }. U/ x' G4 b& _5 q/ o8 I, _
$ g; Y6 l  ?) F  p5 a
# O4 N( w, E0 ?: `2 ?! B3 Y$ n

- o; a! Y* t) M. w/ R/ O) ~
3 f5 O7 o+ h# L* G8 K
Автор: Astraliya    Время: 2024-10-16 21:04
Для управления сложными взаимодействиями, такими как несколько фаз боя с разными состояниями монстра, лучший подход — использовать шаблон проектирования "Состояние" (State Pattern). * g! `1 _  w* X: s: \
8 W: m! @, y6 w1 j2 k
Этот шаблон позволяет разделить логику поведения объекта на разные состояния и управлять ими более гибко, избегая перегрузки основного класса монстра.7 c7 T: E% k3 t# ~

2 K# M2 W8 K6 |# C' WШаг 1: Создание интерфейса для состояний монстраПервый шаг — создать интерфейс, который будет представлять разные состояния монстра. Этот интерфейс определяет метод, который будет вызываться в зависимости от текущего состояния.
% z6 [% i+ w$ T  o
( c' T6 M4 u. `
  1. // Пакет для состояний монстра% ~8 N. a3 n* W0 {5 e/ n
  2. package org.l2jmobius.gameserver.model.actor.state;2 b5 r  g6 o- H6 k: t
  3. + S1 ^3 e9 t# q& r0 s; A
  4. // Интерфейс, представляющий состояния монстра
    $ Y. a& n! a# {9 x
  5. public interface MonsterState {1 J9 \& `+ D8 |) M
  6.     void handleState(Monster monster);( G+ w! N" x1 S6 H9 ^' O! ?
  7. }
    ' Y* i6 F7 S9 C( K9 y! l7 T2 F: ?; ~
Скопировать код
! @7 B& s% p+ v- l
Шаг 2: Реализация различных состоянийТеперь создадим классы для каждого состояния: например, InitialState, AggressiveState и FinalState. $ E: F0 B: `. O  J

6 r" E! \) u3 a$ I7 v: B- `Эти состояния будут реализовывать интерфейс MonsterState и определять поведение монстра на разных этапах боя.
; I4 o$ g  y: _; Z
- V" H( Q7 o# I* p9 VКласс для начального состояния монстра:
1 n" e; A8 z) m, R
  1. // Пакет org.l2jmobius.gameserver.model.actor.state8 N* i% R5 ^: `, @+ ^" p* ~$ W- ~
  2. package org.l2jmobius.gameserver.model.actor.state;
      T* m  E% @- g% Y0 g& B$ M

  3. 0 o+ N/ o+ k( g8 \4 D& K
  4. import org.l2jmobius.gameserver.model.actor.Monster;0 D4 h* [; D6 E' |8 n
  5. & c( ], L4 u! B* i; ~  T
  6. public class InitialState implements MonsterState {
    + Y$ S2 B4 E8 n
  7.     @Override: K7 x8 r0 v; p
  8.     public void handleState(Monster monster) {
    ) e- f! H- L3 a( u
  9.         // Начальная фаза боя
    ; r5 @0 ~( j( _8 s' w8 k# N% y
  10.         System.out.println(monster.getName() + " начинает бой с обычной атакой.");& y5 M4 v! u2 r" `6 U- D
  11.     }5 h& t2 G$ M- D: u5 I- P1 ^/ H! Y8 K
  12. }
    1 E% T4 b7 M4 }" m4 b6 h: n5 D/ ^
Скопировать код
Класс для агрессивного состояния монстра:
! k. T2 }. o4 u' L) b/ c
  1. // Пакет org.l2jmobius.gameserver.model.actor.state
    / U8 M% t% v9 J7 j- O1 B
  2. package org.l2jmobius.gameserver.model.actor.state;! ^/ Q6 m$ j2 ~

  3. 1 F5 e( c! j8 Q, m" g
  4. import org.l2jmobius.gameserver.model.actor.Monster;
    1 i; f, ?$ ?7 g' I8 X! U- J) L
  5. # l" g' A6 v' s: y# j$ ~# V( l% E
  6. public class AggressiveState implements MonsterState {
    ) v6 J2 R5 `8 B% d7 ]
  7.     @Override# V# k. S/ v/ |+ l( u  e4 c
  8.     public void handleState(Monster monster) {& \2 b% N* s4 c$ Z8 B8 {, `
  9.         // Агрессивная фаза боя
    ! U1 C; g$ s8 _* J. r5 q! P4 Z
  10.         System.out.println(monster.getName() + " становится агрессивным! Атаки усиливаются.");# i# l, @: B- \# w: F; A
  11.         monster.setAttackPower(monster.getAttackPower() * 1.5); // Увеличиваем силу атаки
    3 h  C6 R4 {* U1 n/ u: J4 _9 r
  12.     }
    9 x3 J/ t, h1 O/ Y; _: ^) l
  13. }
      o$ S5 j" `; y& F. p
Скопировать код
Класс для финального состояния монстра:
6 L/ E, U9 C5 |5 e6 y) O
  1. // Пакет org.l2jmobius.gameserver.model.actor.state  k! S  j  W: t, q1 E
  2. package org.l2jmobius.gameserver.model.actor.state;, J5 U" |/ y5 T- |8 K+ l% N7 D0 D  L

  3. ) X4 N! E" I. u  r! J% y! X! k5 b
  4. import org.l2jmobius.gameserver.model.actor.Monster;
    ' U3 U5 F7 b/ |7 ?; T/ E

  5. ( ~9 a1 P( Q# D( Z1 Q- c- ?
  6. public class FinalState implements MonsterState {% ]* Z/ Q! [) D  H  ]
  7.     @Override
    7 Q# u* B# A. Y2 Q9 `' |
  8.     public void handleState(Monster monster) {
    $ \1 w" b1 ~* f6 }4 P, Y: q, z% C( ~
  9.         // Финальная фаза боя
    ; o/ e4 {+ s0 |  w, ]* c0 v
  10.         System.out.println(monster.getName() + " готовится к финальной атаке!");3 E) `+ Q3 S5 d3 }1 c/ r
  11.         monster.setAttackPower(monster.getAttackPower() * 2); // Максимальная сила атаки9 f& n2 g: s, W# P& c1 S
  12.     }
    & d/ c: O6 ~! `& a% p6 i' m0 F/ T
  13. }1 N* Q+ ^# L& V( \" o
Скопировать код
+ ^/ V# D& b, b& e2 I
Шаг 3: Изменение класса MonsterЧтобы монстр мог переключаться между состояниями, нам нужно обновить класс Monster. В этой сборке L2J_Mobius, классы для игровых объектов, таких как монстры, находятся в пакете org.l2jmobius.gameserver.model.actor.  F' e0 H0 `5 ^- J& x+ r4 U
  1. // Пакет org.l2jmobius.gameserver.model.actor/ a. ?! H3 T3 D% U' a
  2. package org.l2jmobius.gameserver.model.actor;
    - T" Z: A9 ?. P. h! U
  3. 3 j& u- Z+ ]8 M& M, Z4 g- M$ D
  4. import org.l2jmobius.gameserver.model.actor.state.MonsterState;" h( J! |8 ~, P# @8 K; Q
  5. import org.l2jmobius.gameserver.model.actor.state.InitialState;, ^; Q8 R( N0 Z% V& j
  6. 4 o) T9 W- p6 C# y$ a8 V8 d! f
  7. public class Monster extends Creature {
    6 z+ ?" Y% u1 _
  8.     private String name;
    9 I5 G/ c1 U9 H, Z
  9.     private double attackPower;9 h. U# q( ^/ z, @& H
  10.     private MonsterState state; // Текущее состояние монстра5 i# r0 u' `. V- r$ M

  11. " _8 e3 n" {$ r% n1 N+ j
  12.     // Конструктор монстра% U& N& {  I) t. L
  13.     public Monster(String name, double attackPower) {6 E* C) {# g: x
  14.         this.name = name;* _6 Z8 T% {' r. ]
  15.         this.attackPower = attackPower;
    & H- A1 H; f% ^4 x3 @, a
  16.         this.state = new InitialState(); // Устанавливаем начальное состояние
    4 `% I  o& n) Q3 f2 l% s
  17.     }5 Y- Z) v7 o+ a7 }0 }6 W" p
  18. 8 u) m: ]3 f/ h( R( n- d- \
  19.     // Метод для смены состояния
    1 Y) ~0 {( _" R/ D
  20.     public void setState(MonsterState newState) {
    5 t; k9 C; \8 B9 z% j2 ?: @2 k
  21.         this.state = newState;
    " X* d9 c- D5 a* ^
  22.     }
    5 g3 T5 E8 V( D* b6 T: o- w! }
  23. " c' s% }7 O. z4 b5 |' H
  24.     // Выполнение действий на основе текущего состояния
      n  ?  r4 i" f. O* p
  25.     public void executeState() {
    " p5 @( g# i: n$ q$ u
  26.         state.handleState(this);0 ~0 `$ z' N& y7 R. i2 }
  27.     }
    ' t* R9 m+ l$ F8 n4 [, Z

  28. 5 A0 s8 |- s% q4 n5 t
  29.     // Геттеры и сеттеры
    # r+ W. s" d5 h8 N8 E5 j5 j: R
  30.     public String getName() {
    - D" O+ a( d1 v+ p4 Y
  31.         return name;
    . f) U$ o  u. C$ y4 B0 S
  32.     }
    ( ]4 Y7 c4 i5 t7 Q0 D
  33. 6 {7 I1 t& E% n( F& F
  34.     public double getAttackPower() {
    ; F7 O8 K: f" ?* }* v
  35.         return attackPower;
    2 b/ {( B3 h0 J1 G- p( i6 L
  36.     }# ~2 [& ~, Y5 I) s3 W

  37. : f4 E( J7 V5 y
  38.     public void setAttackPower(double attackPower) {
    " _: _+ P# U+ ^* e
  39.         this.attackPower = attackPower;
    ; C! L. y9 x' z7 T. F8 y' g
  40.     }; R" \: i, C# `6 m% i) \+ P
  41. }
    2 c, q3 {+ {  ]9 Q6 {
Скопировать код

2 R$ b! Z1 e: EШаг 4: Симуляция боя с фазамиТеперь мы можем протестировать логику боя с переключением состояний монстра.
7 e7 G) X: H) c9 X3 T' v+ f
) w% y, r0 K2 t- G" M  s
  1. // Пакет org.l2jmobius.gameserver.model.battle% e) R/ q4 V; l# f3 T
  2. package org.l2jmobius.gameserver.model.battle;  l3 ~+ R6 b" o' S4 n6 K3 M9 n# Q' ^

  3. " Y; t2 A; h% M
  4. import org.l2jmobius.gameserver.model.actor.Monster;
    5 z/ I3 f  J& i) m
  5. import org.l2jmobius.gameserver.model.actor.state.AggressiveState;  k; \/ k$ y* S- d. t) T
  6. import org.l2jmobius.gameserver.model.actor.state.FinalState;
    . ^9 u* L4 Y% C1 ]* T
  7. 3 j+ Y2 I$ g% ^- G1 k# h) T, X' m
  8. public class BattleSimulation {
    9 D# e; ~5 d) \& d0 f1 |) X
  9.     public static void main(String[] args) {
    . i8 d- o* B- L
  10.         // Создаем монстра с начальной атакой
    5 P& ^- ?1 L- _) M4 X
  11.         Monster monster = new Monster("Дракон", 100);
    - h2 @6 V& l1 Y- I6 b9 p: @

  12. ! i% d7 }8 T' ?) r# V  M
  13.         // Начальная фаза& F9 ?& y) F2 D% g
  14.         monster.executeState();
    * a8 t  b9 |3 D

  15. ( D4 Y2 M3 N$ ~% z5 Q3 T* l
  16.         // Переход в агрессивную фазу
    & Y6 O$ u. ?* @% w6 o  A9 p; Y
  17.         monster.setState(new AggressiveState());4 C) v# f2 a2 S! C* A1 b; W1 `8 u5 Q
  18.         monster.executeState();+ M6 V# ~! w1 j3 H3 e4 p2 q

  19.   t3 g; M) _, k) t
  20.         // Финальная фаза
    ( R0 y$ }4 i1 Y0 ^3 Q( e
  21.         monster.setState(new FinalState());
    ! ?0 s% p$ X1 `1 z
  22.         monster.executeState();% X+ {+ m  y5 l0 {" P
  23.     }# c/ u% a2 F. F, {* {2 }
  24. }' u) l5 a9 K  |/ {8 d1 K; J& q3 v
Скопировать код
+ o* M7 ^  v( f1 W/ W
Комментарии по структуре пакетов и классов:
# R; c7 {$ R  i8 w& A& XЗаключениеШаблон "Состояние" позволяет легко управлять фазами боя и не перегружать основной класс монстра. Это делает логику боевых сценариев более гибкой и масштабируемой. В будущем, если появятся новые фазы или состояния, их можно будет легко добавить, не изменяя основной код.
- j+ ]3 r3 c$ X* F! s% _+ c. L$ pЕсли появятся дополнительные вопросы по реализации или структуре классов, буду рада помочь!
2 o2 h, d$ A0 G7 \+ D# C. ?
2 T9 [/ _1 U- I  G6 l; l
0 @% q: w# o# L- B2 q$ ~1 v* ~5 d" M0 B; V" e$ U

1 S; G8 {! i; ^; [6 ]! S
2 n$ u. H% F; I# p* x. R+ m3 w9 s( l7 e- V& [( A2 f) T
+ X5 h/ x4 V, {% U2 L
. q$ p, l3 h5 W% `" |1 P; \

# I& U5 B% v9 `3 c/ o
! u- v' d2 r. p8 e, j! J  _& n2 E, l' _1 j4 e% W7 m
" w) h0 F( H! P  T2 B7 L% q+ {9 z6 n

9 P! B. t/ \9 ?" {1 ^! [+ s# U' c
! ~: E  t" c. ^" S* X3 V/ g& _* D
Автор: AlexCoder    Время: 2024-10-16 21:21
Astraliya опубликовал в 2024-10-16 21:04
) V) m8 }* X' t. Z) s0 R1 UДля управления сложными взаимодействиями, такими как  ...
. F7 \# v4 ]2 N) S8 w# v) u# v7 t7 K
Отличный подход! Использование шаблона "Состояние" действительно помогает сделать код более чистым и управляемым. Я задумался: если мы добавим несколько фаз в бою с различными типами атак (например, магические и физические атаки), можно ли расширить этот паттерн, чтобы каждая фаза также учитывала тип атаки? Например, чтобы в агрессивной фазе монстр мог случайным образом чередовать типы атак. Как лучше организовать это в рамках данного паттерна?
Автор: Astraliya    Время: 2024-10-16 21:33
AlexCoder опубликовал в 2024-10-16 21:21- ?) v- |% ?9 W, I4 h7 d
Отличный подход! Использование шаблона "Состояние" де ...

, G+ P  }" \, _* S+ v( Q6 s/ ~& i$ LХороший вопрос! Да, шаблон "Состояние" можно легко расширить, чтобы учесть различные типы атак. В этом случае можно добавить логику для чередования атак (магических и физических) в каждом состоянии.. _" r. P6 _; h* {5 m0 }

4 p1 |5 V9 o0 K: G& {Шаг 1: Добавление типа атакиДля этого давайте создадим перечисление (enum) для типов атак и добавим его в наши состояния. Это позволит монстру случайным образом выбирать тип атаки во время боя.  m. H: _) R) K- Z

: w  o' A' {% d$ d4 P
  1. // Пакет org.l2jmobius.gameserver.model.actor3 ?+ h! w3 f- p/ x
  2. package org.l2jmobius.gameserver.model.actor;9 U; H% ?5 p" ^

  3. 7 z6 f, `- m) ]+ a; j
  4. // Перечисление для типов атак
    6 N8 c( X% P4 [& Y7 u3 L
  5. public enum AttackType {
    % Q6 E( o, `+ n2 Y4 p# D0 i
  6.     PHYSICAL, MAGICAL;1 j& U  O) L1 A6 y9 k9 z
  7. }1 }% `0 ^% k* M5 B! O/ w" z. e, \
Скопировать код
Шаг 2: Обновление состояний для поддержки разных атакТеперь обновим состояния монстра, чтобы в каждом из них можно было чередовать типы атак.
* y: O) `7 i7 w* F$ c  LОбновленный класс для агрессивного состояния монстра:  B% p! J) G) M: T: i0 ?5 l# x6 U( x

) t$ H4 z( }- F' O, X
  1. // Пакет org.l2jmobius.gameserver.model.actor.state2 D- Q# e' O4 E$ }: w- `+ ]
  2. package org.l2jmobius.gameserver.model.actor.state;
    ' x$ I2 u' p0 I6 Y! H  {

  3. / b  O4 h  S" Z; W# U+ i! n
  4. import org.l2jmobius.gameserver.model.actor.Monster;
    # E! D) [( O1 C7 f5 V
  5. import org.l2jmobius.gameserver.model.actor.AttackType;
    , E2 a3 R. |/ s% k1 p

  6. * X4 \0 |7 f5 F' ]/ W) m) {; N
  7. import java.util.Random;
    - z& c. c; l% b" ?# Q& L4 _1 D
  8. ) z1 `5 T8 X4 Q9 f
  9. public class AggressiveState implements MonsterState {0 D  }' l2 d( K1 W0 j
  10.     private Random random = new Random();& {1 x& D! E$ I4 G. R0 s) y

  11. 1 l0 }1 o( I) j7 p
  12.     @Override
    + _) O. n% n9 N  y- f0 n, U1 z
  13.     public void handleState(Monster monster) {+ f  t/ U2 m1 J! j9 F! W
  14.         // Выбираем случайный тип атаки: физическая или магическая) M+ ?4 Z( I, M4 F2 f' t
  15.         AttackType attackType = random.nextBoolean() ? AttackType.PHYSICAL : AttackType.MAGICAL;; n+ v" S7 G! l( R4 l

  16. 3 j: t& r9 T; e
  17.         // Логика для агрессивной фазы боя
    ( e3 E6 v& p/ L* C* m* @# n
  18.         System.out.println(monster.getName() + " становится агрессивным и использует "
    3 C: x6 A' G7 g/ U: p2 ]* S
  19.             + (attackType == AttackType.PHYSICAL ? "физическую" : "магическую") + " атаку!");- U3 Q6 o; F1 t6 \$ d1 g$ B- F
  20.         & V- C" G( Y  B& T9 \
  21.         // Увеличиваем силу атаки в зависимости от типа атаки
    + \' O" N+ k; T) s4 a
  22.         double multiplier = (attackType == AttackType.PHYSICAL) ? 1.5 : 1.2;
    * [  A3 P2 h' a/ c8 Q$ N
  23.         monster.setAttackPower(monster.getAttackPower() * multiplier);3 G  Z# Z: y0 B& b' Y
  24.     }; M, u& v2 e7 [
  25. }5 n; F4 C( `2 i5 r
Скопировать код
Шаг 3: Модификация класса MonsterТеперь класс Monster будет использовать состояние с логикой выбора типа атаки
9 h5 V' r' W' f6 z7 J+ v; _8 S7 C9 t+ @" k! K8 |
  1. // Пакет org.l2jmobius.gameserver.model.actor! T- B; F3 X7 i# ~+ l
  2. package org.l2jmobius.gameserver.model.actor;7 x9 Z& ~' V9 @- f
  3. - l# D+ t) k- B! ^, b/ _% g/ X
  4. import org.l2jmobius.gameserver.model.actor.state.MonsterState;
    & ?  `% ^, |4 O. z6 k( ^8 L
  5. import org.l2jmobius.gameserver.model.actor.state.InitialState;1 ]& l/ r9 v3 }) L; p

  6. * N( y; f( P& B1 ]7 u1 t
  7. public class Monster extends Creature {* `3 P3 q* M' o: |
  8.     private String name;
    ( G" d8 W% t: L$ v1 C
  9.     private double attackPower;
    ) C6 q+ B# Q) S7 _
  10.     private MonsterState state; // Текущее состояние монстра
    + i! _0 E; `  |) {( A  \
  11. 5 l; V2 f- ~! K
  12.     // Конструктор монстра
    7 [7 P% G" B! b6 |  Y/ J5 L
  13.     public Monster(String name, double attackPower) {
    # a; W; P4 d! l' k% e
  14.         this.name = name;
    5 r5 `; ^1 X! K# h2 s1 w0 R
  15.         this.attackPower = attackPower;7 u' `. \1 e! T: l
  16.         this.state = new InitialState(); // Начальное состояние по умолчанию
    5 P# k4 H' H* X4 }+ B' R8 c8 ]
  17.     }
    3 T* [5 t/ a8 i; `  i& N

  18. / O, F8 ^% ~: m
  19.     // Метод для смены состояния- r2 G) ~& T8 a; O: W! ?2 `
  20.     public void setState(MonsterState newState) {/ C/ @9 B3 v. K# J0 y2 ~
  21.         this.state = newState;, O7 [$ h- t3 X% f2 b# ^
  22.     }4 Z, \' h0 G1 z, U; n% j! g* x6 j
  23.   O: B/ y; `: g2 f! F2 H
  24.     // Выполнение действий на основе текущего состояния
    5 s0 O7 C* @+ \% Z
  25.     public void executeState() {- H% F/ @5 b- o9 E
  26.         state.handleState(this);  X6 D" |6 W2 ^
  27.     }$ n: l4 K/ w( B
  28. . Z2 E1 \5 O. U
  29.     // Геттеры и сеттеры' r- P2 h: m& r8 J
  30.     public String getName() {
    ) @0 G, i( f% _2 A( l6 f  V  X
  31.         return name;
    - U$ u4 {# u4 a& s7 h6 G
  32.     }
    8 Y5 R& ?* P% Q1 {; Q
  33. 8 }1 Y* O; u) _. s) T- @" c6 j
  34.     public double getAttackPower() {
    % H- i: D  Z7 _' G
  35.         return attackPower;
    ! z- F, ]! \6 c. L7 h6 K# ?# |/ p
  36.     }; k- m7 M2 |3 w# y9 p
  37. , s) O2 r/ l  [/ N
  38.     public void setAttackPower(double attackPower) {5 I3 p5 N9 Q4 {* `: {' t' d
  39.         this.attackPower = attackPower;  U7 d: \. O* x: ]9 w8 ], `
  40.     }
    # x( p" v2 h7 P8 M& ?7 ]! p
  41. }
    7 W; ]3 ]8 a3 z# Y7 t+ v" ^
Скопировать код
Шаг 4: Тестирование нового поведенияТеперь давайте посмотрим, как монстр будет чередовать типы атак в агрессивной фазе.
0 }3 ?$ a: z! c/ f. G
7 C6 I9 w8 N; R' P) @1 \
  1. // Пакет org.l2jmobius.gameserver.model.battle
    5 p* l0 W7 h9 N
  2. package org.l2jmobius.gameserver.model.battle;: \* S0 M0 ]+ O. t- r

  3. 9 Q, `  A8 V9 ?# e8 N* S0 o4 r$ m+ O
  4. import org.l2jmobius.gameserver.model.actor.Monster;3 p, A8 e1 U3 b" W" K
  5. import org.l2jmobius.gameserver.model.actor.state.AggressiveState;/ e; c1 }' q9 e* S

  6. 3 `# l0 A) c; q1 J( q! y# ^
  7. public class BattleSimulation {
    . t4 \/ D& R' \1 `5 x4 ~# r
  8.     public static void main(String[] args) {
    3 K% d- V4 k' g4 `+ @' g4 Y
  9.         // Создаем монстра
    " u. X0 M9 x+ M; Z* E, }) ^  V1 [
  10.         Monster monster = new Monster("Дракон", 100);( V( F; e" d: R; q0 m/ i
  11. 0 ?) z- J% ~8 d1 Z+ j( {) B+ S
  12.         // Переключаем монстра в агрессивное состояние с разными типами атак) r$ }. N  {9 Y+ I/ z! d- T
  13.         monster.setState(new AggressiveState());
    7 \) r: ~& P6 Z% @. T! o
  14.         monster.executeState();6 V3 M, v  w/ j& q3 i
  15.         monster.executeState(); // Повторяем, чтобы увидеть чередование атак& S, N" e- a' f" u. f7 G4 s0 I3 p6 e6 Y3 |/ f
  16.     }
    ; A" i1 c: r. B
  17. }
    8 N8 a. n' [( ^* l
Скопировать код
ЗаключениеВ результате, с помощью перечисления AttackType, мы можем легко добавлять и чередовать типы атак в зависимости от состояния. Это гибкий способ управления сложными взаимодействиями в бою, не перегружая основной код. Выбор типа атаки можно ещё больше расширить, добавив, например, урон или специальные способности, в зависимости от типа атаки.
3 X" [. W. j9 k, Z( k- ]3 l: rЕсли у тебя есть еще идеи или предложения по улучшению, всегда рад обсудить!) l, w; p1 o1 y: W2 t, Z

" [$ s1 s) _. s- Y! i! E% d6 k) a! [: e" V- a# E
6 m6 k8 R6 f" e% Z




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