giriş kaydol

bugün

#include

simülasyonda bir karakteri mario gibi zıplatmak

basit zannedilen fizik mekaniği, kinematik 101 konusu 2 boyutlu eğik atış hareketinden (projectile motion ) ilham alınarak tasarlanmış:

#include <SFML/Graphics.hpp>
#include <cmath>
#include <vector>
#include <sstream>

const float GRAVITY = 981.0f;
const float JUMP_SPEED = 400.0f;
const float MOVE_SPEED = 300.0f;
const float BOOST_MULTIPLIER = 1.5f;
const float DOUBLE_JUMP_MULTIPLIER = 1.5f; // ikinci zıplama için hız çarpanı
const float FLOOR_Y = 540.0f;
const float WINDOW_WIDTH = 1920.0f;
const float WINDOW_HEIGHT = 1080.0f;

int main()
{
sf::RenderWindow window(sf::VideoMode(WINDOW_WIDTH, WINDOW_HEIGHT), "2D-EGIK ATIS HAREKETI");

// Font yükleme
sf::Font font;
if (!font.loadFromFile("/home/kratertepesi/Masaüstü/Programlar/arial.ttf"))
{
return -1; // Font yüklenemezse programı sonlandır
}

// Başlık metni oluşturma
sf::Text titleText("2D-EGIK ATIS HAREKETI", font, 50); // Font boyutu 50
titleText.setFillColor(sf::Color::White);
titleText.setPosition(WINDOW_WIDTH / 2 - titleText.getGlobalBounds().width / 2, 10); // Ortalanmış başlık

sf::RectangleShape blueSquare(sf::Vector2f(50.0f, 50.0f));
blueSquare.setFillColor(sf::Color::Blue);
blueSquare.setPosition(960, FLOOR_Y);

sf::RectangleShape ground(sf::Vector2f(WINDOW_WIDTH, WINDOW_HEIGHT - (FLOOR_Y + blueSquare.getSize().y)));
ground.setFillColor(sf::Color::Green);
ground.setPosition(0, FLOOR_Y + blueSquare.getSize().y);

sf::RectangleShape sky(sf::Vector2f(WINDOW_WIDTH, FLOOR_Y));
sky.setFillColor(sf::Color(135, 206, 235));

sf::RectangleShape background(sf::Vector2f(WINDOW_WIDTH, blueSquare.getSize().y));
background.setFillColor(sf::Color(135, 206, 235));
background.setPosition(0, FLOOR_Y);

bool jumping = false;
bool onGround = true;
bool doubleJumpReady = false; // ikinci zıplama hazır mı
float xVelocity = 0.0f;
float yVelocity = 0.0f;
float jumpStartY = FLOOR_Y; // Zıplama başlangıç noktası

sf::Clock clock;
std::vector<sf::Vertex> path; // Paraboli çizmek için yol noktaları

sf::Text angleText, forceText;
angleText.setFont(font);
angleText.setCharacterSize(24);
angleText.setFillColor(sf::Color::White);
forceText.setFont(font);
forceText.setCharacterSize(24);
forceText.setFillColor(sf::Color::White);

while (window.isOpen())
{
sf::Event event;
while (window.pollEvent(event))
{
if (event.type == sf::Event::Closed)
window.close();
}

float dt = clock.restart().asSeconds();

// Hareket hızını ve zıplama hızını belirler
float currentMoveSpeed = MOVE_SPEED;
float currentJumpSpeed = JUMP_SPEED;
if (sf::Keyboard::isKeyPressed(sf::Keyboard::Space))
{
currentMoveSpeed *= BOOST_MULTIPLIER;
currentJumpSpeed *= BOOST_MULTIPLIER;
}

// Hareket kontrolleri
if (sf::Keyboard::isKeyPressed(sf::Keyboard::A))
{
xVelocity = -currentMoveSpeed;
}
else if (sf::Keyboard::isKeyPressed(sf::Keyboard::D))
{
xVelocity = currentMoveSpeed;
}
else
{
xVelocity = 0.0f;
}

// Zıplama işlemi
if (sf::Keyboard::isKeyPressed(sf::Keyboard::W) && onGround)
{
jumping = true;
onGround = false;
yVelocity = -currentJumpSpeed;
jumpStartY = blueSquare.getPosition().y; // Zıplama başlangıç yüksekliği ayarlanır
doubleJumpReady = true; // ikinci zıplama yapılabilir
}
else if (sf::Keyboard::isKeyPressed(sf::Keyboard::W) && doubleJumpReady)
{
yVelocity = -currentJumpSpeed * DOUBLE_JUMP_MULTIPLIER;
doubleJumpReady = false; // ikinci zıplama bir kez yapılır
}

// Yer çekimi etkisi
if (!onGround)
{
yVelocity += GRAVITY * dt;
}

blueSquare.move(xVelocity * dt, yVelocity * dt);

// Parabol çizimi için pozisyon ekle
path.push_back(sf::Vertex(blueSquare.getPosition(), sf::Color::Red));

// Açıyı ve kuvveti hesapla
float angle = atan2(-yVelocity, xVelocity) * 180 / 3.14159; // Derece cinsinden açı
float force = sqrt(xVelocity * xVelocity + yVelocity * yVelocity); // Kuvvet büyüklüğü

std::stringstream angleStream, forceStream;
angleStream << "Angle: " << angle << " degrees";
forceStream << "Force: " << force << " N";

angleText.setString(angleStream.str());
forceText.setString(forceStream.str());
angleText.setPosition(10, 10);
forceText.setPosition(10, 40);

if (blueSquare.getPosition().y >= FLOOR_Y)
{
blueSquare.setPosition(blueSquare.getPosition().x, FLOOR_Y);
yVelocity = 0.0f;
onGround = true;
doubleJumpReady = false; // Yere indiğinde ikinci zıplama sıfırlanır
path.clear(); // Parabol çizgisini sıfırla
}

if (blueSquare.getPosition().x < 0)
{
blueSquare.setPosition(0, blueSquare.getPosition().y);
}
else if (blueSquare.getPosition().x + blueSquare.getSize().x > window.getSize().x)
{
blueSquare.setPosition(window.getSize().x - blueSquare.getSize().x, blueSquare.getPosition().y);
}

window.clear();
window.draw(sky);
window.draw(background);
window.draw(ground);

// Parabol çizimi
if (!path.empty())
{
window.draw(&path[0], path.size(), sf::LinesStrip);
}

window.draw(blueSquare);
window.draw(titleText); // Başlık metnini çiz
window.draw(angleText);
window.draw(forceText);
window.display();
}

return 0;
}

ellerim bos gonlum hos
230 gün önce

0 0 ...

brakistokron eğrisi

bu eğrinin çalışma mantığını özetleyen güzel bir program:

#include <SFML/Graphics.hpp> // SFML grafik kütüphanesini ekle
#include <SFML/Window.hpp> // SFML pencere yönetimi için gerekli kütüphane
#include <iostream> // Girdi/çıktı işlemleri için gerekli kütüphane
#include <cmath> // Matematiksel işlemler için gerekli kütüphane
#include <vector> // Dinamik diziler için gerekli kütüphane

const float radius = 5.0f; // Daire çapı, A ve B noktalarını temsil eden dairelerin yarıçapı
const float pixelToCmConversionFactor = 100.0f / 3640.0f; // Pikseli cm'ye çeviren faktör
const float g = 980.0f; // Yerçekimi ivmesi (cm/s^2), düşme hareketinin hesaplanmasında kullanılır
bool drawing = false; // Çizim durumu, kullanıcı çizim yapıyor mu kontrol eder
std::vector<sf::Vector2f> curvePoints; // Eğri noktalarını tutmak için dinamik bir dizi

// Mesafe hesaplama fonksiyonu
float calculateDistance(const sf::Vector2f& A, const sf::Vector2f& B) {
return std::sqrt(std::pow(B.x - A.x, 2) + std::pow(B.y - A.y, 2)); // A ve B arasındaki mesafeyi hesaplar
}

// Brachistochrone eğrisi için süre hesaplama
float calculateBrachistochroneTime(float length) {
return sqrt(2 * length / g); // Düşme süresini hesaplamak için kullanılan formül
}

int main() {
// Pencere oluştur
sf::RenderWindow window(sf::VideoMode(1920, 1080), "Distance Drawing"); // 1920x1080 boyutunda bir pencere oluştur
window.setFramerateLimit(60); // FPS sınırını 60'a ayarla

// A ve B noktaları
sf::Vector2f A(960, 540); // A noktası, pencerenin ortasında
sf::Vector2f B(960, 460); // B noktası, A noktasının biraz yukarısında

while (window.isOpen()) { // Pencere açık olduğu sürece döngü
sf::Event event; // Olay tanımlaması
while (window.pollEvent(event)) { // Olayları kontrol et
if (event.type == sf::Event::Closed) // Pencere kapandığında
window.close(); // Pencereyi kapat

// Mouse tuşuna basma olayı
if (event.type == sf::Event::MouseButtonPressed) {
if (event.mouseButton.button == sf::Mouse::Left) { // Sol fare tuşuna basıldığında
drawing = true; // Çizim modunu aç
curvePoints.clear(); // Çizimi sıfırla
}
}
// Mouse tuşunu bırakma olayı
if (event.type == sf::Event::MouseButtonReleased) {
if (event.mouseButton.button == sf::Mouse::Left) { // Sol fare tuşu bırakıldığında
drawing = false; // Çizim modunu kapat

// Eğrinin toplam uzunluğunu hesapla
float totalLength = 0.0f; // Toplam uzunluğu başlat
for (size_t i = 1; i < curvePoints.size(); ++i) { // Eğri noktaları arasında döngü
totalLength += calculateDistance(curvePoints[i - 1], curvePoints[i]); // Her iki nokta arasındaki mesafeyi topla
}

// Piksel cinsinden uzunluğu cm cinsine çevir
float totalLengthCm = totalLength * pixelToCmConversionFactor; // Pikseli cm'ye çevir

// Brachistochrone süresini hesapla
float timeToReachB = calculateBrachistochroneTime(totalLengthCm); // Süre hesapla

// Sonuçları terminale yazdır
std::cout << "Total Length of Curve: " << totalLengthCm << " cm" << std::endl; // Eğrinin toplam uzunluğunu yazdır
std::cout << "Time to reach B: " << timeToReachB << " seconds" << std::endl; // B noktasına ulaşma süresini yazdır
}
}

// Mouse hareketi
if (event.type == sf::Event::MouseMoved && drawing) { // Fare hareket ettiyse ve çizim modunda ise
sf::Vector2f currentPoint(static_cast<float>(event.mouseMove.x), // Mevcut fare konumunu al
static_cast<float>(event.mouseMove.y));
curvePoints.push_back(currentPoint); // Mevcut konumu eğri noktalarına ekle
}
}

// Ekranı temizle
window.clear(sf::Color::White); // Ekranı beyaz renkle temizle

// A ve B noktalarını çiz
sf::CircleShape circleA(radius); // A noktası için daire oluştur
circleA.setFillColor(sf::Color::Black); // Dairenin rengini siyah yap
circleA.setPosition(A.x - radius, A.y - radius); // Dairenin konumunu ayarla
window.draw(circleA); // Daireyi çiz

sf::CircleShape circleB(radius); // B noktası için daire oluştur
circleB.setFillColor(sf::Color::Black); // Dairenin rengini siyah yap
circleB.setPosition(B.x - radius, B.y - radius); // Dairenin konumunu ayarla
window.draw(circleB); // Daireyi çiz

// Eğriyi çiz
if (curvePoints.size() > 1) { // Eğri noktaları 2'den fazlaysa
sf::VertexArray line(sf::PrimitiveType::LineStrip, curvePoints.size()); // Eğriyi çizmek için vertex dizisi oluştur
for (size_t i = 0; i < curvePoints.size(); ++i) { // Eğri noktaları arasında döngü
line[i].position = curvePoints[i]; // Her noktanın konumunu ayarla
line[i].color = sf::Color::Black; // Rengi siyah yap
}
window.draw(line); // Eğriyi çiz
}

window.display(); // Çizimi güncelle
}

return 0; // Programı sona erdir
}

ellerim bos gonlum hos
230 gün önce

0 0 ...

üç boyutlu uzay ve kütleçekimle etkileşen küreler

yaşadığımız dünyanın simülasyon olup olmadığını sorgulatan karelere evsahipliği yapar.

#include <GL/glut.h>
#include <glm/glm.hpp>
#include <cmath>
#include <vector>
#include <cstdlib>
#include <ctime>

using namespace glm;

// Fizik sabitleri
const float G = 6.67430e-11f; // Kütleçekim sabiti
const float dt = 20.51f; // Zaman adımı
const int NUM_SPHERES = 402; // 100 rastgele küre ve 2 başlangıç küresi

// Ekran boyutları
int windowWidth = 1920;
int windowHeight = 1080;

// Küre yapısı
struct Sphere {
vec3 position;
vec3 velocity;
vec3 acceleration;
float mass;
float radius;
float angularVelocity; // Açısal hız
float spin; // Dönme açısı
vec3 color; // Renk
};

// Küre tanımları
std::vector<Sphere> spheres;

// Işık kaynağı
vec3 lightPosition = vec3(0.8f, -0.8f, 0.8f);

// Kütleçekim kuvvetini hesaplayan fonksiyon
vec3 computeGravitationalForce(Sphere& a, Sphere& b) {
vec3 direction = b.position - a.position;
float distance = length(direction);

// Kütleçekim kuvveti, mesafe sıfıra inmemeli
if (distance == 0) return vec3(0.0f);

vec3 force = G * a.mass * b.mass / (distance * distance) * normalize(direction);
return force;
}

// Güncelleme fonksiyonu
void updatePhysics() {
for (size_t i = 0; i < spheres.size(); ++i) {
spheres[i].acceleration = vec3(0.0f); // Her küre için ivmeyi sıfırla
}

// Kütleçekim kuvvetlerini hesapla
for (size_t i = 0; i < spheres.size(); ++i) {
for (size_t j = i + 1; j < spheres.size(); ++j) {
vec3 force = computeGravitationalForce(spheres[i], spheres[j]);
spheres[i].acceleration += force / spheres[i].mass;
spheres[j].acceleration -= force / spheres[j].mass; // Üzerine etki eden kuvvetin zıttı
}
}

// Hız ve konum güncellemeleri
for (Sphere& sphere : spheres) {
sphere.velocity += sphere.acceleration * dt;
sphere.position += sphere.velocity * dt;

// Ekranın dışına çıkma kontrolü
if (sphere.position.x < -1.0f - sphere.radius) {
sphere.position.x = 1.0f + sphere.radius; // Sol dışına çıktıysa sağdan gir
} else if (sphere.position.x > 1.0f + sphere.radius) {
sphere.position.x = -1.0f - sphere.radius; // Sağ dışına çıktıysa soldan gir
}

if (sphere.position.y < -1.0f - sphere.radius) {
sphere.position.y = 1.0f + sphere.radius; // Alt dışına çıktıysa üstten gir
} else if (sphere.position.y > 1.0f + sphere.radius) {
sphere.position.y = -1.0f - sphere.radius; // Üst dışına çıktıysa alttan gir
}

// Açısal dönüşü güncelle
sphere.spin += sphere.angularVelocity * dt;
}
}

// Aydınlatmayı ayarla
void setupLighting() {
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);

GLfloat lightPos[] = {lightPosition.x, lightPosition.y, lightPosition.z, 1.0f};
GLfloat lightColor[] = {1.0f, 1.0f, 0.8f, 1.0f}; // Sarımsı ışık
glLightfv(GL_LIGHT0, GL_POSITION, lightPos);
glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor);
}

// Küreleri çizen fonksiyon
void drawSphere(const Sphere& sphere) {
glPushMatrix();
glTranslatef(sphere.position.x, sphere.position.y, sphere.position.z);
glRotatef(sphere.spin * (180.0f / M_PI), 0.0f, 0.0f, 1.0f); // Z ekseni etrafında döndür

// Renk ataması
GLfloat color[] = {sphere.color.r, sphere.color.g, sphere.color.b, 1.0f};
glMaterialfv(GL_FRONT, GL_DIFFUSE, color);

glutSolidSphere(sphere.radius, 50, 50);
glPopMatrix();
}

// Çizim fonksiyonu
void display() {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
setupLighting();

// Küreleri çiz
for (const Sphere& sphere : spheres) {
drawSphere(sphere);
}

glutSwapBuffers();
}

// Ana döngü
void idle() {
updatePhysics();
glutPostRedisplay();
}

// Rastgele bir renk oluşturma fonksiyonu
vec3 randomColor() {
return vec3(static_cast<float>(rand()) / RAND_MAX, // Renk bileşeni 0.0 ile 1.0 arasında
static_cast<float>(rand()) / RAND_MAX,
static_cast<float>(rand()) / RAND_MAX);
}

// Başlangıç ayarları
void init() {
glEnable(GL_DEPTH_TEST);
glClearColor(0.1f, 0.1f, 0.1f, 1.0f);

// Rastgele küreleri oluştur
std::srand(static_cast<unsigned int>(std::time(0))); // Rastgele sayı üreteci için başlangıç
for (int i = 0; i < NUM_SPHERES; ++i) {
float radius = static_cast<float>(rand() % 5 + 1) * 0.01f; // Küre yarıçapı 0.001 ile 0.08 arasında
float mass = radius * 10.0f; // Kütle, yarıçap ile orantılı
vec3 position = vec3(static_cast<float>(rand()) / RAND_MAX * 2.0f - 1.0f, // -1 ile 1 arasında rastgele pozisyon
static_cast<float>(rand()) / RAND_MAX * 2.0f - 1.0f,
0.0f);
vec3 velocity = vec3(static_cast<float>(rand()) / RAND_MAX * 0.02f - 0.01f, // -0.01 ile 0.01 arasında rastgele hız
static_cast<float>(rand()) / RAND_MAX * 0.02f - 0.01f,
0.0f);
float angularVelocity = static_cast<float>(rand()) / RAND_MAX * 2.0f - 1.0f; // Rastgele açısal hız

// Rastgele renk atama
vec3 color = randomColor();

spheres.push_back({position, velocity, vec3(0.0f), mass, radius, angularVelocity, 0.0f, color});
}

// ilk iki küreyi başlangıçta ekleyin
spheres.insert(spheres.begin(), {
{vec3(-0.5f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f), 5.0f, 0.1f, 1.0f, 0.0f, vec3(1.0f, 0.0f, 0.0f)}, // Kırmızı
{vec3(0.5f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f), 5.0f, 0.1f, -1.0f, 0.0f, vec3(0.0f, 0.0f, 1.0f)} // Mavi
});
}

// Program başlangıcı
int main(int argc, char** argv) {
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(windowWidth, windowHeight);
glutCreateWindow("Kütleçekim Simülasyonu");

init();
glutDisplayFunc(display);
glutIdleFunc(idle);
glutMainLoop();

return 0;
}

ellerim bos gonlum hos
230 gün önce

2 0 ...

basit kurallardan doğan karmaşıklık

#include <GLFW/glfw3.h> // GLFW kütüphanesini içe aktarır; pencere oluşturma ve OpenGL ile çizim için kullanılır.
#include <vector> // Dinamik diziler ve iki boyutlu vektör yapısı için vektör kütüphanesi.
#include <ctime> // Rastgele sayı üreteci için zaman kütüphanesi.
#include <cstdlib> // Rastgele sayı üreteci için C standardında kütüphane.

const int WIDTH = 1920; // Pencere genişliği piksel cinsinden
const int HEIGHT = 1080; // Pencere yüksekliği piksel cinsinden
const int CELL_SIZE = 4; // Her bir hücrenin genişliği ve yüksekliği piksel cinsinden
const int GRID_WIDTH = WIDTH / CELL_SIZE; // Hücre matrisinin yatayda hücre sayısı
const int GRID_HEIGHT = HEIGHT / CELL_SIZE; // Hücre matrisinin dikeyde hücre sayısı

// Hücrelerin durumunu tutan iki boyutlu matris; 2: genişleyen hücre, 1: hücre dolu, 0: hücre boş
std::vector<std::vector<int>> grid(GRID_HEIGHT, std::vector<int>(GRID_WIDTH, 0));
// Bir sonraki durumları tutmak için yedek matris
std::vector<std::vector<int>> nextGrid(GRID_HEIGHT, std::vector<int>(GRID_WIDTH, 0));

void initializeGrid() {
srand(static_cast<unsigned>(time(0))); // Rastgele başlangıç için tohum oluşturur.
for (int y = 0; y < GRID_HEIGHT; ++y) { // Her hücre için
for (int x = 0; x < GRID_WIDTH; ++x) {
grid[y][x] = rand() % 2; // Hücreyi rastgele olarak dolu (1) veya boş (0) yapar.
}
}
}

int countNeighbors(int y, int x) {
int count = 0; // Komşu hücre sayacını sıfırla.
for (int dy = -1; dy <= 1; ++dy) { // -1, 0, 1: komşu hücreler için dikey kayma
for (int dx = -1; dx <= 1; ++dx) { // -1, 0, 1: komşu hücreler için yatay kayma
if (dy == 0 && dx == 0) continue; // Kendisi değil, sadece komşuları kontrol et.
int ny = (y + dy + GRID_HEIGHT) % GRID_HEIGHT; // Dikeyde çevrilebilir koordinat
int nx = (x + dx + GRID_WIDTH) % GRID_WIDTH; // Yatayda çevrilebilir koordinat
count += grid[ny][nx]; // Eğer komşu hücre dolu ise sayacı artır.
}
}
return count; // Bulunan komşu hücrelerin toplam sayısını döndür.
}

void updateGrid() {
for (int y = 0; y < GRID_HEIGHT; ++y) { // Her hücreyi güncelle
for (int x = 0; x < GRID_WIDTH; ++x) {
int neighbors = countNeighbors(y, x); // Mevcut hücrenin komşu sayısını al
if (grid[y][x] == 1) { // Hücre dolu ise
nextGrid[y][x] = (neighbors == 2 || neighbors == 3) ? 1 : 0; // 2 veya 3 komşu ile hayatta kalır.
} else if (grid[y][x] == 2) { // Genişleyen hücre durumu
nextGrid[y][x] = (neighbors >= 1) ? 2 : 0; // Komşuları varsa genişlemeye devam et.
} else { // Hücre boş ise
nextGrid[y][x] = (neighbors == 3) ? 1 : 0; // Boş hücre, 3 komşu varsa doğar.
}
}
}
grid.swap(nextGrid); // Eski durumu yeni durumla değiştir.
}

void drawGrid() {
glClear(GL_COLOR_BUFFER_BIT); // Ekranı temizler.

// Hücreleri çizer.
for (int y = 0; y < GRID_HEIGHT; ++y) {
for (int x = 0; x < GRID_WIDTH; ++x) {
if (grid[y][x] == 1) { // Hücre dolu ise
glColor3f(0.0f, 1.0f, 0.0f); // Yeşil rengi ayarla.
} else if (grid[y][x] == 2) { // Genişleyen hücre ise
glColor3f(0.0f, 1.0f, 0.5f); // Yeşil tonunda bir renk
} else {
glColor3f(0.0f, 0.0f, 0.0f); // Boş hücreler için siyah arka plan
}
glBegin(GL_QUADS); // Her hücreyi kare olarak çiz.
glVertex2f(x * CELL_SIZE, y * CELL_SIZE);
glVertex2f((x + 1) * CELL_SIZE - 1, y * CELL_SIZE);
glVertex2f((x + 1) * CELL_SIZE - 1, (y + 1) * CELL_SIZE - 1);
glVertex2f(x * CELL_SIZE, (y + 1) * CELL_SIZE - 1);
glEnd();
}
}

// Izgara çizgilerini çizer.
glColor3f(1.0f, 0.0f, 0.0f); // Izgara için kırmızı çizgi
glLineWidth(1.0f);
glBegin(GL_LINES);
for (int x = 0; x <= WIDTH; x += CELL_SIZE) {
glVertex2f(x, 0); glVertex2f(x, HEIGHT); // Dikey çizgiler
}
for (int y = 0; y <= HEIGHT; y += CELL_SIZE) {
glVertex2f(0, y); glVertex2f(WIDTH, y); // Yatay çizgiler
}
glEnd();
}

int main() {
if (!glfwInit()) { // GLFW başlat.
return -1;
}

GLFWwindow* window = glfwCreateWindow(WIDTH, HEIGHT, "Game of Life", NULL, NULL); // Pencereyi oluştur.
if (!window) {
glfwTerminate(); // Oluşturulmazsa çık.
return -1;
}

glfwMakeContextCurrent(window); // OpenGL bağlamını bu pencereye uygula.
glOrtho(0, WIDTH, HEIGHT, 0, -1, 1); // Oranları ayarla.

initializeGrid(); // Başlangıç gridini oluştur.

while (!glfwWindowShouldClose(window)) { // Pencere açıkken
drawGrid(); // Çizimi güncelle.
updateGrid(); // Oyun kurallarına göre hücre durumlarını güncelle.

glfwSwapBuffers(window); // Çizimi pencereye uygula.
glfwPollEvents(); // Olayları kontrol et.
}

glfwDestroyWindow(window); // Pencereyi temizle.
glfwTerminate(); // GLFW'yi sonlandır.
return 0;
}

ellerim bos gonlum hos
230 gün önce

0 0 ...

analog saat

görsel

Last time: 22:38:33 (12-hour format)

bu programı yapana kadar birçok hata aldım. önce 12 lik saat dilimleriyle, 24 dilimlik saat dilimlerini 1 e 1 eşleştiren bir fonksiyon yaratmam gerekti. ardından program çalışmasa bile, saat verilerini bir yerden almam gerekiyordu. önce istanbul bazlı lokal saati seçtim, fakat bu internet kopmalarında büyük kafa karışıklığı yaratabileceği için, bilgisayar kapalı olsa bile, tüm bileşenler arasında eşzamanlılığı sağlayan bios saatini referans aldım chrono kütüphanesiyle. her bir saati, 360 derecelik daireyi 12 ye bölüp 30 derecelik açılarla yerleştirdiğimde (12 yi 0 dereceden başlatarak, 0 derece daireyi dikey olarak ortadan ikiye böldüğünüzde sol yarım kürede kalan tepe noktasıdır ) kusursuz bir analog saate kavuşmuş oldum.

1 saat: 1
2 saat: 2
3 saat: 3
4 saat: 4
5 saat: 5
6 saat: 6
7 saat: 7
8 saat: 8
9 saat: 9
10 saat: 10
11 saat: 11
12 saat: 12 (Öğle)
13 saat: 1
14 saat: 2
15 saat: 3
16 saat: 4
17 saat: 5
18 saat: 6
19 saat: 7
20 saat: 8
21 saat: 9
22 saat: 10
23 saat: 11

Son saat: 12:59:24 (12 saat formatında)
#include <SFML/Graphics.hpp> // SFML Grafik kütüphanesini içe aktarır
#include <SFML/System.hpp> // SFML Sistem işlevlerini içe aktarır
#include <iostream> // Giriş/Çıkış akışları için standart kütüphane
#include <cmath> // Matematiksel fonksiyonlar için kütüphane
#include <chrono> // Zaman işlemleri için kütüphane
#include <ctime> // C zaman kütüphanesi

// Saatin elini çizen fonksiyon
void drawClockHand(sf::RenderWindow &window, float angle, float length, sf::Color color) {
sf::RectangleShape hand(sf::Vector2f(length, 5)); // El şekli için bir dikdörtgen oluştur
hand.setFillColor(color); // Elin rengini ayarla
hand.setOrigin(0, 2.5f); // Orijini elin sol tarafına ayarla
hand.setRotation(angle); // Belirtilen açıya döndür
hand.setPosition(400, 300); // Saati merkezi noktaya yerleştir
window.draw(hand); // Eli çiz
}

// Saatin yüzünü çizen fonksiyon
void drawClockFace(sf::RenderWindow &window, sf::Font &font) {
sf::CircleShape clockFace(250); // Saat yüzü için bir daire oluştur
clockFace.setFillColor(sf::Color::Transparent); // Dolu renk olarak saydam ayarla
clockFace.setOutlineThickness(5); // Kenar kalınlığını ayarla
clockFace.setOutlineColor(sf::Color::Black); // Kenar rengini siyah ayarla
clockFace.setPosition(150, 50); // Saat yüzünün konumu
window.draw(clockFace); // Saat yüzünü çiz

// Sayıları ve aralarındaki çizgileri çiz
for (int i = 0; i < 12; ++i) { // 1'den 12'ye kadar döngü
float angle = 90 - (i * 30); // Sayının açısını hesapla
float rad = angle * 3.14f / 180; // Dereceleri radyana dönüştür

// Sayı için konumu hesapla
float x = 400 + 200 * cos(rad); // Açıya göre X konumu
float y = 300 - 200 * sin(rad); // Açıya göre Y konumu

// Sayı metni oluştur
sf::Text number(std::to_string(i == 0 ? 12 : i), font, 24); // 0 için 12 kullan
number.setFillColor(sf::Color::Black); // Metin rengini ayarla
number.setPosition(x - 10, y - 10); // Metni merkezle

window.draw(number); // Sayıyı çiz

// Sayılar arasındaki çizgileri çiz
sf::Vertex line[] = {
sf::Vertex(sf::Vector2f(400, 300)), // Saatin merkezi
sf::Vertex(sf::Vector2f(400 + 220 * cos(rad), 300 - 220 * sin(rad))) // Dış çizgi
};
window.draw(line, 2, sf::Lines); // Çizgiyi çiz
}
}

int main() {
// Pencereyi oluştur
sf::RenderWindow window(sf::VideoMode(800, 600), "Analog Saat"); // 800x600 boyutunda pencere

// Yazı tipini yükle
sf::Font font;
if (!font.loadFromFile("arial.ttf")) { // Yazı tipi dosyasının erişilebilir olduğundan emin ol
std::cerr << "Error loading font!" << std::endl; // Hata mesajı yazdır
return 1; // Yazı tipi yükleme başarısızsa çık
}

// Geçerli sistem zamanını al
auto now = std::chrono::system_clock::now(); // Geçerli zamanı al
std::time_t now_c = std::chrono::system_clock::to_time_t(now); // time_t'ye dönüştür
std::tm *currentTime = std::localtime(&now_c); // Yerel zaman yapısına dönüştür

// Sistem zamanından zaman değişkenlerini başlat
int hour = currentTime->tm_hour; // Saat
int minute = currentTime->tm_min; // Dakika
int second = currentTime->tm_sec; // Saniye

// Saat döngüsünü başlat
while (window.isOpen()) { // Pencere açık olduğu sürece
sf::Event event;
while (window.pollEvent(event)) { // Olayları kontrol et
if (event.type == sf::Event::Closed)
window.close(); // Kapatma olayı olduğunda pencereyi kapat
}

// Zamanı güncelle (saniyeleri artır)
second++; // Saniyeyi bir artır
if (second >= 60) { // Eğer saniye 60 veya daha fazlaysa
second = 0; // Saniyeyi sıfırla
minute++; // Dakikayı bir artır
if (minute >= 60) { // Eğer dakika 60 veya daha fazlaysa
minute = 0; // Dakikayı sıfırla
hour++; // Saati bir artır
if (hour >= 24) { // Eğer saat 24 veya daha fazlaysa
hour = 0; // Saati sıfırla
}
}
}

// Açıları dönüştür
float hourAngle = (hour % 12) * 30 + (minute / 60.0f) * 30; // Her saat 30 derece
float minuteAngle = minute * 6; // Her dakika 6 derece
float secondAngle = second * 6; // Her saniye 6 derece

// Pencereyi temizle
window.clear(sf::Color::White); // Pencere arka planını beyazla temizle

// Saat yüzünü çiz
drawClockFace(window, font); // Saat yüzünü çizme fonksiyonunu çağır

// Saat, dakika ve saniye elini çiz
drawClockHand(window, hourAngle - 90, 100, sf::Color::Black); // Saat eli (90 derece döndür)
drawClockHand(window, minuteAngle - 90, 150, sf::Color::Blue); // Dakika eli (90 derece döndür)
drawClockHand(window, secondAngle - 90, 180, sf::Color::Red); // Saniye eli (90 derece döndür)

// Çizimi güncelle
window.display(); // Çizilen içeriği göster

// Saniye elinin güncellenmesi için bir gecikme ekle
sf::sleep(sf::seconds(1)); // 1 saniye bekle
}

// Uygulama kapatıldığında son zamanı terminale yazdır
std::cout << "Last time: " << (hour == 0 ? 12 : hour) << ":" // Son saati yazdır
<< (minute < 10 ? "0" : "") << minute << ":" // Dakikayı yazdır (10'dan küçükse başına 0 ekle)
<< (second < 10 ? "0" : "") << second << " (12-hour format)" << std::endl; // Saniyeyi yazdır (10'dan küçükse başına 0 ekle)

return 0; // Programı başarıyla kapat
}

ellerim bos gonlum hos
231 gün önce

0 0 ...

çarpışan arabaları programla simüle etmek

zemin için çarpışan objelere farklı sürtünme katsayıları verdim, çünkü birinin malzemesi plastik, diğeri metal olabilir, bu da sürtünme değerlerini etkileyecektir.

dikdörtgenlere farklı ağırlıklar atadım ve zeminle etkileşmelerini sağladım.

ortaya çıkan tablo hayli ilginç oldu.

#include <SFML/Graphics.hpp> // SFML grafik kütüphanesini dahil et
#include <cmath> // Matematik fonksiyonları için gerekli kütüphane
#include <sstream> // String akışları için gerekli kütüphane

// Sabitler
const float GRAVITY = 981.0f; // Yerçekimi ivmesi (N)
const float FLOOR_Y = 540.0f; // Zemin seviyesi (Y-koordinatı)
const float WINDOW_WIDTH = 1920.0f; // Pencere genişliği
const float WINDOW_HEIGHT = 1080.0f; // Pencere yüksekliği

// Ağırlıklar (kg)
const float RECTANGLE1_WEIGHT = 3000.0f; // ilk dikdörtgenin ağırlığı
const float RECTANGLE2_WEIGHT = 50.0f; // ikinci dikdörtgenin ağırlığı

// Sürtünme katsayıları
const float FRICTION_RECTANGLE1 = 0.1f; // ilk dikdörtgenin sürtünme katsayısı
const float FRICTION_RECTANGLE2 = 0.2f; // ikinci dikdörtgenin sürtünme katsayısı

int main()
{
// Pencereyi oluştur
sf::RenderWindow window(sf::VideoMode(WINDOW_WIDTH, WINDOW_HEIGHT), "Dikdörtgen Çarpışması");

// Mavi gökyüzü (dikey olarak tam pencere yüksekliği)
sf::RectangleShape sky(sf::Vector2f(WINDOW_WIDTH, WINDOW_HEIGHT));
sky.setFillColor(sf::Color(135, 206, 250)); // Açık mavi gökyüzü rengi

// Yeşil zemin
sf::RectangleShape floor(sf::Vector2f(WINDOW_WIDTH, WINDOW_HEIGHT - FLOOR_Y));
floor.setFillColor(sf::Color::Green);
floor.setPosition(0, FLOOR_Y); // Zemin seviyesini ayarla

// Mavi dikdörtgenler oluştur
sf::RectangleShape rectangle1(sf::Vector2f(50.0f, 50.0f));
rectangle1.setFillColor(sf::Color::Blue);
rectangle1.setPosition(100, FLOOR_Y); // Başlangıç konumu

sf::RectangleShape rectangle2(sf::Vector2f(50.0f, 50.0f));
rectangle2.setFillColor(sf::Color::Red);
rectangle2.setPosition(500, FLOOR_Y); // Başlangıç konumu

// Hız değişkenleri
float xVelocity1 = 400.0f; // ilk dikdörtgenin yatay hızı
float xVelocity2 = -150.0f; // ikinci dikdörtgenin yatay hızı

sf::Clock clock; // Zamanlayıcı oluştur

while (window.isOpen()) // Pencere açık olduğu sürece
{
sf::Event event;
while (window.pollEvent(event)) // Olayları kontrol et
{
if (event.type == sf::Event::Closed) // Pencere kapatıldıysa
window.close(); // Pencereyi kapat
}

float dt = clock.restart().asSeconds(); // Delta zamanını hesapla

// Sürtünmeyi uygula (dikey hareket için değil, sadece yatay hareket için)
if (rectangle1.getPosition().y == FLOOR_Y) {
xVelocity1 -= FRICTION_RECTANGLE1 * GRAVITY * dt * (xVelocity1 < 0 ? -1 : 1);
}
if (rectangle2.getPosition().y == FLOOR_Y) {
xVelocity2 -= FRICTION_RECTANGLE2 * GRAVITY * dt * (xVelocity2 < 0 ? -1 : 1);
}

// iki dikdörtgenin çarpışma kontrolü
if (rectangle1.getGlobalBounds().intersects(rectangle2.getGlobalBounds())) {
// Çarpışma sonrası momentum hesaplama
float totalWeight = RECTANGLE1_WEIGHT + RECTANGLE2_WEIGHT;
float newVelocity1 = ((RECTANGLE1_WEIGHT - RECTANGLE2_WEIGHT) / totalWeight) * xVelocity1 +
((2 * RECTANGLE2_WEIGHT) / totalWeight) * xVelocity2;
float newVelocity2 = ((2 * RECTANGLE1_WEIGHT) / totalWeight) * xVelocity1 +
((RECTANGLE2_WEIGHT - RECTANGLE1_WEIGHT) / totalWeight) * xVelocity2;

// Hızları güncelle
xVelocity1 = newVelocity1;
xVelocity2 = newVelocity2;

// Çarpışma sonrası konum düzeltme
if (xVelocity1 > 0) {
rectangle1.setPosition(rectangle2.getPosition().x - rectangle1.getSize().x, FLOOR_Y);
} else {
rectangle2.setPosition(rectangle1.getPosition().x + rectangle1.getSize().x, FLOOR_Y);
}
}

// Dikdörtgenlerin konumunu güncelle
rectangle1.move(xVelocity1 * dt, 0); // ilk dikdörtgeni yatay olarak hareket ettir
rectangle2.move(xVelocity2 * dt, 0); // ikinci dikdörtgeni yatay olarak hareket ettir

// Pencereyi temizle ve zemin ile gökyüzünü çiz
window.clear();
window.draw(sky); // Gökyüzünü çiz
window.draw(floor); // Zemini çiz
window.draw(rectangle1); // ilk dikdörtgeni çiz
window.draw(rectangle2); // ikinci dikdörtgeni çiz
window.display(); // Pencereyi güncelle
}

return 0; // Program başarıyla tamamlandı
}

ellerim bos gonlum hos
231 gün önce

0 0 ...

fizik

256.

aşağıdaki programda zeminin kütleçekim değeriyle, mavi küpün ağırlığı, zıplama hızı, yatay hareket hızı, a, d tuşlarının uyguladığı kuvvetle küpün kazanacağı hız dahil tüm fizik değişkenlerini dilediğiniz gibi değiştirebilir ve eğik atış simülasyonunun tadını çıkarabilirsiniz. fizik ödevleri için de kullanılabilir:

#include <SFML/Graphics.hpp> // SFML grafik kütüphanesini dahil et
#include <cmath> // Matematik fonksiyonları için gerekli kütüphane
#include <sstream> // String akışları için gerekli kütüphane

// Sabitler
const float GRAVITY = 681.0f; // Yerçekimi ivmesi (N)
const float JUMP_SPEED = 400.0f; // Atlama hızı (m/s)
const float MOVE_SPEED = 300.0f; // Yatay hareket hızı (m/s)
const float BOOST_MULTIPLIER = 1.5f; // Hız artışı çarpanı
const float DOUBLE_JUMP_MULTIPLIER = 1.5f; // ikili atlama hız çarpanı
const float FLOOR_Y = 540.0f; // Zemin seviyesi (Y-koordinatı)
const float WINDOW_WIDTH = 1920.0f; // Pencere genişliği
const float WINDOW_HEIGHT = 1080.0f; // Pencere yüksekliği
const float AIR_DRAG_COEFFICIENT = 0.1f; // Hava sürüklenme katsayısı (yatay hız üzerinde etkili)

// Mavi kare ağırlığı
const float BLUE_SQUARE_WEIGHT = 50.0f; // Ağırlık (kg)

// Hızlandırma için sabitler
const float ADDITIONAL_SPEED_WHEN_SPACE_PRESSED = 150.0f; // Boşluk tuşuna basıldığında kazanılacak hız
const float ADDITIONAL_SPEED_A = 100.0f; // A tuşuna basıldığında kazanılacak hız
const float ADDITIONAL_SPEED_D = 100.0f; // D tuşuna basıldığında kazanılacak hız

int main()
{
// Pencereyi oluştur
sf::RenderWindow window(sf::VideoMode(WINDOW_WIDTH, WINDOW_HEIGHT), "2D-EGIK ATIS HAREKETI");

// Yazı tipi yükle
sf::Font font;
if (!font.loadFromFile("/home/kratertepesi/Masaüstü/Programlar/arial.ttf")) {
return -1; // Yazı tipi yüklenemezse programı kapat
}

// Başlık metni oluştur
sf::Text titleText("2D-EGIK ATIS HAREKETI", font, 50);
titleText.setFillColor(sf::Color::White); // Başlık rengini beyaz yap
titleText.setPosition(WINDOW_WIDTH / 2 - titleText.getGlobalBounds().width / 2, 10); // Başlık konumunu ayarla

// Mavi kare oluştur
sf::RectangleShape blueSquare(sf::Vector2f(50.0f, 50.0f));
blueSquare.setFillColor(sf::Color::Blue); // Mavi kare rengini mavi yap
blueSquare.setPosition(960, FLOOR_Y); // Mavi karenin başlangıç konumunu ayarla

// Zemin oluştur
sf::RectangleShape ground(sf::Vector2f(WINDOW_WIDTH, WINDOW_HEIGHT - (FLOOR_Y + blueSquare.getSize().y)));
ground.setFillColor(sf::Color::Green); // Zemin rengini yeşil yap
ground.setPosition(0, FLOOR_Y + blueSquare.getSize().y); // Zemin konumunu ayarla

// Gökyüzü oluştur
sf::RectangleShape sky(sf::Vector2f(WINDOW_WIDTH, FLOOR_Y - blueSquare.getSize().y)); // Gökyüzü boyutu, karenin bir kenarı kadar aşağı kaydırıldı
sky.setFillColor(sf::Color(135, 206, 235)); // Gökyüzü rengini ayarla

// Durum değişkenleri
bool jumping = false; // Atlama durumu
bool onGround = true; // Zemin üzerindeyken
bool doubleJumpReady = false; // ikili atlama hazır durumu
float xVelocity = 0.0f; // Yatay hız
float yVelocity = 0.0f; // Dikey hız

sf::Clock clock; // Zamanlayıcı oluştur
sf::Text angleText, forceText; // Açı ve kuvvet metni için değişkenler
angleText.setFont(font); // Yazı tipini ayarla
angleText.setCharacterSize(24); // Yazı boyutunu ayarla
angleText.setFillColor(sf::Color::White); // Yazı rengini beyaz yap
forceText.setFont(font); // Yazı tipini ayarla
forceText.setCharacterSize(24); // Yazı boyutunu ayarla
forceText.setFillColor(sf::Color::White); // Yazı rengini beyaz yap

while (window.isOpen()) // Pencere açık olduğu sürece
{
sf::Event event;
while (window.pollEvent(event)) // Olayları kontrol et
{
if (event.type == sf::Event::Closed) // Pencere kapatıldıysa
window.close(); // Pencereyi kapat
}

float dt = clock.restart().asSeconds(); // Delta zamanını hesapla

float currentMoveSpeed = MOVE_SPEED; // Geçerli hareket hızını ayarla
float currentJumpSpeed = JUMP_SPEED; // Geçerli atlama hızını ayarla
if (sf::Keyboard::isKeyPressed(sf::Keyboard::Space)) // Boşluk tuşuna basılmışsa
{
currentMoveSpeed += ADDITIONAL_SPEED_WHEN_SPACE_PRESSED; // Hız artışını uygula
currentJumpSpeed *= BOOST_MULTIPLIER; // Atlama hızını artır
}

// Yatay hareket kontrolü
if (sf::Keyboard::isKeyPressed(sf::Keyboard::A)) // A tuşuna basılmışsa
{
xVelocity = -currentMoveSpeed - ADDITIONAL_SPEED_A; // Sola hareket et
}
else if (sf::Keyboard::isKeyPressed(sf::Keyboard::D)) // D tuşuna basılmışsa
{
xVelocity = currentMoveSpeed + ADDITIONAL_SPEED_D; // Sağa hareket et
}
else
{
xVelocity = 0.0f; // Hiçbir tuşa basılmıyorsa yatay hızı sıfırla
}

// Hava sürüklenmesini uygula
xVelocity -= AIR_DRAG_COEFFICIENT * xVelocity; // Basit sürüklenme formülü

// Atlama kontrolü
if (sf::Keyboard::isKeyPressed(sf::Keyboard::W) && onGround) // W tuşuna ve yerdeyse
{
jumping = true; // Atlama gerçekleşiyor
onGround = false; // Artık yerden yüksekte
yVelocity = -currentJumpSpeed; // Dikey hız ayarla
doubleJumpReady = true; // ikili atlama hazır
}
else if (sf::Keyboard::isKeyPressed(sf::Keyboard::W) && doubleJumpReady) // W tuşuna basılmışsa ve ikili atlama hazırsa
{
yVelocity = -currentJumpSpeed * DOUBLE_JUMP_MULTIPLIER; // ikili atlama için hızı artır
doubleJumpReady = false; // ikili atlama kullanılmadı
}

if (!onGround) // Eğer yerden yüksekteyse
{
yVelocity += GRAVITY * dt; // Dikey hıza yerçekimini ekle
}

blueSquare.move(xVelocity * dt, yVelocity * dt); // Mavi karenin konumunu güncelle

float angle = atan2(-yVelocity, xVelocity) * 180 / 3.14159; // Açıyı hesapla
float force = (BLUE_SQUARE_WEIGHT * yVelocity); // Ağırlığı hesaba kat

// Açı ve kuvvet metni oluştur
std::stringstream angleStream, forceStream;
angleStream << "Angle: " << angle << " degrees"; // Açı metnini oluştur
forceStream << "Force: " << force << " N"; // Kuvvet metnini oluştur

angleText.setString(angleStream.str()); // Açı metnini ayarla
forceText.setString(forceStream.str()); // Kuvvet metnini ayarla
angleText.setPosition(10, 10); // Açı metninin konumunu ayarla
forceText.setPosition(10, 40); // Kuvvet metninin konumunu ayarla

// Yerde olup olmadığını kontrol et
if (blueSquare.getPosition().y >= FLOOR_Y)
{
blueSquare.setPosition(blueSquare.getPosition().x, FLOOR_Y); // Mavi karenin zemin konumunu ayarla
yVelocity = 0.0f; // Dikey hızı sıfırla
onGround = true; // Yerde olduğunu belirt
doubleJumpReady = false; // ikili atlama hazır değil
}

// Pencereyi temizle ve gökyüzünü, zemin ve mavi kareyi çiz
window.clear();
window.draw(sky); // Gökyüzünü çiz
window.draw(ground); // Zeminini çiz
window.draw(blueSquare); // Mavi kareyi çiz
window.draw(titleText); // Başlık metnini çiz
window.draw(angleText); // Açı metnini çiz
window.draw(forceText); // Kuvvet metnini çiz
window.display(); // Pencereyi güncelle
}

return 0; // Program başarıyla tamamlandı
}

ellerim bos gonlum hos
231 gün önce

0 0 ...

kodlamayı ve ingilizceyi öğreten ai modelleri

matematiği sular seller gibi biliyor kerata, 2 boyutlu eğik atış hareketini ağırlık, hız, açı, boyut verileriyle simüle eden programı bir dk da kağıda döktü.
görsel

https://streamable.com/t8uc6z
#include <SFML/Graphics.hpp>
#include <cmath>
#include <sstream>
#include <iostream>

const float GRAVITY = 981.0f; // Yer çekimi ivmesi (pixel/s^2)
const float FLOOR_Y = 540.0f; // Zemin yüksekliği
const float WINDOW_WIDTH = 1920.0f; // Pencere genişliği
const float WINDOW_HEIGHT = 1080.0f; // Pencere yüksekliği

int main()
{
sf::RenderWindow window(sf::VideoMode(WINDOW_WIDTH, WINDOW_HEIGHT), "Projectile Motion");

sf::Font font;
if (!font.loadFromFile("arial.ttf"))
{
return -1;
}

sf::Text infoText;
infoText.setFont(font);
infoText.setCharacterSize(24);
infoText.setFillColor(sf::Color::White);
infoText.setPosition(10, 10);

// Başlangıç hızı, açı, kütle ve çap
float speed;
float angle;
float mass;
float diameter;

std::cout << "Enter initial speed (pixels/second): ";
std::cin >> speed;
std::cout << "Enter initial angle (degrees): ";
std::cin >> angle;
std::cout << "Enter mass of the ball (kg): ";
std::cin >> mass;
std::cout << "Enter diameter of the ball (pixels): ";
std::cin >> diameter;

// Açıyı radyana çevirme
angle = angle * 3.14159 / 180;

// Topun yarıçapını ayarlama
float radius = diameter / 2.0f;

// Kırmızı topun tanımı
sf::CircleShape redCircle(radius); // Yarıçapı kullan
redCircle.setFillColor(sf::Color::Red);
redCircle.setPosition(100.0f, FLOOR_Y - radius * 2); // Başlangıçta yukarıda

float xVelocity = speed * std::cos(angle); // Yatay hız
float yVelocity = -speed * std::sin(angle); // Dikey hız (negatif çünkü yukarı doğru)

sf::Clock clock;
bool launched = true;

// Zemin ve gökyüzü
sf::RectangleShape ground(sf::Vector2f(WINDOW_WIDTH, WINDOW_HEIGHT - FLOOR_Y));
ground.setFillColor(sf::Color::Green);
ground.setPosition(0, FLOOR_Y);

sf::RectangleShape sky(sf::Vector2f(WINDOW_WIDTH, FLOOR_Y));
sky.setFillColor(sf::Color(135, 206, 235));

while (window.isOpen())
{
sf::Event event;
while (window.pollEvent(event))
{
if (event.type == sf::Event::Closed)
window.close();
}

float dt = clock.restart().asSeconds(); // Zaman adımı

// Eğik atış hareketi
if (launched)
{
// Kütle çekimi kuvvetini hesaplama
float gravityForce = mass * (GRAVITY / 1000.0f); // kg cinsinden yer çekimi kuvveti

// Dikey hızı güncelle
yVelocity += gravityForce * dt; // Dikey hız artar (top yere doğru hareket eder)

// Topun hareket ettirilmesi
redCircle.move(xVelocity * dt, yVelocity * dt);

// Top zemine çarptığında
if (redCircle.getPosition().y >= FLOOR_Y - radius * 2)
{
redCircle.setPosition(redCircle.getPosition().x, FLOOR_Y - radius * 2);
launched = false; // Fırlatma sona erer
}
}

// Hız ve açıyı güncelleme
float speedMagnitude = std::sqrt(xVelocity * xVelocity + yVelocity * yVelocity);

std::stringstream ss;
ss << "Speed: " << speedMagnitude << " px/s\n";
ss << "X Velocity: " << xVelocity << " px/s\n";
ss << "Y Velocity: " << yVelocity << " px/s\n";
ss << "Mass: " << mass << " kg\n";
ss << "Diameter: " << diameter << " px\n";
infoText.setString(ss.str());

// Ekranı güncelleme
window.clear();
window.draw(sky);
window.draw(ground);
window.draw(redCircle);
window.draw(infoText);
window.display();
}

return 0;
}

ellerim bos gonlum hos
233 gün önce

0 1 ...

python

106.

Python diğer dillere nazaran Syntax(en basit tabiri ile yazım şekli) yapısı olarak oldukça basit bir programlama dilidir. Python dili bu özelliği sayesinde oldukça kolay öğrenilen ve frameworkleri ve kütüphaneleri sayesinde oyun, web uygulamaları, veri analizi, mobil uygulama, bilimsel veri analizleri, web otomasyon sistemleri, gündelik kullanıma uygun araçlar, siber güvenlik yazılımları, yapay zeka vs gibi programları kolayca yazma ve kullanma imkanı sunar.
Şimdi dilerseniz Python dilini diğer popüler programlama dilleri ile bir karşılaştıralım…
Değişken Tanımlama:
Değişken nedir öncelikle bunu konuşalım. Değişken; hiç programlama bilgisi olmayanların anlayabileceği şekilde anlatmak gerekir ise program içerisinde kullanacağımız her bir veriyi içerisinde barındıran ve ram bellek üzerinde onları saklayan kodlardır.

Örnek:
isim = “Niczsche”
yer = “Uludağ Sözlük”
yas = “24”
gibi tanımlanabilir.
Şimdi Python ve diğer dillerdeki değişken tanımlamalarını karşılaştıralım.
Java,C,C++,C#:
int a = 24;
Python:
a = 24
Python’da değişken tanımlarken başına herhangi bir veri tipi belirteçi yazmamıza gerek kalmaz. Çünkü Python bunu anlar ve o kodu ona göre yorumlar. Devam edelim.
Ekrana Yazdırma:
Java:
public class EkranaYazdir {
public static void main(String[] args) {
System.out.println(“Hello World”);
}
}
C#:
public class Program
{
public static void Main()
{
Console.WriteLine(“Hello World”);
}
}
C++:
#include <iostream>
#include <string>
int main()
{

std::cout << “Hello World “;
}
C:
#include <stdio.h>
int main()
{
printf(“Hello World”);
return 0;
}
Python:
print(“Hello World”)

Görüldüğü üzere Python dili Syntax yapısı olarak diğer dillerden çok çok farklı. Hele bir de bu yazdırma fonksiyonu içine bir değişken atamak ister isek işte o zaman işler daha çok karışıyor. ilk öğrendiğim dil olan C ile örnek vermek gerekir ise ufak bir basılan harfi söyleyen program yazalım…

C BASILAN HARFi SÖYLEYEN PROGRAM:
#include <stdio.h>
int main()
{

char harf;
printf(“Lütfen bir tuşa basınız… \n”);
scanf(“%c”,&harf);
printf(“Bastığınız harf: %c”,harf);
return 0;
}

PYTHON BASILAN HARFi SÖYLEYEN PROGRAM:
harf = input(“Lütfen bir tuşa basınız… “)
print(“Bastığınız tuş: “+harf)

Aradaki fark bariz değil mi? Ben yazılıma ilk başladığım zamanlarda akıl aldığım bir abim “C dili ile başla çözersen her şeyi çözersin” demişti. Dediğini yaptım, C ile başladım fakat C dili o kadar çok yoran bir dildi ki nerede ise yazılımdan soğuyacaktım. Ardından C++ ve en nihayetinde Java ile noktaladım. Ve hepsinden sonra Python ile tanıştım. Kullanımı oldukça rahat, içerisinde kullanıcıyı yormayan kolaylıklar barındıran bir dildi. Diğer diller gibi parantezler kullanmak yerine blok denilen tab sistemi ile içeri girme koşullarını kullanıyordu. Ona da bir örnek verelim sözü geçmişken…

C#:
using System;

public class Program
{
public static void Main()
{
int a = 10;
if (a<20){
Console.WriteLine(“A 20 sayısından küçüktür…”);
}
}
}
DiĞER DiLLERDE DE C# iLE AYNI ŞEKiLDE TANIMLANIR.

Bir de Python’a bakalım…

PYTHON:
a = 10
if a<20:
print(“A 20 sayısından küçüktür”) #print bir tab içeride ama sözlük buna izin vermiyor siz onu o şekilde düşünün

Gördüğünüz gibi iki nokta sonrasında alta inerek bir tab boşluk bıraktık. IDE yani programları yazmamızı kolaylaştıran yazılım programları diyelim buna (bilmeyenler için daha açıklayıcı olacaktır) kendisi zaten alt tarafa atacaktır.
Netice itibari ile Python öğrenmesi kolay, çok güçlü, geniş kütüphanelere sahip bir yazılım dilidir.

nickzsche
08.12.2019 18:46

4 0 ...

#include

simülasyonda bir karakteri mario gibi zıplatmak

brakistokron eğrisi

üç boyutlu uzay ve kütleçekimle etkileşen küreler

basit kurallardan doğan karmaşıklık

analog saat

çarpışan arabaları programla simüle etmek

fizik

kodlamayı ve ingilizceyi öğreten ai modelleri

python

geceye bir kod bırak

kedi medi

benden 5 tane daha olsa ben kaçıncı olurdum