How can I best decouple two classes, which one way dependencies

I am attempting to create a D&D combat encounter simulator using C++ and since it's D&D, all aspects of the simulation are going to depend heavily on the "Dice" Class and its methods. I could instantiate a "Dice" object every time another class needs to invoke its methods, however, that would leave everything heavily coupled and make it very difficult to make changes or extensions later.

I don't have any practical knowledge about things such as Factories, dependency injections, and other such methods. My question therefore in essence is:

What would be the best way to ensure that the "Dice" class remains as decoupled as possible from all other classes? While still enabling them to make use of the "Dice" objects, and its methods, when needed.

Dice.h

#ifndef dice_h_
#define dice_h_

#include <stdlib.h>

class Dice
{
  private:
    int maxValue;

  public:
    Dice(int maxValue);
    ~Dice();

    int getMaxValue( void ){return maxValue;}
    void setMaxValue(int newMaxValue){maxValue = newMaxValue;}

    int rollDice();
    int rollMultipleDice(int numberOfDiceRolls);
};
#endif

Dice.cpp

#ifndef dice_cpp_
#define dice_cpp_

#include "dice.h"

Dice::Dice(int maxValue){this->maxValue = maxValue;}
Dice::~Dice(){}

int Dice::rollDice()
{
  return (rand() % maxValue) + 1;
}

int Dice::rollMultipleDice(int numberOfDiceRolls)
{
  int i = numberOfDiceRolls, sum = 0;

  while(i-- > 0)
  {
    sum += rollDice();
  }

  return sum;
}
#endif

Actor.h

#ifndef actor_h_
#define actor_h_

#include "dice.h"

class Actor
{
  private:
    unsigned int hp;
    unsigned int ac; // Armor Class
    unsigned int dmg;
    
  public:
    Actor(unsigned int hp, unsigned int ac, unsigned int dmg);
    ~Actor();

    unsigned int getHP( void );
    unsigned int getAC( void );
    unsigned int getDmg( void );
    void setHP( unsigned int newHP);
    void setAC( unsigned int newAC);
    void setDmg( unsigned int newDmg);

    void attack(Actor* target);
    bool isHit(Actor target);
};
#endif

Actor.cpp

#ifndef actor_cpp_
#define actor_cpp_

#include "actor.h"

Actor::Actor(unsigned int hp, unsigned int ac, unsigned int dmg)
{
  this->hp = hp;
  this->ac = ac;
  this->dmg = dmg;
}
Actor::~Actor(){}

unsigned int Actor::getHP( void ){return hp;}
unsigned int Actor::getAC( void ){return ac;}
unsigned int Actor::getDmg( void ){return dmg;}
void Actor::setHP( unsigned int newHP ){this->hp = newHP;}
void Actor::setAC( unsigned int newAC ){this->ac = newAC;}
void Actor::setDmg( unsigned int newDmg ){this->dmg = newDmg;}

void Actor::attack(Actor* target)
{ 
  
  Dice damageDice(8);

  if (isHit(*target))
  {
    target->setHP(target->getHP() - damageDice.rollDice());
  }
}

// helper function to attack function
// do not use elsewhere
bool Actor::isHit(Actor target)
{
  Dice atkDice(20);

  return atkDice.rollDice() >= target.getAC();
}


#endif