mirror of
https://github.com/KartKrewDev/RingRacers.git
synced 2025-10-30 08:01:28 +00:00
161 lines
5.2 KiB
C
161 lines
5.2 KiB
C
// SONIC ROBO BLAST 2 KART
|
|
//-----------------------------------------------------------------------------
|
|
// Copyright (C) 2018-2020 by Sean "Sryder" Ryder
|
|
// Copyright (C) 2018-2020 by Kart Krew
|
|
//
|
|
// This program is free software distributed under the
|
|
// terms of the GNU General Public License, version 2.
|
|
// See the 'LICENSE' file for more details.
|
|
//-----------------------------------------------------------------------------
|
|
/// \file k_bheap.h
|
|
/// \brief Binary Heap implementation for SRB2 code base.
|
|
|
|
#ifndef __K_BHEAP__
|
|
#define __K_BHEAP__
|
|
|
|
#include "doomdef.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
typedef void(*updateindexfunc)(void *const, const size_t);
|
|
|
|
struct bheapitem_t
|
|
{
|
|
size_t heapindex; // The index in the heap this item is
|
|
updateindexfunc indexchanged; // A callback function that is called when this item changes index to alert data
|
|
bheap_t *owner; // The heap that owns this item
|
|
void *data; // data for this heap item
|
|
UINT32 value; // The value of this item, the lowest value item is first in the array
|
|
};
|
|
|
|
struct bheap_t
|
|
{
|
|
size_t capacity; // capacity of the heap
|
|
size_t count; // number of items in the heap
|
|
bheapitem_t *array; // pointer to the heap items array
|
|
};
|
|
|
|
|
|
/*--------------------------------------------------
|
|
boolean K_BHeapInit(bheap_t *const heap, size_t initialcapacity)
|
|
|
|
Initialises a binary heap.
|
|
|
|
Input Arguments:-
|
|
heap - The heap to initialise
|
|
initialcapacity - The initial capacity the heap should hold
|
|
|
|
Return:-
|
|
True if the initialisation was successful, false if it wasn't.
|
|
--------------------------------------------------*/
|
|
|
|
boolean K_BHeapInit(bheap_t *const heap, size_t initialcapacity);
|
|
|
|
|
|
/*--------------------------------------------------
|
|
boolean K_BHeapValid(bheap_t *const heap)
|
|
|
|
Checks a binary heap for validity
|
|
|
|
Input Arguments:-
|
|
heap - The heap to validate
|
|
|
|
Return:-
|
|
True if the binary heap is valid, false if it isn't
|
|
--------------------------------------------------*/
|
|
|
|
boolean K_BHeapValid(bheap_t *const heap);
|
|
|
|
|
|
/*--------------------------------------------------
|
|
boolean K_BHeapPush(bheap_t *const heap, void *const item, const UINT32 value, updateindexfunc changeindexcallback)
|
|
|
|
Adds a new item to a binary heap.
|
|
|
|
Input Arguments:-
|
|
heap - The heap to add to.
|
|
item - The item to add to the heap.
|
|
value - The value of this item for the heap, lowest is first in the heap
|
|
changeindexcallback - A callback function that is called when the item's index changes, can be NULL
|
|
|
|
Return:-
|
|
True if the push to the heap was successful, false if it wasn't due to invalid parameters
|
|
--------------------------------------------------*/
|
|
|
|
boolean K_BHeapPush(bheap_t *const heap, void *const item, UINT32 value, updateindexfunc changeindexcallback);
|
|
|
|
|
|
/*--------------------------------------------------
|
|
boolean K_BHeapPop(bheap_t *const heap, bheapitem_t *const returnitemstorage)
|
|
|
|
Pops the first item off of the heap, then orders it back to be correct.
|
|
|
|
Input Arguments:-
|
|
heap - The heap to pop from.
|
|
returnitemstorage - The first item on the Heap is placed in here
|
|
|
|
Return:-
|
|
true if the pop from the heap was successful, false if it wasn't.
|
|
--------------------------------------------------*/
|
|
|
|
boolean K_BHeapPop(bheap_t *const heap, bheapitem_t *const returnitemstorage);
|
|
|
|
|
|
/*--------------------------------------------------
|
|
boolean K_UpdateBHeapItemValue(bheapitem_t *const item, const UINT32 newvalue)
|
|
|
|
Updates the heap item's value, and reorders it in the array appropriately. Only works if the item is in a heap
|
|
validly. If it's a heapitem that is not currently in a heap (ie it's been popped off) just change the value
|
|
manually.
|
|
|
|
Input Arguments:-
|
|
item - The item to update the value of.
|
|
newvalue - The new value the item will hold
|
|
|
|
Return:-
|
|
true if the update was successful, false if it wasn't
|
|
--------------------------------------------------*/
|
|
|
|
boolean K_UpdateBHeapItemValue(bheapitem_t *const item, const UINT32 newvalue);
|
|
|
|
|
|
/*--------------------------------------------------
|
|
size_t K_BHeapContains(bheap_t *const heap, void *const data, size_t index)
|
|
|
|
Checks to see if data is contained in the heap. If index is not SIZE_MAX, then only the index sent in is
|
|
checked. Otherwise every index is checked linearly.
|
|
|
|
Input Arguments:-
|
|
heap - The heap to check the contents of
|
|
data - The data that is being checked for
|
|
index - The index of the heap to check, if SIZE_MAX, check every index
|
|
|
|
Return:-
|
|
The heap index that contains data, SIZE_MAX if it is not in the heap
|
|
--------------------------------------------------*/
|
|
|
|
size_t K_BHeapContains(bheap_t *const heap, void *const data, size_t index);
|
|
|
|
|
|
/*--------------------------------------------------
|
|
boolean K_BHeapFree(bheap_t *const heap)
|
|
|
|
Free the binary heap.
|
|
This does NOT free the data held within the binary heap items. Make sure those can still be freed manually.
|
|
|
|
Input Arguments:-
|
|
heap - The heap to free
|
|
|
|
Return:-
|
|
True if the heap was freed successfully, false if the heap wasn't valid to free
|
|
--------------------------------------------------*/
|
|
|
|
boolean K_BHeapFree(bheap_t *const heap);
|
|
|
|
#ifdef __cplusplus
|
|
} // extern "C"
|
|
#endif
|
|
|
|
#endif
|