Mirrored_Repos/veloren
1
0
Fork 0
mirror of https://gitlab.com/veloren/veloren.git synced 2024-08-30 18:12:32 +00:00
Code Issues Packages Projects Releases Wiki Activity

Addressed review

Browse Source
This commit is contained in:
Sam 2023-02-21 20:08:09 -05:00
parent cc84fb3df3
commit c78c45ec73
3 changed files with 67 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
server-cli/src/main.rs
View File

@ -91,6 +91,10 @@ fn main() -> io::Result<()> {
.unwrap(), .unwrap(),
); );
// agent and world imported here so that mim-alloc can be used when hot
// reloading these crates without separately declaring mim-alloc as the
// allocator in those crates (doing so causes UB when a vec (and presumably
// other allocations) are passed to a dynlib and resized within that dynlib)
#[cfg(feature = "hot-agent")] #[cfg(feature = "hot-agent")]
{ {
agent::init(); agent::init();

146
server/agent/src/attack.rs
View File

@ -771,15 +771,15 @@ impl<'a> AgentData<'a> {
extract_ability(AbilityInput::Auxiliary(3)), extract_ability(AbilityInput::Auxiliary(3)),
extract_ability(AbilityInput::Auxiliary(4)), extract_ability(AbilityInput::Auxiliary(4)),
]; ];
let could_use_input = |input, misc_data| match input { let could_use_input = |input, desired_energy| match input {
InputKind::Primary => primary.as_ref().map_or(false, |p| { InputKind::Primary => primary.as_ref().map_or(false, |p| {
p.could_use(attack_data, self, misc_data, tgt_data) p.could_use(attack_data, self, tgt_data, desired_energy)
}), }),
InputKind::Secondary => secondary.as_ref().map_or(false, |s| { InputKind::Secondary => secondary.as_ref().map_or(false, |s| {
s.could_use(attack_data, self, misc_data, tgt_data) s.could_use(attack_data, self, tgt_data, desired_energy)
}), }),
InputKind::Ability(x) => abilities[x].as_ref().map_or(false, |a| { InputKind::Ability(x) => abilities[x].as_ref().map_or(false, |a| {
a.could_use(attack_data, self, misc_data, tgt_data) a.could_use(attack_data, self, tgt_data, desired_energy)
}), }),
_ => false, _ => false,
}; };
@ -804,9 +804,7 @@ impl<'a> AgentData<'a> {
agent.action_state.int_counters[IntCounters::Tactics as usize], agent.action_state.int_counters[IntCounters::Tactics as usize],
) { ) {
SwordTactics::Unskilled => { SwordTactics::Unskilled => {
let misc_data = MiscData { let desired_energy = 15.0;
desired_energy: 15.0,
};
let current_input = self.char_state.ability_info().map(|ai| ai.input); let current_input = self.char_state.ability_info().map(|ai| ai.input);
let mut next_input = None; let mut next_input = None;
if let Some(input) = current_input { if let Some(input) = current_input {
@ -817,7 +815,7 @@ impl<'a> AgentData<'a> {
next_input = Some(InputKind::Secondary); next_input = Some(InputKind::Secondary);
}; };
if let Some(input) = next_input { if let Some(input) = next_input {
if could_use_input(input, &misc_data) { if could_use_input(input, desired_energy) {
controller.push_basic_input(input); controller.push_basic_input(input);
false false
} else { } else {
@ -828,16 +826,14 @@ impl<'a> AgentData<'a> {
} }
}, },
SwordTactics::Basic => { SwordTactics::Basic => {
let misc_data = MiscData { let desired_energy = 25.0;
desired_energy: 25.0,
};
let current_input = self.char_state.ability_info().map(|ai| ai.input); let current_input = self.char_state.ability_info().map(|ai| ai.input);
let mut next_input = None; let mut next_input = None;
if let Some(input) = current_input { if let Some(input) = current_input {
continue_current_input(input, &mut next_input); continue_current_input(input, &mut next_input);
} else { } else {
let attempt_ability = InputKind::Ability(rng.gen_range(0..5)); let attempt_ability = InputKind::Ability(rng.gen_range(0..5));
if could_use_input(attempt_ability, &misc_data) { if could_use_input(attempt_ability, desired_energy) {
next_input = Some(attempt_ability); next_input = Some(attempt_ability);
} else if rng.gen_bool(0.5) { } else if rng.gen_bool(0.5) {
next_input = Some(InputKind::Primary); next_input = Some(InputKind::Primary);
@ -846,7 +842,7 @@ impl<'a> AgentData<'a> {
} }
}; };
if let Some(input) = next_input { if let Some(input) = next_input {
if could_use_input(input, &misc_data) { if could_use_input(input, desired_energy) {
controller.push_basic_input(input); controller.push_basic_input(input);
false false
} else { } else {
@ -857,9 +853,7 @@ impl<'a> AgentData<'a> {
} }
}, },
SwordTactics::HeavySimple => { SwordTactics::HeavySimple => {
let misc_data = MiscData { let desired_energy = 35.0;
desired_energy: 35.0,
};
let current_input = self.char_state.ability_info().map(|ai| ai.input); let current_input = self.char_state.ability_info().map(|ai| ai.input);
let mut next_input = None; let mut next_input = None;
if let Some(input) = current_input { if let Some(input) = current_input {
@ -868,16 +862,16 @@ impl<'a> AgentData<'a> {
let stance_ability = InputKind::Ability(rng.gen_range(3..5)); let stance_ability = InputKind::Ability(rng.gen_range(3..5));
let random_ability = InputKind::Ability(rng.gen_range(1..5)); let random_ability = InputKind::Ability(rng.gen_range(1..5));
if !matches!(self.stance, Some(Stance::Sword(SwordStance::Heavy))) { if !matches!(self.stance, Some(Stance::Sword(SwordStance::Heavy))) {
if could_use_input(stance_ability, &misc_data) { if could_use_input(stance_ability, desired_energy) {
next_input = Some(stance_ability); next_input = Some(stance_ability);
} else if rng.gen_bool(0.5) { } else if rng.gen_bool(0.5) {
next_input = Some(InputKind::Primary); next_input = Some(InputKind::Primary);
} else { } else {
next_input = Some(InputKind::Secondary); next_input = Some(InputKind::Secondary);
} }
} else if could_use_input(InputKind::Ability(0), &misc_data) { } else if could_use_input(InputKind::Ability(0), desired_energy) {
next_input = Some(InputKind::Ability(0)); next_input = Some(InputKind::Ability(0));
} else if could_use_input(random_ability, &misc_data) { } else if could_use_input(random_ability, desired_energy) {
next_input = Some(random_ability); next_input = Some(random_ability);
} else if rng.gen_bool(0.5) { } else if rng.gen_bool(0.5) {
next_input = Some(InputKind::Primary); next_input = Some(InputKind::Primary);
@ -886,7 +880,7 @@ impl<'a> AgentData<'a> {
} }
}; };
if let Some(input) = next_input { if let Some(input) = next_input {
if could_use_input(input, &misc_data) { if could_use_input(input, desired_energy) {
controller.push_basic_input(input); controller.push_basic_input(input);
false false
} else { } else {
@ -897,9 +891,7 @@ impl<'a> AgentData<'a> {
} }
}, },
SwordTactics::AgileSimple => { SwordTactics::AgileSimple => {
let misc_data = MiscData { let desired_energy = 35.0;
desired_energy: 35.0,
};
let current_input = self.char_state.ability_info().map(|ai| ai.input); let current_input = self.char_state.ability_info().map(|ai| ai.input);
let mut next_input = None; let mut next_input = None;
if let Some(input) = current_input { if let Some(input) = current_input {
@ -908,16 +900,16 @@ impl<'a> AgentData<'a> {
let stance_ability = InputKind::Ability(rng.gen_range(3..5)); let stance_ability = InputKind::Ability(rng.gen_range(3..5));
let random_ability = InputKind::Ability(rng.gen_range(1..5)); let random_ability = InputKind::Ability(rng.gen_range(1..5));
if !matches!(self.stance, Some(Stance::Sword(SwordStance::Agile))) { if !matches!(self.stance, Some(Stance::Sword(SwordStance::Agile))) {
if could_use_input(stance_ability, &misc_data) { if could_use_input(stance_ability, desired_energy) {
next_input = Some(stance_ability); next_input = Some(stance_ability);
} else if rng.gen_bool(0.5) { } else if rng.gen_bool(0.5) {
next_input = Some(InputKind::Primary); next_input = Some(InputKind::Primary);
} else { } else {
next_input = Some(InputKind::Secondary); next_input = Some(InputKind::Secondary);
} }
} else if could_use_input(InputKind::Ability(0), &misc_data) { } else if could_use_input(InputKind::Ability(0), desired_energy) {
next_input = Some(InputKind::Ability(0)); next_input = Some(InputKind::Ability(0));
} else if could_use_input(random_ability, &misc_data) { } else if could_use_input(random_ability, desired_energy) {
next_input = Some(random_ability); next_input = Some(random_ability);
} else if rng.gen_bool(0.5) { } else if rng.gen_bool(0.5) {
next_input = Some(InputKind::Primary); next_input = Some(InputKind::Primary);
@ -926,7 +918,7 @@ impl<'a> AgentData<'a> {
} }
}; };
if let Some(input) = next_input { if let Some(input) = next_input {
if could_use_input(input, &misc_data) { if could_use_input(input, desired_energy) {
controller.push_basic_input(input); controller.push_basic_input(input);
false false
} else { } else {
@ -937,9 +929,7 @@ impl<'a> AgentData<'a> {
} }
}, },
SwordTactics::DefensiveSimple => { SwordTactics::DefensiveSimple => {
let misc_data = MiscData { let desired_energy = 35.0;
desired_energy: 35.0,
};
let current_input = self.char_state.ability_info().map(|ai| ai.input); let current_input = self.char_state.ability_info().map(|ai| ai.input);
let mut next_input = None; let mut next_input = None;
if let Some(input) = current_input { if let Some(input) = current_input {
@ -948,18 +938,18 @@ impl<'a> AgentData<'a> {
let stance_ability = InputKind::Ability(rng.gen_range(3..5)); let stance_ability = InputKind::Ability(rng.gen_range(3..5));
let random_ability = InputKind::Ability(rng.gen_range(1..5)); let random_ability = InputKind::Ability(rng.gen_range(1..5));
if !matches!(self.stance, Some(Stance::Sword(SwordStance::Defensive))) { if !matches!(self.stance, Some(Stance::Sword(SwordStance::Defensive))) {
if could_use_input(stance_ability, &misc_data) { if could_use_input(stance_ability, desired_energy) {
next_input = Some(stance_ability); next_input = Some(stance_ability);
} else if rng.gen_bool(0.5) { } else if rng.gen_bool(0.5) {
next_input = Some(InputKind::Primary); next_input = Some(InputKind::Primary);
} else { } else {
next_input = Some(InputKind::Secondary); next_input = Some(InputKind::Secondary);
} }
} else if could_use_input(InputKind::Ability(0), &misc_data) { } else if could_use_input(InputKind::Ability(0), desired_energy) {
next_input = Some(InputKind::Ability(0)); next_input = Some(InputKind::Ability(0));
} else if could_use_input(InputKind::Ability(3), &misc_data) { } else if could_use_input(InputKind::Ability(3), desired_energy) {
next_input = Some(InputKind::Ability(3)); next_input = Some(InputKind::Ability(3));
} else if could_use_input(random_ability, &misc_data) { } else if could_use_input(random_ability, desired_energy) {
next_input = Some(random_ability); next_input = Some(random_ability);
} else if rng.gen_bool(0.5) { } else if rng.gen_bool(0.5) {
next_input = Some(InputKind::Primary); next_input = Some(InputKind::Primary);
@ -968,7 +958,7 @@ impl<'a> AgentData<'a> {
} }
}; };
if let Some(input) = next_input { if let Some(input) = next_input {
if could_use_input(input, &misc_data) { if could_use_input(input, desired_energy) {
controller.push_basic_input(input); controller.push_basic_input(input);
false false
} else { } else {
@ -979,9 +969,7 @@ impl<'a> AgentData<'a> {
} }
}, },
SwordTactics::CripplingSimple => { SwordTactics::CripplingSimple => {
let misc_data = MiscData { let desired_energy = 35.0;
desired_energy: 35.0,
};
let current_input = self.char_state.ability_info().map(|ai| ai.input); let current_input = self.char_state.ability_info().map(|ai| ai.input);
let mut next_input = None; let mut next_input = None;
if let Some(input) = current_input { if let Some(input) = current_input {
@ -990,16 +978,16 @@ impl<'a> AgentData<'a> {
let stance_ability = InputKind::Ability(rng.gen_range(3..5)); let stance_ability = InputKind::Ability(rng.gen_range(3..5));
let random_ability = InputKind::Ability(rng.gen_range(1..5)); let random_ability = InputKind::Ability(rng.gen_range(1..5));
if !matches!(self.stance, Some(Stance::Sword(SwordStance::Crippling))) { if !matches!(self.stance, Some(Stance::Sword(SwordStance::Crippling))) {
if could_use_input(stance_ability, &misc_data) { if could_use_input(stance_ability, desired_energy) {
next_input = Some(stance_ability); next_input = Some(stance_ability);
} else if rng.gen_bool(0.5) { } else if rng.gen_bool(0.5) {
next_input = Some(InputKind::Primary); next_input = Some(InputKind::Primary);
} else { } else {
next_input = Some(InputKind::Secondary); next_input = Some(InputKind::Secondary);
} }
} else if could_use_input(InputKind::Ability(0), &misc_data) { } else if could_use_input(InputKind::Ability(0), desired_energy) {
next_input = Some(InputKind::Ability(0)); next_input = Some(InputKind::Ability(0));
} else if could_use_input(random_ability, &misc_data) { } else if could_use_input(random_ability, desired_energy) {
next_input = Some(random_ability); next_input = Some(random_ability);
} else if rng.gen_bool(0.5) { } else if rng.gen_bool(0.5) {
next_input = Some(InputKind::Primary); next_input = Some(InputKind::Primary);
@ -1008,7 +996,7 @@ impl<'a> AgentData<'a> {
} }
}; };
if let Some(input) = next_input { if let Some(input) = next_input {
if could_use_input(input, &misc_data) { if could_use_input(input, desired_energy) {
controller.push_basic_input(input); controller.push_basic_input(input);
false false
} else { } else {
@ -1019,9 +1007,7 @@ impl<'a> AgentData<'a> {
} }
}, },
SwordTactics::CleavingSimple => { SwordTactics::CleavingSimple => {
let misc_data = MiscData { let desired_energy = 35.0;
desired_energy: 35.0,
};
let current_input = self.char_state.ability_info().map(|ai| ai.input); let current_input = self.char_state.ability_info().map(|ai| ai.input);
let mut next_input = None; let mut next_input = None;
if let Some(input) = current_input { if let Some(input) = current_input {
@ -1030,16 +1016,16 @@ impl<'a> AgentData<'a> {
let stance_ability = InputKind::Ability(rng.gen_range(3..5)); let stance_ability = InputKind::Ability(rng.gen_range(3..5));
let random_ability = InputKind::Ability(rng.gen_range(1..5)); let random_ability = InputKind::Ability(rng.gen_range(1..5));
if !matches!(self.stance, Some(Stance::Sword(SwordStance::Cleaving))) { if !matches!(self.stance, Some(Stance::Sword(SwordStance::Cleaving))) {
if could_use_input(stance_ability, &misc_data) { if could_use_input(stance_ability, desired_energy) {
next_input = Some(stance_ability); next_input = Some(stance_ability);
} else if rng.gen_bool(0.5) { } else if rng.gen_bool(0.5) {
next_input = Some(InputKind::Primary); next_input = Some(InputKind::Primary);
} else { } else {
next_input = Some(InputKind::Secondary); next_input = Some(InputKind::Secondary);
} }
} else if could_use_input(InputKind::Ability(0), &misc_data) { } else if could_use_input(InputKind::Ability(0), desired_energy) {
next_input = Some(InputKind::Ability(0)); next_input = Some(InputKind::Ability(0));
} else if could_use_input(random_ability, &misc_data) { } else if could_use_input(random_ability, desired_energy) {
next_input = Some(random_ability); next_input = Some(random_ability);
} else if rng.gen_bool(0.5) { } else if rng.gen_bool(0.5) {
next_input = Some(InputKind::Primary); next_input = Some(InputKind::Primary);
@ -1048,7 +1034,7 @@ impl<'a> AgentData<'a> {
} }
}; };
if let Some(input) = next_input { if let Some(input) = next_input {
if could_use_input(input, &misc_data) { if could_use_input(input, desired_energy) {
controller.push_basic_input(input); controller.push_basic_input(input);
false false
} else { } else {
@ -1059,9 +1045,7 @@ impl<'a> AgentData<'a> {
} }
}, },
SwordTactics::HeavyAdvanced => { SwordTactics::HeavyAdvanced => {
let misc_data = MiscData { let desired_energy = 50.0;
desired_energy: 50.0,
};
let current_input = self.char_state.ability_info().map(|ai| ai.input); let current_input = self.char_state.ability_info().map(|ai| ai.input);
let mut next_input = None; let mut next_input = None;
if let Some(input) = current_input { if let Some(input) = current_input {
@ -1070,16 +1054,16 @@ impl<'a> AgentData<'a> {
let stance_ability = InputKind::Ability(rng.gen_range(1..3)); let stance_ability = InputKind::Ability(rng.gen_range(1..3));
let random_ability = InputKind::Ability(rng.gen_range(1..5)); let random_ability = InputKind::Ability(rng.gen_range(1..5));
if !matches!(self.stance, Some(Stance::Sword(SwordStance::Heavy))) { if !matches!(self.stance, Some(Stance::Sword(SwordStance::Heavy))) {
if could_use_input(stance_ability, &misc_data) { if could_use_input(stance_ability, desired_energy) {
next_input = Some(stance_ability); next_input = Some(stance_ability);
} else if rng.gen_bool(0.5) { } else if rng.gen_bool(0.5) {
next_input = Some(InputKind::Primary); next_input = Some(InputKind::Primary);
} else { } else {
next_input = Some(InputKind::Secondary); next_input = Some(InputKind::Secondary);
} }
} else if could_use_input(InputKind::Ability(0), &misc_data) { } else if could_use_input(InputKind::Ability(0), desired_energy) {
next_input = Some(InputKind::Ability(0)); next_input = Some(InputKind::Ability(0));
} else if could_use_input(random_ability, &misc_data) { } else if could_use_input(random_ability, desired_energy) {
next_input = Some(random_ability); next_input = Some(random_ability);
} else if rng.gen_bool(0.5) { } else if rng.gen_bool(0.5) {
next_input = Some(InputKind::Primary); next_input = Some(InputKind::Primary);
@ -1088,7 +1072,7 @@ impl<'a> AgentData<'a> {
} }
}; };
if let Some(input) = next_input { if let Some(input) = next_input {
if could_use_input(input, &misc_data) { if could_use_input(input, desired_energy) {
controller.push_basic_input(input); controller.push_basic_input(input);
false false
} else { } else {
@ -1099,9 +1083,7 @@ impl<'a> AgentData<'a> {
} }
}, },
SwordTactics::AgileAdvanced => { SwordTactics::AgileAdvanced => {
let misc_data = MiscData { let desired_energy = 50.0;
desired_energy: 50.0,
};
let current_input = self.char_state.ability_info().map(|ai| ai.input); let current_input = self.char_state.ability_info().map(|ai| ai.input);
let mut next_input = None; let mut next_input = None;
if let Some(input) = current_input { if let Some(input) = current_input {
@ -1110,16 +1092,16 @@ impl<'a> AgentData<'a> {
let stance_ability = InputKind::Ability(rng.gen_range(1..3)); let stance_ability = InputKind::Ability(rng.gen_range(1..3));
let random_ability = InputKind::Ability(rng.gen_range(1..5)); let random_ability = InputKind::Ability(rng.gen_range(1..5));
if !matches!(self.stance, Some(Stance::Sword(SwordStance::Agile))) { if !matches!(self.stance, Some(Stance::Sword(SwordStance::Agile))) {
if could_use_input(stance_ability, &misc_data) { if could_use_input(stance_ability, desired_energy) {
next_input = Some(stance_ability); next_input = Some(stance_ability);
} else if rng.gen_bool(0.5) { } else if rng.gen_bool(0.5) {
next_input = Some(InputKind::Primary); next_input = Some(InputKind::Primary);
} else { } else {
next_input = Some(InputKind::Secondary); next_input = Some(InputKind::Secondary);
} }
} else if could_use_input(InputKind::Ability(0), &misc_data) { } else if could_use_input(InputKind::Ability(0), desired_energy) {
next_input = Some(InputKind::Ability(0)); next_input = Some(InputKind::Ability(0));
} else if could_use_input(random_ability, &misc_data) { } else if could_use_input(random_ability, desired_energy) {
next_input = Some(random_ability); next_input = Some(random_ability);
} else if rng.gen_bool(0.5) { } else if rng.gen_bool(0.5) {
next_input = Some(InputKind::Primary); next_input = Some(InputKind::Primary);
@ -1128,7 +1110,7 @@ impl<'a> AgentData<'a> {
} }
}; };
if let Some(input) = next_input { if let Some(input) = next_input {
if could_use_input(input, &misc_data) { if could_use_input(input, desired_energy) {
controller.push_basic_input(input); controller.push_basic_input(input);
false false
} else { } else {
@ -1139,9 +1121,7 @@ impl<'a> AgentData<'a> {
} }
}, },
SwordTactics::DefensiveAdvanced => { SwordTactics::DefensiveAdvanced => {
let misc_data = MiscData { let desired_energy = 50.0;
desired_energy: 50.0,
};
let current_input = self.char_state.ability_info().map(|ai| ai.input); let current_input = self.char_state.ability_info().map(|ai| ai.input);
let mut next_input = None; let mut next_input = None;
if let Some(input) = current_input { if let Some(input) = current_input {
@ -1150,18 +1130,18 @@ impl<'a> AgentData<'a> {
let stance_ability = InputKind::Ability(rng.gen_range(1..3)); let stance_ability = InputKind::Ability(rng.gen_range(1..3));
let random_ability = InputKind::Ability(rng.gen_range(1..4)); let random_ability = InputKind::Ability(rng.gen_range(1..4));
if !matches!(self.stance, Some(Stance::Sword(SwordStance::Defensive))) { if !matches!(self.stance, Some(Stance::Sword(SwordStance::Defensive))) {
if could_use_input(stance_ability, &misc_data) { if could_use_input(stance_ability, desired_energy) {
next_input = Some(stance_ability); next_input = Some(stance_ability);
} else if rng.gen_bool(0.5) { } else if rng.gen_bool(0.5) {
next_input = Some(InputKind::Primary); next_input = Some(InputKind::Primary);
} else { } else {
next_input = Some(InputKind::Secondary); next_input = Some(InputKind::Secondary);
} }
} else if could_use_input(InputKind::Ability(0), &misc_data) { } else if could_use_input(InputKind::Ability(0), desired_energy) {
next_input = Some(InputKind::Ability(0)); next_input = Some(InputKind::Ability(0));
} else if could_use_input(random_ability, &misc_data) { } else if could_use_input(random_ability, desired_energy) {
next_input = Some(random_ability); next_input = Some(random_ability);
} else if could_use_input(InputKind::Ability(4), &misc_data) } else if could_use_input(InputKind::Ability(4), desired_energy)
&& rng.gen_bool(2.0 * read_data.dt.0 as f64) && rng.gen_bool(2.0 * read_data.dt.0 as f64)
{ {
next_input = Some(InputKind::Ability(4)); next_input = Some(InputKind::Ability(4));
@ -1172,7 +1152,7 @@ impl<'a> AgentData<'a> {
} }
}; };
if let Some(input) = next_input { if let Some(input) = next_input {
if could_use_input(input, &misc_data) { if could_use_input(input, desired_energy) {
controller.push_basic_input(input); controller.push_basic_input(input);
false false
} else { } else {
@ -1183,9 +1163,7 @@ impl<'a> AgentData<'a> {
} }
}, },
SwordTactics::CripplingAdvanced => { SwordTactics::CripplingAdvanced => {
let misc_data = MiscData { let desired_energy = 50.0;
desired_energy: 50.0,
};
let current_input = self.char_state.ability_info().map(|ai| ai.input); let current_input = self.char_state.ability_info().map(|ai| ai.input);
let mut next_input = None; let mut next_input = None;
if let Some(input) = current_input { if let Some(input) = current_input {
@ -1194,16 +1172,16 @@ impl<'a> AgentData<'a> {
let stance_ability = InputKind::Ability(rng.gen_range(1..3)); let stance_ability = InputKind::Ability(rng.gen_range(1..3));
let random_ability = InputKind::Ability(rng.gen_range(1..5)); let random_ability = InputKind::Ability(rng.gen_range(1..5));
if !matches!(self.stance, Some(Stance::Sword(SwordStance::Crippling))) { if !matches!(self.stance, Some(Stance::Sword(SwordStance::Crippling))) {
if could_use_input(stance_ability, &misc_data) { if could_use_input(stance_ability, desired_energy) {
next_input = Some(stance_ability); next_input = Some(stance_ability);
} else if rng.gen_bool(0.5) { } else if rng.gen_bool(0.5) {
next_input = Some(InputKind::Primary); next_input = Some(InputKind::Primary);
} else { } else {
next_input = Some(InputKind::Secondary); next_input = Some(InputKind::Secondary);
} }
} else if could_use_input(InputKind::Ability(0), &misc_data) { } else if could_use_input(InputKind::Ability(0), desired_energy) {
next_input = Some(InputKind::Ability(0)); next_input = Some(InputKind::Ability(0));
} else if could_use_input(random_ability, &misc_data) { } else if could_use_input(random_ability, desired_energy) {
next_input = Some(random_ability); next_input = Some(random_ability);
} else if rng.gen_bool(0.5) { } else if rng.gen_bool(0.5) {
next_input = Some(InputKind::Primary); next_input = Some(InputKind::Primary);
@ -1212,7 +1190,7 @@ impl<'a> AgentData<'a> {
} }
}; };
if let Some(input) = next_input { if let Some(input) = next_input {
if could_use_input(input, &misc_data) { if could_use_input(input, desired_energy) {
controller.push_basic_input(input); controller.push_basic_input(input);
false false
} else { } else {
@ -1223,9 +1201,7 @@ impl<'a> AgentData<'a> {
} }
}, },
SwordTactics::CleavingAdvanced => { SwordTactics::CleavingAdvanced => {
let misc_data = MiscData { let desired_energy = 50.0;
desired_energy: 50.0,
};
let current_input = self.char_state.ability_info().map(|ai| ai.input); let current_input = self.char_state.ability_info().map(|ai| ai.input);
let mut next_input = None; let mut next_input = None;
if let Some(input) = current_input { if let Some(input) = current_input {
@ -1234,16 +1210,16 @@ impl<'a> AgentData<'a> {
let stance_ability = InputKind::Ability(rng.gen_range(1..3)); let stance_ability = InputKind::Ability(rng.gen_range(1..3));
let random_ability = InputKind::Ability(rng.gen_range(1..5)); let random_ability = InputKind::Ability(rng.gen_range(1..5));
if !matches!(self.stance, Some(Stance::Sword(SwordStance::Cleaving))) { if !matches!(self.stance, Some(Stance::Sword(SwordStance::Cleaving))) {
if could_use_input(stance_ability, &misc_data) { if could_use_input(stance_ability, desired_energy) {
next_input = Some(stance_ability); next_input = Some(stance_ability);
} else if rng.gen_bool(0.5) { } else if rng.gen_bool(0.5) {
next_input = Some(InputKind::Primary); next_input = Some(InputKind::Primary);
} else { } else {
next_input = Some(InputKind::Secondary); next_input = Some(InputKind::Secondary);
} }
} else if could_use_input(InputKind::Ability(0), &misc_data) { } else if could_use_input(InputKind::Ability(0), desired_energy) {
next_input = Some(InputKind::Ability(0)); next_input = Some(InputKind::Ability(0));
} else if could_use_input(random_ability, &misc_data) { } else if could_use_input(random_ability, desired_energy) {
next_input = Some(random_ability); next_input = Some(random_ability);
} else if rng.gen_bool(0.5) { } else if rng.gen_bool(0.5) {
next_input = Some(InputKind::Primary); next_input = Some(InputKind::Primary);
@ -1252,7 +1228,7 @@ impl<'a> AgentData<'a> {
} }
}; };
if let Some(input) = next_input { if let Some(input) = next_input {
if could_use_input(input, &misc_data) { if could_use_input(input, desired_energy) {
controller.push_basic_input(input); controller.push_basic_input(input);
false false
} else { } else {

9
server/agent/src/data.rs
View File

@ -307,10 +307,6 @@ pub enum AbilityData {
}, },
} }
pub struct MiscData {
pub desired_energy: f32,
}
impl AbilityData { impl AbilityData {
pub fn from_ability(ability: &CharacterAbility) -> Option<Self> { pub fn from_ability(ability: &CharacterAbility) -> Option<Self> {
use CharacterAbility::*; use CharacterAbility::*;
@ -440,8 +436,8 @@ impl AbilityData {
&self, &self,
attack_data: &AttackData, attack_data: &AttackData,
agent_data: &AgentData, agent_data: &AgentData,
misc_data: &MiscData,
tgt_data: &TargetData, tgt_data: &TargetData,
desired_energy: f32,
) -> bool { ) -> bool {
let melee_check = |range: f32, angle, forced_movement: Option<ForcedMovement>| { let melee_check = |range: f32, angle, forced_movement: Option<ForcedMovement>| {
let range_inc = forced_movement.map_or(0.0, |fm| match fm { let range_inc = forced_movement.map_or(0.0, |fm| match fm {
@ -456,8 +452,7 @@ impl AbilityData {
}; };
let energy_check = |energy: f32| { let energy_check = |energy: f32| {
agent_data.energy.current() >= energy agent_data.energy.current() >= energy
&& (energy < f32::EPSILON && (energy < f32::EPSILON || agent_data.energy.current() >= desired_energy)
|| agent_data.energy.current() >= misc_data.desired_energy)
}; };
let combo_check = |combo| agent_data.combo.map_or(false, |c| c.counter() >= combo); let combo_check = |combo| agent_data.combo.map_or(false, |c| c.counter() >= combo);
let attack_kind_check = |attacks: AttackFilters| { let attack_kind_check = |attacks: AttackFilters| {