Example #1
0
unsigned char nofGeologist::GetNextNode()
{
    // Überhaupt noch Schilder zum Aufstellen
    if(!signs)
        return 0xFF;
    do
    {
        // Sind überhaupt Punkte verfügbar?
        while(!available_nodes.empty())
        {
            // Dann einen Punkt zufällig auswählen
            int randNode = RANDOM.Rand(__FILE__, __LINE__, GetObjId(), available_nodes.size());
            node_goal = available_nodes[randNode];
            // und aus der Liste entfernen
            available_nodes.erase(available_nodes.begin() + randNode);
            // Gucken, ob er gut ist und ob man hingehen kann und ob er noch nicht reserviert wurde!
            unsigned char ret_dir;
            if(IsNodeGood(node_goal) && (ret_dir = gwg->FindHumanPath(pos, node_goal, 20)) != 0xFF && !gwg->GetNode(node_goal).reserved)
            {
                // Reservieren
                gwg->GetNode(node_goal).reserved = true;;
                return ret_dir;
            }
        }


        // Nach neuen Punkten sucehn
        LookForNewNodes();
    }
    while(!available_nodes.empty());

    return 0xFF;
}
Example #2
0
void nofGeologist::TestNode(const MapPoint pt)
{
    // Prüfen, ob er überhaupt auf der Karte liegt und nicht irgendwo im Nirvana
    if(pt.x < gwg->GetWidth() && pt.y < gwg->GetHeight())
    {
        if(IsNodeGood(pt) && (gwg->FindHumanPath(this->pos, pt, 20)) != 0xFF && !gwg->GetNode(pt).reserved)
        {
            available_nodes.push_back(pt);
        }
    }
}
Example #3
0
void nofGeologist::Walked()
{
    if(state == STATE_GEOLOGIST_GOTONEXTNODE)
    {
        // Ist mein Zielpunkt überhaupt noch geeignet zum Graben (kann ja mittlerweile auch was drauf gebaut worden sein)
        if(!IsNodeGood(node_goal))
        {
            // alten Punkt wieder freigeben
            gwg->GetNode(node_goal).reserved = false;;
            // wenn nicht, dann zu einem neuen Punkt gehen
            GoToNextNode();
            return;
        }

        // Bin ich am Zielpunkt?
        if(pos == node_goal)
        {
            // anfangen zu graben
            current_ev = em->AddEvent(this, 100, 1);
            state = STATE_GEOLOGIST_DIG;
        }
        else
        {
            // Weg zum nächsten Punkt suchen
            unsigned char dir = gwg->FindHumanPath(pos, node_goal, 20);

            // Wenns keinen gibt
            if(dir == 0xFF)
            {
                // alten Punkt wieder freigeben
                gwg->GetNode(node_goal).reserved = false;
                // dann neuen Punkt suchen
                dir = GetNextNode();
                // falls es keinen gibt, dann zurück zur Flagge gehen und es übernimmt der andere "Walked"-Zweig
                if(dir == 0xFF)
                {
                    state = STATE_GOTOFLAG;
                    Walked();
                    return;
                }
            }
            
            StartWalking(dir);
        }
    }
    else if(state == STATE_GOTOFLAG)
    {
        GoToFlag();
    }
}
unsigned char nofGeologist::GetNextNode()
{
    // Überhaupt noch Schilder zum Aufstellen
    if(!signs)
    {
        node_goal = MapPoint::Invalid();
        return INVALID_DIR;
    }

    do
    {
        // Sind überhaupt Punkte verfügbar?
        while(!available_nodes.empty())
        {
            // Dann einen Punkt zufällig auswählen
            int randNode = RANDOM.Rand(__FILE__, __LINE__, GetObjId(), available_nodes.size());
            node_goal = available_nodes[randNode];
            // und aus der Liste entfernen
            available_nodes.erase(available_nodes.begin() + randNode);
            // Gucken, ob er gut ist und ob man hingehen kann und ob er noch nicht reserviert wurde!
            if(!IsNodeGood(node_goal) || gwg->GetNode(node_goal).reserved)
                continue;

            unsigned char ret_dir;
            if(pos == node_goal)
                ret_dir = INVALID_DIR;
            else
            {
                ret_dir = gwg->FindHumanPath(pos, node_goal, 20);
                if(ret_dir == INVALID_DIR)
                    continue;
            }
            // Reservieren
            gwg->SetReserved(node_goal, true);
            return ret_dir;
        }

        // Nach neuen Punkten sucehn
        LookForNewNodes();
    } while(!available_nodes.empty());

    node_goal = MapPoint::Invalid();
    return INVALID_DIR;
}
void nofGeologist::Walked()
{
    if(state == STATE_GEOLOGIST_GOTONEXTNODE)
    {
        // Check if the flag still exists (not destroyed) and the goal node is still available (something could be build there)
        if(!flag || !IsNodeGood(node_goal))
        {
            // alten Punkt wieder freigeben
            gwg->SetReserved(node_goal, false);
            // wenn nicht, dann zu einem neuen Punkt gehen
            GoToNextNode();
            return;
        }

        // Bin ich am Zielpunkt?
        if(pos == node_goal)
        {
            // anfangen zu graben
            current_ev = GetEvMgr().AddEvent(this, 100, 1);
            state = STATE_GEOLOGIST_DIG;
        } else
        {
            // Weg zum nächsten Punkt suchen
            unsigned char dir = gwg->FindHumanPath(pos, node_goal, 20);

            // Wenns keinen gibt
            if(dir == INVALID_DIR)
                GoToNextNode();
            else
                StartWalking(Direction::fromInt(dir));
        }
    } else if(state == STATE_GOTOFLAG)
    {
        GoToFlag();
    }
}
bool nofGeologist::IsValidTargetNode(const MapPoint pt) const
{
    return (IsNodeGood(pt) && !gwg->GetNode(pt).reserved && (pos == pt || gwg->FindHumanPath(pos, pt, 20) != 0xFF));
}