valence/examples/combat.rs

257 lines
8.8 KiB
Rust
Raw Normal View History

2022-07-18 14:29:44 +10:00
use std::net::SocketAddr;
use std::sync::atomic::{AtomicUsize, Ordering};
use valence::prelude::*;
2022-07-18 14:29:44 +10:00
pub fn main() -> ShutdownResult {
tracing_subscriber::fmt().init();
2022-07-18 14:29:44 +10:00
valence::start_server(
Game {
player_count: AtomicUsize::new(0),
},
2022-08-10 07:44:04 +10:00
None,
2022-07-18 14:29:44 +10:00
)
}
struct Game {
player_count: AtomicUsize,
}
#[derive(Default)]
2022-07-28 12:21:11 +10:00
struct ClientState {
2022-07-18 14:29:44 +10:00
/// The client's player entity.
player: EntityId,
/// The extra knockback on the first hit while sprinting.
2022-07-28 00:10:35 +10:00
extra_knockback: bool,
2022-07-18 14:29:44 +10:00
}
#[derive(Default)]
2022-07-28 12:21:11 +10:00
struct EntityState {
2022-07-18 14:29:44 +10:00
client: ClientId,
attacked: bool,
attacker_pos: Vec3<f64>,
extra_knockback: bool,
last_attack_time: Ticks,
}
const MAX_PLAYERS: usize = 10;
const SPAWN_POS: BlockPos = BlockPos::new(0, 20, 0);
#[async_trait]
impl Config for Game {
2022-08-29 14:31:07 +10:00
type ServerState = Option<PlayerListId>;
2022-07-28 12:21:11 +10:00
type ClientState = ClientState;
type EntityState = EntityState;
type WorldState = ();
2022-08-29 14:31:07 +10:00
type ChunkState = ();
type PlayerListState = ();
2022-07-18 14:29:44 +10:00
async fn server_list_ping(
&self,
_server: &SharedServer<Self>,
_remote_addr: SocketAddr,
2022-08-15 08:18:22 +10:00
_protocol_version: i32,
2022-07-18 14:29:44 +10:00
) -> ServerListPing {
ServerListPing::Respond {
online_players: self.player_count.load(Ordering::SeqCst) as i32,
max_players: MAX_PLAYERS as i32,
player_sample: Default::default(),
2022-07-18 14:29:44 +10:00
description: "Hello Valence!".color(Color::AQUA),
2022-09-11 17:20:17 +10:00
favicon_png: Some(include_bytes!("../assets/logo-64x64.png").as_slice().into()),
2022-07-18 14:29:44 +10:00
}
}
fn init(&self, server: &mut Server<Self>) {
let (_, world) = server.worlds.insert(DimensionId::default(), ());
2022-08-10 07:44:04 +10:00
server.state = Some(server.player_lists.insert(()).0);
2022-07-18 14:29:44 +10:00
let min_y = world.chunks.min_y();
let height = world.chunks.height();
2022-07-18 14:29:44 +10:00
// Create circular arena.
let size = 2;
for chunk_z in -size - 2..size + 2 {
for chunk_x in -size - 2..size + 2 {
let mut chunk = UnloadedChunk::new(height);
2022-07-18 14:29:44 +10:00
let r = -size..size;
if r.contains(&chunk_x) && r.contains(&chunk_z) {
for z in 0..16 {
for x in 0..16 {
let block_x = chunk_x * 16 + x as i32;
let block_z = chunk_z * 16 + z as i32;
if f64::hypot(block_x as f64, block_z as f64) <= size as f64 * 16.0 {
for y in 0..(SPAWN_POS.y - min_y + 1) as usize {
chunk.set_block_state(x, y, z, BlockState::STONE);
}
}
}
}
}
world.chunks.insert([chunk_x, chunk_z], chunk, ());
2022-07-18 14:29:44 +10:00
}
}
world.chunks.set_block_state(SPAWN_POS, BlockState::BEDROCK);
}
fn update(&self, server: &mut Server<Self>) {
let (world_id, _) = server.worlds.iter_mut().next().unwrap();
2022-07-18 14:29:44 +10:00
let current_tick = server.shared.current_tick();
server.clients.retain(|client_id, client| {
2022-08-06 05:36:34 +10:00
if client.created_this_tick() {
2022-07-18 14:29:44 +10:00
if self
.player_count
.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |count| {
(count < MAX_PLAYERS).then_some(count + 1)
})
.is_err()
{
client.disconnect("The server is full!".color(Color::RED));
return false;
}
let (player_id, player) = match server.entities.insert_with_uuid(
2022-08-06 05:36:34 +10:00
EntityKind::Player,
client.uuid(),
EntityState::default(),
) {
Some(e) => e,
None => {
client.disconnect("Conflicting UUID");
return false;
}
};
player.state.client = client_id;
client.state.player = player_id;
client.state.extra_knockback = true;
2022-07-18 14:29:44 +10:00
client.spawn(world_id);
client.set_flat(true);
2022-07-18 14:29:44 +10:00
client.set_game_mode(GameMode::Survival);
client.teleport(
[
SPAWN_POS.x as f64 + 0.5,
SPAWN_POS.y as f64 + 1.0,
SPAWN_POS.z as f64 + 0.5,
],
0.0,
0.0,
);
2022-08-10 07:44:04 +10:00
client.set_player_list(server.state.clone());
if let Some(id) = &server.state {
server.player_lists.get_mut(id).insert(
client.uuid(),
client.username(),
client.textures().cloned(),
client.game_mode(),
0,
None,
);
}
2022-07-18 14:29:44 +10:00
client.send_message("Welcome to the arena.".italic());
if self.player_count.load(Ordering::SeqCst) <= 1 {
client.send_message("Have another player join the game with you.".italic());
}
}
if client.is_disconnected() {
self.player_count.fetch_sub(1, Ordering::SeqCst);
server.entities.remove(client.state.player);
2022-08-10 07:44:04 +10:00
if let Some(id) = &server.state {
server.player_lists.get_mut(id).remove(client.uuid());
}
2022-07-18 14:29:44 +10:00
return false;
}
2022-08-06 05:36:34 +10:00
if client.position().y <= 0.0 {
client.teleport(
[
SPAWN_POS.x as f64 + 0.5,
SPAWN_POS.y as f64 + 1.0,
SPAWN_POS.z as f64 + 0.5,
],
client.yaw(),
client.pitch(),
);
}
loop {
let player = server
.entities
.get_mut(client.state.player)
.expect("missing player entity");
match handle_event_default(client, player) {
2022-08-06 05:36:34 +10:00
Some(ClientEvent::StartSprinting) => {
2022-07-28 12:21:11 +10:00
client.state.extra_knockback = true;
2022-07-18 14:29:44 +10:00
}
2022-08-10 08:42:05 +10:00
Some(ClientEvent::StopSprinting) => {
client.state.extra_knockback = false;
}
Some(ClientEvent::InteractWithEntity { id, .. }) => {
2022-07-18 14:29:44 +10:00
if let Some(target) = server.entities.get_mut(id) {
2022-07-28 12:21:11 +10:00
if !target.state.attacked
&& current_tick - target.state.last_attack_time >= 10
&& id != client.state.player
2022-07-18 14:29:44 +10:00
{
2022-07-28 12:21:11 +10:00
target.state.attacked = true;
target.state.attacker_pos = client.position();
target.state.extra_knockback = client.state.extra_knockback;
target.state.last_attack_time = current_tick;
2022-07-18 14:29:44 +10:00
2022-07-28 12:21:11 +10:00
client.state.extra_knockback = false;
2022-07-18 14:29:44 +10:00
}
}
}
2022-08-06 05:36:34 +10:00
Some(_) => {}
None => break,
2022-07-18 14:29:44 +10:00
}
}
2022-08-06 05:36:34 +10:00
true
});
2022-07-18 14:29:44 +10:00
2022-08-06 05:36:34 +10:00
for (_, entity) in server.entities.iter_mut() {
if entity.state.attacked {
entity.state.attacked = false;
if let Some(victim) = server.clients.get_mut(entity.state.client) {
let victim_pos = Vec2::new(victim.position().x, victim.position().z);
let attacker_pos =
Vec2::new(entity.state.attacker_pos.x, entity.state.attacker_pos.z);
let dir = (victim_pos - attacker_pos).normalized();
let knockback_xz = if entity.state.extra_knockback {
18.0
} else {
8.0
};
let knockback_y = if entity.state.extra_knockback {
8.432
} else {
6.432
};
let vel = Vec3::new(dir.x * knockback_xz, knockback_y, dir.y * knockback_xz);
victim.set_velocity(vel.as_());
entity.push_event(EntityEvent::DamageFromGenericSource);
entity.push_event(EntityEvent::Damage);
victim.push_entity_event(EntityEvent::DamageFromGenericSource);
victim.push_entity_event(EntityEvent::Damage);
}
}
}
}
2022-09-05 15:21:24 +10:00
}