Simulation of L-Systems Gaming Project in C++

#include <iostream>
#include <string>
#include <unordered_map>
#include <vector>

class LSystem {
public:
    LSystem(const std::string& axiom, const std::unordered_map<char, std::string>& rules)
        : currentString(axiom), productionRules(rules) {}

    void generate(int iterations) {
        for (int i = 0; i < iterations; ++i) {
            std::string nextString;
            for (char ch : currentString) {
                if (productionRules.find(ch) != productionRules.end()) {
                    nextString += productionRules.at(ch);
                } else {
                    nextString += ch;
                }
            }
            currentString = nextString;
        }
    }

    void display() const {
        std::cout << "L-System string: " << currentString << "\n";
    }

private:
    std::string currentString;
    std::unordered_map<char, std::string> productionRules;
};

int main() {
    // Define the axiom and production rules for the L-System
    std::string axiom = "F";
    std::unordered_map<char, std::string> rules = {
        {'F', "F+F-F-F+F"}
    };

    // Create an LSystem object
    LSystem lSystem(axiom, rules);

    // Generate the L-System string for a number of iterations
    int iterations = 4;
    lSystem.generate(iterations);

    // Display the generated L-System string
    lSystem.display();

    return 0;
}

#include <iostream>

#include <string>

#include <unordered_map>

#include <vector>

class LSystem {

public:

LSystem(const std::string& axiom, const std::unordered_map<char, std::string>& rules)

: currentString(axiom), productionRules(rules) {}

void generate(int iterations) {

for (int i = 0; i < iterations; ++i) {

std::string nextString;

for (char ch : currentString) {

if (productionRules.find(ch) != productionRules.end()) {

nextString += productionRules.at(ch);

} else {

nextString += ch;

}

currentString = nextString;

}

void display() const {

std::cout << "L-System string: " << currentString << "\n";

}

private:

std::string currentString;

std::unordered_map<char, std::string> productionRules;

};

int main() {

// Define the axiom and production rules for the L-System

std::string axiom = "F";

std::unordered_map<char, std::string> rules = {

{'F', "F+F-F-F+F"}

};

// Create an LSystem object

LSystem lSystem(axiom, rules);

// Generate the L-System string for a number of iterations

int iterations = 4;

lSystem.generate(iterations);

// Display the generated L-System string

lSystem.display();

return 0;

}

Explanation

LSystem Class:
- Attributes:
  - currentString: Holds the current state of the L-System string.
  - productionRules: A map of production rules where each character maps to its replacement string.
- Methods:
  - LSystem(const std::string& axiom, const std::unordered_map<char, std::string>& rules): Constructor initializes the L-System with an axiom and production rules.
  - void generate(int iterations): Generates the L-System string for a given number of iterations. It replaces each character in currentString with its corresponding production rule.
  - void display() const: Displays the current L-System string.
main Function:
- Defines the axiom (“F”) and production rules (e.g., “F” → “F+F-F-F+F”).
- Creates an LSystem object with the specified axiom and rules.
- Generates the L-System string for a number of iterations (e.g., 4).
- Displays the final L-System string.

Simulation of L-Systems Gaming Project in C++

Explanation

Related Posts:

Leave a Comment Cancel Reply