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();
}
}
}
