RoadSegment* RoadSegment::create(TypeRoad type, bool isBegin, const Vec2& pos )
{
RoadSegment* pRet = new RoadSegment(type, isBegin, pos);
if (pRet && pRet->init())
{
pRet->autorelease();
return pRet;
}
CC_SAFE_DELETE(pRet);
return nullptr;
}
void noRoadNode::DestroyRoad(const unsigned char dir)
{
if(routes[dir])
{
MapPoint t = routes[dir]->GetF1()->GetPos();
for(unsigned z = 0; z < routes[dir]->GetLength(); ++z)
{
gwg->SetPointRoad(t, routes[dir]->GetRoute(z), 0);
gwg->CalcRoad(t, player);
t = gwg->GetNeighbour(t, routes[dir]->GetRoute(z));
}
noRoadNode* oflag;
if(routes[dir]->GetF1() == this)
oflag = routes[dir]->GetF2();
else
oflag = routes[dir]->GetF1();
#ifndef NDEBUG
bool found = false;
#endif
for(unsigned z = 0; z < 6; ++z)
{
if(oflag->routes[z] == routes[dir])
{
oflag->routes[z] = NULL;
#ifndef NDEBUG
found = true;
#endif
break;
}
}
#ifndef NDEBUG
assert(found);
#endif
RoadSegment* tmp = routes[dir];
routes[dir] = 0;
tmp->Destroy();
delete tmp;
// Spieler Bescheid sagen
gwg->GetPlayer(player)->RoadDestroyed();
}
}
bool nofCarrier::WantInBuilding(bool* calculated)
{
RoadSegment* rs = static_cast<noFlag*>((rs_dir ? cur_rs->GetF1() : cur_rs->GetF2()))->routes[1];
if(!rs)
return false;
if(rs->GetLength() != 1)
return false;
if (calculated)
{
*calculated = true;
}
carried_ware->RecalcRoute();
return (carried_ware->GetNextDir() == 1);
}
bool render(const Tile& tile,const std::vector<RoadSegment>& segments,agg::rendering_buffer& rbuf)
{
typedef agg::renderer_base<agg::pixfmt_rgba32> ren_base;
typedef agg::renderer_outline_aa<ren_base> renderer_oaa;
typedef agg::rasterizer_outline_aa<renderer_oaa> rasterizer_outline_aa;
typedef agg::renderer_scanline_aa_solid<ren_base> renderer;
agg::pixfmt_rgba32 pixf(rbuf);
ren_base renb(pixf);
renderer ren(renb);
agg::rasterizer_scanline_aa<> ras;
agg::scanline_p8 sl;
unsigned i = 0;
for (i=0; i < segments.size(); i++)
{
RoadSegment rseg = segments[i];
Segment seg = rseg.convertToSegment(tile);
ren.color(seg.getColor());
agg::path_storage path;
path.move_to(seg.getFromPoint().getX(), seg.getFromPoint().getY());
path.line_to(seg.getToPoint().getX(), seg.getToPoint().getY());
agg::conv_stroke<agg::path_storage> stroke(path);
stroke.width(seg.getStrokeWidth());
agg::line_cap_e cap = agg::round_cap;
agg::line_join_e join = agg::round_join;
stroke.line_join(join);
stroke.line_cap(cap);
ras.reset();
ras.add_path(stroke);
agg::render_scanlines(ras,sl,ren);
}
return true;
}
void nobBaseWarehouse::OrderCarrier(noRoadNode& goal, RoadSegment& workplace)
{
RTTR_Assert(workplace.getCarrier(0) == NULL);
const bool isBoatRequired = workplace.GetRoadType() == RoadSegment::RT_BOAT;
// We assume, that the caller already checked, if this is possible
RTTR_Assert(inventory[JOB_HELPER]);
if(isBoatRequired)
RTTR_Assert(inventory[GD_BOAT]);
nofCarrier* carrier = new nofCarrier(isBoatRequired ? nofCarrier::CT_BOAT : nofCarrier::CT_NORMAL, pos, player, &workplace, &goal);
workplace.setCarrier(0, carrier);
if(!UseFigureAtOnce(carrier, goal))
AddLeavingFigure(carrier);
inventory.real.Remove(JOB_HELPER);
if(isBoatRequired)
inventory.real.Remove(GD_BOAT);
// Evtl. kein Gehilfe mehr, sodass das Rekrutieren gestoppt werden muss
TryStopRecruiting();
}
void nofDonkeybreeder::WorkFinished()
{
// Straße und Zielflagge für Esel suchen
noRoadNode* flag_goal;
RoadSegment* road = gwg->GetPlayer(player).FindRoadForDonkey(workplace, &flag_goal);
// Esel erzeugen und zum Ziel beordern
nofCarrier* donkey = new nofCarrier(nofCarrier::CT_DONKEY, pos, player, road, flag_goal);
gwg->GetPlayer(player).IncreaseInventoryJob(JOB_PACKDONKEY, 1);
donkey->InitializeRoadWalking(gwg->GetSpecObj<noRoadNode>(pos)->routes[4], 0, true);
// Wenn keine Straße gefunden wurde, muss er nach Hause gehen
if(!road)
donkey->GoHome();
else
// ansonsten Arbeitsplatz Bescheid sagen
road->GotDonkey(donkey);
// Esel absetzen
gwg->AddFigure(donkey, pos);
// In die neue Welt laufen
donkey->ActAtFirst();
}
void nofCarrier::RoadSplitted(RoadSegment* rs1, RoadSegment* rs2)
{
// Bin ich schon auf meinem Arbeitsplatz (=Straße) oder bin ich erst noch auf dem Weg dorthin?
if(state == CARRS_FIGUREWORK)
{
// ich gehe erst noch hin, also gucken, welche Flagge ich anvisiert habe und das jeweilige Teilstück dann als Arbeitsstraße
if(GetGoal() == rs1->GetF1())
workplace = rs1;
else
workplace = rs2;
}
else if(state == CARRS_CARRYWARETOBUILDING || state == CARRS_LEAVEBUILDING)
{
// Wenn ich in ein Gebäude gehen oder rauskomme, auf den Weg gehen, der an dieses Gebäude grenzt
if(cur_rs->GetF1() == rs1->GetF1() || cur_rs->GetF1() == rs1->GetF2())
workplace = rs1;
else
workplace = rs2;
}
else
{
// sonst wurde es ja schon entschieden
workplace = (cur_rs == rs1) ? rs1 : rs2;
}
// Sonstige Sachen für jeweilige States unternehmen
switch(state)
{
default:
break;
case CARRS_WAITFORWARE:
{
// Wenn wir stehen, müssen wir in die Mitte laufen
state = CARRS_GOTOMIDDLEOFROAD;
Walked();
} break;
case CARRS_FETCHWARE:
{
// Wenn wir zur 2. Flagge vom 1. Wegstück gelaufen sind, können wir das nun vergessen
if(!workplace->AreWareJobs(!rs_dir, ct, false))
state = CARRS_GOTOMIDDLEOFROAD;
} break;
}
RoadSegment* otherRoad = (workplace == rs1) ? rs2 : rs1;
unsigned char carrierNr = ct == CT_DONKEY ? 1 : 0;
// Switch road if required
if(workplace->getCarrier(carrierNr) != this)
{
RTTR_Assert(otherRoad->getCarrier(carrierNr) == this); // I should have been on other road
// Mich als Träger für meinen neuen Arbeitsplatz zuweisen
workplace->setCarrier(carrierNr, this);
// Für andere Straße neuen Träger/Esel rufen
otherRoad->setCarrier(carrierNr, NULL);
}else
RTTR_Assert(otherRoad->getCarrier(carrierNr) == NULL); // No carrier expected
if(ct == CT_NORMAL)
gwg->GetPlayer(player).FindCarrierForRoad(otherRoad);
else if(ct == CT_DONKEY)
otherRoad->setCarrier(1, gwg->GetPlayer(player).OrderDonkey(otherRoad));
}
bool operator()(const RoadSegment& segment) const
{
return segment.GetRoadType() != T_roadType;
}
