Prediction: Create infclass objects

Author: Kaffeine

CMakeLists.txt

@@ -2425,6 +2425,10 @@ if(CLIENT)
     prediction/entities/character.h
     prediction/entities/dragger.cpp
     prediction/entities/dragger.h
+    prediction/entities/ic_entity.cpp
+    prediction/entities/ic_entity.h
+    prediction/entities/ic_placed_object.cpp
+    prediction/entities/ic_placed_object.h
     prediction/entities/laser.cpp
     prediction/entities/laser.h
     prediction/entities/pickup.cpp

src/game/client/prediction/entities/ic_entity.cpp

@@ -0,0 +1,86 @@
+#include "ic_entity.h"
+
+CIcEntity::CIcEntity(CGameWorld *pGameWorld, int Id, int ObjectType, vec2 Pos, std::optional<int> Owner,
+	int ProximityRadius) :
+	CEntity(pGameWorld, ObjectType, Pos, ProximityRadius)
+{
+	SetOwner(Owner.value_or(-1));
+	m_Id = Id;
+}
+
+bool CIcEntity::Match(const CIcEntity *pEntity) const
+{
+	return m_Owner == pEntity->m_Owner && m_Pos == pEntity->m_Pos;
+}
+
+void CIcEntity::Read(const CIcEntity &Source)
+{
+	m_EndTick = Source.m_EndTick;
+}
+
+void CIcEntity::SetStartTick(int Tick)
+{
+	
+}
+
+void CIcEntity::SetEndTick(int Tick)
+{
+	
+}
+
+void CIcEntity::SetOwner(int ClientId)
+{
+	if(ClientId < 0)
+	{
+		m_Owner.reset();
+	}
+	else
+	{
+		m_Owner = ClientId;
+	}
+}
+
+CCharacter *CIcEntity::GetOwnerCharacter()
+{
+	return m_Owner.has_value() ? GameWorld()->GetCharacterById(m_Owner.value()) : nullptr;
+}
+
+void CIcEntity::Tick()
+{
+	if(m_EndTick.has_value() && (GameWorld()->GameTick() >= m_EndTick))
+	{
+		GameWorld()->DestroyEntity(this);
+		return;
+	}
+
+	m_Pos += m_Velocity;
+}
+
+void CIcEntity::MoveTo(const vec2 &Position)
+{
+	SetPos(Position);
+}
+
+void CIcEntity::SetPos(const vec2 &Position)
+{
+	m_Pos = Position;
+}
+
+float CIcEntity::GetLifespan() const
+{
+	if (!m_EndTick.has_value())
+		return -1;
+
+	int RemainingTicks = m_EndTick.value_or(0) - GameWorld()->GameTick();
+	return RemainingTicks <= 0 ? 0 : RemainingTicks / static_cast<float>(GameWorld()->GameTickSpeed());
+}
+
+void CIcEntity::SetLifespan(float Lifespan)
+{
+	m_EndTick = GameWorld()->GameTick() + GameWorld()->GameTickSpeed() * Lifespan;
+}
+
+void CIcEntity::ResetLifespan()
+{
+	m_EndTick.reset();
+}

src/game/client/prediction/entities/ic_entity.h

@@ -0,0 +1,55 @@
+#ifndef GAME_CLIENT_ENTITIES_IC_ENTITY_H
+#define GAME_CLIENT_ENTITIES_IC_ENTITY_H
+
+#include <game/client/prediction/entity.h>
+
+inline constexpr int TileSize = 32;
+inline constexpr float TileSizeF = 32.0f;
+inline constexpr vec2 Tile2DSize{TileSizeF, TileSizeF};
+inline constexpr vec2 Tile2DHalfSize{TileSizeF / 2, TileSizeF / 2};
+
+class CIcEntity : public CEntity
+{
+public:
+	CIcEntity(CGameWorld *pGameWorld, int Id, int ObjectType, vec2 Pos = vec2(), std::optional<int> Owner = std::nullopt,
+		int ProximityRadius = 0);
+	
+	using CEntity::GameWorld;
+	const CGameWorld *GameWorld() const { return m_pGameWorld; }
+
+	bool Match(const CIcEntity *pEntity) const;
+	void Read(const CIcEntity &Source);
+
+	int GetSnapData1() const { return m_SnapData1; }
+	void SetSnapData1(int Value) { m_SnapData1 = Value; }
+
+	void SetStartTick(int Tick);
+	void SetEndTick(int Tick);
+
+	bool HasOwner() const { return m_Owner.has_value(); }
+	int GetOwner() const { return m_Owner.value_or(-1); }
+	void SetOwner(int ClientId);
+
+	CCharacter *GetOwnerCharacter();
+
+	void Tick() override;
+
+	virtual void MoveTo(const vec2 &Position);
+	void SetPos(const vec2 &Position);
+
+	vec2 GetVelocity() const { return m_Velocity; }
+	void SetVelocity(vec2 Velocity) { m_Velocity = Velocity; }
+
+	float GetLifespan() const;
+	void SetLifespan(float Lifespan);
+	void ResetLifespan();
+	std::optional<int> GetEndTick() const { return m_EndTick; }
+
+protected:
+	std::optional<int> m_Owner;
+	vec2 m_Velocity{};
+	std::optional<int> m_EndTick;
+	int m_SnapData1{};
+};
+
+#endif // GAME_CLIENT_ENTITIES_IC_ENTITY_H

src/game/client/prediction/entities/ic_placed_object.cpp

@@ -0,0 +1,59 @@
+#include "ic_placed_object.h"
+
+EIcObjectType GetIcObjectTypeFromInt(int Value)
+{
+	if (Value < 0 || Value > static_cast<int>(EIcObjectType::TURRET))
+		return EIcObjectType::CUSTOM;
+	
+	return static_cast<EIcObjectType>(Value);
+}
+
+CIcPlacedObject::CIcPlacedObject(CGameWorld *pGameWorld, int Id, EIcObjectType ObjectType, vec2 Pos, int Owner, int ProximityRadius) :
+	CIcEntity(pGameWorld, Id, CGameWorld::ENTTYPE_IC_PLACED_OBJECT, Pos, Owner, ProximityRadius),
+	m_IcObjectType(ObjectType)
+{
+}
+
+bool CIcPlacedObject::Match(const CIcPlacedObject *pEntity) const
+{
+	if (!CIcEntity::Match(pEntity))
+		return false;
+	
+	if (m_IcObjectType != pEntity->m_IcObjectType)
+		return false;
+
+	return true;
+}
+
+void CIcPlacedObject::Read(const CIcPlacedObject &Source)
+{
+	CIcEntity::Read(Source);
+	m_Pos2 = Source.m_Pos2;
+	m_InfClassObjectFlags = Source.m_InfClassObjectFlags;
+}
+
+void CIcPlacedObject::MoveTo(const vec2 &Position)
+{
+	if(m_Pos2.has_value())
+	{
+		vec2 Difference = Position - m_Pos;
+		CIcEntity::MoveTo(Position);
+		m_Pos2 = m_Pos2.value() + Difference;
+	}
+}
+
+void CIcPlacedObject::SetSecondPosition(vec2 Position)
+{
+	m_Pos2 = Position;
+	m_InfClassObjectFlags = INFCLASS_OBJECT_FLAG_HAS_SECOND_POSITION;
+}
+
+void CIcPlacedObject::Tick()
+{
+	CIcEntity::Tick();
+
+	if(m_Pos2.has_value())
+	{
+		m_Pos2.value() += m_Velocity;
+	}
+}

src/game/client/prediction/entities/ic_placed_object.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <game/client/prediction/entities/ic_entity.h>
+
+enum class EIcObjectType
+{
+	CUSTOM,
+	LASER_WALL,
+	LOOPER_WALL,
+	SOLDIER_BOMB,
+	SCIENTIST_MINE,
+	BIOLOGIST_MINE,
+	MERCENARY_BOMB,
+	TURRET,
+};
+
+EIcObjectType GetIcObjectTypeFromInt(int value);
+
+class CIcPlacedObject : public CIcEntity
+{
+public:
+	CIcPlacedObject(CGameWorld *pGameWorld, int Id, EIcObjectType ObjectType, vec2 Pos, int Owner, int ProximityRadius);
+
+	bool Match(const CIcPlacedObject *pEntity) const;
+	void Read(const CIcPlacedObject &Source);
+
+	void MoveTo(const vec2 &Position) override;
+
+	bool HasSecondPosition() const { return m_Pos2.has_value(); }
+	vec2 SecondPosition() const { return m_Pos2.value_or(m_Pos); }
+	void SetSecondPosition(vec2 Position);
+
+	EIcObjectType IcObjectType() const { return m_IcObjectType; }
+	void Tick() override;
+
+protected:
+	std::optional<vec2> m_Pos2;
+	EIcObjectType m_IcObjectType{};
+	int m_InfClassObjectFlags = 0;
+};

src/game/client/prediction/entities/laser.cpp

@@ -2,6 +2,8 @@
 /* If you are missing that file, acquire a complete release at teeworlds.com.                */
 #include "laser.h"
 #include "character.h"
+#include "ic_placed_object.h"
+
 #include <game/client/laser_data.h>
 #include <game/collision.h>
 #include <game/generated/protocol.h>

src/game/client/prediction/entity.h

@@ -42,6 +42,8 @@ class CEntity
 	float GetProximityRadius() const { return m_ProximityRadius; }
 	virtual bool CanCollide(int ClientId) { return true; }
 
+	virtual void MarkForDestroy() { m_MarkedForDestroy = true; }
+
 	void Destroy() { delete this; }
 	virtual void PreTick() {}
 	virtual void Tick() {}

src/game/client/prediction/gameworld.cpp

@@ -4,6 +4,7 @@
 #include "gameworld.h"
 #include "entities/character.h"
 #include "entities/dragger.h"
+#include "entities/ic_placed_object.h"
 #include "entities/laser.h"
 #include "entities/pickup.h"
 #include "entities/projectile.h"
@@ -12,6 +13,7 @@
 #include <game/client/laser_data.h>
 #include <game/client/pickup_data.h>
 #include <game/client/projectile_data.h>
+#include <game/generated/protocol.h>
 #include <game/mapbugs.h>
 #include <game/mapitems.h>
 
@@ -124,6 +126,11 @@ void CGameWorld::InsertEntity(CEntity *pEnt, bool Last)
 	}
 }
 
+void CGameWorld::DestroyEntity(CEntity *pEnt)
+{
+	pEnt->MarkForDestroy();
+}
+
 void CGameWorld::RemoveEntity(CEntity *pEnt)
 {
 	// not in the list
@@ -549,7 +556,32 @@ void CGameWorld::NetObjAdd(int ObjId, int ObjType, const void *pObjData, const C
 	}
 	else if(ObjType == NETOBJTYPE_INFCLASSOBJECT)
 	{
+		const CNetObj_InfClassObject *pObject = static_cast<const CNetObj_InfClassObject *>(pObjData);
+		vec2 Pos(pObject->m_X, pObject->m_Y);
+		float Radius = fx2f(pObject->m_ProximityRadius);
+		EIcObjectType IcObjectType = GetIcObjectTypeFromInt(pObject->m_Type);
+
+		CIcPlacedObject NetObject(this, ObjId, IcObjectType, Pos, pObject->m_Owner, Radius);
+		if(pObject->m_Flags & INFCLASS_OBJECT_FLAG_HAS_SECOND_POSITION)
+		{
+			vec2 Pos2(pObject->m_X2, pObject->m_Y2);
+			NetObject.SetSecondPosition(Pos2);
+		}
+		NetObject.SetStartTick(pObject->m_StartTick);
+		NetObject.SetEndTick(pObject->m_EndTick);
+		NetObject.SetSnapData1(pObject->m_Data1);
 
+		CIcPlacedObject *pExisting = static_cast<CIcPlacedObject *>(GetEntity(ObjId, ENTTYPE_IC_PLACED_OBJECT));
+		if (pExisting && pExisting->Match(&NetObject))
+		{
+			pExisting->Keep();
+			pExisting->Read(NetObject);
+		}
+		else
+		{
+			CIcPlacedObject *pEnt = new CIcPlacedObject(NetObject);
+			InsertEntity(pEnt);
+		}
 	}
 }
 
@@ -632,6 +664,8 @@ void CGameWorld::CopyWorld(CGameWorld *pFrom)
 				pCopy = new CCharacter(*((CCharacter *)pEnt));
 			else if(Type == ENTTYPE_PICKUP)
 				pCopy = new CPickup(*((CPickup *)pEnt));
+			else if(Type == ENTTYPE_IC_PLACED_OBJECT)
+				pCopy = new CIcPlacedObject(*((CIcPlacedObject *)pEnt));
 			if(pCopy)
 			{
 				pCopy->m_pParent = pEnt;

src/game/client/prediction/gameworld.h

@@ -29,6 +29,7 @@ class CGameWorld
 		ENTTYPE_PICKUP,
 		ENTTYPE_FLAG,
 		ENTTYPE_CHARACTER,
+		ENTTYPE_IC_PLACED_OBJECT,
 		NUM_ENTTYPES
 	};
 
@@ -44,6 +45,15 @@ class CGameWorld
 	CCharacter *IntersectCharacter(vec2 Pos0, vec2 Pos1, float Radius, vec2 &NewPos, const CCharacter *pNotThis = nullptr, int CollideWith = -1, const CCharacter *pThisOnly = nullptr);
 	CEntity *IntersectEntity(vec2 Pos0, vec2 Pos1, float Radius, int Type, vec2 &NewPos, const CEntity *pNotThis = nullptr, int CollideWith = -1, const CEntity *pThisOnly = nullptr);
 	void InsertEntity(CEntity *pEntity, bool Last = false);
+
+	/*
+		Function: destroy_entity
+			Destroys an entity in the world.
+
+		 Arguments:
+			 entity - Entity to destroy
+	 */
+	void DestroyEntity(CEntity *pEntity);
 	void RemoveEntity(CEntity *pEntity);
 	void RemoveCharacter(CCharacter *pChar);
 	void Tick();
@@ -56,8 +66,8 @@ class CGameWorld
 	CCollision *m_pCollision;
 
 	// getter for server variables
-	int GameTick() { return m_GameTick; }
-	int GameTickSpeed() { return SERVER_TICK_SPEED; }
+	int GameTick() const { return m_GameTick; }
+	int GameTickSpeed() const { return SERVER_TICK_SPEED; }
 	CCollision *Collision() { return m_pCollision; }
 	CTeamsCore *Teams() { return &m_Teams; }
 	std::vector<SSwitchers> &Switchers() { return m_Core.m_vSwitchers; }