Пример #1
0
void __fastcall TObjFrm::ClearGroups(void)
{
ClearGroup(CGroup);
ClearGroup(ChrGroup);
ClearGroup(PlaceGroup);
SetChanged(false);
}
Пример #2
0
/**
**  Set group num contents to unit array "units"
**
**  @param units   Array of units to place into group.
**  @param nunits  Number of units in array.
**  @param num     Group number for storage.
*/
void SetGroup(CUnit **units, int nunits, int num)
{
	Assert(num <= NUM_GROUPS && nunits <= MaxSelectable);

	ClearGroup(num);
	AddToGroup(units, nunits, num);
}
Пример #3
0
void
CameraDirector::SetViewObjectGroup(ListIter<Ship> group, bool quick)
{
    if (!ship) return;

    Starshatter* stars = Starshatter::GetInstance();

    if (!stars->InCutscene()) {
        // only view solid contacts:
        while (++group) {
            Ship* s = group.value();

            if (s->GetIFF() != ship->GetIFF()) {
                Contact* c = ship->FindContact(s);
                if (!c || !c->ActLock())
                return;
            }

            if (s->Life() == 0 || s->IsDying() || s->IsDead())
            return;
        }
    }

    group.reset();

    if (external_group.size() > 1 &&
            external_group.size() == group.size()) {

        bool same = true;

        for (int i = 0; same && i < external_group.size(); i++) {
            if (external_group[i] != group.container()[i])
            same = false;
        }

        if (same) {
            SetMode(MODE_ZOOM);
            return;
        }
    }

    ClearGroup();

    if (quick) {
        mode = MODE_ORBIT;
        transition = 0;
    }
    else {
        SetMode(MODE_TRANSLATE);
    }

    external_group.append(group.container());

    ListIter<Ship> iter = external_group;
    while (++iter) {
        Ship* s = iter.value();
        region = s->GetRegion();
        Observe(s);
    }
}
Пример #4
0
void
CameraDirector::SetViewOrbital(Orbital* orb)
{
    external_body = orb;

    if (external_body) {
        range_min = external_body->Radius() * 2.5;
        ClearGroup();
        external_ship = 0;

        if (sim) {
            region = sim->FindNearestSpaceRegion(orb);
            if (region)
            sim->ActivateRegion(region);
        }

        if (ship && !region)
        region = ship->GetRegion();
    }
}
Пример #5
0
void
CameraDirector::SetViewObject(Ship* obj, bool quick)
{
    if (!ship) return;
    if (!obj) {
        obj = ship;
        region = ship->GetRegion();
    }

    external_body  = 0;
    external_point = Point();

    Starshatter* stars = Starshatter::GetInstance();

    if (obj->GetIFF() != ship->GetIFF() && !stars->InCutscene()) {
        // only view solid contacts:
        Contact* c = ship->FindContact(obj);
        if (!c || !c->ActLock()) 
        return;
    }

    if (mode == MODE_TARGET) {
        ClearGroup();
        if (external_ship) {
            external_ship = 0;
        }
    }
    else if (mode >= MODE_ORBIT) {
        if (quick) {
            mode       = MODE_ORBIT;
            transition = 0;
        }
        else {
            SetMode(MODE_TRANSLATE);
        }

        if (external_group.size()) {
            ClearGroup();

            if (external_ship) {
                external_ship = 0;
            }
        }

        else {
            if ((obj == external_ship) || (obj==ship && external_ship==0)) {
                if (!quick)
                SetMode(MODE_ZOOM);
            }
            
            else if (external_ship) {
                external_ship = 0;
            }
        }
    }

    if (external_ship != obj) {
        external_ship = obj;

        if (external_ship) {
            region = external_ship->GetRegion();

            if (external_ship->Life() == 0 || external_ship->IsDying() || external_ship->IsDead()) {
                external_ship = 0;
                range_min = 100;
            }
            else {
                Observe(external_ship);

                if (sim)
                sim->ActivateRegion(external_ship->GetRegion());

                range_min = external_ship->Radius() * 1.5;
            }
        }

        Observe(external_ship);
        ExternalRange(1);
    }
}
Пример #6
0
void
CameraDirector::SetMode(int m, double t)
{
    if (requested_mode == m)
    return;

    external_point = Point();

    // save current mode for after transition:
    if (m == MODE_DROP && mode != MODE_DROP)
    old_mode = mode;

    // if manually leaving drop mode, forget about
    // restoring the previous mode when the drop
    // expires...
    else if (m != MODE_DROP && mode == MODE_DROP)
    old_mode = MODE_NONE;

    if (m == MODE_VIRTUAL && ship && !ship->Cockpit())
    return;

    if (mode == m) {
        if (mode == MODE_TARGET || mode == MODE_ORBIT)
        CycleViewObject();

        return;
    }

    if (m > MODE_NONE && m < MODE_LAST) {
        if (m <= MODE_VIRTUAL) {
            requested_mode = m;
            transition     = t;
            external_ship  = 0;
            ClearGroup();

            // no easy way to do a smooth transition between
            // certain modes, so just go immediately:
            if ((mode == MODE_TARGET  && m == MODE_CHASE)   ||
                    (mode == MODE_COCKPIT && m == MODE_VIRTUAL) ||
                    (mode == MODE_VIRTUAL && m == MODE_COCKPIT))
            {
                mode           = m;
                requested_mode = 0;
                transition     = 0;
            }
        }

        else if (m == MODE_TRANSLATE || m == MODE_ZOOM) {
            requested_mode = m;
            transition     = t;
            base_range     = range;
        }

        else if (m >= MODE_DOCKING) {
            mode           = m;
            transition     = 0;
            external_ship  = 0;
            ClearGroup();
        }

        virt_az = 0;
        virt_el = 0;
        virt_x  = 0;
        virt_y  = 0;
        virt_z  = 0;
    }
}