Стоит ли использовать ООП?

class OwnerApartaments
{
    Set     resources;
    Set     occupants;
}
private void free(Set _resources)
{
    OwnerResource       resource;
    SetEnumerator       se = _resources.getEnumerator();
    ;
 
    while (se.moveNext())
    {
        resource = se.current();
        resource.occupant(null);
    }
}
void new()
{
    ;
 
    resources = new Set(Types::Class);
    occupants = new Set(Types::Class);
 
    resources.add(new OwnerResource_Floor(1));
    resources.add(new OwnerResource_Floor(2));
    resources.add(new OwnerResource_Floor(3));
    resources.add(new OwnerResource_Floor(4));
    resources.add(new OwnerResource_Floor(5));
 
    occupants.add(new Occupant_Baker());
    occupants.add(new Occupant_Cooper());
    occupants.add(new Occupant_Fletcher());
    occupants.add(new Occupant_Miller());
    occupants.add(new Occupant_Smith());
}
private boolean process( Set        _occupants
                       , Set        _resources
                       , Occupant   _occupant
                       )
{
    OwnerResource       resource;
    SetEnumerator       se = _resources.getEnumerator();
    ;
 
    while (se.moveNext())
    {
        resource = se.current();
        if (    resource.occupant() == null
            &&  _occupant.checkResource(resource)
           )
        {
            resource.occupant(_occupant);
            if (this.processResource(_occupants, _resources, _occupant, resource))
            {
                return true;
            }
            resource.occupant(null);
        }
    }
 
    return false;
}
private boolean processResource( Set            _occupants
                               , Set            _resources
                               , Occupant       _occupant
                               , OwnerResource  _resource
                               )
{
    SetEnumerator       se;
    Set                 occupantsLocal;
    Set                 resourcesLocal;
    ;
 
    occupantsLocal  = this.remove(_occupant, _occupants);
    resourcesLocal  = this.remove(_resource, _resources);
    if (occupantsLocal.empty())
    {
        return _occupant.check(this);
    }
 
    se = occupantsLocal.getEnumerator();
    while (se.moveNext())
    {
        if (this.process(occupantsLocal, resourcesLocal, se.current()))
        {
            return _occupant.check(this);
        }
        else
        {
            this.free(resourcesLocal);
        }
    }
 
    return false;
}
private Set remove( object  _o
                  , Set     _set
                  )
{
    Set     set  = new Set(Types::Class);
    ;
 
    set.add(_o);
    return Set::difference(_set, set);
}
public Set resources()
{
    return resources;
}
private void results()
{
    SetEnumerator           se = resources.getEnumerator();
    OwnerResource_Floor     floor;
    ;
 
    while (se.moveNext())
    {
        floor = se.current();
        info(strFmt("%1 - %2"
                   , floor.intFloor()
                   , floor.occupant().getName()
                   ));
    }
}
public void run()
{
    SetEnumerator       se = occupants.getEnumerator();
    ;
 
    while (se.moveNext())
    {
        if (this.process(occupants, resources, se.current()))
        {
            this.results();
            return;
        }
    }
}
static void main(Args _args)
{
    OwnerApartaments   ownerApartaments = new OwnerApartaments();
    ;
 
    ownerApartaments.run();
}
 
class OwnerResource
{
    Occupant    occupant;
}
public Occupant occupant(Occupant _occupant = occupant)
{
    ;
    occupant = _occupant;
    return occupant;
}
 
class   OwnerResource_Floor
extends OwnerResource
{
    int     intFloor;
}
public int intFloor(int _intFloor = intFloor)
{
    ;
    intFloor = _intFloor;
    return intFloor;
}
void new(int _intFloor)
{
    ;
 
    intFloor = _intFloor;
}
 
abstract class Occupant
{
}
public boolean check(OwnerApartaments _ownerApartaments)
{
    return true;
}
public boolean checkResource(OwnerResource _ownerResource)
{
    return true;
}
abstract public Name getName()
{
}
 
class   Occupant_Miller
extends Occupant
{
}
public boolean check(OwnerApartaments _ownerApartaments)
{
    boolean             ret = super(_ownerApartaments);
    SetEnumerator       se = _ownerApartaments.resources().getEnumerator();
    OwnerResource_Floor floor;
    int                 intFloorMiller;
    int                 intFloorCooper;
    ;
 
    if (ret)
    {
        ret = false;
        while (se.moveNext())
        {
            floor = se.current();
            if (SysDictClass::isEqualOrSuperclass(classIdGet(floor.occupant()), classNum(Occupant_Miller)))
            {
                intFloorMiller = floor.intFloor();
                if (intFloorCooper > 0)
                {
                    if (intFloorCooper < intFloorMiller)
                    {
                        ret = true;
                    }
                    break;
                }
            }
            if (SysDictClass::isEqualOrSuperclass(classIdGet(floor.occupant()), classNum(Occupant_Cooper)))
            {
                intFloorCooper = floor.intFloor();
                if (intFloorMiller > 0)
                {
                    if (intFloorCooper < intFloorMiller)
                    {
                        ret = true;
                    }
                    break;
                }
            }
        }
    }
 
    return ret;
}
public Name getName()
{
    return "Miller";
}
 
class   Occupant_Smith
extends Occupant
{
}
public boolean check(OwnerApartaments _ownerApartaments)
{
    boolean             ret = super(_ownerApartaments);
    SetEnumerator       se = _ownerApartaments.resources().getEnumerator();
    OwnerResource_Floor floor;
    int                 intFloorFletcher;
    int                 intFloorSmith;
    ;
 
    if (ret)
    {
        ret = false;
        while (se.moveNext())
        {
            floor = se.current();
            if (SysDictClass::isEqualOrSuperclass(classIdGet(floor.occupant()), classNum(Occupant_Fletcher)))
            {
                intFloorFletcher = floor.intFloor();
                if (intFloorSmith > 0)
                {
                    if (abs(intFloorSmith - intFloorFletcher) > 1)
                    {
                        ret = true;
                    }
                    break;
                }
            }
            if (SysDictClass::isEqualOrSuperclass(classIdGet(floor.occupant()), classNum(Occupant_Smith)))
            {
                intFloorSmith = floor.intFloor();
                if (intFloorFletcher > 0)
                {
                    if (abs(intFloorSmith - intFloorFletcher) > 1)
                    {
                        ret = true;
                    }
                    break;
                }
            }
        }
    }
 
    return ret;
}
public Name getName()
{
    return "Smith";
}
 
class   Occupant_Fletcher
extends Occupant
{
}
public boolean check(OwnerApartaments _ownerApartaments)
{
    boolean             ret = super(_ownerApartaments);
    SetEnumerator       se = _ownerApartaments.resources().getEnumerator();
    OwnerResource_Floor floor;
    int                 intFloorFletcher;
    int                 intFloorCooper;
    ;
 
    if (ret)
    {
        ret = false;
        while (se.moveNext())
        {
            floor = se.current();
            if (SysDictClass::isEqualOrSuperclass(classIdGet(floor.occupant()), classNum(Occupant_Fletcher)))
            {
                intFloorFletcher = floor.intFloor();
                if (intFloorCooper > 0)
                {
                    if (abs(intFloorCooper - intFloorFletcher) > 1)
                    {
                        ret = true;
                    }
                    break;
                }
            }
            if (SysDictClass::isEqualOrSuperclass(classIdGet(floor.occupant()), classNum(Occupant_Cooper)))
            {
                intFloorCooper = floor.intFloor();
                if (intFloorFletcher > 0)
                {
                    if (abs(intFloorCooper - intFloorFletcher) > 1)
                    {
                        ret = true;
                    }
                    break;
                }
            }
        }
    }
 
    return ret;
}
public boolean checkResource(OwnerResource _ownerResource)
{
    OwnerResource_Floor floor   = _ownerResource;
    boolean             ret     = super(_ownerResource);
    ;
 
    if (    floor.intFloor() == 1
        ||  floor.intFloor() == 5
       )
    {
        ret = false;
    }
 
    return ret;
}
public Name getName()
{
    return "Fletcher";
}
 
class   Occupant_Cooper
extends Occupant
{
}
public boolean checkResource(OwnerResource _ownerResource)
{
    OwnerResource_Floor floor   = _ownerResource;
    boolean             ret     = super(_ownerResource);
    ;
 
    if (floor.intFloor() == 1)
    {
        ret = false;
    }
 
    return ret;
}
public Name getName()
{
    return "Cooper";
}
 
class   Occupant_Baker
extends Occupant
{
}
public boolean checkResource(OwnerResource _ownerResource)
{
    OwnerResource_Floor floor   = _ownerResource;
    boolean             ret     = super(_ownerResource);
    ;
 
    if (floor.intFloor() == 5)
    {
        ret = false;
    }
 
    return ret;
}
public Name getName()
{
    return "Baker";
}