Implement Memory Collection Point animations and units

olcCodeJam2023Entry/Constant.h

@@ -1,6 +1,8 @@
 #pragma once
 #include "olcPixelGameEngine.h"
 
+#define PI 3.14159
+
 class CONSTANT{
 public:
 	static vf2d BAR_SQUARE_SIZE;

olcCodeJam2023Entry/Image.h

@@ -7,6 +7,8 @@ enum Image{
 	OUTLINE,
 	MINIMAP_OUTLINE,
 	VIRUS_IMG1,
-	SELECTION_CIRCLE
+	SELECTION_CIRCLE,
+	MATRIX,
+	MEMORY_COLLECTION_POINT,
 };
 

olcCodeJam2023Entry/Info.txt

@@ -4,8 +4,7 @@ Bit Repair
 Memory Swapper
 Corrupter (Randomly destroys bits)
 
-Pipes
+"Memory Collection Point" Attach collectors to them (Unit attaches to pipe)
-Attach collectors to them
 Memory Structure (Allocators)
 RAM Bank (Creates new Memory Structures) has its own rate of creation based on Procedure amount.
 

olcCodeJam2023Entry/VirusAttack.cpp

@@ -3,6 +3,7 @@
 #define OLC_PGEX_TRANSFORMEDVIEW
 #include "olcUTIL_Geometry2D.h"
 #include "TileManager.h"
+#include "util.h"
 
 #include "VirusAttack.h"
 
@@ -22,10 +23,12 @@ void VirusAttack::InitializeImages(){
 	LoadImage(OUTLINE,"assets/outline.png");
 	LoadImage(VIRUS_IMG1,"assets/unit.png");
 	LoadImage(SELECTION_CIRCLE,"assets/selection_circle.png");
-
+	LoadImage(MEMORY_COLLECTION_POINT,"assets/memory_collection_point.png");
 }
 
 bool VirusAttack::OnUserCreate(){
+	SetPixelMode(Pixel::MASK);
+
 	game.Initialise(GetScreenSize());
 
 	InitializeImages();
@@ -33,6 +36,10 @@ bool VirusAttack::OnUserCreate(){
 	IMAGES[MINIMAP_OUTLINE]=std::make_unique<Renderable>();
 	IMAGES[MINIMAP_OUTLINE]->Create(64,64);
 
+	IMAGES[MATRIX]=std::make_unique<Renderable>();
+	IMAGES[MATRIX]->Create(64,64,false,false);
+	IMAGES[MATRIX]->Sprite()->SetSampleMode(Sprite::PERIODIC);
+
 	units.push_back(std::make_unique<BasicUnit>(vf2d{32,32},*IMAGES[VIRUS_IMG1],true));
 	for(int i=0;i<10;i++){
 		if(rand()%2==0){
@@ -41,6 +48,12 @@ bool VirusAttack::OnUserCreate(){
 			units.push_back(std::make_unique<BasicUnit2>(vf2d{float(rand()%ScreenWidth()),float(rand()%ScreenHeight())},*IMAGES[VIRUS_IMG1],false));
 		}
 	}
+
+	for(int i=0;i<5;i++){
+		collectionPoints.push_back(std::make_unique<CollectionPoint>(this,vf2d{32.f+48*i,32.f},0,*IMAGES[MEMORY_COLLECTION_POINT],MemoryType(i)));
+		collectionPoints.push_back(std::make_unique<CollectionPoint>(this,vf2d{32.f,32.f+48*i},-PI/2,*IMAGES[MEMORY_COLLECTION_POINT],MemoryType(i)));
+	}
+
 	return true;
 }
 
@@ -136,11 +149,7 @@ void VirusAttack::DrawMinimap(){
 	vi2d worldPixelSize=CONSTANT::WORLD_SIZE*CONSTANT::TILE_SIZE;
 	vf2d viewingTilesPct=vf2d{float(ScreenWidth()),float(ScreenHeight())}/CONSTANT::TILE_SIZE/CONSTANT::WORLD_SIZE;
 	SetDrawTarget(IMAGES[MINIMAP_OUTLINE]->Sprite());
-	for(int y=0;y<64;y++){
+	Clear(BLANK);
-		for(int x=0;x<64;x++){
-			Draw(x,y,BLANK);
-		}
-	}
 	DrawRect((game.GetWorldOffset()/worldPixelSize*64),viewingTilesPct*64/game.GetWorldScale());
 	for(auto&u:units){
 		FillRect(u->GetGhostPos()/worldPixelSize*64,vf2d{2,2}*u->GetUnitSize()/24,u->IsFriendly()?GREEN:RED);
@@ -184,7 +193,59 @@ void VirusAttack::HandleMinimapClick(){
 	}
 }
 
+void VirusAttack::UpdateMatrixTexture(float fElapsedTime){
+	if(matrixTimer==0){
+		activeLetters.emplace_back(vf2d{float(rand()%64),float(64)},util::random(-40)-20,matrixLetters[rand()%matrixLetters.size()]);
+		matrixTimer=util::random(0.125);
+	}
+	if(updatePixelsTimer==0){
+		SetDrawTarget(IMAGES[MATRIX]->Sprite());
+		Sprite*img=IMAGES[MATRIX]->Sprite();
+		for(int y=63;y>=0;y--){
+			for(int x=63;x>=0;x--){
+				Pixel col=img->GetPixel(x,y);
+				if(col.r>0){
+					if(x>0){
+						Pixel leftCol=img->GetPixel(x-1,y);
+						if(leftCol.r<col.r){
+							leftCol=PixelLerp(col,leftCol,0.125);
+						}
+						Draw(x-1,y,leftCol);
+					}
+					if(x<img->width-1){
+						Pixel rightCol=img->GetPixel(x+1,y);
+						if(rightCol.r<col.r){
+							rightCol=PixelLerp(col,rightCol,0.125);
+						}
+						Draw(x+1,y,rightCol);
+					}
+					col/=8;
+					Draw(x,y,col);
+				}
+			}
+		}
+		for(int y=0;y<64;y++){
+			Draw({0,y},img->GetPixel(1,y));
+		}
+		SetDrawTarget(nullptr);
+		updatePixelsTimer=0.1;
+	}
+	if(activeLetters.size()>0){
+		SetDrawTarget(IMAGES[MATRIX]->Sprite());
+		for(Letter&letter:activeLetters){
+			letter.pos.y+=letter.spd*fElapsedTime;
+			DrawString(letter.pos,std::string(1,letter.c));
+		}
+		SetDrawTarget(nullptr);
+		IMAGES[MATRIX]->Decal()->Update();
+	}
+	matrixTimer=std::max(0.f,matrixTimer-fElapsedTime);
+	updatePixelsTimer=std::max(0.f,updatePixelsTimer-fElapsedTime);
+	std::erase_if(activeLetters,[](Letter&letter){return letter.pos.y<-32;});
+}
+
 bool VirusAttack::OnUserUpdate(float fElapsedTime){
+	UpdateMatrixTexture(fElapsedTime);
 	HandleDraggingSelection();
 	HandleRightClickMove();
 	HandlePanAndZoom(fElapsedTime);
@@ -223,6 +284,34 @@ bool VirusAttack::OnUserUpdate(float fElapsedTime){
 	for(auto&u:units){
 		u->Draw(game,IMAGES);
 	}
+
+	for(auto&collectionPoint:collectionPoints){
+		collectionPoint->Update(this,*IMAGES[MATRIX]);
+		geom2d::rect<float>cpRect=geom2d::rect<float>({collectionPoint->pos-collectionPoint->img.Sprite()->Size()/2,collectionPoint->img.Sprite()->Size()});
+		geom2d::rect<float>viewRegion=geom2d::rect<float>({game.GetWorldTL(),game.GetWorldVisibleArea()});
+		if(geom2d::overlaps(cpRect,viewRegion)){
+			Pixel col;
+			switch(collectionPoint->type){
+				case HEALTH:{
+					col=CONSTANT::HEALTH_COLOR;
+				}break;
+				case RANGE:{
+					col=CONSTANT::RANGE_COLOR;
+				}break;
+				case ATKSPD:{
+					col=CONSTANT::ATKSPD_COLOR;
+				}break;
+				case MOVESPD:{
+					col=CONSTANT::MOVESPD_COLOR;
+				}break;
+				case PROCEDURE:{
+					col=CONSTANT::PROCEDURE_COLOR;
+				}break;
+			}
+			game.DrawRotatedDecal(collectionPoint->pos,collectionPoint->img.Decal(),collectionPoint->rot,collectionPoint->img.Sprite()->Size()/2,{1,1},col);
+		}
+	}
+
 	for(auto&u:units){
 		u->DrawHud(game,IMAGES);
 	}
@@ -240,9 +329,35 @@ bool VirusAttack::OnUserUpdate(float fElapsedTime){
 
 	DrawMinimap();
 
+	DrawDecal({0,0},IMAGES[MATRIX]->Decal(),{1,1},{128,0,128});
+
 	return true;
 }
 
+VirusAttack::CollectionPoint::CollectionPoint(PixelGameEngine*pge,vf2d pos,float rot,Renderable&collectionPointImg,MemoryType type)
+	:pos(pos),rot(rot),type(type),originalCollectionPointImg(collectionPointImg.Sprite()),randomOffset({util::random(128),util::random(128)}){
+	img.Create(collectionPointImg.Sprite()->width,collectionPointImg.Sprite()->height);
+	pge->SetDrawTarget(img.Sprite());
+	pge->Clear(BLANK);
+	pge->DrawSprite({0,0},collectionPointImg.Sprite());
+	pge->SetDrawTarget(nullptr);
+	img.Decal()->Update();
+}
+
+void VirusAttack::CollectionPoint::Update(PixelGameEngine*pge,Renderable&matrixImg){
+	pge->SetDrawTarget(img.Sprite());
+	for(int y=0;y<img.Sprite()->height;y++){
+		for(int x=0;x<img.Sprite()->width;x++){
+			Pixel col=originalCollectionPointImg->GetPixel(x,y);
+			if(col==WHITE){
+				pge->Draw(x,y,matrixImg.Sprite()->GetPixel(int(x+randomOffset.x),int(y+randomOffset.y)));
+			}
+		}
+	}
+	img.Decal()->Update();
+	pge->SetDrawTarget(nullptr);
+}
+
 int main()
 {
 	VirusAttack app;

olcCodeJam2023Entry/VirusAttack.h

@@ -5,15 +5,38 @@
 #include "Constant.h"
 #include "Image.h"
 
+struct Letter{
+	vf2d pos;
+	float spd;
+	char c;
+};
+
 class VirusAttack : public olc::PixelGameEngine
 {
+	class CollectionPoint{
+	public:
+		vf2d pos;
+		Renderable img;
+		Sprite*originalCollectionPointImg;
+		MemoryType type;
+		vf2d randomOffset;
+		float rot;
+		CollectionPoint(PixelGameEngine*pge,vf2d pos,float rot,Renderable&collectionPointImg,MemoryType type);
+		void Update(PixelGameEngine*pge,Renderable&matrixImg);
+	};
 private:
 	std::vector<std::shared_ptr<Unit>>units;
+	std::vector<std::unique_ptr<CollectionPoint>>collectionPoints;
 
 	std::map<Image,std::unique_ptr<Renderable>>IMAGES;
 
 	TileTransformedView game;
 
+	float matrixTimer=0;
+	float updatePixelsTimer=0;
+	const std::array<char,16>matrixLetters={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F',};
+	std::vector<Letter>activeLetters;
+
 	vf2d startingDragPos=CONSTANT::UNSELECTED;
 	void HandleDraggingSelection();
 	void DrawSelectionRectangle();
@@ -25,6 +48,7 @@ private:
 	void DrawMinimap();
 	void HandleMinimapClick();
 	void InitializeImages();
+	void UpdateMatrixTexture(float fElapsedTime);
 
 public:
 	VirusAttack();

olcCodeJam2023Entry/olcCodeJam2023Entry.vcxproj

@@ -145,12 +145,14 @@
     <ClInclude Include="resource1.h" />
     <ClInclude Include="TileManager.h" />
     <ClInclude Include="Unit.h" />
+    <ClInclude Include="util.h" />
     <ClInclude Include="VirusAttack.h" />
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Constant.cpp" />
     <ClCompile Include="TileManager.cpp" />
     <ClCompile Include="Unit.cpp" />
+    <ClCompile Include="util.cpp" />
     <ClCompile Include="VirusAttack.cpp" />
   </ItemGroup>
   <ItemGroup>

olcCodeJam2023Entry/olcCodeJam2023Entry.vcxproj.filters

@@ -63,6 +63,9 @@
     <ClInclude Include="Image.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="util.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="VirusAttack.cpp">
@@ -77,6 +80,9 @@
     <ClCompile Include="TileManager.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="util.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="olcCodeJam2023Entry.rc">

olcCodeJam2023Entry/util.cpp

@@ -0,0 +1,8 @@
+#include "util.h"
+#include "olcPixelGameEngine.h"
+
+namespace util{
+	float random(float range){
+		return float(rand())/RAND_MAX*range;
+	}
+}

olcCodeJam2023Entry/util.h

@@ -0,0 +1,5 @@
+#pragma once
+
+namespace util{
+	float random(float range);
+}