Renderproblem behoben, Input verarbeitung, Positionsupdate

Capter1/ax_funktions.hpp

@@ -0,0 +1,60 @@
+//Funktionsdeklaration ax_funktions.hpp
+
+
+#pragma once
+#include <iostream>
+
+namespace ax{
+    void print_number(int x)
+    {
+        std::cout << "Die Zahl ist: " << x << std::endl;
+        std::cout << "Das doppelte der Zahl ist: " << x*2 << std::endl;
+    }
+
+    void print_char(char x)
+    {
+        std::cout << x;
+    }
+
+
+
+    int sqrt(int x){
+        return x*x;
+    }
+
+    char shift(char x){
+        return x-1;
+    }
+
+    //allgmeine Funktion Deklaration ohne Argumente oder returns für einen unbekannten Datentyp
+    template<typename T> std::string type_name();
+
+    //Spezialisierte Implementation von type_name() für einen entsprechenden Datentyp vgl. mit überladung
+    template<> std::string type_name<int>() {return "Integer";}
+    template<> std::string type_name<char>(){return "Char";}
+    template<> std::string type_name<float>(){return "Float";}
+    template<> std::string type_name<double>(){return "Double";}
+    template<> std::string type_name<bool>(){return "Bool";}
+
+
+
+
+    template<typename T>
+    void ausgebene(T a){
+        std::cout << a << " ist vom Type " << type_name<T>()<< std::endl ;
+    } 
+
+    //CallByRefference
+
+    int fn_CtUp (int &a){
+        a = ++a;
+    return 1;
+    }
+
+
+    int clamp_int(int v, int lo, int hi) {
+        if (v < lo) return lo;
+        if (v > hi) return hi;
+    return v;
+    }
+}

Capter1/ax_game.cpp

@@ -61,6 +61,16 @@ void ax_game::Input(){
             break;
         }
     }
+
+    //Tastatur auslesen
+    const Uint8 *state = SDL_GetKeyboardState(NULL);
+    if(state[SDL_SCANCODE_ESCAPE]) ax_IsRunning = false;
+    if(state[SDL_SCANCODE_S]) ax_ball_one.vely += 10;
+    if(state[SDL_SCANCODE_W]) ax_ball_one.vely -= 10;
+    if(state[SDL_SCANCODE_D]) ax_ball_one.velx += 10;
+    if(state[SDL_SCANCODE_A]) ax_ball_one.velx -= 10;
+
+
 }
 
 void ax_game::Update(){
@@ -73,13 +83,14 @@ void ax_game::Update(){
     ax_TickCounter = SDL_GetTicks();
 
     // Update Ball
-    ax_ball_one.Update();
+    ax_ball_one.Update(DeltaTime);
 }
 
 void ax_game::Output(){
-    SDL_SetRenderDrawColor(ax_Renderer,0,0,255,255);
-    SDL_RenderClear(ax_Renderer);
+    SDL_SetRenderDrawColor(ax_Renderer,0,0,255,255);  // BG Color
+    SDL_RenderClear(ax_Renderer);   //Puffer leeren
 
+    
     ax_ball_one.Draw(ax_Renderer);
 
     SDL_RenderPresent(ax_Renderer);

Capter1/ball.cpp

@@ -1,13 +1,6 @@
 #include "ball.hpp"
-#include <algorithm>
-#include <ranges>
-#include <iostream>
+#include "ax_funktions.hpp"
 
-inline int clamp_int(int v, int lo, int hi) {
-    if (v < lo) return lo;
-    if (v > hi) return hi;
-    return v;
-}
 
 
 ball::ball()
@@ -18,8 +11,8 @@ ball::ball()
     g_dir = -1;
     b_dir = 1;
 
-    x = 50;
-    y = 50;
+    velx = 200;
+    vely = 200;
 
     rect = {20,20,20,20};
     color = {255,0,0,255};
@@ -30,28 +23,30 @@ ball::~ball()
 }
 
 int ball::GetXPos(){
-    return x;
+    return rect.x;
 }
 
 int ball::GetYPos(){
-    return y;
+    return rect.y;
 }
 
 void ball::Draw(SDL_Renderer* renderer){
+    rect.x;
+    rect.y;
     SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, color.a);
     SDL_RenderFillRect(renderer, &rect);
 }
 
-void ball::Update(){
+void ball::Update(float f_DeltaTime){
     color.r += r_dir;
     color.g += g_dir;
     color.b += b_dir;
 
     //=================ColorCycle======================
     // Clamp values between 1 and 254
-    color.g = clamp_int(color.g, 1, 254);
-    color.b = clamp_int(color.b, 1, 254);
-    color.r = clamp_int(color.r, 1, 254);
+    color.g = ax::clamp_int(color.g, 1, 254);
+    color.b = ax::clamp_int(color.b, 1, 254);
+    color.r = ax::clamp_int(color.r, 1, 254);
 
     // Transition logic
     if (r_dir != 0 && (color.r == 254 || color.r == 1)) {
@@ -71,7 +66,12 @@ void ball::Update(){
     }
 
     //=================Movement======================
-    x+=10.0;
-    y+=10.0;
-
+    //Update Position
+    rect.x +=velx * f_DeltaTime;
+    rect.y +=vely * f_DeltaTime;
+    //Kollisioinstest Fenster 1024x768
+    if(rect.x > (1024 -20) || rect.x < 0) velx *= -0.5;
+    if(rect.y > (768 - 20) || rect.y < 0) vely *= -0.5;
+    //std::cout << velx <<"|"<< vely <<std::endl;
+    
 }

Capter1/ball.hpp

@@ -1,4 +1,5 @@
 #include "SDL2/SDL.h"
+#include <iostream>
 
 class ball
 {
@@ -8,17 +9,16 @@ private:
     int b_dir;
 public:
     SDL_Rect rect;
-    float x;
-    float y;
+    SDL_Color color;
     float velx;
     float vely;
-    SDL_Color color;
+    
 
 public:
     ball();
     ~ball();
     int GetXPos();
     int GetYPos();
-    void Update();
+    void Update(float f_DeltaTime);
     void Draw(SDL_Renderer* renderer);
 };

Capter1/main.cpp

@@ -16,6 +16,7 @@ int main(int argc, char** argv)
 
 	ax_game AXGAME;
 	bool success = AXGAME.Init();
+
 	if(success){
 		AXGAME.RunLoop();
 		std::cout<< i++ << std::endl;