Top.Mail.Ru

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

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

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

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

x
Добро пожаловать в обсуждение статьи "Шаг 3.3: Взаимодействие игровых объектов"!
2 C8 F! S6 s9 k0 q
6 m% w+ `9 \. @/ A

/ f! I! c4 d4 T! j# C3 f7 \+ n$ @Здесь вы можете задавать любые вопросы, связанные с реализацией взаимодействий между игровыми объектами, такими как игроки, NPC и монстры, в серверной разработке Lineage 2 на Java. Обсудим, как создать динамическое взаимодействие в игровом мире, как правильно использовать события и триггеры, и как улучшить боевые и диалоговые системы.
" A  p- o1 L5 \) ?: b" oЗадавайте вопросы, делитесь опытом, предложениями и идеями — ваше участие поможет углубить наши знания и сделать разработку серверов еще более интересной!
1 Y! z7 [9 V. N# `1 OАстралия ?) l! Q# I: V* u
' x9 @9 N6 b$ c1 l/ S( G

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

AlexCoder Опубликовано 2024-10-16 18:31:29 | Показать все сообщения
День добрый!$ R2 d) b7 v0 {# n# f
В статье описано взаимодействие игрока с NPC и монстрами через простые методы. Как лучше всего реализовать более сложные взаимодействия, например, если нужно добавить несколько фаз боя с разными состояниями монстра? Есть ли оптимальный способ управления состояниями объектов, чтобы не перегружать логику боевых сценариев?' @& }& p) Z3 i- j" P# r; n6 M3 E
) u* I' M' {' i7 ?
AlexCoder Опубликовано 2024-10-16 20:53:49 | Показать все сообщения
Последний раз это сообщение было отредактировано AlexCoder в 2024-10-16 20:54
3 X9 l7 c5 O1 {* ^$ i
AlexCoder опубликовал в 2024-10-16 18:318 ?3 M9 _4 \3 I( }8 \) E
День добрый!
3 I6 q1 n" `) wВ статье описано взаимодействие игрока с N ...
# l& _3 K7 B6 |+ k8 ^9 c. N! {& A1 P
Для управления сложными взаимодействиями, такими как несколько фаз боя с разными состояниями монстра, лучший подход — использовать шаблон проектирования "Состояние" (State Pattern).
& c- y, z& ^/ f& }$ D; J$ z, w! H# `! r. }2 P
Этот шаблон позволяет разделить логику поведения объекта на разные состояния и управлять ими более гибко, избегая перегрузки основного класса монстра.
/ u; ^2 q& E' V* B' W% N
) v0 E) j0 t7 g3 I6 \. IШаг 1: Создание интерфейса для состояний монстраПервый шаг — создать интерфейс, который будет представлять разные состояния монстра. Этот интерфейс определяет метод, который будет вызываться в зависимости от текущего состояния.- @- R1 V- O0 X: p% Z; n5 j; a. r1 J
( M; Y- J* u' _: G$ J. s
  1. <font color="Green">// Пакет для состояний монстра</font># A9 v" g8 r( W$ g. i# J
  2. package org.l2jmobius.gameserver.model.actor.state;
    ' k6 v( J! I2 z' s
  3. <font color="Green">
    9 d5 m( K7 F0 Z! Q
  4. // Интерфейс, представляющий состояния монстра</font>" ?6 O/ g" z* D
  5. public interface MonsterState {
    4 r3 |2 |/ q' L5 H
  6.     void handleState(Monster monster);
    4 C3 ]8 @9 p  v* x6 G7 k
  7. }
    6 ~  c( f% d) U1 z: U% Y' R1 q
Скопировать код

! U; ?3 K5 J- }! n7 {Шаг 2: Реализация различных состоянийТеперь создадим классы для каждого состояния: например, InitialState, AggressiveState и FinalState. Эти состояния будут реализовывать интерфейс MonsterState и определять поведение монстра на разных этапах боя.1 v: h  B. e' j7 E5 [" E

; W& p9 W1 U6 C& e) l  RКласс для начального состояния монстра:
; d& h$ ~; Y) x2 k
  1. <font color="Green">// Пакет org.l2jmobius.gameserver.model.actor.state</font>
      F1 q- m# z4 \* z
  2. package org.l2jmobius.gameserver.model.actor.state;& Q: ?# H' g0 H
  3. 8 |, o7 Y1 ~& b. g1 [3 A
  4. import org.l2jmobius.gameserver.model.actor.Monster;
    1 T; ]8 a4 v+ h8 F% w

  5. , T2 k9 _5 A$ o0 q' k
  6. public class InitialState implements MonsterState {; D: s; ~* F7 d- |; @2 q% Q8 y
  7.     @Override
    & x( D+ A& i$ A1 e9 Q/ y. d. t$ h
  8.     public void handleState(Monster monster) {
    ; v0 v. D$ {1 w" L5 D$ ?
  9.         // Начальная фаза боя
    0 [& P6 L  v8 O- |* y! c7 y2 B
  10.         System.out.println(monster.getName() + " начинает бой с обычной атакой.");1 R' y  t3 F7 _, {* V" N. d! _* B+ G
  11.     }; i* H- R" i& ?- n. D
  12. }4 r* [8 y5 d1 J. H' b
Скопировать код
; h' J# j2 v" \1 a. N

, _! _9 V% H% k) n& }4 x, W7 l
2 K/ k8 e& p1 ^0 v( {  ^& _4 `/ W+ a3 X. x9 [) j+ V
( c2 M6 Q4 y# T' ~  T9 a
, p5 m- k" x/ B5 |
: v" x& c' g. |
 Автор| Astraliya Опубликовано 2024-10-16 21:04:54 | Показать все сообщения
Для управления сложными взаимодействиями, такими как несколько фаз боя с разными состояниями монстра, лучший подход — использовать шаблон проектирования "Состояние" (State Pattern). 5 j! b! g2 N7 T/ M

, K( x2 n$ P1 A$ g- z4 PЭтот шаблон позволяет разделить логику поведения объекта на разные состояния и управлять ими более гибко, избегая перегрузки основного класса монстра.6 j  j5 [; X- L) u! A

1 }. V: }& {7 w  M7 d+ i4 z9 uШаг 1: Создание интерфейса для состояний монстраПервый шаг — создать интерфейс, который будет представлять разные состояния монстра. Этот интерфейс определяет метод, который будет вызываться в зависимости от текущего состояния.& f! S# }  y( N& v2 `
# e4 F: |! R5 F- R. C. N5 g( `8 k
  1. // Пакет для состояний монстра3 \& v, h4 U1 l$ b
  2. package org.l2jmobius.gameserver.model.actor.state;
    & |  V( ^" O* }) S2 H
  3. 7 `# A! i* V% d# A5 ^% H$ i4 `
  4. // Интерфейс, представляющий состояния монстра
    / J" H4 l% N# f# R9 ]
  5. public interface MonsterState {( L7 ~! Z* w6 S. T% M
  6.     void handleState(Monster monster);! I! \) ?) n7 j3 d) D/ N
  7. }  o8 I5 ?6 Z1 d! K; A" U/ A) F
Скопировать код

2 M+ z! P3 R, D* F7 [# v3 KШаг 2: Реализация различных состоянийТеперь создадим классы для каждого состояния: например, InitialState, AggressiveState и FinalState.
0 i1 I9 h* x' A* r5 e$ M, n1 z6 _" R
; \+ x5 c; B4 T6 E4 j8 HЭти состояния будут реализовывать интерфейс MonsterState и определять поведение монстра на разных этапах боя., F- C5 P/ p+ _  S) g1 \
! N) c; Y! G. B, U$ e) [7 J3 b. u- ^! s
Класс для начального состояния монстра:2 B" D0 a2 i; t' E  j
  1. // Пакет org.l2jmobius.gameserver.model.actor.state4 L/ _) m( X! N+ Q& q, k
  2. package org.l2jmobius.gameserver.model.actor.state;
    ; o: [! i1 e* o* O" P- g

  3. 5 K& C$ u# z' z1 j) a
  4. import org.l2jmobius.gameserver.model.actor.Monster;3 p; [2 B% f+ \' c
  5.   n. K' b) r8 f4 R) F! `
  6. public class InitialState implements MonsterState {
    # \) O% |9 R3 P3 G, V4 P3 P# g
  7.     @Override
    0 z2 v9 Z" e' b$ q( i
  8.     public void handleState(Monster monster) {. g5 M/ [7 _) S* I
  9.         // Начальная фаза боя
    9 S/ l) p3 |7 j" A# V
  10.         System.out.println(monster.getName() + " начинает бой с обычной атакой.");
    $ x( E& g/ P6 e" s. E
  11.     }
    + d+ d8 S3 H/ O6 s; g4 ?
  12. }; E* r% g) S4 f/ h9 |8 D+ C
Скопировать код
Класс для агрессивного состояния монстра:8 H4 K$ C# X( T) l" h+ G
  1. // Пакет org.l2jmobius.gameserver.model.actor.state
    2 f9 m8 f. Z- ^2 W0 e5 m2 f5 t
  2. package org.l2jmobius.gameserver.model.actor.state;5 ^6 V8 F: s9 N1 t! V7 f

  3. 0 D9 S6 O: G) v/ E* @
  4. import org.l2jmobius.gameserver.model.actor.Monster;5 y! y. B& t2 C. S/ r$ _1 ]
  5. . x" N! U# J/ N$ o
  6. public class AggressiveState implements MonsterState {
    3 U: ?7 R: E( Z& ^
  7.     @Override
    ) Q# c7 m- k! n# s; @' n" o+ @
  8.     public void handleState(Monster monster) {* l  F- ?$ e# |
  9.         // Агрессивная фаза боя
    1 g8 }' c& ^3 M% l$ X6 P1 C
  10.         System.out.println(monster.getName() + " становится агрессивным! Атаки усиливаются.");" L0 b  Z( P" z: u% P
  11.         monster.setAttackPower(monster.getAttackPower() * 1.5); // Увеличиваем силу атаки
    ' @0 q9 p5 l0 F) `
  12.     }2 D( V) p9 F3 F
  13. }
    + H8 _1 l1 E5 d0 s* M
Скопировать код
Класс для финального состояния монстра:
& H( K* t# c6 P& }9 c% C) h' H
  1. // Пакет org.l2jmobius.gameserver.model.actor.state
    ! f! d% B4 `: Q0 ]( F2 z
  2. package org.l2jmobius.gameserver.model.actor.state;
    7 {2 Z' u$ n8 V- F' Z6 @- x

  3. * y+ @0 z) H4 Z
  4. import org.l2jmobius.gameserver.model.actor.Monster;! l4 c% N% x' i; ~9 }6 [! l

  5. - l# K4 q2 a8 }9 }6 z" W- Y" c; ]
  6. public class FinalState implements MonsterState {
    ; y9 }* m. s+ H) W( P- {) k  v( f% J
  7.     @Override
    $ i# W0 U; k' R3 h8 L
  8.     public void handleState(Monster monster) {( z3 j- m0 V: t; k
  9.         // Финальная фаза боя
    & u' D: b* P8 b/ a( _9 w% }; ]
  10.         System.out.println(monster.getName() + " готовится к финальной атаке!");
    ) V  E! N' A. V) P" K+ f
  11.         monster.setAttackPower(monster.getAttackPower() * 2); // Максимальная сила атаки
    - w, |( b3 U9 R) {) O2 i% w: m) b
  12.     }. \% E% W. ]( i5 o% ~; C  ?0 T
  13. }
    8 y% x- c+ x, f, s; R& R
Скопировать код

& N; t; ]7 @6 g  S) oШаг 3: Изменение класса MonsterЧтобы монстр мог переключаться между состояниями, нам нужно обновить класс Monster. В этой сборке L2J_Mobius, классы для игровых объектов, таких как монстры, находятся в пакете org.l2jmobius.gameserver.model.actor.
: I8 H* |* M' G+ D" u* }
  1. // Пакет org.l2jmobius.gameserver.model.actor' s. a3 B4 G" j
  2. package org.l2jmobius.gameserver.model.actor;
    / B* A/ N/ F1 L( @2 M/ r
  3. $ ]- w: S  O1 d: J& n* A: i
  4. import org.l2jmobius.gameserver.model.actor.state.MonsterState;
    # |; T8 `/ u6 w$ L* U& r5 W
  5. import org.l2jmobius.gameserver.model.actor.state.InitialState;& n1 C3 G% i0 F$ l$ \

  6. ! k/ {0 q( L( V" o( O- c( q
  7. public class Monster extends Creature {
    ) B& m, y! \8 w# `$ z
  8.     private String name;
    7 F" `! p) G; b
  9.     private double attackPower;
    ( t" Y! c: `3 r2 g6 w5 K
  10.     private MonsterState state; // Текущее состояние монстра
    " X3 r: [0 H$ O0 Z" H/ f5 m

  11. 2 r' C2 [: J2 Y9 L* w6 P
  12.     // Конструктор монстра6 T( l# Q6 H( j$ t& B
  13.     public Monster(String name, double attackPower) {) T6 \6 @7 m( t
  14.         this.name = name;7 \6 K2 M- i" z" l
  15.         this.attackPower = attackPower;
    & m; U- b" |: l$ j* [
  16.         this.state = new InitialState(); // Устанавливаем начальное состояние* ^9 z! ~1 I6 ]
  17.     }
    2 {* w: M/ ^( M: H$ _1 o

  18. 5 K( z% r, ^9 J# [
  19.     // Метод для смены состояния% x; {5 ^, N8 C1 d4 J: E& c' a
  20.     public void setState(MonsterState newState) {
    # b3 v8 J* J- u% A! G1 ~! @% y
  21.         this.state = newState;
    2 X  G& F  c$ K2 q$ {
  22.     }. p, }) e* q) w' F% S& V2 r
  23. 6 ?9 |9 W5 t' a& E6 W7 S
  24.     // Выполнение действий на основе текущего состояния
    ' Z8 }3 R2 @: n2 U+ _
  25.     public void executeState() {
    . }0 q0 u0 @# C/ M- T0 ]$ H
  26.         state.handleState(this);
    4 B/ f) \- w' R/ ]
  27.     }
    $ h; p9 A' P& j6 J7 H- R; x

  28. * w$ I+ t# k3 h- ~$ L+ i
  29.     // Геттеры и сеттеры" t  y4 c$ H5 _& c9 \! U; K5 z
  30.     public String getName() {
    ( u+ M! a  K) c) M5 o, O! m
  31.         return name;0 r4 R# `$ _# e* _+ O
  32.     }
    1 W- K4 t* n) R  f" u3 {
  33. 2 W' u: m$ \+ `' Y: C: V# c5 }$ x
  34.     public double getAttackPower() {8 I: {( A% c4 l
  35.         return attackPower;
    % E8 ]! h2 n) S/ P' _( v0 u/ F0 c
  36.     }
    4 }! n0 S  x: L9 S5 k+ f

  37. 4 I7 J. h9 F9 i
  38.     public void setAttackPower(double attackPower) {
    % Q2 |! g- ]2 D3 e5 r, }
  39.         this.attackPower = attackPower;0 r7 h- D, s0 S" ~+ c1 c  j% T
  40.     }0 m- _9 u9 U: F7 E0 a! `
  41. }
    ' G$ Z1 X" o4 n; H0 ~# v
Скопировать код

8 P  ]  l6 w1 L' dШаг 4: Симуляция боя с фазамиТеперь мы можем протестировать логику боя с переключением состояний монстра.
  |  k0 C7 X2 M8 a& m! m9 W! J: [1 i, Q4 n
  1. // Пакет org.l2jmobius.gameserver.model.battle
    , \0 ^- \# b) F+ V0 |' S
  2. package org.l2jmobius.gameserver.model.battle;" t; N3 c* e, H, g

  3. / N: |; H  c2 \
  4. import org.l2jmobius.gameserver.model.actor.Monster;
    3 F; D" [" i. H( O! g8 q# X: }/ l
  5. import org.l2jmobius.gameserver.model.actor.state.AggressiveState;
    3 D5 W! z. t1 s- \; f# u3 o5 k
  6. import org.l2jmobius.gameserver.model.actor.state.FinalState;
    ' X5 y$ e: n6 W* u. y
  7. , \- J+ V+ @* Z( ~# z; C( x4 a! W
  8. public class BattleSimulation {
    , B* k, ~& w# g7 i
  9.     public static void main(String[] args) {
    3 j* V" ]' p3 `* {* Z
  10.         // Создаем монстра с начальной атакой0 \& x  Z( N* l" d% L' ]
  11.         Monster monster = new Monster("Дракон", 100);
    9 r3 b0 h: R. K6 l( b3 m. y6 H
  12. ! M% n2 Z* H2 k" \( C3 i5 I
  13.         // Начальная фаза: X  k4 G3 ?5 x& n& r+ f, E" T
  14.         monster.executeState();1 O( L9 z& d) k  @+ I5 t
  15. & c  M6 Q1 Y( G% Y: g: L5 A# u
  16.         // Переход в агрессивную фазу' o% b- e- t3 ]7 L. x( Q
  17.         monster.setState(new AggressiveState());1 A8 ?8 E/ H9 c
  18.         monster.executeState();
    ! x/ W/ ?1 [( r; J0 b& j
  19. ; |2 L* w$ A# I" P/ X. c8 }# _
  20.         // Финальная фаза
    1 J$ H6 `% Y2 K7 U3 t1 ~) H- s" g
  21.         monster.setState(new FinalState());: y; G. g+ j/ L
  22.         monster.executeState();
    0 K6 G' D: d9 g  F4 I
  23.     }( d$ n7 x0 T# J3 m+ z1 D' _. S
  24. }' l7 j. z# I5 B
Скопировать код

% v- F+ ]( Y( t% s$ R3 ^4 VКомментарии по структуре пакетов и классов:
, ~4 ]4 U6 r+ Y
  • Пакет org.l2jmobius.gameserver.model.actor: содержит основные игровые сущности, такие как Monster.
  • Пакет org.l2jmobius.gameserver.model.actor.state: отвечает за реализацию состояний для объектов, таких как монстры.
  • Пакет org.l2jmobius.gameserver.model.battle: может содержать примеры взаимодействий, такие как симуляция боевых сценариев.
    , G! f& O& N* w+ F' `" T1 h$ ?$ O4 ]7 ~
ЗаключениеШаблон "Состояние" позволяет легко управлять фазами боя и не перегружать основной класс монстра. Это делает логику боевых сценариев более гибкой и масштабируемой. В будущем, если появятся новые фазы или состояния, их можно будет легко добавить, не изменяя основной код.
% H& I% c7 j- S$ k! Q9 TЕсли появятся дополнительные вопросы по реализации или структуре классов, буду рада помочь!
3 @% A* }, R) N( s2 y+ R6 h% k" z) C; n  ~# M4 U

! u+ S+ B# l7 f# x
5 D6 u3 m" q( J- ], ]3 f. m, X# P% X7 D- \" T# g% T* E7 w" b0 Z; O  A

; _5 v( ^: ^( j! z+ `* T- x2 k( g# I  t. P
/ e. X+ o/ U2 D( w( h. B

2 P) [! [' p$ }' M4 m1 Q5 H9 l/ N! i8 d. R  R

% e/ e$ g1 i" M# {1 i& i7 S2 i$ K, n

; Z/ R. G1 j  n5 u& ]: E2 j  z7 J
9 Y* J  S& a6 q, ?# J1 m7 \, J1 T9 K' Q
AlexCoder Опубликовано 2024-10-16 21:21:15 | Показать все сообщения
Astraliya опубликовал в 2024-10-16 21:04/ T4 u) J* s! `% ^8 B
Для управления сложными взаимодействиями, такими как  ...
2 t7 ?' s: @( Y* c" {" w  Z7 H
Отличный подход! Использование шаблона "Состояние" действительно помогает сделать код более чистым и управляемым. Я задумался: если мы добавим несколько фаз в бою с различными типами атак (например, магические и физические атаки), можно ли расширить этот паттерн, чтобы каждая фаза также учитывала тип атаки? Например, чтобы в агрессивной фазе монстр мог случайным образом чередовать типы атак. Как лучше организовать это в рамках данного паттерна?
 Автор| Astraliya Опубликовано 2024-10-16 21:33:48 | Показать все сообщения
AlexCoder опубликовал в 2024-10-16 21:21
$ K' X! ^9 r& c  IОтличный подход! Использование шаблона "Состояние" де ...

) ?  G$ K) m* P/ T7 {Хороший вопрос! Да, шаблон "Состояние" можно легко расширить, чтобы учесть различные типы атак. В этом случае можно добавить логику для чередования атак (магических и физических) в каждом состоянии.
6 H* S. Q* g' ^  P# P5 r; Y$ k% }* ~! T# }( L' L# K- j
Шаг 1: Добавление типа атакиДля этого давайте создадим перечисление (enum) для типов атак и добавим его в наши состояния. Это позволит монстру случайным образом выбирать тип атаки во время боя.
2 A2 R: T: b# B
! x/ m& m6 v( d
  1. // Пакет org.l2jmobius.gameserver.model.actor
    1 w. {7 ]. ]! g
  2. package org.l2jmobius.gameserver.model.actor;
    2 V" o0 S7 f9 M, q& g

  3. 9 S" ]5 o# q7 K& a, u- B% {* X' R
  4. // Перечисление для типов атак
    ; c) J7 S- ~; j% B4 w
  5. public enum AttackType {
    6 z6 F* F- O1 \: `- M2 c4 N' M: @
  6.     PHYSICAL, MAGICAL;! |# m' ^& P0 A; F% G" O
  7. }+ ]6 |+ r" E( Q1 m. H( h3 B
Скопировать код
Шаг 2: Обновление состояний для поддержки разных атакТеперь обновим состояния монстра, чтобы в каждом из них можно было чередовать типы атак.
* w9 w6 O, V3 P! Z9 {Обновленный класс для агрессивного состояния монстра:7 I' o5 K  d5 v- v& k3 {+ E

2 H) V" _3 c9 c$ A; |, |" W- m- }& |
  1. // Пакет org.l2jmobius.gameserver.model.actor.state
    5 @0 H, E6 c' D6 T! p
  2. package org.l2jmobius.gameserver.model.actor.state;
    0 z' @8 ?3 ^; ~5 s9 ~8 @! b

  3. 4 q* E2 s5 T4 \" Q  w) g
  4. import org.l2jmobius.gameserver.model.actor.Monster;7 \+ L% Z" ]# p; Z5 d! a
  5. import org.l2jmobius.gameserver.model.actor.AttackType;
    5 O$ c( Q8 E# b3 m1 @% H
  6. 1 X0 ?8 x3 g' _! V# u5 F9 R
  7. import java.util.Random;
    4 |0 [2 E& N( d; T5 |* z2 `4 T
  8. ' n# a/ P3 b8 G+ L
  9. public class AggressiveState implements MonsterState {$ a6 y1 \5 e/ V! [
  10.     private Random random = new Random();8 s! @$ b% n; w" m6 I& n
  11. / G! V$ G: y# x  z% q4 Q
  12.     @Override& a' O  c: J$ H, I
  13.     public void handleState(Monster monster) {
    ( q8 O# l* F- z1 t
  14.         // Выбираем случайный тип атаки: физическая или магическая
    * P2 d; ^, U, h8 K. }) O3 P
  15.         AttackType attackType = random.nextBoolean() ? AttackType.PHYSICAL : AttackType.MAGICAL;
    + `& U  g7 R5 B9 f* Z( n
  16. 2 {( Y% I. [1 f$ v
  17.         // Логика для агрессивной фазы боя& p/ q+ l; i+ g0 o& x
  18.         System.out.println(monster.getName() + " становится агрессивным и использует " + u* |$ `- [( g9 _. m$ N
  19.             + (attackType == AttackType.PHYSICAL ? "физическую" : "магическую") + " атаку!");
    9 `& Q. S& M, R2 H* r" H. N9 G
  20.         4 V$ P3 I2 Q( U- X) w; t
  21.         // Увеличиваем силу атаки в зависимости от типа атаки
    : T7 X# u# ]0 S& p; y& u
  22.         double multiplier = (attackType == AttackType.PHYSICAL) ? 1.5 : 1.2;# d& S4 V/ v3 U4 q2 g$ I
  23.         monster.setAttackPower(monster.getAttackPower() * multiplier);; K) Y; `" w$ ^5 t4 x8 @! s! W
  24.     }
    8 X& C1 a& f+ Z% O% @5 K# z4 n" b
  25. }: W: A: d: |4 ?. z% L( m3 Y2 v$ V
Скопировать код
Шаг 3: Модификация класса MonsterТеперь класс Monster будет использовать состояние с логикой выбора типа атаки
; c& F/ r- L! M' X0 W
+ P/ e7 |$ G* g2 s/ g
  1. // Пакет org.l2jmobius.gameserver.model.actor
    $ E! v3 h0 P9 f5 m, W+ v( i; [
  2. package org.l2jmobius.gameserver.model.actor;) U/ M& [# H" w) D/ p) N, s+ U

  3. & e5 P/ {1 t; D) u
  4. import org.l2jmobius.gameserver.model.actor.state.MonsterState;
    ) l& }: \# u/ n1 z
  5. import org.l2jmobius.gameserver.model.actor.state.InitialState;
    # J  |. s) [9 v& H- ^  j( c
  6. ! Q4 X) o- x: S' ?( \
  7. public class Monster extends Creature {
    8 M1 u7 R9 N3 y0 E5 W4 C
  8.     private String name;) y, N* @# P5 y1 g9 W1 Z
  9.     private double attackPower;# s8 v, i" F1 @. R
  10.     private MonsterState state; // Текущее состояние монстра
    * P+ X3 P' E1 }- M3 F9 [

  11. ' \! u7 {2 R, N' |4 O" a; p- V( x
  12.     // Конструктор монстра5 H7 M5 o* k! d6 G. t8 Q8 C
  13.     public Monster(String name, double attackPower) {
    / d, c! V& P" j2 m* X3 O# Y
  14.         this.name = name;
      j( n# R1 u: o, ^
  15.         this.attackPower = attackPower;
    * c' ~2 h7 T8 P& p: y  a; X  e3 y
  16.         this.state = new InitialState(); // Начальное состояние по умолчанию
    9 J4 z2 y0 H& E, Q! r5 I
  17.     }
    ( ]% L% J9 n8 G% n, V) ~: n
  18. * x  K* t( w0 B9 w
  19.     // Метод для смены состояния
    2 d# D1 u2 L% a' @3 S  J6 k( y1 n
  20.     public void setState(MonsterState newState) {
    * u% \8 L( X8 A! A# g* x. g+ H) a
  21.         this.state = newState;. V( [# M' A1 u# s9 `! g( y
  22.     }* p! l! u& K; R; X3 E7 H! c
  23. 5 S% L2 Z- c* o- d; }8 J' c* N
  24.     // Выполнение действий на основе текущего состояния# e3 Q6 o, I* B0 W2 c
  25.     public void executeState() {
    : J6 R# V9 D" a  i
  26.         state.handleState(this);
    ( a( j2 r. b5 \. e
  27.     }) {  ^5 s! B4 U0 F

  28. 3 h1 F) e: N; Q. W' b7 w
  29.     // Геттеры и сеттеры
    $ a( V; K' o$ [  R1 ]6 z6 d- I& f
  30.     public String getName() {
    ( o; L) a) \& A9 `7 m# H( X( _. z5 u( Y4 X6 b
  31.         return name;
    / M/ s2 V# X. A3 W4 j4 D: E
  32.     }& O2 y2 ^. {7 ~. o% h5 Z
  33. - K- h, r$ D4 |. U) g
  34.     public double getAttackPower() {, @- J3 ^/ i& D( M
  35.         return attackPower;
    6 W# S8 J8 \* R
  36.     }4 I0 X) K/ ?$ |9 J5 S
  37. & i, ?/ X  B! K
  38.     public void setAttackPower(double attackPower) {
    , n$ e  W% [5 m7 Q4 Z& x' l
  39.         this.attackPower = attackPower;
    / C' ]1 ~0 Z$ _* b2 F4 x9 E
  40.     }
    / b, s4 x8 g) D2 C; L
  41. }* D, R% j! v7 ]& f" G- {" X
Скопировать код
Шаг 4: Тестирование нового поведенияТеперь давайте посмотрим, как монстр будет чередовать типы атак в агрессивной фазе.! F2 n0 \( [3 n6 H- v- U2 n; t

: j) \" }. t) a% H8 f+ O
  1. // Пакет org.l2jmobius.gameserver.model.battle
    ' c. u% h' g) @; d4 x; d
  2. package org.l2jmobius.gameserver.model.battle;
    ( @& }/ \8 `, H. A+ H
  3. ( ~* M/ A1 D/ f6 |7 d/ I3 y
  4. import org.l2jmobius.gameserver.model.actor.Monster;) ]: O/ F3 g7 H4 i, b
  5. import org.l2jmobius.gameserver.model.actor.state.AggressiveState;# o/ W8 z9 i/ T/ i% n" J
  6. ! W. e) H# a3 o. z
  7. public class BattleSimulation {
    ( ~; b' t: b7 p  ?
  8.     public static void main(String[] args) {
    6 }3 x& M" D7 ?: C& {" w0 m
  9.         // Создаем монстра, M1 o0 O. q0 L
  10.         Monster monster = new Monster("Дракон", 100);
    9 w1 S: j4 S: l% S0 z6 J5 O

  11. 0 x" z( _* ?3 v( D
  12.         // Переключаем монстра в агрессивное состояние с разными типами атак
    / u& A2 y# G2 p5 F7 `: o+ U$ e
  13.         monster.setState(new AggressiveState());
    1 z0 H) M5 A+ K
  14.         monster.executeState();* ]1 @$ Z# E7 _
  15.         monster.executeState(); // Повторяем, чтобы увидеть чередование атак  l% d% ^. f" s) Q
  16.     }
    7 z2 G) K" H, C  q
  17. }
    5 F4 h$ \) D7 {# r/ n( h, q
Скопировать код
ЗаключениеВ результате, с помощью перечисления AttackType, мы можем легко добавлять и чередовать типы атак в зависимости от состояния. Это гибкий способ управления сложными взаимодействиями в бою, не перегружая основной код. Выбор типа атаки можно ещё больше расширить, добавив, например, урон или специальные способности, в зависимости от типа атаки., m5 N5 x9 x. w5 H1 r$ a# z
Если у тебя есть еще идеи или предложения по улучшению, всегда рад обсудить!
% w$ W! Z4 G0 |% z( ?2 W( M
! X9 R$ h* b; h" m6 q6 o+ N
5 l# H5 Y! s9 A6 }9 l' l4 n4 k7 ]1 c" R# h
Чтобы ответить, вам надо авторизироваться в системе Вход | Зарегистрироваться

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

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

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

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

подписок0

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

постов9

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

638638758

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

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

admin@artace.ru Онлайн

QR-код

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