Refactor: Make use of make_unique instead of manual unique ptr initialization

Author: HeatXD

GekkoLib/include/input.h

@@ -8,7 +8,6 @@ namespace Gekko {
 	struct GameInput {
 	public:
 		GameInput();
-		~GameInput();
 
 		void Init(GameInput* other);
 

GekkoLib/include/net.h

@@ -124,8 +124,8 @@ namespace Gekko {
         static const u64 SYNC_MSG_DELAY = std::chrono::milliseconds(200).count();
         static const u64 NET_CHECK_DELAY = std::chrono::milliseconds(1000).count();
 
-        Frame last_acked_frame;
-        u64 last_sent_sync_message;
+        Frame last_acked_frame = -1;
+        u64 last_sent_sync_message = 0;
         u64 last_received_message = -1;
         u64 last_received_frame = 0;
 

GekkoLib/src/backend.cpp

@@ -726,7 +726,7 @@ void Gekko::MessageSystem::AddPendingInput(bool spectator)
 	const u32 input_count = (u32)send_list.size();
 	const u32 total_size = total_input_size * input_count;
 
-	std::unique_ptr<u8[]> inputs(new u8[total_size]);
+    auto inputs = std::make_unique<u8[]>(total_size);
 
     const u32 offset_per_player = total_size / num_players;
 

GekkoLib/src/gekko.cpp

@@ -36,7 +36,7 @@ void Gekko::Session::Init(GekkoConfig* config)
     _storage.Init(_config.input_prediction_window, _config.state_size, _config.limited_saving);
 
     // setup disconnected input for disconnected player within the session
-    _disconnected_input = std::unique_ptr<u8[]>(new u8[_config.input_size]);
+    _disconnected_input = std::make_unique<u8[]>(_config.input_size);
     std::memset(_disconnected_input.get(), 0, _config.input_size);
 
     // we only detect desyncs whenever we are not limited saving for now.

GekkoLib/src/input.cpp

@@ -29,7 +29,7 @@ void Gekko::InputBuffer::Init(u8 delay, u8 input_window, u32 input_size)
 	_incorrent_predicted_input = GameInput::NULL_FRAME;
 
 	// init GameInput array
-    _empty_input = std::unique_ptr<u8[]>(new u8[_input_size]);
+    _empty_input = std::make_unique<u8[]>(_input_size);
     std::memset(_empty_input.get(), 0, _input_size);
 
 	for (u32 i = 0; i < BUFF_SIZE; i++) {
@@ -192,7 +192,7 @@ u32 Gekko::InputBuffer::PreviousFrame(Frame frame)
 
 std::unique_ptr<Gekko::GameInput> Gekko::InputBuffer::GetInput(Frame frame, bool prediction)
 {
-	std::unique_ptr<GameInput> inp(new GameInput());
+    auto inp = std::make_unique<GameInput>();
 
 	if (_last_received_input < frame) {
 		// no input? check if we should predict the input
@@ -264,7 +264,3 @@ Gekko::GameInput::GameInput()
 	input_len = 0;
 	input = std::unique_ptr<u8[]>();
 }
-
-Gekko::GameInput::~GameInput()
-{
-}

GekkoLib/src/net.cpp

@@ -12,7 +12,7 @@ u32 Gekko::NetAddress::GetSize()
 Gekko::NetAddress::NetAddress(void* data, u32 size)
 {
     _size = size;
-    _data = std::unique_ptr<u8[]>(new u8[_size]);
+    _data = std::make_unique<u8[]>(_size);
     // copy address data
     std::memcpy(_data.get(), data, _size);
 }
@@ -35,7 +35,7 @@ void Gekko::NetAddress::Copy(NetAddress* other)
         _data.reset();
     }
 
-    _data = std::unique_ptr<u8[]>(new u8[_size]);
+    _data = std::make_unique<u8[]>(_size);
     // copy address data
     std::memcpy(_data.get(), other->GetAddress(), _size);
 }

GekkoLib/src/storage.cpp

@@ -13,7 +13,7 @@ void Gekko::StateStorage::Init(u32 num_states, u32 state_size, bool limited)
 
 	for (u32 i = 0; i < _max_num_states; i++) {
 		_states.push_back(std::make_unique<StateEntry>());
-		_states.back().get()->state = std::unique_ptr<u8[]>(new u8[state_size]);
+        _states.back().get()->state = std::make_unique<u8[]>(state_size);
 		_states.back().get()->state_len = state_size;
 	}
 }

GekkoLib/src/sync.cpp

@@ -18,8 +18,7 @@ void Gekko::SyncSystem::Init(u8 num_players, u32 input_size)
 	_num_players = num_players;
 	_current_frame = GameInput::NULL_FRAME + 1;
 
-	_input_buffers = std::unique_ptr<InputBuffer[]>(new InputBuffer[_num_players]);
-
+    _input_buffers = std::make_unique<InputBuffer[]>(num_players);
 	// on creation setup input buffers
 	for (int i = 0; i < _num_players; i++) {
 		_input_buffers[i].Init(0, 0, input_size);
@@ -53,7 +52,7 @@ void Gekko::SyncSystem::IncrementFrame()
 
 bool Gekko::SyncSystem::GetSpectatorInputs(std::unique_ptr<u8[]>& inputs, Frame frame) 
 {
-	std::unique_ptr<u8[]> all_input(new u8[_input_size * _num_players]);
+    auto all_input = std::make_unique<u8[]>(_input_size * _num_players);
 	for (u8 i = 0; i < _num_players; i++) {
 		auto inp = _input_buffers[i].GetInput(frame, false);
 
@@ -69,7 +68,7 @@ bool Gekko::SyncSystem::GetSpectatorInputs(std::unique_ptr<u8[]>& inputs, Frame
 
 bool Gekko::SyncSystem::GetCurrentInputs(std::unique_ptr<u8[]>& inputs, Frame& frame)
 {
-	std::unique_ptr<u8[]> all_input(new u8[_input_size * _num_players]);
+    auto all_input = std::make_unique<u8[]>(_input_size * _num_players);
 	for (u8 i = 0; i < _num_players; i++) {
 		auto inp = _input_buffers[i].GetInput(_current_frame, true);
 
@@ -87,7 +86,7 @@ bool Gekko::SyncSystem::GetCurrentInputs(std::unique_ptr<u8[]>& inputs, Frame& f
 bool Gekko::SyncSystem::GetLocalInputs(std::vector<Handle>& handles, std::unique_ptr<u8[]>& inputs, Frame frame)
 {	
 	inputs.reset();
-	std::unique_ptr<u8[]> all_input(new u8[_input_size * handles.size()]);
+    auto all_input = std::make_unique<u8[]>(_input_size * handles.size());
 	for (u8 i = 0; i < handles.size(); i++) {
 		auto inp = _input_buffers[handles[i]].GetInput(frame, true);