The open source repository for the action RPG game in development by Sig Productions titled 'Adventures in Lestoria'!
https://forums.lestoria.net
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
126 lines
4.7 KiB
126 lines
4.7 KiB
#pragma region License
|
|
/*
|
|
License (OLC-3)
|
|
~~~~~~~~~~~~~~~
|
|
|
|
Copyright 2024 Joshua Sigona <sigonasr2@gmail.com>
|
|
|
|
Redistribution and use in source and binary forms, with or without modification,
|
|
are permitted provided that the following conditions are met:
|
|
|
|
1. Redistributions or derivations of source code must retain the above copyright
|
|
notice, this list of conditions and the following disclaimer.
|
|
|
|
2. Redistributions or derivative works in binary form must reproduce the above
|
|
copyright notice. This list of conditions and the following disclaimer must be
|
|
reproduced in the documentation and/or other materials provided with the distribution.
|
|
|
|
3. Neither the name of the copyright holder nor the names of its contributors may
|
|
be used to endorse or promote products derived from this software without specific
|
|
prior written permission.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
|
|
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
|
|
SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
|
|
TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
|
|
BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
|
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
SUCH DAMAGE.
|
|
|
|
Portions of this software are copyright © 2024 The FreeType
|
|
Project (www.freetype.org). Please see LICENSE_FT.txt for more information.
|
|
All rights reserved.
|
|
*/
|
|
#pragma endregion
|
|
#pragma once
|
|
#include <stdlib.h>
|
|
#include "olcUTIL_Geometry2D.h"
|
|
#include "olcPGEX_TTF.h"
|
|
#include "Direction.h"
|
|
#include <random>
|
|
|
|
namespace olc::util{
|
|
//Returns 0-range (as a float).
|
|
float random(float range);
|
|
//Returns a random float value min(inclusive) to max(exclusive).
|
|
const float random_range(const float min,const float max);
|
|
//Returns 0-32767 (as an int).
|
|
int random();
|
|
//Returns a normalized vector pointing from posFrom towards posTo.
|
|
vf2d pointTo(vf2d posFrom,vf2d posTo);
|
|
//Returns the angle (in radians) pointing from posFrom towards posTo.
|
|
float angleTo(vf2d posFrom,vf2d posTo);
|
|
float degToRad(float deg);
|
|
float radToDeg(float rad);
|
|
const float dirToAngle(const Direction dir);
|
|
|
|
#pragma region Lerp templates + specializations
|
|
template<class T,class U>
|
|
inline auto lerp(const T val1,const U val2,const float t){
|
|
return decltype(val1+val2)(val1*(1-t)+val2*t);
|
|
}
|
|
|
|
template<>
|
|
inline auto lerp<vf2d,vf2d>(const vf2d val1,const vf2d val2,const float t){
|
|
return val1.lerp(val2,t);
|
|
}
|
|
|
|
template<>
|
|
//NOTE: Also interpolates the alpha!!!
|
|
inline auto lerp<Pixel,Pixel>(const Pixel val1,const Pixel val2,const float t){
|
|
Pixel col{PixelLerp(val1,val2,t)};
|
|
col.a=lerp(val1.a,val2.a,t);
|
|
return col;
|
|
}
|
|
#pragma endregion
|
|
|
|
template<class T,class U>
|
|
inline auto smoothstep(const T val1,const U val2,const float t){
|
|
auto x{decltype(val1+val2)(1-pow(1-t,3))};
|
|
return val1*(1-x)+val2*x;
|
|
}
|
|
|
|
std::string timerStr(float time);
|
|
std::string WrapText(PixelGameEngine*pge,std::string str,int width,bool proportional,vd2d scale);
|
|
std::u32string WrapText(PixelGameEngine*pge,std::u32string str,int width,Font&font,vd2d scale);
|
|
float angle_difference(float angle_1, float angle_2);
|
|
std::string GetHash(std::string file);
|
|
const float distance(const vf2d&point1,const vf2d&point2);
|
|
//Modifies angle argument directly to turn towards said direction. rate is in radians, please multiply by fElapsedTime if you intend to use this per frame.
|
|
void turn_towards_direction(float&angle,float target,float rate);
|
|
std::wstring to_wstring(const std::string&str);
|
|
|
|
template<class..._Args>
|
|
const std::string vformat(const std::string_view str,_Args..._Vals){
|
|
return std::vformat(str,std::make_format_args(_Vals...));
|
|
}
|
|
template<class..._Args>
|
|
const std::wstring wformat(const std::string_view str,_Args..._Vals){
|
|
return util::to_wstring(std::vformat(str,std::make_format_args(_Vals...)));
|
|
}
|
|
|
|
template<class T>
|
|
T map_range(T x, T in_min, T in_max, T out_min, T out_max) {
|
|
return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
|
|
}
|
|
}
|
|
|
|
template<class TL, class TR>
|
|
constexpr auto circ_add(
|
|
const TL& lhs,
|
|
const TR& rhs,
|
|
const decltype(lhs + rhs) rmin = 0,
|
|
const decltype(lhs + rhs) rmax = 360)
|
|
{
|
|
auto c = lhs + rhs;
|
|
auto range = rmax - rmin;
|
|
while (c >= rmax) c -= range;
|
|
while (c < rmin) c += range;
|
|
return c;
|
|
}
|
|
|
|
//Converts unit distances to pixels. (Every 100 units = 24 pixels)
|
|
long double operator""_Pixels(long double unitDist); |