Top.Mail.Ru

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

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

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

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

x
Добро пожаловать в обсуждение статьи "Шаг 3.3: Взаимодействие игровых объектов"!
' ?% b- q& F6 W9 `7 t0 t2 ^* S- R5 v& I2 n
* `% J  i  Q  J5 r
Здесь вы можете задавать любые вопросы, связанные с реализацией взаимодействий между игровыми объектами, такими как игроки, NPC и монстры, в серверной разработке Lineage 2 на Java. Обсудим, как создать динамическое взаимодействие в игровом мире, как правильно использовать события и триггеры, и как улучшить боевые и диалоговые системы.
' V3 i2 u$ Z  gЗадавайте вопросы, делитесь опытом, предложениями и идеями — ваше участие поможет углубить наши знания и сделать разработку серверов еще более интересной!
6 V4 p2 c4 @% V% O) @& z* ~Астралия ?
* Z/ W6 P3 E/ O& i, \7 R0 \- {' b% X- F# S. n

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

AlexCoder Опубликовано 2024-10-16 18:31:29 | Показать все сообщения
День добрый!" h" v# v! H) F: a$ C! }4 _$ m
В статье описано взаимодействие игрока с NPC и монстрами через простые методы. Как лучше всего реализовать более сложные взаимодействия, например, если нужно добавить несколько фаз боя с разными состояниями монстра? Есть ли оптимальный способ управления состояниями объектов, чтобы не перегружать логику боевых сценариев?, S9 y4 v, V' r  Q
' }0 F! S+ F$ w
AlexCoder Опубликовано 2024-10-16 20:53:49 | Показать все сообщения
Последний раз это сообщение было отредактировано AlexCoder в 2024-10-16 20:54 - l) G( m/ H* ^4 X8 X' @
AlexCoder опубликовал в 2024-10-16 18:31% Q3 `0 G/ T5 l, c: g8 L) n
День добрый!
2 P+ i0 s' P/ t3 \В статье описано взаимодействие игрока с N ...

# |" S7 j1 E8 k3 uДля управления сложными взаимодействиями, такими как несколько фаз боя с разными состояниями монстра, лучший подход — использовать шаблон проектирования "Состояние" (State Pattern).
: x2 i3 U/ g( Y  E0 m- V% s
( k: q' p8 A9 a: hЭтот шаблон позволяет разделить логику поведения объекта на разные состояния и управлять ими более гибко, избегая перегрузки основного класса монстра.
, Z$ s( G* c: X' B  z" S5 w9 {* D# D: f
Шаг 1: Создание интерфейса для состояний монстраПервый шаг — создать интерфейс, который будет представлять разные состояния монстра. Этот интерфейс определяет метод, который будет вызываться в зависимости от текущего состояния.
: P  o. l% K# ?# {% y% l# O* E) i4 D
  1. <font color="Green">// Пакет для состояний монстра</font>
    " p: \% t: o$ U& U$ k$ B7 K
  2. package org.l2jmobius.gameserver.model.actor.state;4 ]5 U. m. k3 s+ M1 {
  3. <font color="Green">4 H& u) X" Q/ M9 }% Y
  4. // Интерфейс, представляющий состояния монстра</font>! W+ b; t# e! V  a
  5. public interface MonsterState {5 ?  F! U; W8 c0 A! [
  6.     void handleState(Monster monster);
    ( _5 B% {; g2 ]4 [0 b: L. R1 U
  7. }
    8 I) j; o, @5 p+ o. X/ N% q
Скопировать код

7 V: c8 y8 ]4 DШаг 2: Реализация различных состоянийТеперь создадим классы для каждого состояния: например, InitialState, AggressiveState и FinalState. Эти состояния будут реализовывать интерфейс MonsterState и определять поведение монстра на разных этапах боя.) _+ H1 Y; x) ?1 p$ o6 d, r6 }
3 l3 \+ `2 _# b9 b
Класс для начального состояния монстра:
; I8 w: ]% o# R8 j/ `
  1. <font color="Green">// Пакет org.l2jmobius.gameserver.model.actor.state</font>
    4 S8 {% |" k0 x0 w- [2 m, E
  2. package org.l2jmobius.gameserver.model.actor.state;
    6 g0 N8 G0 _! _% d! u$ [( Z
  3. ; v& V! q! B, f! Z
  4. import org.l2jmobius.gameserver.model.actor.Monster;
    + ?3 i; I2 x" E7 e* U* n( h* ~
  5. / W# s1 N& a, O& m) y
  6. public class InitialState implements MonsterState {
    2 V: V2 T' X* k3 w
  7.     @Override5 k0 M! I, J: q) w& }/ G
  8.     public void handleState(Monster monster) {
    2 A* k4 w* K9 e$ r3 ~$ _
  9.         // Начальная фаза боя$ q- P' z+ z* L
  10.         System.out.println(monster.getName() + " начинает бой с обычной атакой.");! {0 `! Z( g! I/ W4 L1 v
  11.     }
    2 Q9 @; i! V# |
  12. }8 @  m9 X/ S3 ~* e
Скопировать код

8 _( G2 o( h! r. o$ G1 k% w" a# H, b1 Y: M# x6 h, T' m

) F3 {; S8 u. b) w4 z- e. q- {& o8 N9 y, _) g5 Q

  s& E0 ?2 \$ d  J, k: S$ O! [+ X
1 i1 m- u* @. `. \* d
" B7 e  Q4 c# ~: J5 P! N3 d6 d
 Автор| Astraliya Опубликовано 2024-10-16 21:04:54 | Показать все сообщения
Для управления сложными взаимодействиями, такими как несколько фаз боя с разными состояниями монстра, лучший подход — использовать шаблон проектирования "Состояние" (State Pattern). 7 _# r' }3 A+ P

1 h% N% v" p% b0 vЭтот шаблон позволяет разделить логику поведения объекта на разные состояния и управлять ими более гибко, избегая перегрузки основного класса монстра.1 ^, ^! ?: b! Y( y/ X) E( C5 H

! U# S8 w8 y5 h5 X4 p$ b! \Шаг 1: Создание интерфейса для состояний монстраПервый шаг — создать интерфейс, который будет представлять разные состояния монстра. Этот интерфейс определяет метод, который будет вызываться в зависимости от текущего состояния.5 R( ^7 l' g5 _% A3 X0 R# Y- l
8 v  H: {; c# J, n, u7 R
  1. // Пакет для состояний монстра: q' u  u* B. X/ M  L$ J' X1 u
  2. package org.l2jmobius.gameserver.model.actor.state;
    + \6 L, K3 o) P* N3 T& p

  3. 2 k) H: C& l) E, c2 {" `  D
  4. // Интерфейс, представляющий состояния монстра5 ~9 Z, L1 A# n9 Y0 H
  5. public interface MonsterState {$ C8 q5 f3 b$ u+ g; C6 A  E6 `
  6.     void handleState(Monster monster);5 u2 ^# i/ |( c0 [6 b: o1 Q& m. k
  7. }
    + z; I# E4 O, R6 Z' `: R
Скопировать код

8 P  V; A% t8 G' X6 Q: pШаг 2: Реализация различных состоянийТеперь создадим классы для каждого состояния: например, InitialState, AggressiveState и FinalState.
/ B- `  R4 m! _$ c; @5 t$ h
2 U" i  q" k' X% y  U& \5 [Эти состояния будут реализовывать интерфейс MonsterState и определять поведение монстра на разных этапах боя.) A/ D% |9 h$ r7 X2 G
* Y0 ^3 p' ?/ G& w
Класс для начального состояния монстра:/ a3 f) D* A1 p! o) q# W  t
  1. // Пакет org.l2jmobius.gameserver.model.actor.state( x  f1 K7 i: k! a3 ]
  2. package org.l2jmobius.gameserver.model.actor.state;3 J8 x/ O+ c0 \1 [. h8 b

  3. $ U  J" t, t+ \% m0 X2 M7 E
  4. import org.l2jmobius.gameserver.model.actor.Monster;
    9 C% z6 U$ X* A  T# A( X& `

  5. " }  }2 W+ k% L- ^# l
  6. public class InitialState implements MonsterState {4 I1 |( N0 q4 x1 \5 l
  7.     @Override. r4 ]1 Z9 I6 V0 m: l
  8.     public void handleState(Monster monster) {, X" z) u: W9 Q4 a" O8 J' Z
  9.         // Начальная фаза боя
    / q4 W7 _+ Y4 N, o( A7 a8 K0 k8 `$ A/ G
  10.         System.out.println(monster.getName() + " начинает бой с обычной атакой.");" f! Z& a. c0 D% a. f2 O- ?) _+ |
  11.     }
    8 w. o2 {: b: X: o* ~( M8 J
  12. }
    . q. J9 a8 {7 Y
Скопировать код
Класс для агрессивного состояния монстра:( R; k. ]4 F+ M% ]" u$ V8 ]' W$ r
  1. // Пакет org.l2jmobius.gameserver.model.actor.state
    & i; ?! t5 [1 M) r
  2. package org.l2jmobius.gameserver.model.actor.state;( h; c) e" g: L5 v6 t

  3. 9 k( }( d  X2 G: p- P
  4. import org.l2jmobius.gameserver.model.actor.Monster;
    - f3 h* J5 X- C  r" _: C

  5. ! k& v+ N  A8 m1 E6 h
  6. public class AggressiveState implements MonsterState {
    ' f% u: o8 p7 b7 }8 J6 ~
  7.     @Override" z7 [1 x: h1 ^$ _7 l" a: m' }
  8.     public void handleState(Monster monster) {) W% i; j% j7 E0 p/ H+ m
  9.         // Агрессивная фаза боя6 R2 f- P! Y4 J8 H$ ?6 d" ]# `
  10.         System.out.println(monster.getName() + " становится агрессивным! Атаки усиливаются.");
    $ l- g: u2 n' W0 F1 r4 F
  11.         monster.setAttackPower(monster.getAttackPower() * 1.5); // Увеличиваем силу атаки
    - b: o9 x" Q" `! M  ?* H! E
  12.     }2 [- Y* l' @% o
  13. }& ^% E: @1 @9 _# a. c
Скопировать код
Класс для финального состояния монстра:4 I( c: R. o, e- X# L* P' b, U2 ~* o
  1. // Пакет org.l2jmobius.gameserver.model.actor.state
    . ]5 X' t( p( q
  2. package org.l2jmobius.gameserver.model.actor.state;
      s9 ^$ ~* |9 I* }# {
  3.   A2 ^* G" M* s, ?4 V# ?7 l
  4. import org.l2jmobius.gameserver.model.actor.Monster;
    # N; I6 a) \' i0 T
  5.   N; ?( B; X. Q
  6. public class FinalState implements MonsterState {3 Z! j) n& B) w0 u9 o7 O
  7.     @Override
    : P- _& o2 x$ \5 ]# Q' c
  8.     public void handleState(Monster monster) {+ [4 |7 ?8 |- U$ Z
  9.         // Финальная фаза боя0 s0 J1 n* T$ ~* X. B! k
  10.         System.out.println(monster.getName() + " готовится к финальной атаке!");3 {6 t8 P4 J' t( l* L: g9 Z. x$ T
  11.         monster.setAttackPower(monster.getAttackPower() * 2); // Максимальная сила атаки
    + D" N2 }* `5 c5 x2 {3 t% K6 j
  12.     }
    2 ]9 b  H# h; p. q3 \$ I+ o: a
  13. }' P3 L1 [9 ]5 G) @' Q
Скопировать код
+ {& E  V. k3 `" ~  M* h  k; L
Шаг 3: Изменение класса MonsterЧтобы монстр мог переключаться между состояниями, нам нужно обновить класс Monster. В этой сборке L2J_Mobius, классы для игровых объектов, таких как монстры, находятся в пакете org.l2jmobius.gameserver.model.actor.
7 q' o" P: K/ Z5 `
  1. // Пакет org.l2jmobius.gameserver.model.actor& d! G* X4 D/ b
  2. package org.l2jmobius.gameserver.model.actor;& o9 w7 n4 s( O9 h. ^( H; ~

  3. ( T# V' D, x# r2 S2 ^% {1 W8 a
  4. import org.l2jmobius.gameserver.model.actor.state.MonsterState;
    ( f. h' J9 T2 r$ E1 A1 d! a% C" l# b
  5. import org.l2jmobius.gameserver.model.actor.state.InitialState;
    . @! z1 y$ G' @9 p! n

  6. 1 x0 k( r4 \* F" W' {1 b  C  w0 a
  7. public class Monster extends Creature {# V5 j" b& l) R3 |5 K
  8.     private String name;9 m, X0 W& q( t% O4 _
  9.     private double attackPower;% ^6 J% n# T. o
  10.     private MonsterState state; // Текущее состояние монстра: f( p% g, G5 a8 M) w( E2 W
  11. 5 Y/ p% Y  C! M* P
  12.     // Конструктор монстра* `# P( R  Y: _7 c9 `1 G
  13.     public Monster(String name, double attackPower) {1 L( D# z6 d; J8 r; h: V, l
  14.         this.name = name;/ I5 N" Z. h. @+ H+ V) \1 n& [
  15.         this.attackPower = attackPower;
    5 `6 I3 e0 V" P
  16.         this.state = new InitialState(); // Устанавливаем начальное состояние
    $ ?/ ^2 t9 r& J( w7 Z1 k6 i# }8 N
  17.     }: J+ _6 p& }- p# Q" ?8 \: H

  18. , |9 P" ]& N# o3 u2 n+ Y: p
  19.     // Метод для смены состояния5 @) w2 R% q; J7 U% [
  20.     public void setState(MonsterState newState) {* `" |: U$ ~! T" T4 Y% n% a
  21.         this.state = newState;
    4 T% r( O. w9 O0 }6 N
  22.     }
    & i- {1 i. ^& G0 e- c  D; ~
  23. ( T2 K" T4 G8 Q% i/ b) r$ E. }& v/ j0 w
  24.     // Выполнение действий на основе текущего состояния
    ) n9 a4 G  ]1 \+ t- s$ q: b9 ]0 _' h
  25.     public void executeState() {
    + t7 n: A* `% _* v6 x# I/ `0 s* {  q. c
  26.         state.handleState(this);
    . m4 D- A% g8 g, ^/ }: k
  27.     }
    7 a3 }& u7 c- D$ ?
  28. + }' F  v) q; w5 ]% @$ i6 W. O  I
  29.     // Геттеры и сеттеры
    9 T' `% p2 Y. h% J. ~
  30.     public String getName() {" o" [3 {0 k6 ^! S" K7 t& w! P
  31.         return name;
    ( B9 F( X  |! p. S
  32.     }
    7 t6 I( f' L* a7 I9 ~) ]8 ?) t
  33. 6 Y3 m- o; P( t% p  G6 m
  34.     public double getAttackPower() {- z' _* H8 ?' ]( Z+ N( \* r* E
  35.         return attackPower;
    & \( ]  |, i, m! M' ~1 o
  36.     }: i: i& e  F0 w& F: y
  37. 4 i. r- A/ K9 @: M$ g! ~0 b; q
  38.     public void setAttackPower(double attackPower) {0 ?& V, `& ?0 D8 c! i- p
  39.         this.attackPower = attackPower;8 X! f8 C+ j2 V6 ?
  40.     }
    & x2 G1 r/ Q6 [6 B+ t4 J: J) R0 I
  41. }
    5 h% F1 K  W2 F) i& h0 W
Скопировать код
- v. N8 L4 K$ m! @. K
Шаг 4: Симуляция боя с фазамиТеперь мы можем протестировать логику боя с переключением состояний монстра.
5 [) o0 T* }+ H; w
* d5 j* }- z" e4 C) n0 A* p
  1. // Пакет org.l2jmobius.gameserver.model.battle0 X) U; U. D9 K% P" q
  2. package org.l2jmobius.gameserver.model.battle;3 T; r3 X  c; D% Z$ U
  3. 0 R# G3 ~* h( l4 O' m
  4. import org.l2jmobius.gameserver.model.actor.Monster;& W3 Q5 x9 h5 H3 f2 C
  5. import org.l2jmobius.gameserver.model.actor.state.AggressiveState;
    : n8 a( ^8 ~' Z: o
  6. import org.l2jmobius.gameserver.model.actor.state.FinalState;
    ' {6 {' ?. ]6 m1 {  J( u
  7. " a# x! m# q9 A6 }, ]; n  I0 ~$ C
  8. public class BattleSimulation {
    ; n3 r( _% O2 v
  9.     public static void main(String[] args) {
      I0 g& @: p6 ]' o9 e6 w' F/ S/ D
  10.         // Создаем монстра с начальной атакой
    , e! B4 z9 {' o. L& w! ^
  11.         Monster monster = new Monster("Дракон", 100);" g5 a; h; J* t+ Q4 |  g
  12. % z% Q% p$ l- W/ z* k1 b/ }3 K
  13.         // Начальная фаза' m* x) E, ~$ t; Z5 E: ]& ^
  14.         monster.executeState();
    5 b* [/ a# c% q/ f0 w7 l$ g! C
  15. 5 h7 v: G5 ?9 n4 s: s% E7 Q7 ]: J
  16.         // Переход в агрессивную фазу
    % c$ X5 [' E8 ?5 G7 T9 M
  17.         monster.setState(new AggressiveState());
    % i! ^: @0 _. n8 X: H9 }+ U
  18.         monster.executeState();
    6 l: l2 S9 Q4 U8 a8 F0 i  I2 J

  19. 6 w% _' R5 w( j
  20.         // Финальная фаза
    1 R* m& k7 Z! {: r
  21.         monster.setState(new FinalState());- }" F6 p; x  `5 U' s
  22.         monster.executeState();
    * [' p6 ?9 X; P2 R5 W+ J: `
  23.     }# J, a  y8 _* p6 e1 ?) I
  24. }
    ; l+ k* W+ R9 _! E$ L
Скопировать код

* E+ a- F  ?) @4 R7 B) A2 m& t8 C7 yКомментарии по структуре пакетов и классов:" d1 A5 F( w% I3 w2 R/ w( L
  • Пакет org.l2jmobius.gameserver.model.actor: содержит основные игровые сущности, такие как Monster.
  • Пакет org.l2jmobius.gameserver.model.actor.state: отвечает за реализацию состояний для объектов, таких как монстры.
  • Пакет org.l2jmobius.gameserver.model.battle: может содержать примеры взаимодействий, такие как симуляция боевых сценариев., M# L% L& ]/ z5 A1 Q3 r+ O
ЗаключениеШаблон "Состояние" позволяет легко управлять фазами боя и не перегружать основной класс монстра. Это делает логику боевых сценариев более гибкой и масштабируемой. В будущем, если появятся новые фазы или состояния, их можно будет легко добавить, не изменяя основной код.
2 R$ r2 m1 h: y" yЕсли появятся дополнительные вопросы по реализации или структуре классов, буду рада помочь!
$ U" B/ v* L# V2 M) e
6 y. H" j& p7 ?9 s* }9 h
6 \8 Z; Z' {4 z4 g; c- V* W( h5 I  l0 h8 J0 v
% V7 i4 m/ g! Z6 W
" }. ^* x0 L; a# w4 L
8 l1 r% h9 t$ ]8 K

2 q- V- x5 Q+ a9 e" z( e& V4 a- O, s4 n6 M

# ]% }% A0 v" W
1 h! ^, O. `* o% p6 B8 d" w7 C0 {9 M- ~7 I
9 l. ?" b, A7 G, Y

) N7 z1 A# [  m1 i9 T+ x* T, V% s( E5 [/ B0 E
AlexCoder Опубликовано 2024-10-16 21:21:15 | Показать все сообщения
Astraliya опубликовал в 2024-10-16 21:04) F0 o/ J6 U- a+ B2 A1 ]
Для управления сложными взаимодействиями, такими как  ...
) }. X! ^  v) T" a- P- U
Отличный подход! Использование шаблона "Состояние" действительно помогает сделать код более чистым и управляемым. Я задумался: если мы добавим несколько фаз в бою с различными типами атак (например, магические и физические атаки), можно ли расширить этот паттерн, чтобы каждая фаза также учитывала тип атаки? Например, чтобы в агрессивной фазе монстр мог случайным образом чередовать типы атак. Как лучше организовать это в рамках данного паттерна?
 Автор| Astraliya Опубликовано 2024-10-16 21:33:48 | Показать все сообщения
AlexCoder опубликовал в 2024-10-16 21:21
/ G3 V2 E% d# r& n- C) AОтличный подход! Использование шаблона "Состояние" де ...
) M  t4 ]4 A/ z: j2 {
Хороший вопрос! Да, шаблон "Состояние" можно легко расширить, чтобы учесть различные типы атак. В этом случае можно добавить логику для чередования атак (магических и физических) в каждом состоянии./ f' N' t# k' J; A$ C* U

: j* [/ ]" q! A- y/ f( G8 I$ aШаг 1: Добавление типа атакиДля этого давайте создадим перечисление (enum) для типов атак и добавим его в наши состояния. Это позволит монстру случайным образом выбирать тип атаки во время боя.9 I2 f- L9 N. ]1 X* ]
9 |* w, l' l7 V
  1. // Пакет org.l2jmobius.gameserver.model.actor
    % N# r+ K3 Q. Y6 Q* U
  2. package org.l2jmobius.gameserver.model.actor;$ |6 {8 r% ?9 D. Z% U5 V
  3. - E2 m3 @. N( v, t
  4. // Перечисление для типов атак
    ' L- A0 }5 t; v& b' c. t
  5. public enum AttackType {
    ; u7 @' v- a, `' H' C8 u
  6.     PHYSICAL, MAGICAL;
    , b* L! b- G9 a4 R' {" R
  7. }
    ; Q. m* K+ D. y: s( _2 w
Скопировать код
Шаг 2: Обновление состояний для поддержки разных атакТеперь обновим состояния монстра, чтобы в каждом из них можно было чередовать типы атак.5 ?7 Q4 P$ B, V" t0 C6 Q
Обновленный класс для агрессивного состояния монстра:
. [- v% @4 F; K1 {  `5 Y. a8 a! u, F( J, w
  1. // Пакет org.l2jmobius.gameserver.model.actor.state- b, Z; `- j1 h
  2. package org.l2jmobius.gameserver.model.actor.state;
    - b% ~$ {- h' a( V

  3. % h( y" p% o% g/ Z# i
  4. import org.l2jmobius.gameserver.model.actor.Monster;
    ( `) _+ Z5 C9 G6 {
  5. import org.l2jmobius.gameserver.model.actor.AttackType;4 l5 h5 J( v; i" D$ j9 A' A+ J) p' f* M4 |

  6. 1 S9 a! ^3 ^1 j6 i+ j
  7. import java.util.Random;2 E6 y1 U# E+ l" N1 J9 T9 l
  8. 9 y$ c$ T2 ^( V# `% p
  9. public class AggressiveState implements MonsterState {
    ! S' C  S! Y# @9 l8 ?, e. p
  10.     private Random random = new Random();, @) s4 [- v: f) j! A7 T

  11.   C7 k: t! L7 r. s. D0 T
  12.     @Override
    3 D+ W+ Z! g" g
  13.     public void handleState(Monster monster) {
    * g/ f* `" j1 H" d, u3 P# h
  14.         // Выбираем случайный тип атаки: физическая или магическая1 c- I% f1 x/ t' J: k/ k
  15.         AttackType attackType = random.nextBoolean() ? AttackType.PHYSICAL : AttackType.MAGICAL;9 u7 |4 w- Z- c8 v4 |4 v3 r6 W! h

  16. # S9 F6 C& M/ s7 C
  17.         // Логика для агрессивной фазы боя
    $ O4 Q- l6 _/ {: e$ d
  18.         System.out.println(monster.getName() + " становится агрессивным и использует " * Q% V9 B$ W1 a1 ]$ K: R2 K9 y3 N
  19.             + (attackType == AttackType.PHYSICAL ? "физическую" : "магическую") + " атаку!");( Q6 [; [; h6 K# b
  20.         
    ( c& F! u3 d; @0 Z- U
  21.         // Увеличиваем силу атаки в зависимости от типа атаки  X. v, \0 _5 a1 G$ L, u( L
  22.         double multiplier = (attackType == AttackType.PHYSICAL) ? 1.5 : 1.2;& o; ^! N' n/ W2 G- y' b+ |
  23.         monster.setAttackPower(monster.getAttackPower() * multiplier);
    4 V/ q1 b4 @- F& k$ Y6 K
  24.     }
    : x/ d% f/ {! @+ ^# d  g+ ~1 W
  25. }
    7 t7 X2 ?5 o2 B3 O  _
Скопировать код
Шаг 3: Модификация класса MonsterТеперь класс Monster будет использовать состояние с логикой выбора типа атаки3 S* E% M9 D; D2 b8 A: P  x
% @8 l! s" ~& N( [2 b- |9 [
  1. // Пакет org.l2jmobius.gameserver.model.actor8 C5 N+ I9 d5 X2 W1 [9 E
  2. package org.l2jmobius.gameserver.model.actor;
    # N- A2 H3 `$ D" }6 V

  3. 7 \3 P2 W* N. ^, {% l  n3 [: |
  4. import org.l2jmobius.gameserver.model.actor.state.MonsterState;: _! ?; n1 |1 A2 E( L. ]7 ]9 s
  5. import org.l2jmobius.gameserver.model.actor.state.InitialState;/ r: P( ~# r+ |- X7 W7 ?: J

  6. 1 s) X6 A7 r1 x2 G8 f4 ]
  7. public class Monster extends Creature {% r2 b; ]% z5 Y& s; Q( j* ?/ G
  8.     private String name;
    ) m8 U- ]" l, f
  9.     private double attackPower;
    & {8 }; J! n. }" q9 O
  10.     private MonsterState state; // Текущее состояние монстра7 ^( b/ F3 r& L5 _3 h
  11. 7 W( I5 t+ n) S5 V. F% Y
  12.     // Конструктор монстра
    * |- h* v" D7 g6 ?8 Y4 s* I
  13.     public Monster(String name, double attackPower) {0 K! W/ z3 S+ s+ ^
  14.         this.name = name;5 M' v) f) d" u/ I9 L, Y; Y; r
  15.         this.attackPower = attackPower;; g' A- f' E, y4 N: a
  16.         this.state = new InitialState(); // Начальное состояние по умолчанию
    5 V1 Z( }9 J$ e+ N
  17.     }7 I8 Z7 i+ q' X9 X4 j4 }" L+ Q6 V, n

  18. ( p5 X+ _! s5 j; A5 D* o% D
  19.     // Метод для смены состояния5 p" {, F2 i! O4 A: ^# M: W
  20.     public void setState(MonsterState newState) {
    ' {$ _' G2 J$ y" g0 s2 M! s
  21.         this.state = newState;* t8 y' ~; ]  W1 T
  22.     }) H- G4 J8 m. x, P1 z, j
  23. : }; O/ c. D4 k
  24.     // Выполнение действий на основе текущего состояния
    4 J' ~, X& ], f+ n4 H* {; l
  25.     public void executeState() {
    , m5 l, A; }% _0 I1 @
  26.         state.handleState(this);1 ~) T4 t( l7 x( H
  27.     }
    . T6 f& {& w" y8 n+ c
  28. 1 U$ U6 I) n& K2 x
  29.     // Геттеры и сеттеры
    4 q* F8 E" `8 H3 ^! z" o( |; f. O
  30.     public String getName() {* \- g8 i; M2 i5 C- M, Z
  31.         return name;
    7 W# j5 C) ^3 f8 d9 R5 n
  32.     }4 Z) f( t$ I# h& }) z% o' }

  33. 3 }1 [1 ]1 a' _3 P7 Q# @+ @
  34.     public double getAttackPower() {# R. g: z- a( E
  35.         return attackPower;- B# e. i. R" @4 L: g' |/ h
  36.     }
    / T- N1 }3 U+ U( C6 s
  37. 5 s% M3 R6 \: O. D  W" d; [* `$ O
  38.     public void setAttackPower(double attackPower) {2 d7 s$ @. ?+ D* t7 T, r
  39.         this.attackPower = attackPower;
      t- ?) l* \& q' j1 q$ g
  40.     }1 y" {# V4 b. `
  41. }
    8 o( P9 f/ k  K2 W; o
Скопировать код
Шаг 4: Тестирование нового поведенияТеперь давайте посмотрим, как монстр будет чередовать типы атак в агрессивной фазе.
* a4 k. N" K+ |- {, q8 ?  {& e" S8 i  l) ?" e& |; v. s) a2 a5 R7 ^
  1. // Пакет org.l2jmobius.gameserver.model.battle8 r" A, w: b% A0 C! L4 P6 z: x- Y
  2. package org.l2jmobius.gameserver.model.battle;
    + a+ m2 |$ K7 W4 S
  3. + ~9 [8 N8 p' a# i1 U; {$ R. |
  4. import org.l2jmobius.gameserver.model.actor.Monster;
    . {. `5 }* D, s) T0 M* U& t2 C% R
  5. import org.l2jmobius.gameserver.model.actor.state.AggressiveState;
    & Z) b" _  |1 e2 H5 w3 e# a
  6. % H6 |: A/ R% Y- y
  7. public class BattleSimulation {, _" s0 j# O; n+ Z) s
  8.     public static void main(String[] args) {
    $ [9 p9 q: y. u7 e' I  |
  9.         // Создаем монстра8 d+ @* u$ Y3 ]  M1 u* b
  10.         Monster monster = new Monster("Дракон", 100);
    - u" l; O( _+ E! p7 Y+ ?

  11. , G1 {+ d9 X5 W/ N
  12.         // Переключаем монстра в агрессивное состояние с разными типами атак% c) u4 I: K: |% c* p
  13.         monster.setState(new AggressiveState());
    8 _/ C* _- j: \+ [
  14.         monster.executeState();
    : d5 F  @) {1 B, @7 e, e9 [
  15.         monster.executeState(); // Повторяем, чтобы увидеть чередование атак* I# Y. n2 b9 J: ^
  16.     }
    - L; x0 U# l2 T) A1 |) L% a
  17. }
    + X8 }0 h+ {% S; s9 k" {! d3 w
Скопировать код
ЗаключениеВ результате, с помощью перечисления AttackType, мы можем легко добавлять и чередовать типы атак в зависимости от состояния. Это гибкий способ управления сложными взаимодействиями в бою, не перегружая основной код. Выбор типа атаки можно ещё больше расширить, добавив, например, урон или специальные способности, в зависимости от типа атаки.
; F, w- A+ T( y" AЕсли у тебя есть еще идеи или предложения по улучшению, всегда рад обсудить!
8 U; z! U0 D) _; U5 Y
+ j! u: t5 u# Z3 k  D4 |" z! x8 M( F5 J( {

& b7 f6 w( t: W9 i
Чтобы ответить, вам надо авторизироваться в системе Вход | Зарегистрироваться

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

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

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

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

подписок0

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

постов9

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

638638758

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

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

admin@artace.ru Онлайн

QR-код

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