C++ Ship::GetHangar方法代码示例

void
NetGameClient::DoShipLaunch(NetMsg* msg)
{
	if (!msg) return;

	NetShipLaunch ship_launch;
	ship_launch.Unpack(msg->Data());

	Sim*  sim      = Sim::GetSim();
	int   squadron = ship_launch.GetSquadron();
	int   slot     = ship_launch.GetSlot();

	Ship* carrier = FindShipByObjID(ship_launch.GetObjID());

	if (carrier) {
		Hangar* hangar = carrier->GetHangar();

		if (hangar) {
			hangar->Launch(squadron, slot);
		}
	}
}

//.........这里部分代码省略.........
                ClearRadioOrders();
            }
            break;

        case RadioMessage::ESCORT:
        case RadioMessage::COVER_ME:
            {
                SimObject* tgt = orders->GetTarget();
                if (tgt && tgt->Type() == SimObject::SIM_SHIP) {
                    roe = DEFENSIVE;
                    ship_ai->SetWard((Ship*) tgt);
                    ship_ai->SetNavPoint(0);
                }
                else {
                    ClearRadioOrders();
                }
            }
            break;

        case RadioMessage::WEP_FREE:
            roe = AGRESSIVE;
            ship_ai->DropTarget(0.1);
            break;

        case RadioMessage::WEP_HOLD:
        case RadioMessage::FORM_UP:
            roe = NONE;
            ship_ai->DropTarget(5);
            break;

        case RadioMessage::MOVE_PATROL:
            roe = SELF_DEFENSIVE;
            ship_ai->SetPatrol(orders->Location());
            ship_ai->SetNavPoint(0);
            ship_ai->DropTarget(Random(5, 10));
            break;

        case RadioMessage::RTB:
        case RadioMessage::DOCK_WITH:
            roe = NONE;

            ship_ai->DropTarget(10);
            
            if (!ship->GetInbound()) {
                RadioMessage* msg = 0;
                Ship* controller = ship->GetController();

                if (orders->Action() == RadioMessage::DOCK_WITH && orders->GetTarget()) {
                    controller = (Ship*) orders->GetTarget();
                }

                if (!controller) {
                    Element* elem = ship->GetElement();
                    if (elem && elem->GetCommander()) {
                        Element* cmdr = elem->GetCommander();
                        controller    = cmdr->GetShip(1);
                    }
                }

                if (controller && controller->GetHangar() &&
                        controller->GetHangar()->CanStow(ship)) {
                    SimRegion*  self_rgn = ship->GetRegion();
                    SimRegion*  rtb_rgn  = controller->GetRegion();

                    if (self_rgn == rtb_rgn) {
                        double range = Point(controller->Location() - ship->Location()).length();

                        if (range < 50e3) {
                            msg = new(__FILE__,__LINE__) RadioMessage(controller, ship, RadioMessage::CALL_INBOUND);
                            RadioTraffic::Transmit(msg);
                        }
                    }
                }
                else {
                    ship->ClearRadioOrders();
                }

                ship_ai->SetNavPoint(0);
            }
            break;

        case RadioMessage::QUANTUM_TO:
        case RadioMessage::FARCAST_TO:
            roe = NONE;
            ship_ai->DropTarget(10);
            break;

        }

        action = orders->Action();
        return true;
    }

    // if we had an action before, this must be a "cancel orders" 
    else if (action) {
        ClearRadioOrders();
    }

    return false;
}

void
NetGameClient::DoElemCreate(NetMsg* msg)
{
	if (!msg) return;

	NetElemCreate elem_create;
	elem_create.Unpack(msg->Data());

	const char* elem_name = elem_create.GetName().data();

	::Print("NetGameClient::DoElemCreate name: %s iff: %d type %s\n",
	elem_name,
	elem_create.GetIFF(),
	Mission::RoleName(elem_create.GetType()));

	Sim*     sim   = Sim::GetSim();
	Element* elem  = sim->FindElement(elem_name);
	if (elem) {
		::Print("  element '%' already exists - ignored\n", elem_name);
		return;
	}

	elem = sim->CreateElement(elem_name,
	elem_create.GetIFF(),
	elem_create.GetType());

	int*     load     = elem_create.GetLoadout();
	int*     slots    = elem_create.GetSlots();
	int      squadron = elem_create.GetSquadron();
	int      code     = elem_create.GetObjCode();
	Text     target   = elem_create.GetObjective();
	bool     alert    = elem_create.GetAlert();
	bool     active   = elem_create.GetInFlight();

	elem->SetIntelLevel(elem_create.GetIntel());
	elem->SetLoadout(load);

	if (code > Instruction::RTB || target.length() > 0) {
		Instruction* obj  = new(__FILE__,__LINE__) Instruction(code, target);
		elem->AddObjective(obj);
	}

	Ship* carrier = sim->FindShip(elem_create.GetCarrier());
	if (carrier) {
		elem->SetCarrier(carrier);

		Hangar* hangar = carrier->GetHangar();
		if (hangar) {
			Text squadron_name = hangar->SquadronName(squadron);
			elem->SetSquadron(squadron_name);

			if (active) {
				for (int i = 0; i < 4; i++) {
					int slot = slots[i];
					if (slot > -1) {
						hangar->GotoActiveFlight(squadron, slot, elem, load);
					}
				}
			}

			else {
				FlightDeck* deck   = 0;
				int         queue  = 1000;

				for (int i = 0; i < carrier->NumFlightDecks(); i++) {
					FlightDeck* d = carrier->GetFlightDeck(i);

					if (d && d->IsLaunchDeck()) {
						int dq = hangar->PreflightQueue(d);

						if (dq < queue) {
							queue = dq;
							deck  = d;
						}
					}
				}

				for (int i = 0; i < 4; i++) {
					int slot = slots[i];
					if (slot > -1) {
						hangar->GotoAlert(squadron, slot, deck, elem, load, !alert);
					}
				}
			}
		}
	}
}