19047185932

Committed 03 Nov 2025 07:42PM UTC coverage: 50.469% (-0.005%) from 50.474%

Build # 19047185932

Build Type

Pull #1817

github

Committed by

web-flow

Commit Message

Merge 82ee3db19 into 7333cc249

Pull Request Pull Request #1817: Proposal to turn off/on bird sounds

Run Details

2 of 34 new or added lines in 4 files covered. (5.88%)

5 existing lines in 3 files now uncovered.

22510 of 44602 relevant lines covered (50.47%)

35645.8 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

61.9

/libs/s25main/nodeObjs/noMovable.cpp

// Copyright (C) 2005 - 2021 Settlers Freaks (sf-team at siedler25.org)
//
// SPDX-License-Identifier: GPL-2.0-or-later

#include "noMovable.h"

#include "EventManager.h"
#include "GameEvent.h"
#include "SerializedGameData.h"
#include "enum_cast.hpp"
#include "network/GameClient.h"
#include "world/GameWorld.h"
#include "gameData/MapConsts.h"
#include "s25util/Log.h"

EventState::EventState(SerializedGameData& sgd) : elapsed(sgd.PopUnsignedInt()), length(sgd.PopUnsignedInt()) {}

noMovable::noMovable(const NodalObjectType nop, const MapPoint pos)
    : noCoordBase(nop, pos), curMoveDir(Direction::SouthEast), ascent(0), moving(false), current_ev(nullptr)
{}

void noMovable::Serialize(SerializedGameData& sgd) const
{
    noCoordBase::Serialize(sgd);

    sgd.PushEnum<uint8_t>(curMoveDir);
    sgd.PushUnsignedChar(ascent);
    sgd.PushEvent(current_ev);
    sgd.PushUnsignedInt(pauseEv.elapsed);
    sgd.PushUnsignedInt(pauseEv.length);
    sgd.PushBool(moving);
}

noMovable::noMovable(SerializedGameData& sgd, const unsigned obj_id)
    : noCoordBase(sgd, obj_id), curMoveDir(sgd.Pop<Direction>()), ascent(sgd.PopUnsignedChar())
{
    current_ev = sgd.PopEvent();
    pauseEv = EventState(sgd);
    moving = sgd.PopBool();
}

void noMovable::Walk()
{
    moving = false;
    const MapPoint oldPos = pos;
    pos = world->GetNeighbour(pos, curMoveDir);
    world->AddFigure(pos, world->RemoveFigure(oldPos, *this));
}

void noMovable::FaceDir(Direction newDir)
{
    curMoveDir = newDir;
}

void noMovable::StartMoving(const Direction dir, unsigned gf_length)
{
    RTTR_Assert(!moving);

    // Ist das Wesen stehengeblieben mitten aufm Weg?
    if(IsStoppedBetweenNodes())
    {
        // Das Laufevent fortführen
        RTTR_Assert(dir == curMoveDir);
        // Avoid setting an event for current gf by increasing the length
        if(pauseEv.length == pauseEv.elapsed)
            pauseEv.length++;
        current_ev = GetEvMgr().AddEvent(this, pauseEv.length, 0, pauseEv.elapsed);
        pauseEv = EventState();
        moving = true;
        return;
    }

    // Steigung ermitteln, muss entsprechend langsamer (hoch) bzw. schneller (runter) laufen
    // runter natürlich nich so viel schneller werden wie langsamer hoch
    switch(int(world->GetNeighbourNode(pos, dir).altitude) - int(world->GetNode(pos).altitude))
    {
        default: ascent = 3; break; // gerade
        case 1:
            ascent = 4;
            gf_length += (gf_length / 2);
            break; // leicht hoch
        case 2:
        case 3:
            ascent = 5;
            gf_length *= 2;
            break; // mittelsteil hoch
        case 4:
        case 5:
            ascent = 6;
            gf_length *= 3;
            break;                  // steil hoch
        case -1: ascent = 2; break; // leicht runter
        case -2:
        case -3: ascent = 1; break; // mittelsteil runter
        case -4:
        case -5: ascent = 0; break; // steil runter
    }

    current_ev = GetEvMgr().AddEvent(this, gf_length);
    this->curMoveDir = dir;
    moving = true;
}

DrawPoint noMovable::CalcRelative(DrawPoint curPt, DrawPoint nextPt) const
{
    if(current_ev)
    {
        RTTR_Assert(current_ev->length > 0);
        if(current_ev->length == 0)
        {
            LOG.write("WARNING: Bug detected (GF: %u). Please report this with the savegame and replay. "
                      "noMovable::CalcRelative: "
                      "current_ev->gf_length = 0!\n")
              % GetEvMgr().GetCurrentGF();
            return Position(0, 0);
        }
    }

    RTTR_Assert(IsMoving() || IsStoppedBetweenNodes());

    using milliseconds_i32_t = std::chrono::duration<int32_t, std::milli>;

    // Wenn wir mittem aufm Weg stehen geblieben sind, die gemerkten Werte jeweils nehmen
    EventState curState;
    milliseconds_i32_t frame_time;
    if(current_ev)
    {
        curState.elapsed = GetEvMgr().GetCurrentGF() - current_ev->startGF;
        curState.length = current_ev->length;
        frame_time = GAMECLIENT.GetFrameTime();
    } else
    {
        curState = pauseEv;
        frame_time = milliseconds_i32_t::zero();
    }

    // Convert to real world time
    const milliseconds_i32_t gfLength = GAMECLIENT.GetGFLength();
    // Time since the start of the event
    milliseconds_i32_t curTimePassed = curState.elapsed * gfLength + frame_time;
    // Duration of the event
    milliseconds_i32_t duration = curState.length * gfLength;

    // We are in that event
    RTTR_Assert(curTimePassed <= duration);

    // Check for map border crossing
    const Position mapDrawSize = world->GetSize() * Position(TR_W, TR_H);
    if(std::abs(nextPt.x - curPt.x) >= mapDrawSize.x / 2)
    {
        // So we need to get closer to nextPt
        if(curPt.x > nextPt.x)
            curPt.x -= mapDrawSize.x;
        else
            curPt.x += mapDrawSize.x;
    }
    if(std::abs(curPt.y - nextPt.y) >= mapDrawSize.y / 2)
    {
        if(curPt.y > nextPt.y)
            curPt.y -= mapDrawSize.y;
        else
            curPt.y += mapDrawSize.y;
    }

    return ((nextPt - curPt) * curTimePassed.count()) / duration.count();
}

/// Interpoliert fürs Laufen zwischen zwei Kartenpunkten
DrawPoint noMovable::CalcWalkingRelative() const
{
    Position curPt = world->GetNodePos(pos);
    Position nextPt = world->GetNodePos(world->GetNeighbour(pos, curMoveDir));

    return CalcRelative(curPt, nextPt);
}

void noMovable::PauseWalking()
{
    RTTR_Assert(IsMoving());
    // Frames festhalten, bis zu denen wir gekommen sind
    pauseEv = EventState(GetEvMgr().GetCurrentGF() - current_ev->startGF, current_ev->length);
    // Event abmelden
    GetEvMgr().RemoveEvent(current_ev);
    moving = false;
}

/// Gibt zurück, ob sich das angegebene Objekt zwischen zwei Punkten bewegt
bool noMovable::IsMoving() const
{
    return current_ev && (current_ev->id == 0);
}

/// Gibt die Position zurück, wo wir uns hinbewegen (selbe Position, wenn Schiff steht)
MapPoint noMovable::GetDestinationForCurrentMove() const
{
    // Bewegt sich das Ding gerade?
    if(IsMoving())
        // Dann unsere Zielrichtung zur Berechnung verwenden
        return world->GetNeighbour(pos, curMoveDir);

    return pos;
}

1	// Copyright (C) 2005 - 2021 Settlers Freaks (sf-team at siedler25.org)
2	//
3	// SPDX-License-Identifier: GPL-2.0-or-later
4
5	#include "noMovable.h"
6
7	#include "EventManager.h"
8	#include "GameEvent.h"
9	#include "SerializedGameData.h"
10	#include "enum_cast.hpp"
11	#include "network/GameClient.h"
12	#include "world/GameWorld.h"
13	#include "gameData/MapConsts.h"
14	#include "s25util/Log.h"
15
16	EventState::EventState(SerializedGameData& sgd) : elapsed(sgd.PopUnsignedInt()), length(sgd.PopUnsignedInt()) {}	5✔
17
18	noMovable::noMovable(const NodalObjectType nop, const MapPoint pos)	1,082✔
19	: noCoordBase(nop, pos), curMoveDir(Direction::SouthEast), ascent(0), moving(false), current_ev(nullptr)	1,082✔
20	{}	1,082✔
21
22	void noMovable::Serialize(SerializedGameData& sgd) const	10✔
23	{
24	noCoordBase::Serialize(sgd);	10✔
25
26	sgd.PushEnum<uint8_t>(curMoveDir);	10✔
27	sgd.PushUnsignedChar(ascent);	10✔
28	sgd.PushEvent(current_ev);	10✔
29	sgd.PushUnsignedInt(pauseEv.elapsed);	10✔
30	sgd.PushUnsignedInt(pauseEv.length);	10✔
31	sgd.PushBool(moving);	10✔
32	}	10✔
33
34	noMovable::noMovable(SerializedGameData& sgd, const unsigned obj_id)	5✔
35	: noCoordBase(sgd, obj_id), curMoveDir(sgd.Pop<Direction>()), ascent(sgd.PopUnsignedChar())	5✔
36	{
37	current_ev = sgd.PopEvent();	5✔
38	pauseEv = EventState(sgd);	5✔
39	moving = sgd.PopBool();	5✔
40	}	5✔
41
42	void noMovable::Walk()	3,869✔
43	{
44	moving = false;	3,869✔
45	const MapPoint oldPos = pos;	3,869✔
46	pos = world->GetNeighbour(pos, curMoveDir);	3,869✔
47	world->AddFigure(pos, world->RemoveFigure(oldPos, *this));	3,869✔
48	}	3,869✔
49
50	void noMovable::FaceDir(Direction newDir)	523✔
51	{
52	curMoveDir = newDir;	523✔
53	}	523✔
54
55	void noMovable::StartMoving(const Direction dir, unsigned gf_length)	4,373✔
56	{
57	RTTR_Assert(!moving);	4,373✔
58
59	// Ist das Wesen stehengeblieben mitten aufm Weg?
60	if(IsStoppedBetweenNodes())	4,373✔
61	{
62	// Das Laufevent fortführen
63	RTTR_Assert(dir == curMoveDir);	1✔
64	// Avoid setting an event for current gf by increasing the length
65	if(pauseEv.length == pauseEv.elapsed)	1✔
66	pauseEv.length++;	×
67	current_ev = GetEvMgr().AddEvent(this, pauseEv.length, 0, pauseEv.elapsed);	1✔
68	pauseEv = EventState();	1✔
69	moving = true;	1✔
70	return;	1✔
71	}
72
73	// Steigung ermitteln, muss entsprechend langsamer (hoch) bzw. schneller (runter) laufen
74	// runter natürlich nich so viel schneller werden wie langsamer hoch
75	switch(int(world->GetNeighbourNode(pos, dir).altitude) - int(world->GetNode(pos).altitude))	4,372✔
76	{
77	default: ascent = 3; break; // gerade	4,040✔
78	case 1:	45✔
79	ascent = 4;	45✔
80	gf_length += (gf_length / 2);	45✔
81	break; // leicht hoch	45✔
82	case 2:	110✔
83	case 3:
84	ascent = 5;	110✔
85	gf_length *= 2;	110✔
86	break; // mittelsteil hoch	110✔
87	case 4:	×
88	case 5:
89	ascent = 6;	×
90	gf_length *= 3;	×
91	break; // steil hoch	×
92	case -1: ascent = 2; break; // leicht runter	70✔
93	case -2:	107✔
94	case -3: ascent = 1; break; // mittelsteil runter	107✔
UNCOV 95	case -4:	×
UNCOV 96	case -5: ascent = 0; break; // steil runter	×
97	}
98
99	current_ev = GetEvMgr().AddEvent(this, gf_length);	4,372✔
100	this->curMoveDir = dir;	4,372✔
101	moving = true;	4,372✔
102	}
103
104	DrawPoint noMovable::CalcRelative(DrawPoint curPt, DrawPoint nextPt) const	×
105	{
106	if(current_ev)	×
107	{
108	RTTR_Assert(current_ev->length > 0);	×
109	if(current_ev->length == 0)	×
110	{
111	LOG.write("WARNING: Bug detected (GF: %u). Please report this with the savegame and replay. "	×
112	"noMovable::CalcRelative: "
113	"current_ev->gf_length = 0!\n")
114	% GetEvMgr().GetCurrentGF();	×
115	return Position(0, 0);	×
116	}
117	}
118
119	RTTR_Assert(IsMoving() \|\| IsStoppedBetweenNodes());	×
120
121	using milliseconds_i32_t = std::chrono::duration<int32_t, std::milli>;
122
123	// Wenn wir mittem aufm Weg stehen geblieben sind, die gemerkten Werte jeweils nehmen
124	EventState curState;	×
125	milliseconds_i32_t frame_time;
126	if(current_ev)	×
127	{
128	curState.elapsed = GetEvMgr().GetCurrentGF() - current_ev->startGF;	×
129	curState.length = current_ev->length;	×
130	frame_time = GAMECLIENT.GetFrameTime();	×
131	} else
132	{
133	curState = pauseEv;	×
134	frame_time = milliseconds_i32_t::zero();	×
135	}
136
137	// Convert to real world time
138	const milliseconds_i32_t gfLength = GAMECLIENT.GetGFLength();	×
139	// Time since the start of the event
140	milliseconds_i32_t curTimePassed = curState.elapsed * gfLength + frame_time;	×
141	// Duration of the event
142	milliseconds_i32_t duration = curState.length * gfLength;	×
143
144	// We are in that event
145	RTTR_Assert(curTimePassed <= duration);	×
146
147	// Check for map border crossing
148	const Position mapDrawSize = world->GetSize() * Position(TR_W, TR_H);	×
149	if(std::abs(nextPt.x - curPt.x) >= mapDrawSize.x / 2)	×
150	{
151	// So we need to get closer to nextPt
152	if(curPt.x > nextPt.x)	×
153	curPt.x -= mapDrawSize.x;	×
154	else
155	curPt.x += mapDrawSize.x;	×
156	}
157	if(std::abs(curPt.y - nextPt.y) >= mapDrawSize.y / 2)	×
158	{
159	if(curPt.y > nextPt.y)	×
160	curPt.y -= mapDrawSize.y;	×
161	else
162	curPt.y += mapDrawSize.y;	×
163	}
164
165	return ((nextPt - curPt) * curTimePassed.count()) / duration.count();	×
166	}
167
168	/// Interpoliert fürs Laufen zwischen zwei Kartenpunkten
169	DrawPoint noMovable::CalcWalkingRelative() const	×
170	{
171	Position curPt = world->GetNodePos(pos);	×
172	Position nextPt = world->GetNodePos(world->GetNeighbour(pos, curMoveDir));	×
173
174	return CalcRelative(curPt, nextPt);	×
175	}
176
177	void noMovable::PauseWalking()	1✔
178	{
179	RTTR_Assert(IsMoving());	1✔
180	// Frames festhalten, bis zu denen wir gekommen sind
181	pauseEv = EventState(GetEvMgr().GetCurrentGF() - current_ev->startGF, current_ev->length);	1✔
182	// Event abmelden
183	GetEvMgr().RemoveEvent(current_ev);	1✔
184	moving = false;	1✔
185	}	1✔
186
187	/// Gibt zurück, ob sich das angegebene Objekt zwischen zwei Punkten bewegt
188	bool noMovable::IsMoving() const	609✔
189	{
190	return current_ev && (current_ev->id == 0);	609✔
191	}
192
193	/// Gibt die Position zurück, wo wir uns hinbewegen (selbe Position, wenn Schiff steht)
194	MapPoint noMovable::GetDestinationForCurrentMove() const	246✔
195	{
196	// Bewegt sich das Ding gerade?
197	if(IsMoving())	246✔
198	// Dann unsere Zielrichtung zur Berechnung verwenden
199	return world->GetNeighbour(pos, curMoveDir);	186✔
200
201	return pos;	60✔
202	}

Return-To-The-Roots / s25client / 19047185932

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous