Migrate ACT_CHOP_[LOGS|PLANKS|TREE] to the new activity actor system. (#54638)

Author: ahmedcharles

src/activity_actor.cpp

@@ -111,6 +111,7 @@ static const activity_id ACT_MEDITATE( "ACT_MEDITATE" );
 static const activity_id ACT_MIGRATION_CANCEL( "ACT_MIGRATION_CANCEL" );
 static const activity_id ACT_MILK( "ACT_MILK" );
 static const activity_id ACT_MOVE_ITEMS( "ACT_MOVE_ITEMS" );
+static const activity_id ACT_MULTIPLE_CHOP_TREES( "ACT_MULTIPLE_CHOP_TREES" );
 static const activity_id ACT_OPEN_GATE( "ACT_OPEN_GATE" );
 static const activity_id ACT_OXYTORCH( "ACT_OXYTORCH" );
 static const activity_id ACT_PICKUP( "ACT_PICKUP" );
@@ -161,11 +162,15 @@ static const item_group_id Item_spawn_data_grave( "grave" );
 static const item_group_id Item_spawn_data_jewelry_front( "jewelry_front" );
 static const item_group_id Item_spawn_data_trash_forest( "trash_forest" );
 
+static const itype_id itype_2x4( "2x4" );
 static const itype_id itype_bone_human( "bone_human" );
 static const itype_id itype_disassembly( "disassembly" );
 static const itype_id itype_electrohack( "electrohack" );
+static const itype_id itype_log( "log" );
 static const itype_id itype_paper( "paper" );
 static const itype_id itype_pseudo_bio_picklock( "pseudo_bio_picklock" );
+static const itype_id itype_splinter( "splinter" );
+static const itype_id itype_stick_long( "stick_long" );
 
 static const json_character_flag json_flag_SUPER_HEARING( "SUPER_HEARING" );
 
@@ -5392,6 +5397,235 @@ std::unique_ptr<activity_actor> pickup_menu_activity_actor::deserialize( JsonVal
     return actor.clone();
 }
 
+static void chop_single_do_turn( player_activity &act )
+{
+    const map &here = get_map();
+    sfx::play_activity_sound( "tool", "axe", sfx::get_heard_volume( here.getlocal( act.placement ) ) );
+    if( calendar::once_every( 1_minutes ) ) {
+        //~ Sound of a wood chopping tool at work!
+        sounds::sound( here.getlocal( act.placement ), 15, sounds::sound_t::activity, _( "CHK!" ) );
+    }
+}
+
+void chop_logs_activity_actor::start( player_activity &act, Character & )
+{
+    act.moves_total = moves;
+    act.moves_left = moves;
+}
+
+void chop_logs_activity_actor::do_turn( player_activity &act, Character & )
+{
+    chop_single_do_turn( act );
+}
+
+void chop_logs_activity_actor::finish( player_activity &act, Character &who )
+{
+    map &here = get_map();
+    const tripoint &pos = here.getlocal( act.placement );
+    int log_quan;
+    int stick_quan;
+    int splint_quan;
+    if( here.ter( pos ) == t_trunk ) {
+        log_quan = rng( 2, 3 );
+        stick_quan = rng( 0, 1 );
+        splint_quan = 0;
+    } else if( here.ter( pos ) == t_stump ) {
+        log_quan = rng( 0, 2 );
+        stick_quan = 0;
+        splint_quan = rng( 5, 15 );
+    } else {
+        log_quan = 0;
+        stick_quan = 0;
+        splint_quan = 0;
+    }
+    for( int i = 0; i != log_quan; ++i ) {
+        item obj( itype_log, calendar::turn );
+        obj.set_var( "activity_var", who.name );
+        here.add_item_or_charges( pos, obj );
+    }
+    for( int i = 0; i != stick_quan; ++i ) {
+        item obj( itype_stick_long, calendar::turn );
+        obj.set_var( "activity_var", who.name );
+        here.add_item_or_charges( pos, obj );
+    }
+    for( int i = 0; i != splint_quan; ++i ) {
+        item obj( itype_splinter, calendar::turn );
+        obj.set_var( "activity_var", who.name );
+        here.add_item_or_charges( pos, obj );
+    }
+    here.ter_set( pos, t_dirt );
+    who.add_msg_if_player( m_good, _( "You finish chopping wood." ) );
+
+    act.set_to_null();
+    activity_handlers::resume_for_multi_activities( who );
+}
+
+void chop_logs_activity_actor::serialize( JsonOut &jsout ) const
+{
+    jsout.start_object();
+
+    jsout.member( "moves", moves );
+    jsout.member( "tool", tool );
+
+    jsout.end_object();
+}
+
+std::unique_ptr<activity_actor> chop_logs_activity_actor::deserialize( JsonValue &jsin )
+{
+    chop_logs_activity_actor actor( {}, {} );
+
+    JsonObject data = jsin.get_object();
+
+    data.read( "moves", actor.moves );
+    data.read( "tool", actor.tool );
+
+    return actor.clone();
+}
+
+void chop_planks_activity_actor::start( player_activity &act, Character & )
+{
+    act.moves_total = moves;
+    act.moves_left = moves;
+}
+
+void chop_planks_activity_actor::do_turn( player_activity &act, Character & )
+{
+    chop_single_do_turn( act );
+}
+
+void chop_planks_activity_actor::finish( player_activity &act, Character &who )
+{
+    const int max_planks = 10;
+    /** @EFFECT_FABRICATION increases number of planks cut from a log */
+    int planks = normal_roll( 2 + who.get_skill_level( skill_fabrication ), 1 );
+    int wasted_planks = max_planks - planks;
+    int scraps = rng( wasted_planks, wasted_planks * 3 );
+    planks = std::min( planks, max_planks );
+
+    map &here = get_map();
+    if( planks > 0 ) {
+        here.spawn_item( here.getlocal( act.placement ), itype_2x4, planks, 0, calendar::turn );
+        who.add_msg_if_player( m_good, n_gettext( "You produce %d plank.", "You produce %d planks.",
+                               planks ), planks );
+    }
+    if( scraps > 0 ) {
+        here.spawn_item( here.getlocal( act.placement ), itype_splinter, scraps, 0, calendar::turn );
+        who.add_msg_if_player( m_good, n_gettext( "You produce %d splinter.", "You produce %d splinters.",
+                               scraps ), scraps );
+    }
+    if( planks < max_planks / 2 ) {
+        who.add_msg_if_player( m_bad, _( "You waste a lot of the wood." ) );
+    }
+    act.set_to_null();
+    activity_handlers::resume_for_multi_activities( who );
+}
+
+void chop_planks_activity_actor::serialize( JsonOut &jsout ) const
+{
+    jsout.start_object();
+
+    jsout.member( "moves", moves );
+
+    jsout.end_object();
+}
+
+std::unique_ptr<activity_actor> chop_planks_activity_actor::deserialize( JsonValue &jsin )
+{
+    chop_planks_activity_actor actor( {} );
+
+    JsonObject data = jsin.get_object();
+
+    data.read( "moves", actor.moves );
+
+    return actor.clone();
+}
+
+void chop_tree_activity_actor::start( player_activity &act, Character & )
+{
+    act.moves_total = moves;
+    act.moves_left = moves;
+}
+
+void chop_tree_activity_actor::do_turn( player_activity &act, Character & )
+{
+    chop_single_do_turn( act );
+}
+
+void chop_tree_activity_actor::finish( player_activity &act, Character &who )
+{
+    map &here = get_map();
+    const tripoint &pos = here.getlocal( act.placement );
+
+    tripoint direction;
+    if( !who.is_npc() ) {
+        if( who.backlog.empty() || who.backlog.front().id() != ACT_MULTIPLE_CHOP_TREES ) {
+            while( true ) {
+                if( const cata::optional<tripoint> dir = choose_direction(
+                            _( "Select a direction for the tree to fall in." ) ) ) {
+                    direction = *dir;
+                    break;
+                }
+                // try again
+            }
+        }
+    } else {
+        creature_tracker &creatures = get_creature_tracker();
+        for( const tripoint &elem : here.points_in_radius( pos, 1 ) ) {
+            bool cantuse = false;
+            tripoint direc = elem - pos;
+            tripoint proposed_to = pos + point( 3 * direction.x, 3 * direction.y );
+            std::vector<tripoint> rough_tree_line = line_to( pos, proposed_to );
+            for( const tripoint &elem : rough_tree_line ) {
+                if( creatures.creature_at( elem ) ) {
+                    cantuse = true;
+                    break;
+                }
+            }
+            if( !cantuse ) {
+                direction = direc;
+            }
+        }
+    }
+
+    const tripoint to = pos + 3 * direction.xy() + point( rng( -1, 1 ), rng( -1, 1 ) );
+    std::vector<tripoint> tree = line_to( pos, to, rng( 1, 8 ) );
+    for( const tripoint &elem : tree ) {
+        here.batter( elem, 300, 5 );
+        here.ter_set( elem, t_trunk );
+    }
+
+    here.ter_set( pos, t_stump );
+    who.add_msg_if_player( m_good, _( "You finish chopping down a tree." ) );
+    // sound of falling tree
+    sfx::play_variant_sound( "misc", "timber",
+                             sfx::get_heard_volume( here.getlocal( act.placement ) ) );
+    get_event_bus().send<event_type::cuts_tree>( who.getID() );
+    act.set_to_null();
+    activity_handlers::resume_for_multi_activities( who );
+}
+
+void chop_tree_activity_actor::serialize( JsonOut &jsout ) const
+{
+    jsout.start_object();
+
+    jsout.member( "moves", moves );
+    jsout.member( "tool", tool );
+
+    jsout.end_object();
+}
+
+std::unique_ptr<activity_actor> chop_tree_activity_actor::deserialize( JsonValue &jsin )
+{
+    chop_tree_activity_actor actor( {}, {} );
+
+    JsonObject data = jsin.get_object();
+
+    data.read( "moves", actor.moves );
+    data.read( "tool", actor.tool );
+
+    return actor.clone();
+}
+
 void firstaid_activity_actor::start( player_activity &act, Character & )
 {
     act.moves_total = moves;

src/activity_actor_definitions.h

@@ -1654,6 +1654,83 @@ class pickup_menu_activity_actor : public activity_actor
         std::vector<drop_location> selection;
 };
 
+class chop_logs_activity_actor : public activity_actor
+{
+    public:
+        chop_logs_activity_actor() = default;
+        chop_logs_activity_actor( int moves, const item_location &tool ) : moves( moves ), tool( tool ) {}
+
+        activity_id get_type() const override {
+            return activity_id( "ACT_CHOP_LOGS" );
+        }
+
+        void start( player_activity &act, Character &who ) override;
+        void do_turn( player_activity &, Character & ) override;
+        void finish( player_activity &act, Character &who ) override;
+
+        std::unique_ptr<activity_actor> clone() const override {
+            return std::make_unique<chop_logs_activity_actor>( *this );
+        }
+
+        void serialize( JsonOut &jsout ) const override;
+        static std::unique_ptr<activity_actor> deserialize( JsonValue &jsin );
+
+    private:
+        int moves;
+        item_location tool;
+};
+
+class chop_planks_activity_actor : public activity_actor
+{
+    public:
+        chop_planks_activity_actor() = default;
+        explicit chop_planks_activity_actor( int moves ) : moves( moves ) {}
+
+        activity_id get_type() const override {
+            return activity_id( "ACT_CHOP_PLANKS" );
+        }
+
+        void start( player_activity &act, Character &who ) override;
+        void do_turn( player_activity &, Character & ) override;
+        void finish( player_activity &act, Character &who ) override;
+
+        std::unique_ptr<activity_actor> clone() const override {
+            return std::make_unique<chop_planks_activity_actor>( *this );
+        }
+
+        void serialize( JsonOut &jsout ) const override;
+        static std::unique_ptr<activity_actor> deserialize( JsonValue &jsin );
+
+    private:
+        int moves;
+};
+
+class chop_tree_activity_actor : public activity_actor
+{
+    public:
+        chop_tree_activity_actor() = default;
+        chop_tree_activity_actor( int moves, const item_location &tool ) : moves( moves ), tool( tool ) {}
+
+        activity_id get_type() const override {
+            return activity_id( "ACT_CHOP_TREE" );
+        }
+
+        void start( player_activity &act, Character &who ) override;
+        void do_turn( player_activity &, Character & ) override;
+        void finish( player_activity &act, Character &who ) override;
+
+        std::unique_ptr<activity_actor> clone() const override {
+            return std::make_unique<chop_tree_activity_actor>( *this );
+        }
+
+        void serialize( JsonOut &jsout ) const override;
+        static std::unique_ptr<activity_actor> deserialize( JsonValue &jsin );
+
+    private:
+        int moves;
+        item_location tool;
+};
+
 class disable_activity_actor : public activity_actor
 {
     public: