void movement_system::set_movement_flags_from_input(const logic_step step) {
auto& cosmos = step.cosm;
const auto& delta = step.get_delta();
const auto& events = step.transient.messages.get_queue<messages::intent_message>();
for (const auto& it : events) {
auto* const movement = cosmos[it.subject].find<components::movement>();
if (movement == nullptr) {
continue;
}
switch (it.intent) {
case intent_type::MOVE_FORWARD:
movement->moving_forward = it.is_pressed;
break;
case intent_type::MOVE_BACKWARD:
movement->moving_backward = it.is_pressed;
break;
case intent_type::MOVE_LEFT:
movement->moving_left = it.is_pressed;
break;
case intent_type::MOVE_RIGHT:
movement->moving_right = it.is_pressed;
break;
case intent_type::WALK:
movement->walking_enabled = it.is_pressed;
break;
case intent_type::SPRINT:
movement->sprint_enabled = it.is_pressed;
break;
default: break;
}
}
}
void trace_system::lengthen_sprites_of_traces(logic_step& step) const {
auto& cosmos = step.cosm;
const auto delta = step.get_delta();
for (const auto t : cosmos.get(processing_subjects::WITH_TRACE)) {
auto& trace = t.get<components::trace>();
auto& sprite = t.get<components::sprite>();
if (trace.chosen_lengthening_duration_ms < 0.f) {
trace.reset(cosmos.get_rng_for(t));
}
vec2 surplus_multiplier;
if (!trace.is_it_finishing_trace) {
surplus_multiplier = trace.chosen_multiplier * trace.lengthening_time_passed_ms / trace.chosen_lengthening_duration_ms;
}
else {
surplus_multiplier = (trace.chosen_multiplier + vec2(1, 1)) * (1.f - (trace.lengthening_time_passed_ms / trace.chosen_lengthening_duration_ms)) - vec2(1, 1);
}
sprite.size_multiplier = vec2(1, 1) + surplus_multiplier;
sprite.center_offset = sprite.size * (surplus_multiplier / 2.f);
trace.lengthening_time_passed_ms += static_cast<float>(delta.in_milliseconds());
}
}
void item_system::handle_trigger_confirmations_as_pick_requests(const logic_step step) {
auto& cosmos = step.cosm;
const auto& delta = step.get_delta();
const auto& confirmations = step.transient.messages.get_queue<messages::trigger_hit_confirmation_message>();
for (const auto& e : confirmations) {
const auto detector = cosmos[e.detector_body];
auto* const item_slot_transfers = detector.find<components::item_slot_transfers>();
const auto item_entity = cosmos[e.trigger].get_owner_body();
const auto* const item = item_entity.find<components::item>();
if (item_slot_transfers && item && item_entity.get_owning_transfer_capability().dead()) {
const auto& pick_list = item_slot_transfers->only_pick_these_items;
const bool found_on_subscription_list = found_in(pick_list, item_entity);
const bool item_subscribed = (pick_list.empty() && item_slot_transfers->pick_all_touched_items_if_list_to_pick_empty)
|| found_in(item_slot_transfers->only_pick_these_items, item_entity);
if (item_subscribed) {
const auto pickup_slot = detector.determine_pickup_target_slot_for(item_entity);
const bool can_pick_already = item_slot_transfers->pickup_timeout.try_to_fire_and_reset(cosmos.get_timestamp(), delta);
if (pickup_slot.alive() && can_pick_already) {
const item_slot_transfer_request request(item_entity, pickup_slot);
perform_transfer(request, step);
}
else {
// TODO: post gui message
}
}
}
}
}
void melee_system::consume_melee_intents(const logic_step step) {
auto& cosmos = step.cosm;
const auto& delta = step.get_delta();
const auto& events = step.transient.messages.get_queue<messages::intent_message>();
for (const auto& it : events) {
/*
we search the whole intent message queue for events of interest;
here we can even find gunshot requests for some distant enemy AI,
therefore we need to filter out events we're interested in, and that would be
melee-related intents and only these applied to an entity with a melee component
*/
auto* const maybe_melee = cosmos[it.subject].find<components::melee>();
if (maybe_melee == nullptr)
continue;
auto& melee = *maybe_melee;
if (it.intent == intent_type::MELEE_PRIMARY_MOVE) {
melee.primary_move_flag = it.is_pressed;
}
if (it.intent == intent_type::MELEE_SECONDARY_MOVE) {
melee.secondary_move_flag = it.is_pressed;
}
if (it.intent == intent_type::MELEE_TERTIARY_MOVE) {
melee.tertiary_move_flag = it.is_pressed;
}
}
}
void destruction_system::apply_damages_and_split_fixtures(const logic_step step) const {
auto& cosmos = step.cosm;
const auto delta = step.get_delta();
const auto& damages = step.transient.messages.get_queue<messages::damage_message>();
for (const auto& d : damages) {
const auto subject = cosmos[d.subject];
if (subject.has<components::fixtures>()) {
auto& fixtures = subject.get<components::fixtures>();
const auto& data_indices = d.subject_collider_and_convex_indices;
const auto& coll = fixtures.get_collider_data(data_indices.first);
if (coll.destructible) {
auto& dest_data = fixtures.get_modifiable_destruction_data(data_indices);
dest_data.scars.resize(1);
dest_data.scars[0].first_impact = d.point_of_impact;
dest_data.scars[0].depth_point = d.point_of_impact + d.impact_velocity;
//LOG("Destructible fixture has been applied damage to with direction: %x", d.impact_velocity);
}
}
}
}
void detonate_if(const entity_id& id, const transformr& where, const logic_step& step) {
step.get_cosmos()[id].dispatch_on_having_all<invariants::explosive>([&](const auto typed_handle) {
detonate({
step, id, typed_handle.template get<invariants::explosive>(), where
});
});
}
void movement_system::generate_movement_responses(const logic_step step) {
auto& cosmos = step.cosm;
const auto& delta = step.get_delta();
step.transient.messages.get_queue<messages::movement_response>().clear();
for (const auto& it : cosmos.get(processing_subjects::WITH_MOVEMENT)) {
const auto& movement = it.get<components::movement>();
float32 speed = 0.0f;
if (movement.enable_animation) {
if (it.has<components::physics>()) {
speed = it.get<components::physics>().velocity().length();
}
}
messages::movement_response msg;
if (movement.max_speed_for_movement_response == 0.f) msg.speed = 0.f;
else msg.speed = speed / movement.max_speed_for_movement_response;
for (const auto receiver : movement.response_receivers) {
messages::movement_response copy(msg);
copy.stop_response_at_zero_speed = receiver.stop_response_at_zero_speed;
copy.subject = receiver.target;
step.transient.messages.post(copy);
}
}
}
void physics_system::step_and_set_new_transforms(logic_step& step) {
auto& cosmos = step.cosm;
const auto delta = step.get_delta();
int32 velocityIterations = 8;
int32 positionIterations = 3;
ray_casts_since_last_step = 0;
b2world->Step(static_cast<float32>(delta.in_seconds()), velocityIterations, positionIterations);
post_and_clear_accumulated_collision_messages(step);
for (b2Body* b = b2world->GetBodyList(); b != nullptr; b = b->GetNext()) {
if (b->GetType() == b2_staticBody) continue;
entity_handle entity = cosmos[b->GetUserData()];
auto& physics = entity.get<components::physics>();
recurential_friction_handler(step, b, b->m_ownerFrictionGround);
physics.component.transform = b->m_xf;
physics.component.sweep = b->m_sweep;
physics.component.velocity = b->GetLinearVelocity();
physics.component.angular_velocity = b->GetAngularVelocity();
}
}
void demolitions_system::advance_cascade_explosions(const logic_step step) {
auto& cosm = step.get_cosmos();
const auto& clk = cosm.get_clock();
cosm.for_each_having<components::cascade_explosion>(
[&](const auto it) {
const auto& cascade_def = it.template get<invariants::cascade_explosion>();
auto& cascade = it.template get<components::cascade_explosion>();
auto& when_next = cascade.when_next_explosion;
if (clk.now >= when_next) {
auto rng = cosm.get_nontemporal_rng_for(it);
{
const auto next_explosion_in_ms = rng.randval(cascade_def.explosion_interval_ms);
when_next = clk.now;
when_next.step += next_explosion_in_ms / clk.dt.in_milliseconds();
}
{
const auto angle_displacement = rng.randval_h(cascade_def.max_explosion_angle_displacement);
const auto& body = it.template get<components::rigid_body>();
auto vel = body.get_velocity();
vel.rotate(angle_displacement, vec2());
body.set_velocity(vel);
}
auto expl_in = cascade_def.explosion;
expl_in *= rng.randval_vm(1.f, cascade_def.explosion_scale_variation);
expl_in.instantiate(
step,
it.get_logic_transform(),
damage_cause(it)
);
--cascade.explosions_left;
if (0 == cascade.explosions_left) {
step.queue_deletion_of(it, "Cascade explosions exhausted");
}
}
}
);
}
void intent_contextualization_system::contextualize_crosshair_action_intents(const logic_step step) {
auto& cosmos = step.cosm;
const auto& delta = step.get_delta();
auto& events = step.transient.messages.get_queue<messages::intent_message>();
for (auto& it : events) {
entity_id callee;
const auto subject = cosmos[it.subject];
const auto maybe_crosshair = subject[sub_entity_name::CHARACTER_CROSSHAIR];
if (it.intent == intent_type::MOVE_CROSSHAIR && maybe_crosshair.alive()) {
it.subject = maybe_crosshair;
continue;
}
if (subject.has<components::container>()) {
if (it.intent == intent_type::CROSSHAIR_PRIMARY_ACTION) {
const auto hand = subject[slot_function::PRIMARY_HAND];
if (hand.alive() && hand->items_inside.size() > 0)
callee = hand.get_items_inside()[0];
}
if (it.intent == intent_type::CROSSHAIR_SECONDARY_ACTION) {
const auto hand = subject[slot_function::SECONDARY_HAND];
if (hand.alive() && hand->items_inside.size() > 0)
callee = hand.get_items_inside()[0];
else {
const auto prim_hand = subject[slot_function::PRIMARY_HAND];
if (prim_hand.alive() && prim_hand->items_inside.size() > 0)
callee = prim_hand.get_items_inside()[0];
}
}
}
const auto callee_handle = cosmos[callee];
if (callee_handle.alive()) {
if (callee_handle.find<components::gun>()) {
it.intent = intent_type::PRESS_GUN_TRIGGER;
it.subject = callee;
continue;
}
if (callee_handle.find<components::melee>()) {
if (it.intent == intent_type::CROSSHAIR_PRIMARY_ACTION)
it.intent = intent_type::MELEE_PRIMARY_MOVE;
else if (it.intent == intent_type::CROSSHAIR_SECONDARY_ACTION)
it.intent = intent_type::MELEE_SECONDARY_MOVE;
it.subject = callee;
continue;
}
}
}
}
void driver_system::release_drivers_due_to_requests(const logic_step step) {
auto& cosmos = step.cosm;
const auto& delta = step.get_delta();
const auto& intents = step.transient.messages.get_queue<messages::intent_message>();
for (const auto& e : intents) {
if (e.intent == intent_type::RELEASE_CAR && e.is_pressed) {
release_car_ownership(cosmos[e.subject]);
}
}
}
void intent_contextualization_system::contextualize_movement_intents(const logic_step step) {
auto& cosmos = step.cosm;
const auto& delta = step.get_delta();
auto& intents = step.transient.messages.get_queue<messages::intent_message>();
for (auto& e : intents) {
entity_id callee;
bool callee_resolved = false;
const auto subject = cosmos[e.subject];
const auto* const maybe_driver = subject.find<components::driver>();
const auto* const maybe_container = subject.find<components::container>();
if (maybe_driver && cosmos[maybe_driver->owned_vehicle].alive()) {
if (e.intent == intent_type::MOVE_FORWARD
|| e.intent == intent_type::MOVE_BACKWARD
|| e.intent == intent_type::MOVE_LEFT
|| e.intent == intent_type::MOVE_RIGHT
|| e.intent == intent_type::WALK
|| e.intent == intent_type::SPRINT
) {
callee = maybe_driver->owned_vehicle;
callee_resolved = true;
}
else if (e.intent == intent_type::SPACE_BUTTON) {
callee = maybe_driver->owned_vehicle;
callee_resolved = true;
e.intent = intent_type::HAND_BRAKE;
}
}
if (!callee_resolved) {
if (maybe_container) {
if (e.intent == intent_type::SPACE_BUTTON) {
const auto hand = subject[slot_function::PRIMARY_HAND];
if (hand.alive() && hand->items_inside.size() > 0) {
e.intent = intent_type::MELEE_TERTIARY_MOVE;
callee = hand.get_items_inside()[0];
callee_resolved = true;
}
}
}
}
if (callee_resolved) {
e.subject = callee;
}
}
}
void melee_system::initiate_and_update_moves(const logic_step step) {
auto& cosmos = step.cosm;
const auto& delta = step.get_delta();
/*
- fixed delta timestep if it's a logic procedure
- variable frame time if it is a rendering-time procedure
*/
const auto dt = static_cast<float>(delta.in_milliseconds());
/* clear melee swing response queue because this is the only place where we send them */
step.transient.messages.get_queue<messages::melee_swing_response>().clear();
/* all entities in the "targets" vector are guaranteed to have both melee and damage components
therefore we use get instead of find
*/
const auto targets_copy = cosmos.get(processing_subjects::WITH_MELEE);
for (const auto& t : targets_copy) {
auto& melee = t.get<components::melee>();
auto& damage = t.get<components::damage>();
// LOG("P: %x, S: %x, T: %x CDT: %x MVT: %x STATE: %x", melee.primary_move_flag, melee.secondary_move_flag, melee.tertiary_move_flag,melee.swing_current_cooldown_time,melee.swing_current_time,melee.state);
switch (melee.current_state) {
case melee_state::FREE:
if (melee.primary_move_flag) {
melee.current_state = primary_action(step, dt, t, melee, damage);
}
/* send a response message so that the rest of the game knows that a swing has occured;
the message could be read by particles system, audio system and possibly animation system
to apply each their own effects.
*/
break;
case melee_state::ONCOOLDOWN:
melee.swing_current_cooldown_time += dt;
if (melee.swing_current_cooldown_time >= melee.swings[0].cooldown_ms) {
melee.swing_current_cooldown_time = 0;
melee.current_state = melee_state::FREE;
}
break;
case melee_state::PRIMARY:
melee.current_state = primary_action(step,dt,t,melee,damage);
break;
default:
LOG("Uknown action in melee_system.cpp");
}
}
}
void trigger_detector_system::post_trigger_requests_from_continuous_detectors(const logic_step step) const {
auto& cosmos = step.cosm;
const auto delta = step.get_delta();
auto targets_copy = cosmos.get(processing_subjects::WITH_TRIGGER_QUERY_DETECTOR);
for (auto& t : targets_copy) {
if (!t.get<components::trigger_query_detector>().detection_intent_enabled) {
t.get<components::processing>().disable_in(processing_subjects::WITH_TRIGGER_QUERY_DETECTOR);
}
else {
messages::trigger_hit_request_message request;
request.detector = t;
step.transient.messages.post(request);
}
}
}
void demolitions_system::detonate_fuses(const logic_step step) {
auto& cosm = step.get_cosmos();
const auto& clk = cosm.get_clock();
cosm.for_each_having<components::hand_fuse>(
[&](const auto& it) {
const auto fuse_logic = fuse_logic_provider(it, step);
fuse_logic.advance_arming_and_defusing();
auto& fuse = fuse_logic.fuse;
const auto& fuse_def = fuse_logic.fuse_def;
if (fuse.armed()) {
{
auto& when_beep = fuse.when_last_beep;
if (!when_beep.was_set()) {
when_beep = clk.now;
/* Don't play the beep effect for the first time. */
}
else {
const auto beep = beep_math { fuse, fuse_def, clk };
if (beep.should_beep_again()) {
fuse_def.beep_sound.start(
step,
sound_effect_start_input::fire_and_forget(fuse_logic.fused_transform),
always_predictable_v
);
when_beep = clk.now;
}
}
}
const auto when_armed = fuse.when_armed;
const auto& fuse_def = it.template get<invariants::hand_fuse>();
if (clk.is_ready(fuse_def.fuse_delay_ms, when_armed)) {
detonate_if(it, step);
}
}
}
);
}
void driver_system::assign_drivers_from_successful_trigger_hits(const logic_step step) {
auto& cosmos = step.cosm;
const auto& delta = step.get_delta();
const auto& confirmations = step.transient.messages.get_queue<messages::trigger_hit_confirmation_message>();
for (const auto& e : confirmations) {
const auto& subject_car = cosmos[cosmos[e.trigger].get<components::trigger>().entity_to_be_notified];
if (subject_car.dead()) {
continue;
}
const auto* const maybe_car = subject_car.find<components::car>();
if (maybe_car && e.trigger == maybe_car->left_wheel_trigger) {
assign_car_ownership(cosmos[e.detector_body], subject_car);
}
}
}
void item_system::handle_holster_item_intents(const logic_step step) {
auto& cosmos = step.cosm;
const auto& delta = step.get_delta();
const auto& requests = step.transient.messages.get_queue<messages::intent_message>();
for (const auto& r : requests) {
if (r.is_pressed &&
(r.intent == intent_type::HOLSTER_PRIMARY_ITEM
|| r.intent == intent_type::HOLSTER_SECONDARY_ITEM)
) {
const auto subject = cosmos[r.subject];
if (subject.has<components::gui_element>() && subject.find<components::item_slot_transfers>()) {
const auto hand_type = subject.map_primary_action_to_secondary_hand_if_primary_empty(intent_type::HOLSTER_SECONDARY_ITEM == r.intent).get_id().type;
auto new_setup = components::gui_element::get_actual_selection_setup(subject);
if (hand_type == slot_function::PRIMARY_HAND) {
new_setup.primary_selection.unset();
}
else if (hand_type == slot_function::SECONDARY_HAND) {
new_setup.secondary_selection.unset();
}
components::gui_element::apply_and_save_hotbar_selection_setup(step, new_setup, subject);
}
else if (subject.has<components::item_slot_transfers>()) {
const auto hand = subject.map_primary_action_to_secondary_hand_if_primary_empty(intent_type::HOLSTER_SECONDARY_ITEM == r.intent);
const auto item_inside = hand.get_item_if_any();
if (item_inside.alive()) {
const auto holstering_slot = subject.determine_hand_holstering_slot_for(item_inside);
if (holstering_slot.alive()) {
const item_slot_transfer_request request(item_inside, holstering_slot);
perform_transfer(request, step);
}
}
}
}
}
}
void animation_system::game_responses_to_animation_messages(const logic_step step) {
auto& cosmos = step.cosm;
const auto& delta = step.get_delta();
const auto& movements = step.transient.messages.get_queue<movement_response>();
const auto& gunshots = step.transient.messages.get_queue<gunshot_response>();
for (auto it : movements) {
animation_message msg;
msg.subject = it.subject;
msg.change_speed = true;
msg.change_animation = true;
msg.preserve_state_if_animation_changes = false;
msg.action = ((it.speed <= 1.f) ? animation_message::STOP : animation_message::CONTINUE);
if (!it.stop_response_at_zero_speed)
msg.action = animation_message::CONTINUE;
msg.animation_priority = 0;
msg.set_animation = (*(cosmos[it.subject].get<components::animation_response>().response))[animation_response_type::MOVE];
msg.speed_factor = it.speed;
step.transient.messages.post(msg);
}
for (auto it : gunshots) {
// animation_message msg;
// msg.preserve_state_if_animation_changes = false;
// msg.change_animation = true;
// msg.change_speed = true;
// msg.speed_factor = 1.f;
// msg.subject = it.subject;
// msg.action = messages::animation_message::START;
// msg.animation_priority = 1;
// msg.set_animation = (*(it.subject.get<components::animation_response>().response))[animation_response_type::SHOT];
//
// step.transient.messages.post(msg);
}
}
void driver_system::release_drivers_due_to_ending_contact_with_wheel(const logic_step step) {
auto& cosmos = step.cosm;
const auto& delta = step.get_delta();
const auto& contacts = step.transient.messages.get_queue<messages::collision_message>();
const auto& physics = cosmos.systems_temporary.get<physics_system>();
for (const auto& c : contacts) {
if (c.type == messages::collision_message::event_type::END_CONTACT) {
const auto& driver = cosmos[c.subject];
const auto& car = cosmos[c.collider].get_owner_body();
const auto* const maybe_driver = driver.find<components::driver>();
if (maybe_driver) {
if (maybe_driver->owned_vehicle == car) {
release_car_ownership(driver);
driver.get<components::movement>().make_inert_for_ms = 500.f;
}
}
}
}
}
void item_system::handle_throw_item_intents(const logic_step step) {
auto& cosmos = step.cosm;
const auto& delta = step.get_delta();
const auto& requests = step.transient.messages.get_queue<messages::intent_message>();
for (const auto& r : requests) {
if (r.is_pressed &&
(r.intent == intent_type::THROW_PRIMARY_ITEM
|| r.intent == intent_type::THROW_SECONDARY_ITEM)
) {
const auto subject = cosmos[r.subject];
if (subject.find<components::item_slot_transfers>()) {
const auto hand = subject.map_primary_action_to_secondary_hand_if_primary_empty(intent_type::THROW_SECONDARY_ITEM == r.intent);
const auto item_inside = hand.get_item_if_any();
if (item_inside.alive()) {
perform_transfer({ item_inside, cosmos[inventory_slot_id()] }, step);
}
}
}
}
}
void intent_contextualization_system::contextualize_use_button_intents(const logic_step step) {
auto& cosmos = step.cosm;
auto& delta = step.get_delta();
auto& intents = step.transient.messages.get_queue<messages::intent_message>();
for (auto& e : intents) {
const auto subject = cosmos[e.subject];
const auto* const query_detector = subject.find<components::trigger_query_detector>();
const auto* const collision_detector = subject.find<components::trigger_collision_detector>();
if (e.intent == intent_type::USE_BUTTON) {
const auto* const maybe_driver = subject.find<components::driver>();
if (maybe_driver) {
const auto car_id = maybe_driver->owned_vehicle;
const auto car = cosmos[car_id];
if (car.alive() && car.get<components::car>().current_driver == e.subject) {
e.intent = intent_type::RELEASE_CAR;
continue;
}
}
if (query_detector) {
e.intent = intent_type::QUERY_TOUCHING_TRIGGERS;
continue;
}
}
else if (e.intent == intent_type::START_PICKING_UP_ITEMS) {
if (collision_detector) {
e.intent = intent_type::DETECT_TRIGGER_COLLISIONS;
continue;
}
}
}
}
void item_system::process_mounting_and_unmounting(const logic_step step) {
ensure(false);
auto& cosmos = step.cosm;
const auto& delta = step.get_delta();
for (const auto& e : cosmos.get(processing_subjects::WITH_ITEM_SLOT_TRANSFERS)) {
auto& item_slot_transfers = e.get<components::item_slot_transfers>();
const auto currently_mounted_item = cosmos[item_slot_transfers.mounting.current_item];
if (currently_mounted_item.alive()) {
auto& item = currently_mounted_item.get<components::item>();
if (item.current_slot != item_slot_transfers.mounting.intented_mounting_slot) {
item_slot_transfers.interrupt_mounting();
}
else {
ensure(item.intended_mounting != item.current_mounting);
if (item.montage_time_left_ms > 0) {
item.montage_time_left_ms -= static_cast<float>(delta.in_milliseconds());
}
else {
item.current_mounting = item.intended_mounting;
if (item.current_mounting == components::item::UNMOUNTED) {
perform_transfer({ currently_mounted_item, cosmos[item.target_slot_after_unmount] }, step);
}
}
}
}
if (currently_mounted_item.dead()) {
item_slot_transfers.mounting = components::item_slot_transfers::find_suitable_montage_operation(e);
}
}
}
void animation_system::handle_animation_messages(const logic_step step) {
auto& cosmos = step.cosm;
const auto& delta = step.get_delta();
const auto& events = step.transient.messages.get_queue<animation_message>();
for (auto it : events) {
auto ptr = cosmos[it.subject].find<components::animation>();
if (!ptr) continue; auto& animation = *ptr;
if (it.animation_priority >= animation.priority || animation.state == components::animation::playing_state::PAUSED) {
if (it.change_speed)
animation.speed_factor = it.speed_factor;
//if (it.change_animation) {
assets::animation_id new_instance = it.set_animation;
if (new_instance != animation.current_animation) {
animation.current_animation = new_instance;
if (it.action == animation_message::CONTINUE) {
it.action = animation_message::START;
}
//if (!it.preserve_state_if_animation_changes) {
// animation.set_current_frame(0, it.subject);
// animation.player_position_ms = 0.f;
//}
//else {
/* update callback */
//animation.set_current_frame(animation.get_current_frame(), it.subject);
//}
}
//}
animation.priority = it.animation_priority;
switch (it.action) {
case animation_message::PAUSE:
if (animation.state != components::animation::playing_state::PAUSED) {
animation.paused_state = animation.state;
animation.state = components::animation::playing_state::PAUSED;
}
break;
case animation_message::STOP:
animation.paused_state = components::animation::playing_state::PAUSED;
animation.state = components::animation::playing_state::PAUSED;
animation.set_current_frame(0);
animation.player_position_ms = 0.f;
break;
case animation_message::START:
animation.state = components::animation::playing_state::INCREASING;
animation.set_current_frame(0);
animation.player_position_ms = 0.f;
break;
case animation_message::CONTINUE:
if (animation.state == components::animation::playing_state::PAUSED) {
if (animation.paused_state == components::animation::playing_state::PAUSED)
animation.paused_state = components::animation::playing_state::INCREASING;
animation.state = animation.paused_state;
}
break;
default: break;
}
}
}
step.transient.messages.get_queue<animation_message>().clear();
}
void animation_system::progress_animation_states(const logic_step step) {
auto& cosmos = step.cosm;
const auto& delta = step.get_delta();
for (const auto& it : cosmos.get(processing_subjects::WITH_ANIMATION)) {
auto& animation_state = it.get<components::animation>();
if (animation_state.state != components::animation::playing_state::PAUSED) {
auto& animation = *get_resource_manager().find(animation_state.current_animation);
if (animation.frames.empty()) continue;
animation_state.player_position_ms += static_cast<float>(delta.in_milliseconds()) * animation_state.speed_factor;
while (true) {
float frame_duration = animation.frames[animation_state.get_current_frame()].duration_milliseconds;
if (animation_state.player_position_ms > frame_duration) {
animation_state.player_position_ms -= frame_duration;
if (animation.loop_mode == animation::loop_type::INVERSE) {
if (animation_state.state == components::animation::playing_state::INCREASING) {
if (animation_state.get_current_frame() < animation.frames.size() - 1) animation_state.increase_frame();
else {
animation_state.decrease_frame();
animation_state.state = components::animation::playing_state::DECREASING;
}
}
else if (animation_state.state == components::animation::playing_state::DECREASING) {
if (animation_state.get_current_frame() > 0) animation_state.decrease_frame();
else {
animation_state.increase_frame();
animation_state.state = components::animation::playing_state::INCREASING;
}
}
}
else if (animation.loop_mode == animation::loop_type::REPEAT) {
if (animation_state.state == components::animation::playing_state::INCREASING) {
if (animation_state.get_current_frame() < animation.frames.size() - 1)
animation_state.increase_frame();
else animation_state.set_current_frame(0);
}
else if (animation_state.state == components::animation::playing_state::DECREASING) {
if (animation_state.get_current_frame() > 0) animation_state.decrease_frame();
else animation_state.set_current_frame(animation.frames.size() - 1);
}
}
else if (animation.loop_mode == animation::loop_type::NONE) {
if (animation_state.state == components::animation::playing_state::INCREASING) {
if (animation_state.get_current_frame() < animation.frames.size() - 1)
animation_state.increase_frame();
else animation_state.state = components::animation::playing_state::PAUSED;
}
else if (animation_state.state == components::animation::playing_state::DECREASING) {
if (animation_state.get_current_frame() > 0) animation_state.decrease_frame();
else animation_state.state = components::animation::playing_state::PAUSED;
}
}
}
else break;
}
auto& sprite = it.get<components::sprite>();
sprite = animation.frames[animation_state.get_current_frame()].sprite;
}
}
}
void force_joint_system::apply_forces_towards_target_entities(logic_step& step) {
auto& cosmos = step.cosm;
const auto delta = step.get_delta();
for (const auto& it : cosmos.get(processing_subjects::WITH_FORCE_JOINT)) {
if (!it.has<components::physics>()) continue;
const auto& physics = it.get<components::physics>();
if (!physics.is_constructed()) continue;
const auto& force_joint = it.get<components::force_joint>();
const auto& chased_entity = cosmos[force_joint.chased_entity];
if (chased_entity.dead()) continue;
const auto& chased_entity_transform = chased_entity.logic_transform();
const auto& chased_transform = chased_entity_transform + force_joint.chased_entity_offset;
auto direction = chased_transform.pos - physics.get_position();
const auto& distance = direction.length();
direction.normalize_hint(distance);
if (force_joint.divide_transform_mode) {
const auto current_transform = it.logic_transform();
const auto interpolated = augs::interp(current_transform, chased_transform, 1.0 - 1.0 / (1.0 + delta.in_seconds() * (60.0)));
//LOG("Cur: %x,%x, Chas: %x,%x, Inter: %x,%x", current_transform.pos, current_transform.rotation, chased_entity_transform.pos, chased_entity_transform.rotation, interpolated.pos, interpolated.rotation);
physics.set_transform(interpolated);
}
else {
float force_length = force_joint.force_towards_chased_entity;
if (distance < force_joint.distance_when_force_easing_starts) {
auto mult = distance / force_joint.distance_when_force_easing_starts;
force_length *= pow(mult, force_joint.power_of_force_easing_multiplier);
}
const auto& force_for_chaser = vec2(direction).set_length(force_length * 1.f - force_joint.percent_applied_to_chased_entity);
const auto& force_for_chased = -force_for_chaser * force_joint.percent_applied_to_chased_entity;
const bool is_force_epsilon = force_for_chaser.length() < 500;
const auto& offsets = force_joint.force_offsets;
const int& offsets_count = static_cast<int>(offsets.size());
//if (!is_force_epsilon)
{
for (const auto& offset : offsets)
physics.apply_force(force_for_chaser * physics.get_mass() / offsets_count, offset);
//LOG("F: %x, %x, %x", force_for_chaser, physics.velocity(), AS_INTV physics.get_position());
}
//else if (is_force_epsilon && physics.velocity().is_epsilon(1.f)) {
// physics.set_velocity(vec2(0, 0));
// //physics.set_transform(components::transform(chased_transform.pos, physics.get_angle()));
// LOG("Zeroed");
//}
if (force_for_chased.length() > 5) {
const auto& chased_physics = cosmos[force_joint.chased_entity].get<components::physics>();
chased_physics.apply_force(force_for_chaser * chased_physics.get_mass());
}
//if (force_joint.consider_rotation)
// it.get<components::rotation_copying>().target_angle = chased_transform.rotation;
//LOG("F: %x", physics.body->GetLinearDamping());
}
}
}