spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

//fügt eine neue Lichtquelle in Form eines Kreises hinzu
void CLightMachine::AddLightCircle(int _x, int _y, int _radius, Color _color)
{
    //Erstellt ein neues VertexArray in Form eines Kreises mit 92 Vertices
    VertexArray circle(TrianglesFan, 92);

    //Setzt die Position des Mittelpunktes auf der Rendertextur, die die Größe des Fensters +10 hat
    circle[0].position.x = _x - m_ViewX + 10;
    circle[0].position.y = _y - m_ViewY + 10;
    circle[0].color = Color(255, 255, 255, _color.a);

    //durchläuft die einzelnen Vertices
    for (int angle = 1; angle <= 91; angle++)
    {
        //setzt die Position abhängig vom Radius
        circle[angle].position = Vector2f((_x - m_ViewX + 10) + _radius * cos(angle*4*3.1415926535 / 180), (_y - m_ViewY + 10) + _radius * sin(angle*4*3.1415926535 / 180));

        //überprüft auf Kollision des Lichtstrahls mit einem soliden Block
        circle[angle].position = IsLineIntersecting(circle[0], circle[angle], angle*4, _radius);

        //setzt die Farbe
        circle[angle].color = Color(_color.r, _color.g, _color.b, 255);
    }

    //zeichnet den Lichtkreis
    m_lightTexture.draw(circle, BlendMultiply);
}

C-/C++-Quelltext

Vector2f CLightMachine::IsLineIntersecting(Vertex _firstPoint, Vertex _secondPoint, int _angle, int _radius)
{
   //wenn der Lichtstrahl außerhalb der Welt ist: Beende die Funktion und gib 0,0 zurück
    if (_firstPoint.position.y <= 0 && _secondPoint.position.y < _firstPoint.position.y)
        return Vector2f(0, 0);

    //setzt einen Startwert
    int currentRadius = 5;
    int x, y;

    bool is_intersecting = false;
    
    //läuft durch, bis der Strahl kollidiert oder den Radius erreicht hat
    while (is_intersecting == false)
    {
        //setzt die neue Position des Endpunktes abhängig vom derzeitigen Radius
        _secondPoint.position = Vector2f(_firstPoint.position.x + currentRadius * cos(_angle*3.1415926535 / 180), _firstPoint.position.y + currentRadius * sin(_angle*3.1415926535 / 180));

    //berechnet Position des Blockes in der Matrix, den der Lichtstrahl schneidet (Die Blöcke sind in einer Matrix angeordnet mit Seitenlänge 100)
        x = (_secondPoint.position.x - 10 + m_ViewX) / 100;
        y = (_secondPoint.position.y - 10 + m_ViewY) / 100;

        //prüft, ob der entsprechende Block Licht durchlässt, oder nicht
        if (!m_pWorld->isBlockPassable(x, y))
        {
            //berechne Länge des Lichtstrahles, damit er genau einen Block erleuchtet
            int length = 0;
            if ((_angle >= 45 && _angle < 135) || (_angle >= 225 && _angle < 315))
                length = 100 / (abs(sin(_angle*3.1415926535 / 180)));
            else
                length = 100 / (abs(cos(_angle*3.1415926535 / 180)));

            //prüft, ob die Länge des Lichtstrahls den Radius überschreitet und setzt die Länge ggf. auf diesen
            if (currentRadius + length > _radius)
                _secondPoint.position = Vector2f(_firstPoint.position.x + _radius * cos(_angle*3.1415926535 / 180), _firstPoint.position.y + _radius * sin(_angle*3.1415926535 / 180));
            else
                _secondPoint.position = Vector2f(_firstPoint.position.x + (length + currentRadius) * cos(_angle*3.1415926535 / 180), _firstPoint.position.y + (currentRadius + length) * sin(_angle*3.1415926535 / 180));

            //gibt den neuen Endpunkt des Lichtstrahls zurücl
            return _secondPoint.position;
        }

        //kollidierte der Lichtstrahl nicht: erhöhe den Radius um 2 (bzw. 10, wenn schnelle Lichtberechnung eingestellt ist)
        if (m_fastLight)
            currentRadius += 10;
        else
            currentRadius += 2;

        //ist der Lichtstrahl bis jetzt nicht kollidiert, aber der Radius überschritten: gib Ausgangspunkt zurück
        if (currentRadius > _radius)
            return _secondPoint.position;
    }

    return _secondPoint.position;
}

C-/C++-Quelltext

        Vector2f CLightMachine::IsLineIntersecting(Vertex _firstPoint, Vertex _secondPoint, int _angle, int _radius)
{
    //Wenn der Strahl außerhalb der Welt ist: gib 0,0 zurück
    if (_firstPoint.position.y <= 0 && _secondPoint.position.y < _firstPoint.position.y)
        return Vector2f(0, 0);

    int lastX, lastY;

    Vector2f firstCollisionPoint(-1, -1);
    Vector2f secondCollisionPoint(-1, -1);

    //Berechne Position des Startpunktes des Strahls
    int x = _firstPoint.position.x - 10 + m_ViewX;
    int y = _firstPoint.position.y - 10 + m_ViewY;

    //die Position des ersten Kollisionspunktes
    int xA = 0;
    int yA = 0;
    
    //Der Betrag, der in jedem Schritt addiert wird
    int stepX = 0;
    int stepY = 0;

    //Prüfe Kollision mit Horizontalen nach oben
    if (_angle >= 180)
    {
        //Berechne die y-Koordinate des nächsten Kollisionspunktes, durch den der Lichtstrahl geht
        yA = (y / 100) * 100 - 1;

        //Berechne die x-Koordinate des nächsten Kollisionspunktes, durch den der Lichtstrahl geht
        xA = x + (y - yA) / tan(_angle*3.1415926535 / 180);

        if (yA < 0 || xA < 0)
        {
            firstCollisionPoint = _secondPoint.position;
        }
        //ist der Block solide: speichere diesen Punkt als Kollisionspunkt mit der Horizontalen
        else if (!m_pWorld->isBlockPassable(xA / 100, yA / 100))
        {
            firstCollisionPoint = Vector2f(xA - m_ViewX + 10, yA - m_ViewY + 10);
        }

        //Berechne den Betrag, der in jedem Schritt addiert wird
        stepX = 100 / tan(_angle*3.1415926535 / 180);
        stepY = -100;

    }
    //Prüfe Kollision mit Horizontalen nach unten
    else
    {
        yA = (y / 100) * 100 + 100;

        xA = x + (y - yA) / tan(_angle*3.1415926535 / 180);

        if (yA < 0 || xA < 0)
        {
            firstCollisionPoint = _secondPoint.position;
        }
        else if(!m_pWorld->isBlockPassable(xA / 100, yA / 100))
        {
            firstCollisionPoint = Vector2f(xA - m_ViewX + 10, yA - m_ViewY + 10);
        }

        stepX = 100 / tan(_angle*3.1415926535 / 180);
        stepY = 100;
    }
    



    bool is_intersecting = false;

    if (firstCollisionPoint.x != -1 && firstCollisionPoint.y != -1)
    {
        while (is_intersecting == false)
        {
            //Berechne den nächsten Kollisionspunkt
            xA = xA + stepX;
            yA = yA + stepY;

            if (yA < 0 || xA < 0)
            {
                firstCollisionPoint = _secondPoint.position;
                is_intersecting = true;
            }
            //Prüfe, ob der Strahl nun länger als der Radius ist
            else if (sqrt(pow(x - xA, 2) + pow(y - yA, 2)) > _radius)
            {
                firstCollisionPoint = Vector2f(_firstPoint.position.x + _radius * cos(_angle*3.1415926535 / 180), _firstPoint.position.y + _radius * sin(_angle*3.1415926535 / 180));
                is_intersecting = true;
            }
            //Prüfe, ob der Endpunkt des Strahls in einem soliden Block liegt
            else if (!m_pWorld->isBlockPassable(xA / 100, yA / 100))
            {
                firstCollisionPoint = Vector2f(xA - m_ViewX + 10, yA - m_ViewY + 10);
                is_intersecting = true;
            }
        }
    }


    //das gleiche wird nun mit der Vertikalen durchgeführt, sodass man am Ende einen Kollisionspunkt mit der Horizontalen und einen mit der Vertikalen hat

    //Prüfe Kollision mit Vertikalen nach links
    if (_angle <= 90 || _angle > 315)
    {
        xA = (x / 100) * 100 - 1;

        yA = y + (x - xA) * tan(_angle*3.1415926535 / 180);

        if (yA < 0 || xA < 0)
        {
            secondCollisionPoint = _secondPoint.position;
        }
        else if (!m_pWorld->isBlockPassable(xA / 100, yA / 100))
        {
            secondCollisionPoint = Vector2f(xA - m_ViewX + 10, yA - m_ViewY + 10);
        }

        stepX = -100;  
        stepY = 100 * tan(_angle*3.1415926535 / 180);
    }
    else
    {
        xA = (x / 100) * 100 + 100;

        yA = y + abs(x - xA) * tan(_angle*3.1415926535 / 180);

        if (yA < 0 || xA < 0)
        {
            secondCollisionPoint = _secondPoint.position;
        }
        else if (!m_pWorld->isBlockPassable(xA / 100, yA / 100))
        {
            secondCollisionPoint = Vector2f(xA - m_ViewX + 10, yA - m_ViewY + 10);
        }
        stepX = 100;
        stepY = 100 * tan(_angle*3.1415926535 / 180);
    }



    is_intersecting = false;
    while (is_intersecting == false)
    {
        xA = xA + stepX;
        yA = yA + stepY;

        if (yA < 0 || xA < 0)
        {
            secondCollisionPoint = _secondPoint.position;
            is_intersecting = true;
        }
        else if (sqrt(pow(x - xA, 2) + pow(y - yA, 2)) > _radius)
        {
            secondCollisionPoint = Vector2f(_firstPoint.position.x + _radius * cos(_angle*3.1415926535 / 180), _firstPoint.position.y + _radius * sin(_angle*3.1415926535 / 180));
            is_intersecting = true;
        }
        else if (!m_pWorld->isBlockPassable(xA / 100, yA / 100))
        {
            secondCollisionPoint = Vector2f(xA - m_ViewX + 10, yA - m_ViewY + 10);
            is_intersecting = true;
        }
    }


    //gib den Punkt zurück, bei dem die Länge des Strahls kürzer ist
    if (sqrt(pow(firstCollisionPoint.x - x, 2) + pow(firstCollisionPoint.y - y, 2)) < sqrt(pow(secondCollisionPoint.x - x, 2) + pow(secondCollisionPoint.y - y, 2)))
        return firstCollisionPoint;
    else
        return secondCollisionPoint;

}