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.
272 lines
11 KiB
272 lines
11 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
|
|
|
|
#include "AdventuresInLestoria.h"
|
|
#include "DEFINES.h"
|
|
#include "Unlock.h"
|
|
#include "util.h"
|
|
|
|
INCLUDE_game
|
|
INCLUDE_GFX
|
|
|
|
void Minimap::Initialize(){
|
|
std::vector<vf2d>enlargedCircle;
|
|
for(int i=360;i>=0;i-=4){
|
|
float angle=util::degToRad(float(i))-PI/2;
|
|
if(i==360){enlargedCircle.push_back(vf2d{cos(angle),sin(angle)}*"Minimap.Minimap HUD Size"_I/2+"Minimap.Minimap HUD Size"_I/2);}
|
|
enlargedCircle.push_back(vf2d{cos(angle),sin(angle)}*"Minimap.Minimap HUD Size"_I/2+"Minimap.Minimap HUD Size"_I/2);
|
|
}
|
|
mapCircleHud=ViewPort{enlargedCircle,vi2d{game->ScreenWidth()-"Minimap.Minimap HUD Size"_I-4,4}};
|
|
|
|
enlargedCircle.clear();
|
|
for(int i=360;i>=0;i-=4){
|
|
float angle=util::degToRad(float(i))-PI/2;
|
|
if(i==360){enlargedCircle.push_back(vf2d{cos(angle),sin(angle)}*game->ScreenWidth()/3+game->ScreenWidth()/3);}
|
|
enlargedCircle.push_back(vf2d{cos(angle),sin(angle)}*game->ScreenWidth()/3+game->ScreenWidth()/3);
|
|
}
|
|
mapCircleLargeHud=ViewPort{enlargedCircle,vi2d{game->ScreenWidth()/2-game->ScreenWidth()/3,game->ScreenHeight()/2-game->ScreenWidth()/3}};
|
|
|
|
}
|
|
|
|
void Minimap::Reset(){
|
|
if(minimap.Sprite()==nullptr)minimap.Create(1,1);
|
|
if(cover.Sprite()==nullptr)cover.Create(1,1);
|
|
if(coverOutline.Sprite()==nullptr)coverOutline.Create(1,1);
|
|
|
|
Sprite baseMinimap;
|
|
|
|
#pragma region Cleanup minimap and cover images
|
|
minimap.Sprite()->Resize(game->GetCurrentMapData().width,game->GetCurrentMapData().height);
|
|
cover.Sprite()->Resize(game->GetCurrentMapData().width,game->GetCurrentMapData().height);
|
|
coverOutline.Sprite()->Resize(game->GetCurrentMapData().width,game->GetCurrentMapData().height);
|
|
baseMinimap.Resize(game->GetCurrentMapData().width,game->GetCurrentMapData().height);
|
|
game->SetDrawTarget(minimap.Sprite());
|
|
game->SetPixelMode(Pixel::ALPHA);
|
|
game->Clear(BLANK);
|
|
game->SetDrawTarget(&baseMinimap);
|
|
game->Clear(BLANK);
|
|
game->SetDrawTarget(cover.Sprite());
|
|
game->Clear(BLANK);
|
|
game->SetDrawTarget(coverOutline.Sprite());
|
|
game->Clear(BLANK);
|
|
game->SetPixelMode(Pixel::NORMAL);
|
|
//Will update the minimap decal at the end, since we are about to change it anyways.
|
|
cover.Decal()->Update();
|
|
#pragma endregion
|
|
|
|
|
|
for(int x=0;x<game->GetCurrentMapData().width;x++){
|
|
for(int y=0;y<game->GetCurrentMapData().height;y++){
|
|
bool tileFound=false;
|
|
bool collision=false;
|
|
Pixel tileCol;
|
|
for(const LayerTag&layer:game->MAP_DATA[game->GetCurrentLevel()].GetLayers()){
|
|
if(Unlock::IsUnlocked(layer.unlockCondition)){
|
|
int tileID=layer.tiles[y][x]-1;
|
|
if(tileID!=-1){
|
|
tileFound=true;
|
|
if(game->GetTileCollision(game->GetCurrentMapName(),vf2d{float(x),float(y)}*game->GetCurrentMapData().tilewidth)!=game->NO_COLLISION){
|
|
baseMinimap.SetPixel({x,y},BLANK);
|
|
collision=true;
|
|
}
|
|
tileCol=game->GetTileColor(game->GetCurrentMapName(),vf2d{float(x),float(y)}*game->GetCurrentMapData().tilewidth);
|
|
}
|
|
}
|
|
}
|
|
if(tileFound&&!collision){
|
|
baseMinimap.SetPixel({x,y},{uint8_t(std::min(255.f,tileCol.r*1.5f)),uint8_t(std::min(255.f,tileCol.g*1.5f)),uint8_t(std::min(255.f,tileCol.b*1.5f))});
|
|
}else
|
|
if(!tileFound){
|
|
baseMinimap.SetPixel({x,y},BLANK);
|
|
}
|
|
}
|
|
}
|
|
|
|
for(int sy=0;sy<baseMinimap.height;sy++){
|
|
for(int sx=0;sx<baseMinimap.width;sx++){
|
|
if(baseMinimap.GetPixel(sx,sy).a>0){
|
|
for(int y=-1;y<=1;y++){
|
|
for(int x=-1;x<=1;x++){
|
|
if(x==0&&y==0)continue;
|
|
minimap.Sprite()->SetPixel(sx+x,sy+y,BLACK);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for(int sy=0;sy<baseMinimap.height;sy++){
|
|
for(int sx=0;sx<baseMinimap.width;sx++){
|
|
if(baseMinimap.GetPixel(sx,sy).a>0){
|
|
minimap.Sprite()->SetPixel(sx,sy,baseMinimap.GetPixel(sx,sy));
|
|
}
|
|
}
|
|
}
|
|
|
|
if(game->GetZones().count("EndZone")){
|
|
for(const ZoneData&zone:game->GetZones().at("EndZone")){
|
|
vf2d ringPos=zone.zone.pos/game->GetCurrentMapData().TileSize;
|
|
vf2d ringSize=zone.zone.size/game->GetCurrentMapData().TileSize;
|
|
vf2d ringCenter=ringPos+ringSize/2;
|
|
for(int y=0;y<=ringSize.y;y++){
|
|
for(int x=0;x<=ringSize.x;x++){
|
|
float ringRadiusX=ringSize.x/2;
|
|
float ringRadiusY=ringSize.y/2;
|
|
float distanceFromCenterX=abs(ringCenter.x-(ringPos.x+x));
|
|
float distanceFromCenterY=abs(ringCenter.y-(ringPos.y+y));
|
|
|
|
if(distanceFromCenterX<ringRadiusX&&distanceFromCenterY<ringRadiusY){
|
|
for(int shadowY=-1;shadowY<=1;shadowY++){
|
|
for(int shadowX=-1;shadowX<=1;shadowX++){
|
|
if(shadowX==0&&shadowY==0)continue;
|
|
if(minimap.Sprite()->GetPixel(ringPos+vi2d{x+shadowX,y+shadowY})!=GREEN){
|
|
minimap.Sprite()->SetPixel(ringPos+vi2d{x+shadowX,y+shadowY},BLACK);
|
|
}
|
|
}
|
|
}
|
|
minimap.Sprite()->SetPixel(ringPos+vi2d{x,y},GREEN);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
game->SetDrawTarget(nullptr);
|
|
|
|
minimap.Decal()->Update();
|
|
|
|
#pragma region Load all minimap chunks already explored
|
|
for(auto&chunk:loadedChunks[game->GetCurrentMapName()]){
|
|
vi2d chunkPos={stoi(chunk.substr(0,chunk.find('_'))),stoi(chunk.substr(chunk.find('_')+1))};
|
|
UpdateChunk(game->GetCurrentMapName(),chunkPos,InitialLoad::YES);
|
|
}
|
|
#pragma endregion
|
|
|
|
revealedChunks.clear();
|
|
}
|
|
|
|
void Minimap::Update(){
|
|
if(game->KEY_TOGGLE_MAP.Pressed()&&MinimapVisible()){
|
|
if(displayMode==MinimapMode::SMALL)displayMode=MinimapMode::LARGE;
|
|
else if(displayMode==MinimapMode::LARGE)displayMode=MinimapMode::OFF;
|
|
else if(displayMode==MinimapMode::OFF)displayMode=MinimapMode::SMALL;
|
|
}
|
|
}
|
|
|
|
void Minimap::UpdateChunk(const MapName map,const vi2d chunkPos,const InitialLoad initialLoad){
|
|
if(game->TestingModeEnabled())return;
|
|
const bool minimapChunkLoadSucceeded{loadedChunks[map].insert(std::format("{}_{}",chunkPos.x,chunkPos.y)).second};
|
|
const bool minimapChunkRevealSucceeded{revealedChunks[map].insert(std::format("{}_{}",chunkPos.x,chunkPos.y)).second};
|
|
if(!minimapChunkLoadSucceeded&&!minimapChunkRevealSucceeded)return;
|
|
|
|
if(game->GetCurrentMapName()!=map)return; //Don't update the minimap when the map name doesn't match the current map.
|
|
|
|
vi2d centerChunkPos=chunkPos*"Minimap.Chunk Size"_I;
|
|
|
|
vi2d pixelPos=centerChunkPos-"Minimap.Chunk Size"_I*2;
|
|
vi2d chunkEndPixelPos=centerChunkPos+"Minimap.Chunk Size"_I*4;
|
|
|
|
//We start twice the distance we are supposed to outwards.
|
|
for(int y=pixelPos.y;y<chunkEndPixelPos.y;y++){
|
|
for(int x=pixelPos.x;x<chunkEndPixelPos.x;x++){
|
|
Pixel sourceCol=minimap.Sprite()->GetPixel(x,y);
|
|
|
|
bool sourceWasBlack=sourceCol==BLACK;
|
|
|
|
if(cover.Sprite()->GetPixel(x,y).a==255||sourceCol.a==0)continue; //Already revealed or invisible anyways.
|
|
|
|
vi2d chunk=vi2d{x,y}/"Minimap.Chunk Size"_I;
|
|
if(chunk==chunkPos){
|
|
if(initialLoad==InitialLoad::YES)sourceCol.a=std::min(sourceCol.a,uint8_t("Minimap.Map Explore Transparency"_I));
|
|
cover.Sprite()->SetPixel(x,y,sourceCol);
|
|
if(sourceWasBlack)coverOutline.Sprite()->SetPixel(x,y,sourceCol);
|
|
}else{
|
|
const vi2d chunkOffset={"Minimap.Chunk Size"_I/2,"Minimap.Chunk Size"_I/2};
|
|
|
|
const float distance=geom2d::line<float>(centerChunkPos+chunkOffset,vf2d{float(x),float(y)}).length();
|
|
const int alpha=std::clamp(util::lerp(255,0,(distance-"Minimap.Chunk Size"_I)/"Minimap.Chunk Size"_I),0.f,255.f);
|
|
|
|
if(cover.Sprite()->GetPixel(x,y).a>alpha)continue; //The distance was uncovered by another closer chunk, don't need to reveal it here.
|
|
|
|
sourceCol.a=alpha;
|
|
if(initialLoad==InitialLoad::YES)sourceCol.a=std::min(sourceCol.a,uint8_t("Minimap.Map Explore Transparency"_I));
|
|
cover.Sprite()->SetPixel(x,y,sourceCol);
|
|
if(sourceWasBlack)coverOutline.Sprite()->SetPixel(x,y,sourceCol);
|
|
}
|
|
}
|
|
}
|
|
|
|
cover.Decal()->Update();
|
|
coverOutline.Decal()->Update();
|
|
}
|
|
|
|
void Minimap::Draw(){
|
|
const vf2d minimapPos=vf2d{float("Minimap.Minimap HUD Size"_I),float("Minimap.Minimap HUD Size"_I)}/2;
|
|
if(MinimapVisible()){
|
|
switch(displayMode){
|
|
case MinimapMode::SMALL:{
|
|
mapCircleHud.DrawRotatedDecal(minimapPos,cover.Decal(),0.f,game->camera.GetPosition()/game->GetCurrentMapData().tilewidth,vf2d{0.5f,0.5f});
|
|
game->DrawRotatedDecal(mapCircleHud.GetOffset()+minimapPos,GFX["skill_overlay_icon.png"].Decal(),0.f,GFX["skill_overlay_icon.png"].Sprite()->Size()/2,vf2d{float("Minimap.Minimap HUD Size"_I),float("Minimap.Minimap HUD Size"_I)}/24.f*1.05f);
|
|
game->DrawRotatedDecal(mapCircleHud.GetOffset()+minimapPos,game->GetPlayer()->GetMinimapImage().Decal(),0.f,vi2d{"Player.Minimap Image Size"_i[0],"Player.Minimap Image Size"_i[1]}/2,{0.5f,0.5f});
|
|
}break;
|
|
case MinimapMode::LARGE:{
|
|
mapCircleLargeHud.DrawRotatedDecal(vf2d{game->ScreenWidth()/3.f,game->ScreenWidth()/3.f},coverOutline.Decal(),0.f,game->camera.GetPosition()/game->GetCurrentMapData().tilewidth,vf2d{2.f,2.f},{255,255,255,48});
|
|
}break;
|
|
case MinimapMode::OFF:{}break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Minimap::EraseChunkData(){
|
|
loadedChunks.clear();
|
|
}
|
|
|
|
const std::unordered_map<MapName,std::unordered_set<std::string>>&Minimap::GetChunkData(){
|
|
return loadedChunks;
|
|
}
|
|
|
|
const MinimapMode&Minimap::GetMinimapMode()const{
|
|
return displayMode;
|
|
}
|
|
|
|
void Minimap::SetMinimapMode(MinimapMode newMode){
|
|
displayMode=newMode;
|
|
}
|
|
|
|
bool Minimap::MinimapVisible(){
|
|
return !game->InBossEncounter();
|
|
} |