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.
188 lines
6.9 KiB
188 lines
6.9 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
|
|
|
|
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}};
|
|
|
|
}
|
|
|
|
void Minimap::Reset(){
|
|
if(minimap.Sprite()==nullptr)minimap.Create(1,1);
|
|
if(cover.Sprite()==nullptr)cover.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);
|
|
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->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));
|
|
}
|
|
}
|
|
}
|
|
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);
|
|
}
|
|
#pragma endregion
|
|
}
|
|
|
|
void Minimap::Update(){
|
|
|
|
}
|
|
|
|
void Minimap::UpdateChunk(const MapName map,const vi2d chunkPos){
|
|
loadedChunks[map].insert(std::format("{}_{}",chunkPos.x,chunkPos.y));
|
|
|
|
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++){
|
|
if(cover.Sprite()->GetPixel(x,y).a==255||minimap.Sprite()->GetPixel(x,y).a==0)continue; //Already revealed or invisible anyways.
|
|
|
|
vi2d chunk=vi2d{x,y}/"Minimap.Chunk Size"_I;
|
|
if(chunk==chunkPos){
|
|
cover.Sprite()->SetPixel(x,y,minimap.Sprite()->GetPixel(x,y));
|
|
}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.
|
|
|
|
Pixel sourceCol=minimap.Sprite()->GetPixel(x,y);
|
|
sourceCol.a=alpha;
|
|
cover.Sprite()->SetPixel(x,y,sourceCol);
|
|
}
|
|
}
|
|
}
|
|
|
|
cover.Decal()->Update();
|
|
}
|
|
|
|
void Minimap::Draw(){
|
|
if(!game->InBossEncounter())mapCircleHud.DrawRotatedDecal(vf2d{float("Minimap.Minimap HUD Size"_I),float("Minimap.Minimap HUD Size"_I)}/2,cover.Decal(),0.f,game->GetPlayer()->GetPos()/game->GetCurrentMapData().tilewidth,vf2d{0.5f,0.5f});
|
|
}
|
|
|
|
void Minimap::EraseChunkData(){
|
|
loadedChunks.clear();
|
|
}
|
|
|
|
const std::unordered_map<MapName,std::unordered_set<std::string>>&Minimap::GetChunkData(){
|
|
return loadedChunks;
|
|
} |