int Game::LeaveParty (Actor* actor) { core->SetEventFlag(EF_PORTRAIT); actor->CreateStats(); //create or update stats for leaving actor->SetBase(IE_EXPLORE, 0); SelectActor(actor, false, SELECT_NORMAL); int slot = InParty( actor ); if (slot < 0) { return slot; } std::vector< Actor*>::iterator m = PCs.begin() + slot; PCs.erase( m ); ieDword id = actor->GetGlobalID(); for ( m = PCs.begin(); m != PCs.end(); ++m) { (*m)->PCStats->LastLeft = id; if ( (*m)->InParty>actor->InParty) { (*m)->InParty--; } } //removing from party, but actor remains in 'game' actor->SetPersistent(0); NPCs.push_back( actor ); if (core->HasFeature( GF_HAS_DPLAYER )) { actor->SetScript( "", SCR_DEFAULT ); if (actor->GetBase(IE_MC_FLAGS) & MC_EXPORTABLE) { actor->SetDialog("MULTIJ"); } } actor->SetBase( IE_EA, EA_NEUTRAL ); return ( int ) NPCs.size() - 1; }
int Game::JoinParty(Actor* actor, int join) { core->SetEventFlag(EF_PORTRAIT); actor->CreateStats(); //create stats if they didn't exist yet actor->InitButtons(actor->GetStat(IE_CLASS), false); //init actor's buttons actor->SetBase(IE_EXPLORE, 1); if (join&JP_INITPOS) { InitActorPos(actor); } int slot = InParty( actor ); if (slot != -1) { return slot; } size_t size = PCs.size(); //set the lastjoined trigger if (join&JP_JOIN) { //update kit abilities of actor actor->ApplyKit(false); //update the quickslots actor->ReinitQuickSlots(); //set the joining date actor->PCStats->JoinDate = GameTime; if (size) { ieDword id = actor->GetGlobalID(); for (size_t i=0;i<size; i++) { Actor *a = GetPC(i, false); a->PCStats->LastJoined = id; } } else { Reputation = actor->GetStat(IE_REPUTATION); } } slot = InStore( actor ); if (slot >= 0) { std::vector< Actor*>::iterator m = NPCs.begin() + slot; NPCs.erase( m ); } PCs.push_back( actor ); if (!actor->InParty) { actor->InParty = (ieByte) (size+1); } if (join&(JP_INITPOS|JP_SELECT)) { actor->Selected = 0; // don't confuse SelectActor! SelectActor(actor,true, SELECT_NORMAL); } return ( int ) size; }
int Game::DelPC(unsigned int slot, bool autoFree) { if (slot >= PCs.size()) { return -1; } if (!PCs[slot]) { return -1; } SelectActor(PCs[slot], false, SELECT_NORMAL); if (autoFree) { delete( PCs[slot] ); } std::vector< Actor*>::iterator m = PCs.begin() + slot; PCs.erase( m ); return 0; }
void UUnrealEdEngine::SelectGroup(AGroupActor* InGroupActor, bool bForceSelection/*=false*/, bool bInSelected/*=true*/, bool bNotify/*=true*/) { USelection* SelectedActors = GetSelectedActors(); SelectedActors->BeginBatchSelectOperation(); SelectedActors->Modify(); static bool bIteratingGroups = false; if( !bIteratingGroups ) { bIteratingGroups = true; // Select all actors within the group (if locked or forced) if( bForceSelection || InGroupActor->IsLocked() ) { TArray<AActor*> GroupActors; InGroupActor->GetGroupActors(GroupActors); for( int32 ActorIndex=0; ActorIndex < GroupActors.Num(); ++ActorIndex ) { SelectActor(GroupActors[ActorIndex], bInSelected, false ); } bForceSelection = true; // Recursively select any subgroups TArray<AGroupActor*> SubGroups; InGroupActor->GetSubGroups(SubGroups); for( int32 GroupIndex=0; GroupIndex < SubGroups.Num(); ++GroupIndex ) { SelectGroup(SubGroups[GroupIndex], bForceSelection, bInSelected, false); } } SelectedActors->EndBatchSelectOperation(bNotify); if (bNotify) { NoteSelectionChange(); } //whenever selection changes, recompute whether the selection contains a locked actor bCheckForLockActors = true; //whenever selection changes, recompute whether the selection contains a world info actor bCheckForWorldSettingsActors = true; bIteratingGroups = false; } }
bool Game::SelectActor(Actor* actor, bool select, unsigned flags) { std::vector< Actor*>::iterator m; // actor was not specified, which means all selectables should be (de)selected if (! actor) { for ( m = selected.begin(); m != selected.end(); ++m) { (*m)->Select( false ); (*m)->SetOver( false ); } selected.clear(); if (select) { area->SelectActors(); /* for ( m = PCs.begin(); m != PCs.end(); ++m) { if (! *m) { continue; } SelectActor( *m, true, SELECT_QUIET ); } */ } if (! (flags & SELECT_QUIET)) { core->SetEventFlag(EF_SELECTION); } Infravision(); return true; } // actor was specified, so we will work with him if (select) { if (! actor->ValidTarget( GA_SELECT | GA_NO_DEAD )) return false; // deselect all actors first when exclusive if (flags & SELECT_REPLACE) { if (selected.size() == 1 && actor->IsSelected()) { assert(selected[0] == actor); // already the only selected actor return true; } SelectActor( NULL, false, SELECT_QUIET ); } else if (actor->IsSelected()) { // already selected return true; } actor->Select( true ); assert(actor->IsSelected()); selected.push_back( actor ); } else { if (!actor->IsSelected()) { // already not selected return true; /*for ( m = selected.begin(); m != selected.end(); ++m) { assert((*m) != actor); } return true;*/ } for ( m = selected.begin(); m != selected.end(); ++m) { if ((*m) == actor) { selected.erase( m ); break; } } actor->Select( false ); assert(!actor->IsSelected()); } if (! (flags & SELECT_QUIET)) { core->SetEventFlag(EF_SELECTION); } Infravision(); return true; }
void UUnrealEdEngine::SelectNone(bool bNoteSelectionChange, bool bDeselectBSPSurfs, bool WarnAboutManyActors) { if( GEdSelectionLock ) { return; } bool bShowProgress = false; // If there are a lot of actors to process, pop up a warning "are you sure?" box if( WarnAboutManyActors ) { int32 NumSelectedActors = GEditor->GetSelectedActorCount(); if( NumSelectedActors >= EditorActorSelectionDefs::MaxActorsToSelectBeforeWarning ) { bShowProgress = true; const FText ConfirmText = FText::Format( NSLOCTEXT("UnrealEd", "Warning_ManyActorsForDeselect", "There are {0} selected actors. Are you sure you want to deselect them all?" ), FText::AsNumber(NumSelectedActors) ); FSuppressableWarningDialog::FSetupInfo Info( ConfirmText, NSLOCTEXT( "UnrealEd", "Warning_ManyActors", "Warning: Many Actors" ), "Warning_ManyActors" ); Info.ConfirmText = NSLOCTEXT("ModalDialogs", "ManyActorsForDeselectConfirm", "Continue Deselection"); Info.CancelText = NSLOCTEXT("ModalDialogs", "ManyActorsForDeselectCancel", "Keep Current Selection"); FSuppressableWarningDialog ManyActorsWarning( Info ); if( ManyActorsWarning.ShowModal() == FSuppressableWarningDialog::Cancel ) { return; } } } if( bShowProgress ) { GWarn->BeginSlowTask( LOCTEXT("BeginDeselectingActorsTaskMessage", "Deselecting Actors"), true ); } // Make a list of selected actors . . . TArray<AActor*> ActorsToDeselect; for ( FSelectionIterator It( GetSelectedActorIterator() ) ; It ; ++It ) { AActor* Actor = static_cast<AActor*>( *It ); checkSlow( Actor->IsA(AActor::StaticClass()) ); ActorsToDeselect.Add( Actor ); } USelection* SelectedActors = GetSelectedActors(); SelectedActors->BeginBatchSelectOperation(); SelectedActors->Modify(); // . . . and deselect them. for ( int32 ActorIndex = 0 ; ActorIndex < ActorsToDeselect.Num() ; ++ActorIndex ) { AActor* Actor = ActorsToDeselect[ ActorIndex ]; SelectActor( Actor, false, false ); } uint32 NumDeselectSurfaces = 0; UWorld* World = GWorld; if( bDeselectBSPSurfs && World ) { // Unselect all surfaces in all levels. NumDeselectSurfaces += DeselectAllSurfacesForLevel( World->PersistentLevel ); for( int32 LevelIndex = 0 ; LevelIndex < World->StreamingLevels.Num() ; ++LevelIndex ) { ULevelStreaming* StreamingLevel = World->StreamingLevels[LevelIndex]; if( StreamingLevel ) { ULevel* Level = StreamingLevel->GetLoadedLevel(); if ( Level != NULL ) { NumDeselectSurfaces += DeselectAllSurfacesForLevel( Level ); } } } } SelectedActors->EndBatchSelectOperation(bNoteSelectionChange); //prevents clicking on background multiple times spamming selection changes if (ActorsToDeselect.Num() || NumDeselectSurfaces) { GetSelectedActors()->DeselectAll(); if( bNoteSelectionChange ) { NoteSelectionChange(); } //whenever selection changes, recompute whether the selection contains a locked actor bCheckForLockActors = true; //whenever selection changes, recompute whether the selection contains a world info actor bCheckForWorldSettingsActors = true; } if( bShowProgress ) { GWarn->EndSlowTask(); } }
void UUnrealEdEngine::NoteActorMovement() { if( !GUndo && !(GEditor->ClickFlags & CF_MOVE_ACTOR) ) { GEditor->ClickFlags |= CF_MOVE_ACTOR; const FScopedTransaction Transaction( NSLOCTEXT("UnrealEd", "ActorMovement", "Actor Movement") ); GLevelEditorModeTools().Snapping=0; AActor* SelectedActor = NULL; for ( FSelectionIterator It( GetSelectedActorIterator() ) ; It ; ++It ) { AActor* Actor = static_cast<AActor*>( *It ); checkSlow( Actor->IsA(AActor::StaticClass()) ); SelectedActor = Actor; break; } if( SelectedActor == NULL ) { USelection* SelectedActors = GetSelectedActors(); SelectedActors->Modify(); SelectActor( GWorld->GetDefaultBrush(), true, true ); } // Look for an actor that requires snapping. for ( FSelectionIterator It( GetSelectedActorIterator() ) ; It ; ++It ) { AActor* Actor = static_cast<AActor*>( *It ); checkSlow( Actor->IsA(AActor::StaticClass()) ); GLevelEditorModeTools().Snapping = 1; break; } TSet<AGroupActor*> GroupActors; // Modify selected actors. for ( FSelectionIterator It( GetSelectedActorIterator() ) ; It ; ++It ) { AActor* Actor = static_cast<AActor*>( *It ); checkSlow( Actor->IsA(AActor::StaticClass()) ); Actor->Modify(); if (GEditor->bGroupingActive) { // if this actor is in a group, add the GroupActor into a list to be modified shortly AGroupActor* ActorLockedRootGroup = AGroupActor::GetRootForActor(Actor, true); if (ActorLockedRootGroup != nullptr) { GroupActors.Add(ActorLockedRootGroup); } } ABrush* Brush = Cast< ABrush >( Actor ); if ( Brush ) { if( Brush->Brush ) { Brush->Brush->Polys->Element.ModifyAllItems(); } } } // Modify unique group actors for (auto* GroupActor : GroupActors) { GroupActor->Modify(); } } }