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

Название: Шаг 3.3: Взаимодействие игровых объектов [Версия для печати]
Автор: Astraliya    Время: 2024-10-16 17:54
Название: Шаг 3.3: Взаимодействие игровых объектов
Добро пожаловать в обсуждение статьи "Шаг 3.3: Взаимодействие игровых объектов"!
( i) @8 Q/ n3 K6 N" ?: O1 q0 w1 a

: G% R. Y8 i0 h, q! |. \7 m$ y- iЗдесь вы можете задавать любые вопросы, связанные с реализацией взаимодействий между игровыми объектами, такими как игроки, NPC и монстры, в серверной разработке Lineage 2 на Java. Обсудим, как создать динамическое взаимодействие в игровом мире, как правильно использовать события и триггеры, и как улучшить боевые и диалоговые системы.8 ]& `! F$ q1 c7 c4 ^$ J
Задавайте вопросы, делитесь опытом, предложениями и идеями — ваше участие поможет углубить наши знания и сделать разработку серверов еще более интересной!
1 ~6 M1 R/ O4 M, \. P! Z8 ?) TАстралия ?
0 q( u( _0 m& }' `
# J- I' n; B+ u/ H
Автор: AlexCoder    Время: 2024-10-16 18:31
День добрый!: M2 Z' E; o- B3 v& l2 s
В статье описано взаимодействие игрока с NPC и монстрами через простые методы. Как лучше всего реализовать более сложные взаимодействия, например, если нужно добавить несколько фаз боя с разными состояниями монстра? Есть ли оптимальный способ управления состояниями объектов, чтобы не перегружать логику боевых сценариев?
( O2 G* w3 \0 {$ {+ N% u: f* Q! o  z5 M) [# B* b% t
Автор: AlexCoder    Время: 2024-10-16 20:53
Последний раз это сообщение было отредактировано AlexCoder в 2024-10-16 20:54 ) ~9 o9 o1 Z4 c" \! l$ s* ?! e
AlexCoder опубликовал в 2024-10-16 18:31: x$ _0 Z4 C! e: g, \; p
День добрый!2 |8 M+ o3 s& ^
В статье описано взаимодействие игрока с N ...
1 f9 A2 m7 n- O. E% J; M7 L% I+ N
Для управления сложными взаимодействиями, такими как несколько фаз боя с разными состояниями монстра, лучший подход — использовать шаблон проектирования "Состояние" (State Pattern). 8 Q1 p$ R+ ^. v/ `5 k* _# `
0 o$ H+ o& t5 x7 @
Этот шаблон позволяет разделить логику поведения объекта на разные состояния и управлять ими более гибко, избегая перегрузки основного класса монстра.9 b! u" b% U4 Y* \- }

$ d7 m+ D. L2 F; i5 r' fШаг 1: Создание интерфейса для состояний монстраПервый шаг — создать интерфейс, который будет представлять разные состояния монстра. Этот интерфейс определяет метод, который будет вызываться в зависимости от текущего состояния.
4 T9 W, C: H( ~4 x: d  c6 e0 B
1 B1 ?1 b; y4 l+ F- O7 w
  1. <font color="Green">// Пакет для состояний монстра</font>
    $ X" ?+ z0 k- }0 S: e; f
  2. package org.l2jmobius.gameserver.model.actor.state;! K1 S( Z: S0 G2 _3 D
  3. <font color="Green">$ Y4 {3 E# e3 I2 g& V
  4. // Интерфейс, представляющий состояния монстра</font>
    / Y: s2 M8 G4 Q. k
  5. public interface MonsterState {4 \* H$ h+ P; |# G5 J0 d
  6.     void handleState(Monster monster);
    * L8 i# U1 D0 c6 r& e8 }. K
  7. }
    # B/ |3 Z! `% s' G
Скопировать код
! u$ i& Y1 H, A
Шаг 2: Реализация различных состоянийТеперь создадим классы для каждого состояния: например, InitialState, AggressiveState и FinalState. Эти состояния будут реализовывать интерфейс MonsterState и определять поведение монстра на разных этапах боя.9 ^* K! p( Q+ Y7 [: l

# w1 g! |. D* F) s: ]7 l" AКласс для начального состояния монстра:
, X6 J% y) \' \/ _: h7 ]8 X
  1. <font color="Green">// Пакет org.l2jmobius.gameserver.model.actor.state</font>5 q, S# v+ ~2 g+ z, D" m; Z1 H
  2. package org.l2jmobius.gameserver.model.actor.state;+ u) R  l! a0 k

  3. 1 x7 A# d- z: ~* J0 H& q- }
  4. import org.l2jmobius.gameserver.model.actor.Monster;, r* w4 O9 S1 G* @- G& o' H+ j
  5. 0 F: x+ e9 e: P; m2 Z, ]
  6. public class InitialState implements MonsterState {0 r  W3 a* }- q* `4 X  m8 r) a+ j
  7.     @Override
    ; l3 V% k* Y% r8 u
  8.     public void handleState(Monster monster) {8 \9 [, W; h  ~% q5 r8 D
  9.         // Начальная фаза боя
    ; R0 x& ^/ P1 {/ Y
  10.         System.out.println(monster.getName() + " начинает бой с обычной атакой.");
    . c" O' v) K9 j  k) U' H+ O" a
  11.     }" C4 f5 U" _& N; t
  12. }
    6 I( g8 N2 \2 W
Скопировать код
3 {4 X. Q) W  ]3 V% N" _# k

, }  Z% n2 y5 ]/ v0 M  Z$ x. W2 `5 e% P2 I! L5 N8 B8 F1 ]- Z. Q
% J/ z" @. i* e/ Z' M

0 A* n. T: q9 a/ }- j
! x* U: G4 d& R: |8 k' `, p# e3 b, q) K0 n  O* B$ N9 W0 c. U' k
Автор: Astraliya    Время: 2024-10-16 21:04
Для управления сложными взаимодействиями, такими как несколько фаз боя с разными состояниями монстра, лучший подход — использовать шаблон проектирования "Состояние" (State Pattern). * v' B, z; A* Y# F: X

2 d* N. n* ^1 _Этот шаблон позволяет разделить логику поведения объекта на разные состояния и управлять ими более гибко, избегая перегрузки основного класса монстра.9 c! c6 Y( b3 C
. _9 u7 G4 H2 q- a, J6 M
Шаг 1: Создание интерфейса для состояний монстраПервый шаг — создать интерфейс, который будет представлять разные состояния монстра. Этот интерфейс определяет метод, который будет вызываться в зависимости от текущего состояния.
. `' H6 I% G8 X7 g  D6 R
% G) i8 \7 U0 j5 k
  1. // Пакет для состояний монстра
    + ~7 @- z! @1 S2 s) C
  2. package org.l2jmobius.gameserver.model.actor.state;' i! t+ R; ^( O- c5 z
  3. $ `: E% e+ z' G: Z/ D1 J( d
  4. // Интерфейс, представляющий состояния монстра3 k2 a/ P* n; w# q: T5 ^
  5. public interface MonsterState {
    * m3 [$ h; r6 R6 j4 l7 U
  6.     void handleState(Monster monster);; e# M6 T' t4 ]% K
  7. }
    5 w6 ?1 a, V& N  e) _2 X
Скопировать код
/ h0 E/ d+ v5 h0 Y
Шаг 2: Реализация различных состоянийТеперь создадим классы для каждого состояния: например, InitialState, AggressiveState и FinalState. ' {7 [  Z/ y0 z6 M2 l* h
( o) o; w* r- b8 L
Эти состояния будут реализовывать интерфейс MonsterState и определять поведение монстра на разных этапах боя.
4 c! `( i) d5 k- A/ [6 X- o' z" t" N( T& j# k+ p
Класс для начального состояния монстра:
& |- a$ V* F, r: [+ g
  1. // Пакет org.l2jmobius.gameserver.model.actor.state7 o4 L/ M) ]  S. t0 c: z
  2. package org.l2jmobius.gameserver.model.actor.state;$ }/ U) O$ v, ]% J0 Z
  3. ' V! @- l" l: d
  4. import org.l2jmobius.gameserver.model.actor.Monster;
    1 b: ?* W- S& G3 }& B, Q6 b- [
  5. & p" [$ p! A' ]- y+ \
  6. public class InitialState implements MonsterState {
    - T: O1 K9 Q* c+ x: ]! N5 D
  7.     @Override; d$ W. E3 ^! O) o) A; f* F
  8.     public void handleState(Monster monster) {9 g3 Z& \* h- F% W) y
  9.         // Начальная фаза боя
    / \4 M8 x2 ?8 J- a) ^; ^
  10.         System.out.println(monster.getName() + " начинает бой с обычной атакой.");
    , N, Q! a5 u0 b
  11.     }# s: r3 X8 T6 A/ x
  12. }; b7 A( b! H$ z1 w
Скопировать код
Класс для агрессивного состояния монстра:" S" B2 {( x) I6 k
  1. // Пакет org.l2jmobius.gameserver.model.actor.state& I6 N: Q/ H7 i" ^1 j& U4 U+ e* C& w
  2. package org.l2jmobius.gameserver.model.actor.state;4 s$ u5 B- g4 x; A% n. y

  3. " M" s* `' R& S9 X  O- X
  4. import org.l2jmobius.gameserver.model.actor.Monster;
    ) |' a" c0 D. R3 E5 Y$ R0 d& ]

  5. 6 Z  y% X* ~( R) m, @" U! c- y
  6. public class AggressiveState implements MonsterState {
    5 `: v6 t& H; m. U
  7.     @Override
    $ Y! q& ?' C9 F/ ~# \
  8.     public void handleState(Monster monster) {1 V6 B+ c& A" h3 m2 W! ?
  9.         // Агрессивная фаза боя) E! y* o' h% j. D& X
  10.         System.out.println(monster.getName() + " становится агрессивным! Атаки усиливаются.");
    8 x; w$ N1 v( G( S( U* E
  11.         monster.setAttackPower(monster.getAttackPower() * 1.5); // Увеличиваем силу атаки
    / J0 b8 [; i- D! K* U8 |3 Q$ C5 N
  12.     }
    ! K; p  Z1 x. L. f# w
  13. }
    , l- p8 f. p& f3 j. p3 T. O
Скопировать код
Класс для финального состояния монстра:
# l0 k( m# x/ N9 g' ]
  1. // Пакет org.l2jmobius.gameserver.model.actor.state% G( Q9 ?# o0 Z8 H- J3 C
  2. package org.l2jmobius.gameserver.model.actor.state;* P9 K. h  R. H2 p3 ]
  3. # L: n$ k; ~) R% D
  4. import org.l2jmobius.gameserver.model.actor.Monster;
    7 L4 R5 i- @$ q0 A$ p( ]
  5. ' V- l' p: X3 a; W3 F5 F5 l" _
  6. public class FinalState implements MonsterState {
    $ j' g! f& ]* g; `3 Z% y
  7.     @Override
    ( G& n9 ?  A+ X
  8.     public void handleState(Monster monster) {- O/ L5 o3 X" \
  9.         // Финальная фаза боя
    ! b) n( U9 F/ _  Q0 ^, I6 W
  10.         System.out.println(monster.getName() + " готовится к финальной атаке!");
    2 t0 H6 F0 q- `0 l5 @: f
  11.         monster.setAttackPower(monster.getAttackPower() * 2); // Максимальная сила атаки# \3 Y- b* ~, f8 |1 x0 ?
  12.     }4 m; W9 Y5 v# C. W; O
  13. }2 y+ w. b7 G! l
Скопировать код
/ r3 F$ X9 j" O
Шаг 3: Изменение класса MonsterЧтобы монстр мог переключаться между состояниями, нам нужно обновить класс Monster. В этой сборке L2J_Mobius, классы для игровых объектов, таких как монстры, находятся в пакете org.l2jmobius.gameserver.model.actor.& h& a9 e$ L+ I/ s
  1. // Пакет org.l2jmobius.gameserver.model.actor
    : m' \$ `/ B) m" X# w; x" u
  2. package org.l2jmobius.gameserver.model.actor;
    . V  v. g$ @7 v/ c; E! E
  3. 9 Y/ s! [7 E" v6 X
  4. import org.l2jmobius.gameserver.model.actor.state.MonsterState;  [3 r8 S+ m: }( t& y* z( V
  5. import org.l2jmobius.gameserver.model.actor.state.InitialState;- k( D6 X9 t0 I3 M( n6 q$ ]1 |4 S

  6. 9 H9 T  s! y: E: G  W$ u) j. a
  7. public class Monster extends Creature {
    0 j" @2 {' w. n7 n* D" @1 y
  8.     private String name;
    0 a' @. P) W  s/ b% v4 j8 p# V
  9.     private double attackPower;
    1 \/ C0 N8 I+ J" t( Z/ H
  10.     private MonsterState state; // Текущее состояние монстра
    & l. U# V: H6 ?& }
  11. + T) n2 s7 x" M/ a" h0 K
  12.     // Конструктор монстра
    ( U5 c  P4 d! e& ?2 y/ w* i/ F" G
  13.     public Monster(String name, double attackPower) {
    ( J) P$ e1 N, n2 T# ^9 j$ X' p
  14.         this.name = name;
    4 W& Z9 z4 _# j
  15.         this.attackPower = attackPower;9 E. }1 w1 B/ G2 N1 M% E) y; R
  16.         this.state = new InitialState(); // Устанавливаем начальное состояние
    ' g/ O% F, U/ `! {( O0 S+ h
  17.     }& D# @. b4 Q6 g+ \5 ^' q) S

  18. 2 s) d+ g4 I2 g( M0 F( J
  19.     // Метод для смены состояния
    % p7 T8 a; B+ s7 @8 r6 y1 {
  20.     public void setState(MonsterState newState) {
    9 w6 Z- k% o+ `. C0 h
  21.         this.state = newState;
    9 z0 _" S: r. L" O# j8 p1 T
  22.     }
    3 ~7 X. v% w. M
  23. $ b4 e5 r" l, Z
  24.     // Выполнение действий на основе текущего состояния+ K$ o# C$ C) T, y1 l7 G
  25.     public void executeState() {
    . Y! Y& z8 C/ b7 p
  26.         state.handleState(this);
    0 q. k: i/ W0 v3 L8 j
  27.     }
    8 M! F- [8 o1 D) O% b! g

  28. 5 X$ |& J! m7 U2 H
  29.     // Геттеры и сеттеры& `  ~. y( D6 q
  30.     public String getName() {6 j$ {# n2 @* k: B1 ~
  31.         return name;
    # v$ w$ x' G5 U  @3 \2 c
  32.     }
    0 q: q2 R6 Y( S

  33. 1 t8 ?# q6 O7 j& t
  34.     public double getAttackPower() {
    : Y# W* B  p$ _5 T7 G
  35.         return attackPower;
    - i0 q, u( _8 v7 m% K# x% h/ G! M
  36.     }
    0 o# q) U$ H* B0 Z

  37. 7 u: {" N6 ]3 z6 i
  38.     public void setAttackPower(double attackPower) {
    , F, M6 z2 n0 N/ N
  39.         this.attackPower = attackPower;
    # i" l  s7 }: }; Z6 x) }
  40.     }
    0 e/ x# S% s2 r" ^
  41. }
    0 l% p! e  N( G" h7 H
Скопировать код
4 s% j( G! s) l: k. X! T
Шаг 4: Симуляция боя с фазамиТеперь мы можем протестировать логику боя с переключением состояний монстра.$ n( M+ Z1 }8 q% k/ R% Y

' `6 R- \. X, X' {* d0 {
  1. // Пакет org.l2jmobius.gameserver.model.battle
    - J. A6 q7 J9 M( B5 }
  2. package org.l2jmobius.gameserver.model.battle;0 m+ e- t# K7 u' I/ N
  3. 7 h& d) |( p, u6 A
  4. import org.l2jmobius.gameserver.model.actor.Monster;( z8 v% \4 _6 \( y& N0 ~& J3 ?8 [
  5. import org.l2jmobius.gameserver.model.actor.state.AggressiveState;% e& G3 s: J: S' q8 Q% P1 \& l
  6. import org.l2jmobius.gameserver.model.actor.state.FinalState;
    6 g8 I, C6 w5 ?
  7. 0 ?! d" ]9 q: W* H! r
  8. public class BattleSimulation {+ V  M9 |) x0 l4 Z
  9.     public static void main(String[] args) {
    , u9 o! x+ n" d' K; @8 p! j7 `
  10.         // Создаем монстра с начальной атакой
    / `; x7 H5 D7 C; O; H2 H& W
  11.         Monster monster = new Monster("Дракон", 100);
    ; Y3 l6 s$ d3 a! J3 ~. {

  12. + ~$ O, O8 r9 D; T0 O" C
  13.         // Начальная фаза$ Z, G6 q, }" o! R6 S. J
  14.         monster.executeState();" L. U% X) A5 c2 R5 H- P* K! ^
  15. % R2 V( t0 `4 f6 P) X
  16.         // Переход в агрессивную фазу" f# l" F+ J' @- Q9 @
  17.         monster.setState(new AggressiveState());% r8 j8 A5 u8 r
  18.         monster.executeState();' o8 J- e! A9 g  H* Y

  19. 1 X' r- ~0 g/ ^8 w8 F; E
  20.         // Финальная фаза
    9 y6 ]# d% d2 ~* k0 h. O5 `
  21.         monster.setState(new FinalState());
    , Z9 U  [6 I( g; J& y
  22.         monster.executeState();0 U3 C: I, c8 w- F
  23.     }% \; ?. B6 O- r
  24. }
    5 ?, J$ {6 L, O6 g  U0 N
Скопировать код

* [' y" \5 s( JКомментарии по структуре пакетов и классов:* a9 M3 z) X7 n
ЗаключениеШаблон "Состояние" позволяет легко управлять фазами боя и не перегружать основной класс монстра. Это делает логику боевых сценариев более гибкой и масштабируемой. В будущем, если появятся новые фазы или состояния, их можно будет легко добавить, не изменяя основной код.$ L6 S7 c; j& B' @
Если появятся дополнительные вопросы по реализации или структуре классов, буду рада помочь!; \6 y& y/ r3 c5 O$ b) J' I

( J6 q( G( F! a2 I5 j
# E' [6 Y3 M% K3 o3 ~6 h2 L; s1 Z' n
5 _4 r( t5 ?1 w
* P! N, s" h" H- G$ G3 d1 F, ^; D4 T8 q, g
) o6 [0 y# B$ ?

9 p( i" k0 Z" u0 i/ J) \; z
6 c1 Y9 I, i! s1 p, R
* }3 |! ^: v9 l  d
6 w& _: T) w; c7 b& f8 L! `* I" |' k2 O5 i# d! F6 r( B* t9 \/ Y
* M) N1 `) c* [1 l+ H

& K. h5 _. w$ f  h
3 ~1 I: u6 W, E/ I8 S1 x, Z( e
Автор: AlexCoder    Время: 2024-10-16 21:21
Astraliya опубликовал в 2024-10-16 21:042 V+ c- T0 i& ]4 I5 c  P  a
Для управления сложными взаимодействиями, такими как  ...
5 M, n, g* z( u  o: i7 @: F4 Y
Отличный подход! Использование шаблона "Состояние" действительно помогает сделать код более чистым и управляемым. Я задумался: если мы добавим несколько фаз в бою с различными типами атак (например, магические и физические атаки), можно ли расширить этот паттерн, чтобы каждая фаза также учитывала тип атаки? Например, чтобы в агрессивной фазе монстр мог случайным образом чередовать типы атак. Как лучше организовать это в рамках данного паттерна?
Автор: Astraliya    Время: 2024-10-16 21:33
AlexCoder опубликовал в 2024-10-16 21:21
3 z: |- @/ ]' RОтличный подход! Использование шаблона "Состояние" де ...

7 X2 I: i- T" q8 L. E# n" H  ~: @Хороший вопрос! Да, шаблон "Состояние" можно легко расширить, чтобы учесть различные типы атак. В этом случае можно добавить логику для чередования атак (магических и физических) в каждом состоянии.% B+ g2 C& K) I- I7 ?  Z3 R: t
' i& i( e1 O# O$ j9 \; F
Шаг 1: Добавление типа атакиДля этого давайте создадим перечисление (enum) для типов атак и добавим его в наши состояния. Это позволит монстру случайным образом выбирать тип атаки во время боя.
% m2 z& r8 X5 O7 f. }) @; s7 T8 @* j3 R9 f  Q7 {7 T0 D& e
  1. // Пакет org.l2jmobius.gameserver.model.actor9 J1 v3 C# q$ y! \
  2. package org.l2jmobius.gameserver.model.actor;
    ! o  X% Z$ ^9 h+ l5 h7 _
  3. 0 M5 F- D2 f# f: P9 k$ {+ d
  4. // Перечисление для типов атак
    & h8 x* ~, i1 ]1 s( w( l, t
  5. public enum AttackType {+ u3 P$ A6 u/ P1 a% [8 O
  6.     PHYSICAL, MAGICAL;% o: [4 |! i0 s" }% U& M- J+ D
  7. }/ b1 L8 u. Q  K, z% Y
Скопировать код
Шаг 2: Обновление состояний для поддержки разных атакТеперь обновим состояния монстра, чтобы в каждом из них можно было чередовать типы атак.
/ N; Y/ n8 F9 t% K8 \3 Y9 d+ V7 Y4 ]/ a. WОбновленный класс для агрессивного состояния монстра:3 p0 D8 ]% {! r! b& \. i

* c) M/ o, T5 s  j; c' e
  1. // Пакет org.l2jmobius.gameserver.model.actor.state
    # Y% C! _' E" v* h: X3 N5 O
  2. package org.l2jmobius.gameserver.model.actor.state;- }4 P" T' a1 h8 U

  3. 9 D% Z  j9 Y! ~/ J  H& z5 w
  4. import org.l2jmobius.gameserver.model.actor.Monster;# A! q8 r, o4 {$ k9 }# E
  5. import org.l2jmobius.gameserver.model.actor.AttackType;/ _' U; b; a) ^" t! y
  6. 4 o+ o( ?: N5 l6 j5 O7 l2 j9 K
  7. import java.util.Random;$ P5 K! l5 u. s' V/ [, W" z! m
  8. 3 k) s$ U& Q( L  R6 H; r+ n# X
  9. public class AggressiveState implements MonsterState {0 \0 h! t) B6 F+ h  V/ P) U
  10.     private Random random = new Random();
    1 d! G% e# `. [/ _+ \$ d
  11. * w+ E8 d( }2 R& F- z% W, i  E  K2 d% F
  12.     @Override) S; S2 P$ {$ r& j* P# K  ?
  13.     public void handleState(Monster monster) {
    6 \  ?! N) z7 ~: e- k+ x
  14.         // Выбираем случайный тип атаки: физическая или магическая
    # A+ }1 q$ Z5 \
  15.         AttackType attackType = random.nextBoolean() ? AttackType.PHYSICAL : AttackType.MAGICAL;
    9 k7 {) e# P4 S, Y+ e. A
  16. ) S1 b7 u, |; u% H, u) ], m8 d
  17.         // Логика для агрессивной фазы боя
    8 r: B4 K: d" n) w" ]7 c' [
  18.         System.out.println(monster.getName() + " становится агрессивным и использует " + h6 Q. F- L: Y% s% V3 {+ r" G
  19.             + (attackType == AttackType.PHYSICAL ? "физическую" : "магическую") + " атаку!");
    0 n! E) H$ m% l3 \  t
  20.         " ~3 d5 A5 ?( R5 g# T
  21.         // Увеличиваем силу атаки в зависимости от типа атаки" u6 {$ y0 Q7 ]& S$ b" B
  22.         double multiplier = (attackType == AttackType.PHYSICAL) ? 1.5 : 1.2;1 C' M7 C' d! E, B6 b% [5 A
  23.         monster.setAttackPower(monster.getAttackPower() * multiplier);
    : j( K' B! X$ a$ d1 e9 @! ^
  24.     }  t; }& C# ^9 K9 ?4 Y
  25. }2 s. Z  N0 t' R. [/ ~1 L! t1 H
Скопировать код
Шаг 3: Модификация класса MonsterТеперь класс Monster будет использовать состояние с логикой выбора типа атаки8 T: }6 O6 l* l% R  ^4 ?0 P/ r

4 v8 [- Y* k1 r; r
  1. // Пакет org.l2jmobius.gameserver.model.actor
    / `. o* O/ G1 h' h0 H  R
  2. package org.l2jmobius.gameserver.model.actor;
      m- [% q# `7 p; J+ t& h

  3. ! w7 }+ D8 E/ Y
  4. import org.l2jmobius.gameserver.model.actor.state.MonsterState;
    8 _( z4 S2 Q- @! U: F
  5. import org.l2jmobius.gameserver.model.actor.state.InitialState;
    - }3 a  r6 ]6 Z! P( R! ^$ b

  6. ! Q9 K7 M4 s4 A/ Y# C% ~
  7. public class Monster extends Creature {
    0 P4 L/ O3 ]8 o
  8.     private String name;, U* n) e9 ]1 k/ L* U; r
  9.     private double attackPower;
    # Q+ w; S( q+ n/ V
  10.     private MonsterState state; // Текущее состояние монстра6 O3 Z2 T# ?+ \. e

  11. # A& {" W6 i7 w9 L0 l5 a
  12.     // Конструктор монстра
    $ i4 w+ d$ q" z5 j; L7 J3 C2 Z
  13.     public Monster(String name, double attackPower) {4 N7 G7 @# t, m/ B/ O
  14.         this.name = name;9 d& R3 V% V+ n: A, `. S( h% D: Z; X
  15.         this.attackPower = attackPower;
    2 w0 U9 l- f3 D* n6 c0 X  r
  16.         this.state = new InitialState(); // Начальное состояние по умолчанию. x% y( ~$ C* X( q- f9 ^
  17.     }
    , l- k6 j" G0 e8 Q/ \% y/ C
  18. 8 N0 q, M% X+ g3 w! H
  19.     // Метод для смены состояния; v& [4 u' V# y9 _
  20.     public void setState(MonsterState newState) {
    % d6 G0 i; ?; e
  21.         this.state = newState;
    " m( Z' b* L: C1 e# f- Z6 r
  22.     }5 e% B, G/ \7 P* g+ ^

  23. 3 F) R( ^4 [) ?$ S# p6 w
  24.     // Выполнение действий на основе текущего состояния+ M3 A& x0 b0 W7 d0 ~
  25.     public void executeState() {
    8 |. t8 q. Z5 K# Z) F2 \
  26.         state.handleState(this);, n: ?# f+ B4 G
  27.     }4 E! r  g7 I2 i- x" S  ?! h6 Y
  28. 9 |# ~" ]( _; \1 a* \# b
  29.     // Геттеры и сеттеры" ?3 m) m9 V- N5 A
  30.     public String getName() {, Q5 L6 e# B( v2 H2 t/ K9 U9 J" O; Q
  31.         return name;
    & N) ^, V/ a5 ]6 A+ `
  32.     }5 i$ I6 n: `) P% A& \5 D; U( M

  33. ; v; `6 a2 ?4 |; m1 r! r
  34.     public double getAttackPower() {1 `- L+ b5 t" a$ p
  35.         return attackPower;6 l  @9 _' R9 q  Q/ ^" P
  36.     }
    ) _2 L' M5 q  t: \
  37. 2 O! Z  n3 X4 }  Z7 B0 Z0 Z1 }3 W
  38.     public void setAttackPower(double attackPower) {
    . T# u! n+ \( s
  39.         this.attackPower = attackPower;
    1 [0 x! {  ~1 E. o
  40.     }/ N4 t- f! z( t" E2 s
  41. }: c( Q! V. ]7 k# ~( }3 r
Скопировать код
Шаг 4: Тестирование нового поведенияТеперь давайте посмотрим, как монстр будет чередовать типы атак в агрессивной фазе.9 D9 y/ P; e6 P! K4 T5 E' V
( _# d, y% e- K$ t' V
  1. // Пакет org.l2jmobius.gameserver.model.battle
    # w, |! N3 D# l
  2. package org.l2jmobius.gameserver.model.battle;" _* B; x5 k) J; A

  3. + S: O# e0 f# M0 s
  4. import org.l2jmobius.gameserver.model.actor.Monster;) B4 q4 ]; s$ D6 b$ i. i* a
  5. import org.l2jmobius.gameserver.model.actor.state.AggressiveState;
    8 E5 n5 c5 B) Z0 Q

  6. & ]+ g- G9 U$ M4 ?) L
  7. public class BattleSimulation {
    7 D$ l# e# g2 y/ f1 \$ Q
  8.     public static void main(String[] args) {; @# L$ j1 d/ K
  9.         // Создаем монстра
    " W: n5 s4 b( H/ W# M; L) Y
  10.         Monster monster = new Monster("Дракон", 100);
    - ^! `, z3 l7 M8 x+ G

  11. . X+ {& Z. m0 ~4 W( }2 g: Q. l
  12.         // Переключаем монстра в агрессивное состояние с разными типами атак2 A; R. ~  h( x$ K
  13.         monster.setState(new AggressiveState());" I* m8 Z. Q. M" n) ~
  14.         monster.executeState();
    ! E$ r- @; W5 i% }% L" }! |
  15.         monster.executeState(); // Повторяем, чтобы увидеть чередование атак
    " o# x: p8 n% ]5 C* B
  16.     }
    ' i7 y) O, x3 q' X! f  y
  17. }8 \: _5 |' m8 \* Y/ T$ g0 b
Скопировать код
ЗаключениеВ результате, с помощью перечисления AttackType, мы можем легко добавлять и чередовать типы атак в зависимости от состояния. Это гибкий способ управления сложными взаимодействиями в бою, не перегружая основной код. Выбор типа атаки можно ещё больше расширить, добавив, например, урон или специальные способности, в зависимости от типа атаки.
9 o0 y/ t' J0 O! c  l0 YЕсли у тебя есть еще идеи или предложения по улучшению, всегда рад обсудить!! R6 f! i# N( ?% e
1 S7 }/ m( w3 F/ J- |; h
" F9 Y9 t1 h- [& Q& @

) S3 {+ g' `3 l( N% G$ m7 k& \3 W



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