veloren_server/rtsim/
tick.rs

1use super::*;
2use crate::sys::terrain::SpawnEntityData;
3use common::{
4    LoadoutBuilder,
5    calendar::Calendar,
6    comp::{
7        self, Body, Item, Presence, PresenceKind, inventory::trade_pricing::TradePricing,
8        slot::ArmorSlot,
9    },
10    event::{CreateNpcEvent, CreateShipEvent, DeleteEvent, EventBus, NpcBuilder},
11    generation::{BodyBuilder, EntityConfig, EntityInfo},
12    resources::{DeltaTime, Time, TimeOfDay},
13    rtsim::{Actor, NpcId, RtSimEntity},
14    slowjob::SlowJobPool,
15    terrain::CoordinateConversions,
16    trade::{Good, SiteInformation},
17    util::Dir,
18};
19use common_ecs::{Job, Origin, Phase, System};
20use rand::Rng;
21use rtsim::data::{
22    Npc, Sites,
23    npc::{Profession, SimulationMode},
24};
25use specs::{Entities, Join, LendJoin, Read, ReadExpect, ReadStorage, WriteExpect, WriteStorage};
26use std::{sync::Arc, time::Duration};
27use tracing::error;
28
29pub fn trader_loadout(
30    loadout_builder: LoadoutBuilder,
31    economy: Option<&SiteInformation>,
32    mut permitted: impl FnMut(Good) -> bool,
33) -> LoadoutBuilder {
34    let rng = &mut rand::thread_rng();
35    let mut backpack = Item::new_from_asset_expect("common.items.armor.misc.back.backpack");
36    let mut bag1 = Item::new_from_asset_expect("common.items.armor.misc.bag.sturdy_red_backpack");
37    let mut bag2 = Item::new_from_asset_expect("common.items.armor.misc.bag.sturdy_red_backpack");
38    let mut bag3 = Item::new_from_asset_expect("common.items.armor.misc.bag.sturdy_red_backpack");
39    let mut bag4 = Item::new_from_asset_expect("common.items.armor.misc.bag.sturdy_red_backpack");
40    let slots = backpack.slots().len() + 4 * bag1.slots().len();
41    let mut stockmap: hashbrown::HashMap<Good, f32> = economy
42        .map(|e| {
43            e.unconsumed_stock
44                .clone()
45                .into_iter()
46                .filter(|(good, _)| permitted(*good))
47                .collect()
48        })
49        .unwrap_or_default();
50    // modify stock for better gameplay
51
52    // TODO: currently econsim spends all its food on population, resulting in none
53    // for the players to buy; the `.max` is temporary to ensure that there's some
54    // food for sale at every site, to be used until we have some solution like NPC
55    // houses as a limit on econsim population growth
56    if permitted(Good::Food) {
57        stockmap
58            .entry(Good::Food)
59            .and_modify(|e| *e = e.max(10_000.0))
60            .or_insert(10_000.0);
61    }
62    // Reduce amount of potions so merchants do not oversupply potions.
63    // TODO: Maybe remove when merchants and their inventories are rtsim?
64    // Note: Likely without effect now that potions are counted as food
65    if permitted(Good::Potions) {
66        stockmap
67            .entry(Good::Potions)
68            .and_modify(|e| *e = e.powf(0.25));
69    }
70    // It's safe to truncate here, because coins clamped to 3000 max
71    // also we don't really want negative values here
72    if permitted(Good::Coin) {
73        stockmap
74            .entry(Good::Coin)
75            .and_modify(|e| *e = e.min(rng.gen_range(1000.0..3000.0)));
76    }
77    // assume roughly 10 merchants sharing a town's stock (other logic for coins)
78    stockmap
79        .iter_mut()
80        .filter(|(good, _amount)| **good != Good::Coin)
81        .for_each(|(_good, amount)| *amount *= 0.1);
82    // Fill bags with stuff according to unclaimed stock
83    let ability_map = &comp::tool::AbilityMap::load().read();
84    let msm = &comp::item::MaterialStatManifest::load().read();
85    let mut wares: Vec<Item> =
86        TradePricing::random_items(&mut stockmap, slots as u32, true, true, 16)
87            .iter()
88            .filter_map(|(n, a)| {
89                let i = Item::new_from_item_definition_id(n.as_ref(), ability_map, msm).ok();
90                i.map(|mut i| {
91                    i.set_amount(*a)
92                        .map_err(|_| tracing::error!("merchant loadout amount failure"))
93                        .ok();
94                    i
95                })
96            })
97            .collect();
98    sort_wares(&mut wares);
99    transfer(&mut wares, &mut backpack);
100    transfer(&mut wares, &mut bag1);
101    transfer(&mut wares, &mut bag2);
102    transfer(&mut wares, &mut bag3);
103    transfer(&mut wares, &mut bag4);
104
105    loadout_builder
106        .back(Some(backpack))
107        .bag(ArmorSlot::Bag1, Some(bag1))
108        .bag(ArmorSlot::Bag2, Some(bag2))
109        .bag(ArmorSlot::Bag3, Some(bag3))
110        .bag(ArmorSlot::Bag4, Some(bag4))
111}
112
113fn sort_wares(bag: &mut [Item]) {
114    use common::comp::item::TagExampleInfo;
115
116    bag.sort_by(|a, b| {
117        a.quality()
118            .cmp(&b.quality())
119        // sort by kind
120        .then(
121            Ord::cmp(
122                a.tags().first().map_or("", |tag| tag.name()),
123                b.tags().first().map_or("", |tag| tag.name()),
124            )
125        )
126        // sort by name
127        .then(#[expect(deprecated)] Ord::cmp(&a.name(), &b.name()))
128    });
129}
130
131fn transfer(wares: &mut Vec<Item>, bag: &mut Item) {
132    let capacity = bag.slots().len();
133    for (s, w) in bag
134        .slots_mut()
135        .iter_mut()
136        .zip(wares.drain(0..wares.len().min(capacity)))
137    {
138        *s = Some(w);
139    }
140}
141
142fn humanoid_config(profession: &Profession) -> &'static str {
143    match profession {
144        Profession::Farmer => "common.entity.village.farmer",
145        Profession::Hunter => "common.entity.village.hunter",
146        Profession::Herbalist => "common.entity.village.herbalist",
147        Profession::Captain => "common.entity.village.captain",
148        Profession::Merchant => "common.entity.village.merchant",
149        Profession::Guard => "common.entity.village.guard",
150        Profession::Adventurer(rank) => match rank {
151            0 => "common.entity.world.traveler0",
152            1 => "common.entity.world.traveler1",
153            2 => "common.entity.world.traveler2",
154            3 => "common.entity.world.traveler3",
155            _ => {
156                error!(
157                    "Tried to get configuration for invalid adventurer rank {}",
158                    rank
159                );
160                "common.entity.world.traveler3"
161            },
162        },
163        Profession::Blacksmith => "common.entity.village.blacksmith",
164        Profession::Chef => "common.entity.village.chef",
165        Profession::Alchemist => "common.entity.village.alchemist",
166        Profession::Pirate => "common.entity.spot.pirate",
167        Profession::Cultist => "common.entity.dungeon.cultist.cultist",
168    }
169}
170
171fn loadout_default(
172    loadout: LoadoutBuilder,
173    _economy: Option<&SiteInformation>,
174    _time: Option<&(TimeOfDay, Calendar)>,
175) -> LoadoutBuilder {
176    loadout
177}
178
179fn merchant_loadout(
180    loadout_builder: LoadoutBuilder,
181    economy: Option<&SiteInformation>,
182    _time: Option<&(TimeOfDay, Calendar)>,
183) -> LoadoutBuilder {
184    trader_loadout(loadout_builder, economy, |_| true)
185}
186
187fn farmer_loadout(
188    loadout_builder: LoadoutBuilder,
189    economy: Option<&SiteInformation>,
190    _time: Option<&(TimeOfDay, Calendar)>,
191) -> LoadoutBuilder {
192    trader_loadout(loadout_builder, economy, |good| matches!(good, Good::Food))
193}
194
195fn herbalist_loadout(
196    loadout_builder: LoadoutBuilder,
197    economy: Option<&SiteInformation>,
198    _time: Option<&(TimeOfDay, Calendar)>,
199) -> LoadoutBuilder {
200    trader_loadout(loadout_builder, economy, |good| {
201        matches!(good, Good::Ingredients)
202    })
203}
204
205fn chef_loadout(
206    loadout_builder: LoadoutBuilder,
207    economy: Option<&SiteInformation>,
208    _time: Option<&(TimeOfDay, Calendar)>,
209) -> LoadoutBuilder {
210    trader_loadout(loadout_builder, economy, |good| matches!(good, Good::Food))
211}
212
213fn blacksmith_loadout(
214    loadout_builder: LoadoutBuilder,
215    economy: Option<&SiteInformation>,
216    _time: Option<&(TimeOfDay, Calendar)>,
217) -> LoadoutBuilder {
218    trader_loadout(loadout_builder, economy, |good| {
219        matches!(good, Good::Tools | Good::Armor)
220    })
221}
222
223fn alchemist_loadout(
224    loadout_builder: LoadoutBuilder,
225    economy: Option<&SiteInformation>,
226    _time: Option<&(TimeOfDay, Calendar)>,
227) -> LoadoutBuilder {
228    trader_loadout(loadout_builder, economy, |good| {
229        matches!(good, Good::Potions)
230    })
231}
232
233fn profession_extra_loadout(
234    profession: Option<&Profession>,
235) -> fn(
236    LoadoutBuilder,
237    Option<&SiteInformation>,
238    time: Option<&(TimeOfDay, Calendar)>,
239) -> LoadoutBuilder {
240    match profession {
241        Some(Profession::Merchant) => merchant_loadout,
242        Some(Profession::Farmer) => farmer_loadout,
243        Some(Profession::Herbalist) => herbalist_loadout,
244        Some(Profession::Chef) => chef_loadout,
245        Some(Profession::Blacksmith) => blacksmith_loadout,
246        Some(Profession::Alchemist) => alchemist_loadout,
247        _ => loadout_default,
248    }
249}
250
251fn profession_agent_mark(profession: Option<&Profession>) -> Option<comp::agent::Mark> {
252    match profession {
253        Some(
254            Profession::Merchant
255            | Profession::Farmer
256            | Profession::Herbalist
257            | Profession::Chef
258            | Profession::Blacksmith
259            | Profession::Alchemist,
260        ) => Some(comp::agent::Mark::Merchant),
261        Some(Profession::Guard) => Some(comp::agent::Mark::Guard),
262        _ => None,
263    }
264}
265
266fn get_npc_entity_info(
267    npc: &Npc,
268    sites: &Sites,
269    index: IndexRef,
270    time: Option<&(TimeOfDay, Calendar)>,
271) -> EntityInfo {
272    let pos = comp::Pos(npc.wpos);
273
274    let mut rng = npc.rng(Npc::PERM_ENTITY_CONFIG);
275    if let Some(profession) = npc.profession() {
276        let economy = npc.home.and_then(|home| {
277            let site = sites.get(home)?.world_site?;
278            index.sites.get(site).trade_information(site)
279        });
280
281        let config_asset = humanoid_config(&profession);
282
283        let entity_config = EntityConfig::from_asset_expect_owned(config_asset)
284            .with_body(BodyBuilder::Exact(npc.body));
285        EntityInfo::at(pos.0)
286            .with_entity_config(entity_config, Some(config_asset), &mut rng, time)
287            .with_alignment(if matches!(profession, Profession::Cultist) {
288                comp::Alignment::Enemy
289            } else {
290                comp::Alignment::Npc
291            })
292            .with_economy(economy.as_ref())
293            .with_lazy_loadout(profession_extra_loadout(Some(&profession)))
294            .with_alias(npc.get_name())
295            .with_agent_mark(profession_agent_mark(Some(&profession)))
296    } else {
297        let config_asset = match npc.body {
298            Body::BirdLarge(body) => match body.species {
299                comp::bird_large::Species::Phoenix => "common.entity.wild.aggressive.phoenix",
300                comp::bird_large::Species::Cockatrice => "common.entity.wild.aggressive.cockatrice",
301                comp::bird_large::Species::Roc => "common.entity.wild.aggressive.roc",
302                comp::bird_large::Species::CloudWyvern => {
303                    "common.entity.wild.aggressive.cloudwyvern"
304                },
305                comp::bird_large::Species::FlameWyvern => {
306                    "common.entity.wild.aggressive.flamewyvern"
307                },
308                comp::bird_large::Species::FrostWyvern => {
309                    "common.entity.wild.aggressive.frostwyvern"
310                },
311                comp::bird_large::Species::SeaWyvern => "common.entity.wild.aggressive.seawyvern",
312                comp::bird_large::Species::WealdWyvern => {
313                    "common.entity.wild.aggressive.wealdwyvern"
314                },
315            },
316            Body::BipedLarge(body) => match body.species {
317                comp::biped_large::Species::Ogre => "common.entity.wild.aggressive.ogre",
318                comp::biped_large::Species::Cyclops => "common.entity.wild.aggressive.cyclops",
319                comp::biped_large::Species::Wendigo => "common.entity.wild.aggressive.wendigo",
320                comp::biped_large::Species::Werewolf => "common.entity.wild.aggressive.werewolf",
321                comp::biped_large::Species::Cavetroll => "common.entity.wild.aggressive.cave_troll",
322                comp::biped_large::Species::Mountaintroll => {
323                    "common.entity.wild.aggressive.mountain_troll"
324                },
325                comp::biped_large::Species::Swamptroll => {
326                    "common.entity.wild.aggressive.swamp_troll"
327                },
328                comp::biped_large::Species::Blueoni => "common.entity.wild.aggressive.blue_oni",
329                comp::biped_large::Species::Redoni => "common.entity.wild.aggressive.red_oni",
330                comp::biped_large::Species::Tursus => "common.entity.wild.aggressive.tursus",
331                comp::biped_large::Species::Gigasfrost => {
332                    "common.entity.world.world_bosses.gigas_frost"
333                },
334                species => unimplemented!("rtsim spawning for {:?}", species),
335            },
336            body => unimplemented!("rtsim spawning for {:?}", body),
337        };
338        let entity_config = EntityConfig::from_asset_expect_owned(config_asset)
339            .with_body(BodyBuilder::Exact(npc.body));
340
341        EntityInfo::at(pos.0).with_entity_config(entity_config, Some(config_asset), &mut rng, time)
342    }
343}
344
345#[derive(Default)]
346pub struct Sys;
347impl<'a> System<'a> for Sys {
348    type SystemData = (
349        Entities<'a>,
350        Read<'a, DeltaTime>,
351        Read<'a, Time>,
352        Read<'a, TimeOfDay>,
353        Read<'a, EventBus<CreateShipEvent>>,
354        Read<'a, EventBus<CreateNpcEvent>>,
355        Read<'a, EventBus<DeleteEvent>>,
356        WriteExpect<'a, RtSim>,
357        ReadExpect<'a, Arc<world::World>>,
358        ReadExpect<'a, world::IndexOwned>,
359        ReadExpect<'a, SlowJobPool>,
360        ReadStorage<'a, comp::Pos>,
361        ReadStorage<'a, RtSimEntity>,
362        WriteStorage<'a, comp::Agent>,
363        ReadStorage<'a, Presence>,
364        ReadExpect<'a, Calendar>,
365        <rtsim::OnTick as rtsim::Event>::SystemData<'a>,
366    );
367
368    const NAME: &'static str = "rtsim::tick";
369    const ORIGIN: Origin = Origin::Server;
370    const PHASE: Phase = Phase::Create;
371
372    fn run(
373        _job: &mut Job<Self>,
374        (
375            entities,
376            dt,
377            time,
378            time_of_day,
379            create_ship_events,
380            create_npc_events,
381            delete_events,
382            mut rtsim,
383            world,
384            index,
385            slow_jobs,
386            positions,
387            rtsim_entities,
388            mut agents,
389            presences,
390            calendar,
391            mut tick_data,
392        ): Self::SystemData,
393    ) {
394        let mut create_ship_emitter = create_ship_events.emitter();
395        let mut create_npc_emitter = create_npc_events.emitter();
396        let mut delete_emitter = delete_events.emitter();
397        let rtsim = &mut *rtsim;
398        let calendar_data = (*time_of_day, (*calendar).clone());
399
400        // Set up rtsim inputs
401        {
402            let mut data = rtsim.state.data_mut();
403
404            // Update time of day
405            data.time_of_day = *time_of_day;
406
407            // Update character map (i.e: so that rtsim knows where players are)
408            // TODO: Other entities too like animals? Or do we now care about that?
409            data.npcs.character_map.clear();
410            for (presence, wpos) in (&presences, &positions).join() {
411                if let PresenceKind::Character(character) = &presence.kind {
412                    let chunk_pos = wpos.0.xy().as_().wpos_to_cpos();
413                    data.npcs
414                        .character_map
415                        .entry(chunk_pos)
416                        .or_default()
417                        .push((*character, wpos.0));
418                }
419            }
420        }
421
422        // Tick rtsim
423        rtsim.state.tick(
424            &mut tick_data,
425            &world,
426            index.as_index_ref(),
427            *time_of_day,
428            *time,
429            dt.0,
430        );
431
432        // Perform a save if required
433        if rtsim
434            .last_saved
435            .is_none_or(|ls| ls.elapsed() > Duration::from_secs(60))
436        {
437            // TODO: Use slow jobs
438            let _ = slow_jobs;
439            rtsim.save(/* &slow_jobs, */ false);
440        }
441
442        let chunk_states = rtsim.state.resource::<ChunkStates>();
443        let data = &mut *rtsim.state.data_mut();
444
445        let mut create_event = |id: NpcId, npc: &Npc, steering: Option<NpcBuilder>| match npc.body {
446            Body::Ship(body) => {
447                create_ship_emitter.emit(CreateShipEvent {
448                    pos: comp::Pos(npc.wpos),
449                    ori: comp::Ori::from(Dir::new(npc.dir.with_z(0.0))),
450                    ship: body,
451                    rtsim_entity: Some(RtSimEntity(id)),
452                    driver: steering,
453                });
454            },
455            _ => {
456                let entity_info = get_npc_entity_info(
457                    npc,
458                    &data.sites,
459                    index.as_index_ref(),
460                    Some(&calendar_data),
461                );
462
463                let (mut npc_builder, pos) = SpawnEntityData::from_entity_info(entity_info)
464                    .into_npc_data_inner()
465                    .expect("Entity loaded from assets cannot be special")
466                    .to_npc_builder();
467
468                if let Some(agent) = &mut npc_builder.agent {
469                    agent.rtsim_outbox = Some(Default::default());
470                }
471
472                if let Some(health) = &mut npc_builder.health {
473                    health.set_fraction(npc.health_fraction);
474                }
475
476                create_npc_emitter.emit(CreateNpcEvent {
477                    pos,
478                    ori: comp::Ori::from(Dir::new(npc.dir.with_z(0.0))),
479                    npc: npc_builder.with_rtsim(RtSimEntity(id)).with_rider(steering),
480                });
481            },
482        };
483
484        // Load in mounted npcs and their riders
485        for mount in data.npcs.mounts.iter_mounts() {
486            let mount_npc = data.npcs.npcs.get_mut(mount).expect("This should exist");
487            let chunk = mount_npc.wpos.xy().as_::<i32>().wpos_to_cpos();
488
489            if matches!(mount_npc.mode, SimulationMode::Simulated)
490                && chunk_states.0.get(chunk).is_some_and(|c| c.is_some())
491            {
492                mount_npc.mode = SimulationMode::Loaded;
493
494                let mut actor_info = |actor: Actor| {
495                    let npc_id = actor.npc()?;
496                    let npc = data.npcs.npcs.get_mut(npc_id)?;
497                    if matches!(npc.mode, SimulationMode::Simulated) {
498                        npc.mode = SimulationMode::Loaded;
499                        let entity_info = get_npc_entity_info(
500                            npc,
501                            &data.sites,
502                            index.as_index_ref(),
503                            Some(&calendar_data),
504                        );
505
506                        let mut npc_builder = SpawnEntityData::from_entity_info(entity_info)
507                            .into_npc_data_inner()
508                            // EntityConfig can't represent Waypoints at all
509                            // as of now, and if someone will try to spawn
510                            // rtsim waypoint it is definitely error.
511                            .expect("Entity loaded from assets cannot be special")
512                            .to_npc_builder()
513                            .0
514                            .with_rtsim(RtSimEntity(npc_id));
515
516                        if let Some(agent) = &mut npc_builder.agent {
517                            agent.rtsim_outbox = Some(Default::default());
518                        }
519
520                        Some(npc_builder)
521                    } else {
522                        error!("Npc is loaded but vehicle is unloaded");
523                        None
524                    }
525                };
526
527                let steerer = data
528                    .npcs
529                    .mounts
530                    .get_steerer_link(mount)
531                    .and_then(|link| actor_info(link.rider));
532
533                let mount_npc = data.npcs.npcs.get(mount).expect("This should exist");
534                create_event(mount, mount_npc, steerer);
535            }
536        }
537
538        // Load in NPCs
539        for (npc_id, npc) in data.npcs.npcs.iter_mut() {
540            let chunk = npc.wpos.xy().as_::<i32>().wpos_to_cpos();
541
542            // Load the NPC into the world if it's in a loaded chunk and is not already
543            // loaded
544            if matches!(npc.mode, SimulationMode::Simulated)
545                && chunk_states.0.get(chunk).is_some_and(|c| c.is_some())
546                // Riding npcs will be spawned by the vehicle.
547                && data.npcs.mounts.get_mount_link(npc_id).is_none()
548            {
549                npc.mode = SimulationMode::Loaded;
550                create_event(npc_id, npc, None);
551            }
552        }
553
554        // Synchronise rtsim NPC with entity data
555        for (entity, pos, rtsim_entity, agent) in (
556            &entities,
557            &positions,
558            &rtsim_entities,
559            (&mut agents).maybe(),
560        )
561            .join()
562        {
563            if let Some(npc) = data.npcs.get_mut(rtsim_entity.0) {
564                match npc.mode {
565                    SimulationMode::Loaded => {
566                        // Update rtsim NPC state
567                        npc.wpos = pos.0;
568
569                        // Update entity state
570                        if let Some(agent) = agent {
571                            agent.rtsim_controller.personality = npc.personality;
572                            agent.rtsim_controller.look_dir = npc.controller.look_dir;
573                            agent.rtsim_controller.activity = npc.controller.activity;
574                            agent
575                                .rtsim_controller
576                                .actions
577                                .extend(std::mem::take(&mut npc.controller.actions));
578                            if let Some(rtsim_outbox) = &mut agent.rtsim_outbox {
579                                npc.inbox.append(rtsim_outbox);
580                            }
581                        }
582                    },
583                    SimulationMode::Simulated => {
584                        delete_emitter.emit(DeleteEvent(entity));
585                    },
586                }
587            }
588        }
589    }
590}
veloren_server/rtsim/tick.rs

veloren_server/rtsim/
tick.rs
