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

Название: Шаг 3.3: Взаимодействие игровых объектов [Версия для печати]
Автор: Astraliya    Время: 2024-10-16 17:54
Название: Шаг 3.3: Взаимодействие игровых объектов
Добро пожаловать в обсуждение статьи "Шаг 3.3: Взаимодействие игровых объектов"!
9 M- U! j6 X3 n- q: q1 i- Y3 C8 J7 r) @- v  D- O& C! s$ {

( T* f- F& B" {! W  k5 @1 z5 m3 vЗдесь вы можете задавать любые вопросы, связанные с реализацией взаимодействий между игровыми объектами, такими как игроки, NPC и монстры, в серверной разработке Lineage 2 на Java. Обсудим, как создать динамическое взаимодействие в игровом мире, как правильно использовать события и триггеры, и как улучшить боевые и диалоговые системы.
6 G$ b* w! |8 ?3 G- [Задавайте вопросы, делитесь опытом, предложениями и идеями — ваше участие поможет углубить наши знания и сделать разработку серверов еще более интересной!. b+ L) `4 j, K' M7 s5 r' g( \
Астралия ?
" q% w3 _! `9 A+ d: v
; _9 e6 J' D3 w0 _; m
Автор: AlexCoder    Время: 2024-10-16 18:31
День добрый!
+ H* z; u9 ?, g/ k0 w: g% m( W% SВ статье описано взаимодействие игрока с NPC и монстрами через простые методы. Как лучше всего реализовать более сложные взаимодействия, например, если нужно добавить несколько фаз боя с разными состояниями монстра? Есть ли оптимальный способ управления состояниями объектов, чтобы не перегружать логику боевых сценариев?
4 O2 u8 b) L, d: r! h7 e
( n7 R$ p7 n; d. p
Автор: AlexCoder    Время: 2024-10-16 20:53
Последний раз это сообщение было отредактировано AlexCoder в 2024-10-16 20:54
: t0 i/ w& Q2 _  D. S4 G  ~
AlexCoder опубликовал в 2024-10-16 18:31
" w8 L0 p5 c/ ?2 Y+ ?  LДень добрый!+ s+ S! O6 E2 ]0 P
В статье описано взаимодействие игрока с N ...

" d2 i9 D& a6 @! dДля управления сложными взаимодействиями, такими как несколько фаз боя с разными состояниями монстра, лучший подход — использовать шаблон проектирования "Состояние" (State Pattern). ' O3 i* D, Q9 K) b: R

3 Y' j$ c5 N8 w/ kЭтот шаблон позволяет разделить логику поведения объекта на разные состояния и управлять ими более гибко, избегая перегрузки основного класса монстра.
9 H/ a, P6 `& s8 k' |0 R" f1 i/ @& U* V- T6 {7 J
Шаг 1: Создание интерфейса для состояний монстраПервый шаг — создать интерфейс, который будет представлять разные состояния монстра. Этот интерфейс определяет метод, который будет вызываться в зависимости от текущего состояния.3 z2 [/ O& L  Y- Y; m3 d) |2 q: t
& W0 _* C* {: q% U3 E0 n/ L+ ]
  1. <font color="Green">// Пакет для состояний монстра</font>
      U! Q; q1 L) [
  2. package org.l2jmobius.gameserver.model.actor.state;, W4 {3 r* K- S) X4 Y$ R
  3. <font color="Green">
    9 F, C6 N4 U7 X
  4. // Интерфейс, представляющий состояния монстра</font>
    ' q, x$ l& [0 ]4 ?% _+ @
  5. public interface MonsterState {
    * T2 j; L9 B* I1 }
  6.     void handleState(Monster monster);+ `$ b) e' @7 ?: q  J5 N: @+ E
  7. }+ c, |9 f9 M4 Y
Скопировать код

6 U3 _. ]4 A! nШаг 2: Реализация различных состоянийТеперь создадим классы для каждого состояния: например, InitialState, AggressiveState и FinalState. Эти состояния будут реализовывать интерфейс MonsterState и определять поведение монстра на разных этапах боя.  |) E% J3 \; G9 w

+ m! p1 i& h( dКласс для начального состояния монстра:
; L* ]: o9 k& g
  1. <font color="Green">// Пакет org.l2jmobius.gameserver.model.actor.state</font>4 I; A9 ~" T( G' m; k( k
  2. package org.l2jmobius.gameserver.model.actor.state;! o/ S5 C5 J5 l
  3. % G3 r- `0 ]$ Z! [
  4. import org.l2jmobius.gameserver.model.actor.Monster;, j# P' A  {+ E+ T

  5. # b7 H2 w& A6 n& \6 b$ z* s
  6. public class InitialState implements MonsterState {
    4 T/ ~8 ?3 I  O2 ]1 i+ Q
  7.     @Override
    # K- `( P: c. b3 W# Y& h" |( L
  8.     public void handleState(Monster monster) {
    " N5 X, q" ~3 w7 e6 c
  9.         // Начальная фаза боя/ O3 T/ s3 R# }$ @4 ]% U
  10.         System.out.println(monster.getName() + " начинает бой с обычной атакой.");
    # e. T. l& o, g( |- B' _
  11.     }6 T7 d7 l. r5 A$ u
  12. }6 I2 T2 u1 V# b9 `- ?
Скопировать код

# O$ w3 g' i+ {7 ~3 s& g: G0 `6 g5 x" E8 g! k4 d  z* J1 G
6 j' X( d4 g: p( K, N
. l6 g) ?. K3 ]& r5 F# @

' l+ I" r- a3 z; n0 X
/ R: b' n8 _7 w) y
; ?6 m6 D. {  a5 [$ p
Автор: Astraliya    Время: 2024-10-16 21:04
Для управления сложными взаимодействиями, такими как несколько фаз боя с разными состояниями монстра, лучший подход — использовать шаблон проектирования "Состояние" (State Pattern).
; e5 G4 L- t1 ?
9 s, Q. }! v! `Этот шаблон позволяет разделить логику поведения объекта на разные состояния и управлять ими более гибко, избегая перегрузки основного класса монстра.
, @# S! m2 ]! T& A! u4 Y0 O
( y, ?( g% W  F, I3 fШаг 1: Создание интерфейса для состояний монстраПервый шаг — создать интерфейс, который будет представлять разные состояния монстра. Этот интерфейс определяет метод, который будет вызываться в зависимости от текущего состояния.$ y& K, |" C+ u* P( W8 N

2 @9 D; {2 h+ o( k
  1. // Пакет для состояний монстра  f$ p  ~# k: S3 \" i) q( G* }3 `
  2. package org.l2jmobius.gameserver.model.actor.state;% z  I9 J5 u$ I! q4 B! b
  3. - I7 l5 e. O7 L: {
  4. // Интерфейс, представляющий состояния монстра/ U, l% I7 E  j8 C$ z  U# J
  5. public interface MonsterState {* C& ^0 z1 U/ i$ C7 p5 ~* _: i% Z
  6.     void handleState(Monster monster);3 k  u2 j2 d3 F6 p- W0 i
  7. }, ^; S5 K! f5 Y
Скопировать код

2 o" K7 n& u/ O/ \; I9 fШаг 2: Реализация различных состоянийТеперь создадим классы для каждого состояния: например, InitialState, AggressiveState и FinalState. 5 A" C2 K. G  T5 ~

4 p6 o' F& n- G3 ?- fЭти состояния будут реализовывать интерфейс MonsterState и определять поведение монстра на разных этапах боя.& c3 X/ P1 ]7 p
& y6 s7 J. I/ I% j1 I0 A* z/ R
Класс для начального состояния монстра:1 J: |: I# L9 M; D
  1. // Пакет org.l2jmobius.gameserver.model.actor.state$ A1 c# e$ L3 T+ Z  [  I
  2. package org.l2jmobius.gameserver.model.actor.state;, j$ ?. i$ h, B$ |5 z( @

  3. 8 u8 l$ V: _. ?1 r% V
  4. import org.l2jmobius.gameserver.model.actor.Monster;" l/ P) J2 J$ h5 H- U# K2 D
  5. # b9 s" G1 q( X' Q' \# p; H5 X
  6. public class InitialState implements MonsterState {: S8 K! f& i7 x" r
  7.     @Override
    . q. X& A( f8 o6 _
  8.     public void handleState(Monster monster) {
    % T7 z8 x( z* }$ B2 C
  9.         // Начальная фаза боя
    3 T  d! G5 U, y* W8 ]: t8 p
  10.         System.out.println(monster.getName() + " начинает бой с обычной атакой.");, I& Z% [$ L- X, y! B6 m9 a
  11.     }
    ( E$ ~3 E  b3 k
  12. }0 \3 U- p$ u6 Z+ m
Скопировать код
Класс для агрессивного состояния монстра:
; b( a9 F7 E" U
  1. // Пакет org.l2jmobius.gameserver.model.actor.state
    ' t4 D7 r$ z( R
  2. package org.l2jmobius.gameserver.model.actor.state;
    2 H& ?7 T* }1 ?6 h' \; n' I

  3. 8 t/ a2 e! [  o
  4. import org.l2jmobius.gameserver.model.actor.Monster;
    ' m3 `& f4 [+ r

  5. 9 Q5 A; R* f/ g: e* S/ ^
  6. public class AggressiveState implements MonsterState {( I0 S/ e3 U6 X* b# l, c
  7.     @Override+ C  N/ r  {) N/ b* i  Q
  8.     public void handleState(Monster monster) {" p" U6 w( d1 f* }, D
  9.         // Агрессивная фаза боя
    . _6 j; t' F: V' Y
  10.         System.out.println(monster.getName() + " становится агрессивным! Атаки усиливаются.");  X: ^' g) F% q" x  ?  ?
  11.         monster.setAttackPower(monster.getAttackPower() * 1.5); // Увеличиваем силу атаки; q. y# G6 f1 U) h; E! T+ J7 ^
  12.     }
    # h# ?2 N) ~! Y* j, S
  13. }
    $ U7 c5 Y5 v. ?
Скопировать код
Класс для финального состояния монстра:
2 D( ]( e* K" Y
  1. // Пакет org.l2jmobius.gameserver.model.actor.state
    7 `- b1 n8 A/ e: _
  2. package org.l2jmobius.gameserver.model.actor.state;6 @. Z* d; o4 V* o$ ~( k. j; M
  3. 9 g% B2 t1 E/ R. ]8 o$ \3 ]6 x
  4. import org.l2jmobius.gameserver.model.actor.Monster;' F) ?2 i* r( W' n4 L9 ]7 |; f; n

  5. 7 [1 j  \" |( ]  u  b* f
  6. public class FinalState implements MonsterState {
    & q8 C% u8 k! |, I3 C2 S' n  H$ @
  7.     @Override
    # `1 `; t# I! f+ s4 }% y
  8.     public void handleState(Monster monster) {
    . n9 J5 X; B8 P+ n5 [" a5 Y
  9.         // Финальная фаза боя
    3 U  p# f- c. y" J1 y9 E/ O
  10.         System.out.println(monster.getName() + " готовится к финальной атаке!");( u$ E/ A+ C" t+ C( D, R9 l
  11.         monster.setAttackPower(monster.getAttackPower() * 2); // Максимальная сила атаки
    8 l  \- J- U$ d, G2 U) ?
  12.     }0 R0 Q/ W3 ?) V% s3 h( D& p8 j) O
  13. }
    2 O7 r9 _6 {4 ?
Скопировать код
4 _0 v% S( o3 T, x* j- M) D
Шаг 3: Изменение класса MonsterЧтобы монстр мог переключаться между состояниями, нам нужно обновить класс Monster. В этой сборке L2J_Mobius, классы для игровых объектов, таких как монстры, находятся в пакете org.l2jmobius.gameserver.model.actor.
0 K" I' M- y! ]2 z8 s( ~# M8 ~
  1. // Пакет org.l2jmobius.gameserver.model.actor
    $ o/ i( j" G; I  D" k
  2. package org.l2jmobius.gameserver.model.actor;
    / X- I- Z+ c, b3 p! L* n( o* d! B$ e2 Y
  3. / q# T* K( l; L2 d# f# l1 ?
  4. import org.l2jmobius.gameserver.model.actor.state.MonsterState;
    # g- K; ~1 G# y: R( c: ]1 @9 e. A
  5. import org.l2jmobius.gameserver.model.actor.state.InitialState;
    ; N' h) d/ x# [

  6. & M8 j4 j2 G( |* z& X  _1 ^
  7. public class Monster extends Creature {2 ]- ^4 ?0 S0 z  B4 O2 F
  8.     private String name;
    9 J% S# y8 t# J& J0 m( q" c
  9.     private double attackPower;
    ) T. ]5 W- I7 r7 ?( y& g
  10.     private MonsterState state; // Текущее состояние монстра
    : N! W2 h  P, d1 \6 G/ s, g  \6 }
  11. 7 }/ h& @0 y; Y( `9 _7 f2 Z' [
  12.     // Конструктор монстра8 K; I* |5 |" p! Y, ~+ \7 o  [' ~
  13.     public Monster(String name, double attackPower) {& ^* |" A7 e4 N: ~6 m
  14.         this.name = name;! s' z2 |, x9 U  Y$ [% e
  15.         this.attackPower = attackPower;
      |: y" w6 L# e/ P0 f; B' E
  16.         this.state = new InitialState(); // Устанавливаем начальное состояние% N3 K0 t. T! h' c: b
  17.     }
    . ^4 w0 s$ I& y/ e  h0 H
  18. : o2 E* [$ F% d
  19.     // Метод для смены состояния
    9 E* j% b* T! O9 U% z
  20.     public void setState(MonsterState newState) {9 ]  G1 D! \, A3 ^( k
  21.         this.state = newState;3 Q( t$ q0 Q/ X: b
  22.     }
    9 {( ^3 L% v: R( D3 X8 c7 K/ l

  23. ; g2 U4 s) t/ u+ v3 ~- a! D7 B6 _: S
  24.     // Выполнение действий на основе текущего состояния' T0 A2 {& `; x, U1 f, S; O  |9 Y6 R
  25.     public void executeState() {
      t, x! S% V4 y' L: i2 P
  26.         state.handleState(this);
    " o, P0 @6 R, p! O" Q% m' m( C
  27.     }6 C* X4 C5 X* y. r7 d) W

  28. 0 A( r" s7 `( F8 w" _6 m- {3 H
  29.     // Геттеры и сеттеры3 a2 ^: h; ]7 K6 A9 z! W' W: ?, k# D
  30.     public String getName() {
    % a- ^" d! ]0 _+ {2 r4 p; L
  31.         return name;
    6 ~, F6 [8 v" J3 p; \2 I' y" {
  32.     }
    ! f) k9 o; P: e5 c
  33. 1 }# w. _# }. k2 b; U* \. m
  34.     public double getAttackPower() {
    # |5 }- A# _3 j7 g8 j. Q
  35.         return attackPower;
    ! d4 O4 W' D% s8 d8 z
  36.     }9 V2 X6 E3 y# Y& g

  37. & g8 [) F+ k  c- ^) T4 q7 z
  38.     public void setAttackPower(double attackPower) {
    ' i6 H. }4 E& w0 ?5 o3 l. K
  39.         this.attackPower = attackPower;3 J+ a2 h3 r+ O" P. @
  40.     }9 H) p$ s' R2 H2 d. s5 u
  41. }
    ' l: M$ U6 r) o4 I* I1 I
Скопировать код

/ C+ t( E' A+ `0 p7 c; m8 E+ mШаг 4: Симуляция боя с фазамиТеперь мы можем протестировать логику боя с переключением состояний монстра.7 j+ `. w1 u  k
. R: Y' k& _  [: K! x5 F2 {- ]
  1. // Пакет org.l2jmobius.gameserver.model.battle
    8 v& C: ?- M0 q' J; F
  2. package org.l2jmobius.gameserver.model.battle;4 y' e6 ~: ]* H8 X" q) D6 i3 Q

  3. $ E" g7 I2 f7 q5 n9 [  H; s
  4. import org.l2jmobius.gameserver.model.actor.Monster;
    # j# q! J. l( C# {/ x
  5. import org.l2jmobius.gameserver.model.actor.state.AggressiveState;) Z+ p+ Z* D' @0 |$ `
  6. import org.l2jmobius.gameserver.model.actor.state.FinalState;5 |5 z5 h5 r/ _; D

  7. 4 \3 S. ^$ o0 e+ Z* _( V
  8. public class BattleSimulation {5 b9 U% P3 }& ~" g
  9.     public static void main(String[] args) {
    4 o# D1 [; ^) J
  10.         // Создаем монстра с начальной атакой% {1 z/ u; P! U# p# S+ j
  11.         Monster monster = new Monster("Дракон", 100);
    1 s( X( C5 ]- ?% L2 V0 X

  12. + S9 f: M  m. t' J6 a: x* I
  13.         // Начальная фаза
    : Z1 ]& D  k( u! S% l/ R
  14.         monster.executeState();. M8 j5 p" s' ?1 i1 o

  15. . X2 ^; x7 O8 a; ]: ?' l, v
  16.         // Переход в агрессивную фазу$ m# D9 l' ?0 D$ J- `
  17.         monster.setState(new AggressiveState());4 b& J  r+ e/ D
  18.         monster.executeState();
    # T2 f" `' Z4 P

  19. / X* H$ _( ]4 O
  20.         // Финальная фаза" i. X9 G9 v) c+ L
  21.         monster.setState(new FinalState());! y  j) Y) F8 `+ D$ y0 N
  22.         monster.executeState();  A# `5 v% @# j1 _- e8 N
  23.     }
    0 b. G  N/ F6 B: t$ S
  24. }
    2 F6 P; m% w$ o: _
Скопировать код
- |5 @( F/ }! g- R) ~1 z
Комментарии по структуре пакетов и классов:/ r. N4 R# u$ J1 w( t: S  P; N' q
ЗаключениеШаблон "Состояние" позволяет легко управлять фазами боя и не перегружать основной класс монстра. Это делает логику боевых сценариев более гибкой и масштабируемой. В будущем, если появятся новые фазы или состояния, их можно будет легко добавить, не изменяя основной код.' l7 j  Z8 L$ ]0 L9 Z
Если появятся дополнительные вопросы по реализации или структуре классов, буду рада помочь!6 ?5 D; g: P* W9 @8 ?( u% p
  I, B) [, t; y0 i& Y% g$ x# E

  {  _9 p4 l6 K: K; j! l5 S" f. `
1 D8 E9 b2 ^) [) d9 U! I
  a$ |4 l; ?( R7 n: K; q+ C" Z6 l: z5 ?4 U' I1 t& @/ _- }( C
  V0 g9 [/ Z; v5 a7 S: p( A. |
1 ^* i, S: k4 {

" N! ?3 M# O) D" L( ^* m/ w$ i0 X% z& n5 E% x
$ L* h: V' _6 M5 x5 Y  `% v9 M
6 K. c# P! q1 f" w1 D: c- q
0 ~3 S( ?. e7 p5 ?

- F- v6 U+ N* J: i
, D1 ~1 q. D+ W, t. _" k& ^$ |
Автор: AlexCoder    Время: 2024-10-16 21:21
Astraliya опубликовал в 2024-10-16 21:04
- i, w" l; b6 X* n; Y. JДля управления сложными взаимодействиями, такими как  ...
" x& K% {4 C9 `. r
Отличный подход! Использование шаблона "Состояние" действительно помогает сделать код более чистым и управляемым. Я задумался: если мы добавим несколько фаз в бою с различными типами атак (например, магические и физические атаки), можно ли расширить этот паттерн, чтобы каждая фаза также учитывала тип атаки? Например, чтобы в агрессивной фазе монстр мог случайным образом чередовать типы атак. Как лучше организовать это в рамках данного паттерна?
Автор: Astraliya    Время: 2024-10-16 21:33
AlexCoder опубликовал в 2024-10-16 21:21  `$ J0 S+ I0 h8 {8 C- q) I
Отличный подход! Использование шаблона "Состояние" де ...

  `6 T8 \  C  m+ a) O+ xХороший вопрос! Да, шаблон "Состояние" можно легко расширить, чтобы учесть различные типы атак. В этом случае можно добавить логику для чередования атак (магических и физических) в каждом состоянии.
* N7 F8 s4 I' w5 V# Q4 X0 P# D3 y8 S* c+ u8 R$ h3 }) f
Шаг 1: Добавление типа атакиДля этого давайте создадим перечисление (enum) для типов атак и добавим его в наши состояния. Это позволит монстру случайным образом выбирать тип атаки во время боя.8 P6 M0 b3 O  N& z% e) W9 z

# O" A/ e9 Y3 M* H2 M1 J9 I
  1. // Пакет org.l2jmobius.gameserver.model.actor- d/ Q; J3 b: b1 `% j
  2. package org.l2jmobius.gameserver.model.actor;  z+ w8 }; L5 c% E! c% L% f& ~
  3. * U' ?0 l9 u2 _  d! ?; [: P
  4. // Перечисление для типов атак
    , K) U0 M% G) L. Z8 m) j1 C( f
  5. public enum AttackType {
    / i3 J& V) r4 D' _; O2 Y0 N! J
  6.     PHYSICAL, MAGICAL;
    9 r( s+ z4 V' N* m
  7. }
    , p, [3 d' n# Q3 M9 J. W% K
Скопировать код
Шаг 2: Обновление состояний для поддержки разных атакТеперь обновим состояния монстра, чтобы в каждом из них можно было чередовать типы атак.
- U) R; s, @3 P5 }; CОбновленный класс для агрессивного состояния монстра:
* i6 ~. p  I1 {: {( |' u, Q
. T/ k- {2 e+ Y! u7 ]$ A" @2 k
  1. // Пакет org.l2jmobius.gameserver.model.actor.state
    & `. d9 b* q, K+ |: V9 H
  2. package org.l2jmobius.gameserver.model.actor.state;4 {4 o" X0 `7 U* L" }
  3. + f/ q% P* ~+ i
  4. import org.l2jmobius.gameserver.model.actor.Monster;
    # [0 ?& U& n$ |! ?
  5. import org.l2jmobius.gameserver.model.actor.AttackType;
    " r# C" L/ |: y# B* {( `

  6. 3 ?7 _- \' U$ v1 d( G
  7. import java.util.Random;  ?# {/ m' Z, c

  8. " R1 P4 `( C3 i/ p
  9. public class AggressiveState implements MonsterState {* ]3 E$ f8 q$ |$ s5 r: \
  10.     private Random random = new Random();5 I* o; K* `1 s. ?: a7 i
  11. - K: G. ]9 z& S
  12.     @Override
    " V" ]( E  {% H
  13.     public void handleState(Monster monster) {
    ; }' K4 |2 z: G% [
  14.         // Выбираем случайный тип атаки: физическая или магическая) w2 F6 h! N0 M0 |6 A
  15.         AttackType attackType = random.nextBoolean() ? AttackType.PHYSICAL : AttackType.MAGICAL;
    # y; y# L! d/ h4 s

  16. $ G# t  N) B$ K) G0 l# X$ W; n3 f: N7 M
  17.         // Логика для агрессивной фазы боя
    / t0 g+ z8 Z4 \( r3 Z- w2 n- {* c
  18.         System.out.println(monster.getName() + " становится агрессивным и использует " 0 J& k* e& M8 ^% Y- L; M0 N5 r  S, O7 c
  19.             + (attackType == AttackType.PHYSICAL ? "физическую" : "магическую") + " атаку!");
    - d( y. t1 _1 ~* P
  20.         
    / P1 E! W1 w1 i. ]
  21.         // Увеличиваем силу атаки в зависимости от типа атаки
    6 y# @0 x4 g: ^  g  B
  22.         double multiplier = (attackType == AttackType.PHYSICAL) ? 1.5 : 1.2;+ V% y2 x/ {% S$ N5 V3 D; d* t# O5 k
  23.         monster.setAttackPower(monster.getAttackPower() * multiplier);
    " K2 y& H' D, w2 o0 v
  24.     }
    * \% P# m! n* X" ^3 w
  25. }
    + I' @3 r: u* M( R
Скопировать код
Шаг 3: Модификация класса MonsterТеперь класс Monster будет использовать состояние с логикой выбора типа атаки
  W: p  T3 i* d  C" x2 E+ m" r  Q" V& S$ m, q. t
  1. // Пакет org.l2jmobius.gameserver.model.actor) P9 q( w2 b& Q& s% d
  2. package org.l2jmobius.gameserver.model.actor;: R: ]% b: \" l( W% I; Q& I/ o- l
  3. 8 {! H6 s( ^1 [& H% Q8 E/ J5 i- K
  4. import org.l2jmobius.gameserver.model.actor.state.MonsterState;
      Q! d! w3 p' Q; q1 K' H
  5. import org.l2jmobius.gameserver.model.actor.state.InitialState;; Y$ q2 ]. {9 [
  6. ! ~, {. H8 J0 y0 @: z
  7. public class Monster extends Creature {
    # g0 d7 F8 L+ ]; k5 S2 q; V! K- S
  8.     private String name;7 g. N! }9 m  h: X2 h
  9.     private double attackPower;+ ?& C6 Z, S2 L5 ]$ F/ r. i
  10.     private MonsterState state; // Текущее состояние монстра7 }6 H0 t# E- S

  11. - ]' x. r* ~+ R% N
  12.     // Конструктор монстра  G2 U6 h3 P' V# k0 c" c- t
  13.     public Monster(String name, double attackPower) {* e1 A2 p% W8 F+ y1 ^( k: X. N6 \
  14.         this.name = name;* p% b/ H( B* l2 C: z# Y8 r- {5 p7 H
  15.         this.attackPower = attackPower;+ M: J' T; ^2 l0 ^' m
  16.         this.state = new InitialState(); // Начальное состояние по умолчанию
    4 ]0 f$ f3 X1 |* o5 f% M
  17.     }
    9 `+ P5 P- S, }: q4 D6 a' c

  18. 8 R* a7 @0 c& `/ k5 @
  19.     // Метод для смены состояния
    ! z# W  E% t8 M
  20.     public void setState(MonsterState newState) {* B/ Q/ h6 @# u: T" `; G
  21.         this.state = newState;
    4 g" {4 I' P0 b% I' ]
  22.     }- c$ a, S6 a& g6 E2 O( e& F) H* ?
  23. 7 g5 ]; e! c+ R* h) D2 o4 J+ b
  24.     // Выполнение действий на основе текущего состояния5 D1 L. @( l8 h3 \+ _* D0 S/ |
  25.     public void executeState() {1 c  O7 a! {" k% {
  26.         state.handleState(this);3 Y2 p$ V  ]8 V
  27.     }4 s/ h. E2 E; ]6 ^# Q( t9 k8 H( r
  28.   t8 H- Q0 a) E
  29.     // Геттеры и сеттеры
    3 a2 C8 s5 R: t: a" R3 a
  30.     public String getName() {/ t/ L, z$ b# _" u. v- M
  31.         return name;& A6 e( Y6 l) z0 u
  32.     }
    3 _7 B: J' x3 }

  33. 6 b1 e7 [4 T7 G3 D/ E& ^( ^
  34.     public double getAttackPower() {4 G2 N4 \1 G0 c4 f
  35.         return attackPower;# F% m& t" T- L0 I6 M) ]
  36.     }
    ! b' T" a* u" ?+ A
  37. " H% I% @) A, v! p; Z) \
  38.     public void setAttackPower(double attackPower) {
      ?' q' h7 L8 U; _: K( @. G; b
  39.         this.attackPower = attackPower;& ]& j: m9 M, d: w2 O
  40.     }
    $ V4 K: {! W' M; C/ ~5 A: g
  41. }
      h* \) G6 {# `/ C
Скопировать код
Шаг 4: Тестирование нового поведенияТеперь давайте посмотрим, как монстр будет чередовать типы атак в агрессивной фазе.8 K7 d% C& j& u% J, H: C8 H

% b0 h6 s2 r6 J4 g
  1. // Пакет org.l2jmobius.gameserver.model.battle
    - z1 O& h( H. k) C8 B
  2. package org.l2jmobius.gameserver.model.battle;
    0 [, U2 Z3 U/ X% W

  3. . U% s& d& N# @1 m
  4. import org.l2jmobius.gameserver.model.actor.Monster;
    ) E3 r8 ~8 ^' b1 L# w
  5. import org.l2jmobius.gameserver.model.actor.state.AggressiveState;. Y* _8 q  o/ X/ h6 E. Q

  6. 5 h  l3 L; s2 U
  7. public class BattleSimulation {, {4 a1 ~9 W4 {) k; L; o
  8.     public static void main(String[] args) {
    8 N" N1 I2 ^% ^& a6 L, a
  9.         // Создаем монстра+ H7 z1 k( K3 B6 H% l
  10.         Monster monster = new Monster("Дракон", 100);* j+ `- |% {, y8 J3 O& q

  11. ! \  H4 ]2 B) Y' c6 z2 ]5 L! T
  12.         // Переключаем монстра в агрессивное состояние с разными типами атак- u- c3 J- T' M+ c' [$ B7 B
  13.         monster.setState(new AggressiveState());
    8 A" u0 T1 K3 C: I% B; _+ M3 m" o
  14.         monster.executeState();. g+ a/ d. n4 N
  15.         monster.executeState(); // Повторяем, чтобы увидеть чередование атак  _9 ?% B# w4 Q/ i# [
  16.     }
    & A8 X! e7 y8 @$ b1 ^' j1 r
  17. }
    5 }- a* I1 F* t4 a
Скопировать код
ЗаключениеВ результате, с помощью перечисления AttackType, мы можем легко добавлять и чередовать типы атак в зависимости от состояния. Это гибкий способ управления сложными взаимодействиями в бою, не перегружая основной код. Выбор типа атаки можно ещё больше расширить, добавив, например, урон или специальные способности, в зависимости от типа атаки.8 [6 E7 ~$ x9 T
Если у тебя есть еще идеи или предложения по улучшению, всегда рад обсудить!2 M6 U& V4 o4 j8 {6 l8 D5 C

+ k" a3 `( Y( m0 t/ h- A  e# q7 V6 L  g/ }: b4 P- ^' i
) Y$ G$ W- q* m) f+ ^* F




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