Fortnite Free Redeem codes

Hi guys here is yours demand on Fortnite free code 

The Fortnite game code in C++  
make sure it work on an unreal engine 4 , 5 
you just copy it and paste ! 
the game is in same graphics 

                                                                   C++ 


#include <iostream>
#include <vector>
#include <cmath>
#include <GL/glut.h>
#include <string>
#include <cstdlib>
#include <ctime>

// Constants
const float WORLD_SIZE = 50.0f;
const int NUM_HOUSES = 15;
const int NUM_LOOTS = 100;
const int NUM_ENEMIES = 10;
const float GRAVITY = -9.8f;

// Vector3 structure
struct Vector3 {
    float x, y, z;
    Vector3(float x = 0, float y = 0, float z = 0) : x(x), y(y), z(z) {}
    Vector3 operator+(const Vector3& other) const { return Vector3(x + other.x, y + other.y, z + other.z); }
    Vector3 operator-(const Vector3& other) const { return Vector3(x - other.x, y - other.y, z - other.z); }
    Vector3 operator*(float scalar) const { return Vector3(x * scalar, y * scalar, z * scalar); }
    float Magnitude() const { return std::sqrt(x * x + y * y + z * z); }
    Vector3 Normalize() const {
        float mag = Magnitude();
        return mag > 0 ? *this * (1.0f / mag) : Vector3();
    }
};

// PhysicsObject base class
class PhysicsObject {
public:
    Vector3 position;
    Vector3 velocity;
    Vector3 acceleration;
    float mass;
    bool isGrounded;

    PhysicsObject(Vector3 pos, float m = 1.0f) : position(pos), velocity(0, 0, 0), acceleration(0, 0, 0), mass(m), isGrounded(false) {}

    virtual void ApplyForce(Vector3 force) {
        acceleration = acceleration + force * (1.0f / mass);
    }

    virtual void Update(float deltaTime) {
        velocity = velocity + acceleration * deltaTime;
        position = position + velocity * deltaTime;

        if (position.y <= 0) {
            position.y = 0;
            velocity.y = 0;
            isGrounded = true;
        } else {
            isGrounded = false;
        }

        acceleration = Vector3(0, GRAVITY, 0);
    }
};

// Gun class
class Gun {
public:
    std::string type;
    int ammo;
    float fireRate; // Shots per second
    float damage;

    Gun(std::string t, int a, float fr, float dmg) : type(t), ammo(a), fireRate(fr), damage(dmg) {}
};

// Player class
class Player : public PhysicsObject {
public:
    std::vector<Gun> inventory;
    int currentGunIndex;
    float health;
    float shield;

    Player(Vector3 pos) : PhysicsObject(pos), currentGunIndex(-1), health(100.0f), shield(100.0f) {}

    void Jump() {
        if (isGrounded) {
            velocity.y = 6.0f;
            isGrounded = false;
        }
    }

    void Move(float dx, float dz) {
        velocity.x = dx * 6.0f;
        velocity.z = dz * 6.0f;
    }

    void PickUpGun(const Gun& gun) {
        inventory.push_back(gun);
        if (currentGunIndex == -1) {
            currentGunIndex = 0;
            std::cout << "Equipped: " << gun.type << std::endl;
        }
        std::cout << "Picked up: " << gun.type << " with " << gun.ammo << " ammo\n";
    }

    void SwitchGun(int index) {
        if (index >= 0 && index < inventory.size()) {
            currentGunIndex = index;
            std::cout << "Switched to: " << inventory[currentGunIndex].type << std::endl;
        }
    }

    bool Shoot(Vector3 direction) {
        if (currentGunIndex >= 0 && inventory[currentGunIndex].ammo > 0) {
            inventory[currentGunIndex].ammo--;
            std::cout << "Shot " << inventory[currentGunIndex].type << ", ammo left: " << inventory[currentGunIndex].ammo << "\n";
            return true;
        }
        return false;
    }

    void TakeDamage(float damage) {
        if (shield > 0) {
            shield -= damage;
            if (shield < 0) {
                health += shield;
                shield = 0;
            }
        } else {
            health -= damage;
        }
        if (health <= 0) {
            std::cout << "Player died!\n";
            health = 0;
        }
    }
};

// LootItem class
class LootItem : public PhysicsObject {
public:
    Gun gun;

    LootItem(Vector3 pos, const Gun& g) : PhysicsObject(pos), gun(g) {}
};

// Enemy class
class Enemy : public PhysicsObject {
public:
    float health;
    float moveSpeed;

    Enemy(Vector3 pos) : PhysicsObject(pos), health(50.0f), moveSpeed(3.0f) {}

    void Update(float deltaTime, const Vector3& playerPos) {
        PhysicsObject::Update(deltaTime);
        // Simple AI: move towards player
        Vector3 direction = (playerPos - position).Normalize();
        velocity.x = direction.x * moveSpeed;
        velocity.z = direction.z * moveSpeed;
        // Basic attack simulation
        if ((playerPos - position).Magnitude() < 2.0f) {
            std::cout << "Enemy attacks player!\n";
        }
    }

    void TakeDamage(float damage) {
        health -= damage;
        if (health <= 0) {
            std::cout << "Enemy defeated!\n";
        }
    }
};

// House class with interior
class House {
public:
    Vector3 position;
    float size;
    bool hasDoor;

    House(Vector3 pos, float s = 4.0f) : position(pos), size(s), hasDoor(true) {}

    void Render() {
        // Floor
        glBegin(GL_QUADS);
        glColor3f(0.6f, 0.6f, 0.6f);
        glVertex3f(position.x - size, position.y, position.z - size);
        glVertex3f(position.x - size, position.y, position.z + size);
        glVertex3f(position.x + size, position.y, position.z + size);
        glVertex3f(position.x + size, position.y, position.z - size);
        glEnd();

        // Walls with door gap
        glBegin(GL_QUADS);
        glColor3f(0.8f, 0.6f, 0.4f);
        // Front wall (with door)
        if (!hasDoor) {
            glVertex3f(position.x - size, position.y, position.z - size);
            glVertex3f(position.x + size, position.y, position.z - size);
            glVertex3f(position.x + size, position.y + size * 1.5f, position.z - size);
            glVertex3f(position.x - size, position.y + size * 1.5f, position.z - size);
        } else {
            // Left part of front wall
            glVertex3f(position.x - size, position.y, position.z - size);
            glVertex3f(position.x - size * 0.3f, position.y, position.z - size);
            glVertex3f(position.x - size * 0.3f, position.y + size * 1.5f, position.z - size);
            glVertex3f(position.x - size, position.y + size * 1.5f, position.z - size);
            // Right part of front wall
            glVertex3f(position.x + size * 0.3f, position.y, position.z - size);
            glVertex3f(position.x + size, position.y, position.z - size);
            glVertex3f(position.x + size, position.y + size * 1.5f, position.z - size);
            glVertex3f(position.x + size * 0.3f, position.y + size * 1.5f, position.z - size);
        }
        // Back wall
        glVertex3f(position.x - size, position.y, position.z + size);
        glVertex3f(position.x + size, position.y, position.z + size);
        glVertex3f(position.x + size, position.y + size * 1.5f, position.z + size);
        glVertex3f(position.x - size, position.y + size * 1.5f, position.z + size);
        // Left wall
        glVertex3f(position.x - size, position.y, position.z - size);
        glVertex3f(position.x - size, position.y, position.z + size);
        glVertex3f(position.x - size, position.y + size * 1.5f, position.z + size);
        glVertex3f(position.x - size, position.y + size * 1.5f, position.z - size);
        // Right wall
        glVertex3f(position.x + size, position.y, position.z - size);
        glVertex3f(position.x + size, position.y, position.z + size);
        glVertex3f(position.x + size, position.y + size * 1.5f, position.z + size);
        glVertex3f(position.x + size, position.y + size * 1.5f, position.z - size);
        glEnd();

        // Roof
        glBegin(GL_TRIANGLES);
        glColor3f(0.7f, 0.3f, 0.3f);
        glVertex3f(position.x - size, position.y + size * 1.5f, position.z - size);
        glVertex3f(position.x + size, position.y + size * 1.5f, position.z - size);
        glVertex3f(position.x, position.y + size * 2.0f, position.z);
        glVertex3f(position.x - size, position.y + size * 1.5f, position.z + size);
        glVertex3f(position.x + size, position.y + size * 1.5f, position.z + size);
        glVertex3f(position.x, position.y + size * 2.0f, position.z);
        glEnd();

        // Interior: simple table
        glBegin(GL_QUADS);
        glColor3f(0.5f, 0.3f, 0.2f);
        glVertex3f(position.x - size * 0.5f, position.y + 0.5f, position.z - size * 0.5f);
        glVertex3f(position.x - size * 0.5f, position.y + 0.5f, position.z + size * 0.5f);
        glVertex3f(position.x + size * 0.5f, position.y + 0.5f, position.z + size * 0.5f);
        glVertex3f(position.x + size * 0.5f, position.y + 0.5f, position.z - size * 0.5f);
        glEnd();
    }

    bool IsInside(const Vector3& pos) const {
        return pos.x > position.x - size && pos.x < position.x + size &&
               pos.z > position.z - size && pos.z < position.z + size &&
               pos.y < size * 1.5f;
    }
};

// Global variables
Player player(Vector3(0, 1, 0));
std::vector<PhysicsObject> objects;
std::vector<LootItem> loots;
std::vector<House> houses;
std::vector<Enemy> enemies;
float cameraAngleX = 0.0f;
float cameraAngleY = 0.0f;
Vector3 cameraPos(0, 2, 5);
bool keys[256] = {false};
float lastShotTime = 0.0f;

// Generate world
void GenerateWorld() {
    srand(time(NULL));
    // Houses
    for (int i = 0; i < NUM_HOUSES; ++i) {
        float x = (rand() % int(WORLD_SIZE * 20) - WORLD_SIZE * 10) / 10.0f;
        float z = (rand() % int(WORLD_SIZE * 20) - WORLD_SIZE * 10) / 10.0f;
        houses.emplace_back(Vector3(x, 0, z));
    }

    // Loot (guns)
    std::vector<Gun> gunTypes = {
        Gun("Pistol", 30, 2.0f, 10.0f),
        Gun("Rifle", 60, 5.0f, 15.0f),
        Gun("Shotgun", 8, 1.0f, 25.0f),
        Gun("Sniper", 10, 0.5f, 50.0f)
    };
    for (int i = 0; i < NUM_LOOTS; ++i) {
        float x = (rand() % int(WORLD_SIZE * 20) - WORLD_SIZE * 10) / 10.0f;
        float z = (rand() % int(WORLD_SIZE * 20) - WORLD_SIZE * 10) / 10.0f;
        loots.emplace_back(Vector3(x, 1, z), gunTypes[rand() % gunTypes.size()]);
    }

    // Enemies
    for (int i = 0; i < NUM_ENEMIES; ++i) {
        float x = (rand() % int(WORLD_SIZE * 20) - WORLD_SIZE * 10) / 10.0f;
        float z = (rand() % int(WORLD_SIZE * 20) - WORLD_SIZE * 10) / 10.0f;
        enemies.emplace_back(Vector3(x, 1, z));
    }

    // Static objects (crates)
    for (int i = 0; i < 20; ++i) {
        float x = (rand() % int(WORLD_SIZE * 20) - WORLD_SIZE * 10) / 10.0f;
        float z = (rand() % int(WORLD_SIZE * 20) - WORLD_SIZE * 10) / 10.0f;
        objects.emplace_back(Vector3(x, 1, z));
    }
}

// Check collisions
void CheckCollisions() {
    for (const auto& house : houses) {
        if (house.IsInside(player.position)) {
            // Simple collision: push player out
            Vector3 dir = player.position - house.position;
            dir.y = 0;
            dir = dir.Normalize();
            player.position = house.position + dir * (house.size + 0.5f);
            player.velocity.x = 0;
            player.velocity.z = 0;
        }
    }
}

// Check loot pickup
void CheckLootPickup() {
    for (auto it = loots.begin(); it != loots.end();) {
        Vector3 dist = player.position - it->position;
        if (dist.Magnitude() < 1.0f) {
            player.PickUpGun(it->gun);
            it = loots.erase(it);
        } else {
            ++it;
        }
    }
}

// Check enemy hits
void CheckEnemyHits(const Vector3& shotDir) {
    for (auto& enemy : enemies) {
        if (enemy.health > 0) {
            Vector3 dist = enemy.position - player.position;
            if (dist.Magnitude() < 10.0f && dist.Normalize().Magnitude() > 0) {
                float dot = dist.Normalize().x * shotDir.x + dist.Normalize().z * shotDir.z;
                if (dot > 0.9f) {
                    enemy.TakeDamage(player.inventory[player.currentGunIndex].damage);
                }
            }
        }
    }
}

// Display function
void display() {
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glLoadIdentity();

    // Third-person camera
    Vector3 lookAt = player.position;
    Vector3 cameraOffset = Vector3(
        5 * sin(cameraAngleX) * cos(cameraAngleY),
        2 + 5 * sin(cameraAngleY),
        5 * cos(cameraAngleX) * cos(cameraAngleY)
    );
    cameraPos = player.position + cameraOffset;
    gluLookAt(cameraPos.x, cameraPos.y, cameraPos.z,
              lookAt.x, lookAt.y, lookAt.z,
              0, 1, 0);

    // Player (blue cube)
    glPushMatrix();
    glTranslatef(player.position.x, player.position.y, player.position.z);
    glColor3f(0, 0, 1);
    glutSolidCube(0.5f);
    glPopMatrix();

    // Objects (red cubes)
    for (const auto& obj : objects) {
        glPushMatrix();
        glTranslatef(obj.position.x, obj.position.y, obj.position.z);
        glColor3f(1, 0, 0);
        glutSolidCube(0.5f);
        glPopMatrix();
    }

    // Loot (yellow spheres)
    for (const auto& loot : loots) {
        glPushMatrix();
        glTranslatef(loot.position.x, loot.position.y, loot.position.z);
        glColor3f(1, 1, 0);
        glutSolidSphere(0.3f, 20, 20);
        glPopMatrix();
    }

    // Houses
    for (const auto& house : houses) {
        house.Render();
    }

    // Enemies (purple cubes)
    for (const auto& enemy : enemies) {
        if (enemy.health > 0) {
            glPushMatrix();
            glTranslatef(enemy.position.x, enemy.position.y, enemy.position.z);
            glColor3f(0.5f, 0, 0.5f);
            glutSolidCube(0.5f);
            glPopMatrix();
        }
    }

    // Ground
    glBegin(GL_QUADS);
    glColor3f(0, 1, 0);
    glVertex3f(-WORLD_SIZE, 0, -WORLD_SIZE);
    glVertex3f(-WORLD_SIZE, 0, WORLD_SIZE);
    glVertex3f(WORLD_SIZE, 0, WORLD_SIZE);
    glVertex3f(WORLD_SIZE, 0, -WORLD_SIZE);
    glEnd();

    glutSwapBuffers();
}

// Update function
void update(int value) {
    float deltaTime = 0.016f;
    lastShotTime += deltaTime;

    // Handle movement
    if (keys['w']) player.Move(0, -1);
    if (keys['s']) player.Move(0, 1);
    if (keys['a']) player.Move(-1, 0);
    if (keys['d']) player.Move(1, 0);

    player.Update(deltaTime);
    for (auto& obj : objects) {
        obj.Update(deltaTime);
    }
    for (auto& loot : loots) {
        loot.Update(deltaTime);
    }
    for (auto& enemy : enemies) {
        if (enemy.health > 0) {
            enemy.Update(deltaTime, player.position);
        }
    }

    CheckCollisions();
    CheckLootPickup();

    glutPostRedisplay();
    glutTimerFunc(16, update, 0);
}

// Keyboard down
void keyboardDown(unsigned char key, int x, int y) {
    keys[key] = true;
    if (key == ' ') player.Jump();
    if (key == 'e') player.SwitchGun((player.currentGunIndex + 1) % player.inventory.size());
    if (key == 'f' && player.currentGunIndex >= 0 && lastShotTime > 1.0f / player.inventory[player.currentGunIndex].fireRate) {
        Vector3 direction = (player.position - cameraPos).Normalize();
        if (player.Shoot(direction)) {
            CheckEnemyHits(direction);
            lastShotTime = 0.0f;
        }
    }
    if (key == 27) exit(0);
}

// Keyboard up
void keyboardUp(unsigned char key, int x, int y) {
    keys[key] = false;
}

// Mouse motion
void mouseMotion(int x, int y) {
    static int lastX = -1, lastY = -1;
    if (lastX == -1) {
        lastX = x;
        lastY = y;
    }
    cameraAngleX += (x - lastX) * 0.01f;
    cameraAngleY = std::max(-1.5f, std::min(1.5f, cameraAngleY + (y - lastY) * 0.01f));
    lastX = x;
    lastY = y;
}

// Init
void init() {
    glEnable(GL_DEPTH_TEST);
    glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
    GenerateWorld();
}

// Reshape
void reshape(int w, int h) {
    glViewport(0, 0, w, h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(60, (float)w / h, 0.1, WORLD_SIZE * 2);
    glMatrixMode(GL_MODELVIEW);
}

int main(int argc, char** argv) {
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
    glutInitWindowSize(800, 600);
    glutCreateWindow("Fortnite-Like 3D Game");
    init();
    glutDisplayFunc(display);
    glutReshapeFunc(reshape);
    glutKeyboardFunc(keyboardDown);
    glutKeyboardUpFunc(keyboardUp);
    glutPassiveMotionFunc(mouseMotion);
    glutTimerFunc(0, update, 0);
    glutMainLoop();
    return 0;
}

write in comments if you need more codes about that 

Comments

Post a Comment

Popular Posts