Robot* otherRobotAt(Robot* rp) const
//      If there is at least one robot (other than the one rp points to)
//      at the same (r,c) coordinates as the one rp points to, return a
//      pointer to the one of those other robots with the least amount
//      of energy remaining (if there's a tie, any one of the tied robots
//      will do); otherwise, return NULL.
//
{
	for (int i = 0; i< m_nrobots; i++)
	{
		if ((m_robots[i] -> row()==r)
			&& (m_robots[i] -> col()==c)
			return this; 
	}
	return NULL;
}

Robot* otherRobotAt(Robot* rp) const
//      If there is at least one robot (other than the one rp points to)
//      at the same (r,c) coordinates as the one rp points to, return a
//      pointer to the one of those other robots with the least amount
//      of energy remaining (if there's a tie, any one of the tied robots
//      will do); otherwise, return NULL.
//
{
	for (int i = 0; i< m_nrobots; i++)   // check each robot
	{
		if ((m_robots[i] -> row()==m_row)      // if robot matches coordinate
			&& (m_robots[i] -> col()==m_col && (m_robot[i]!= rp))  // and robot not the one we're looking at
			int n = m_source[i];       
			for (int j = 0; j < i; j++)        // find robot of minimum energy
			{   
				if (m_source[j] < n) 
				       n = m_source[j];
			}	
			return m_robots[i];                 //returns robot of least energy
				
	}
	return NULL;
}

Robot* Valley::otherRobotAt(Robot* rp) const
{
Robot* robotToReturn = NULL;
int leastEnergy = FULL_ENERGY;
for (int i=0; i < m_nrobots; i++)
{
	if ((m_robots[i] -> row() == rp -> row() ) 
		&& (m_robots[i] ->  col() == rp -> col()) 
		&& (m_robots[i] != rp) 
		&& (robotToReturn -> energy() < leastEnergy))
	{
		robotToReturn = m_robots[i];
		leastEnergy = robotToReturn -> energy();
	}
}
	return robotToReturn;


}

     for (int h=0; h < m_nrobots; h++)
    {
        if ((m_robots[h] -> row() == this -> row() )
            && (m_robots[h] ->  col() == this -> col())
            && (m_robots[h] != this)
            && ((m_robots[h] -> energy() == 0)))
            return true;
        {
            m_energy -= SHARE_AMOUNT;
            m_robots[h] -> energy() = SHARE_AMOUNT;
        }
    }

        
// TODO:  indicate each robot's position
// for each robot in the valley,
//   set the appropriate element of the grid to the first character
//          of the robot's name.
    for (int b = 0; b < m_nrobots; b++)
    {
        grid[r][c] = 'name()';   // TODO: Fix name() so only first char of name

        
        // TODO:  Write robot energy info
        // for each robot in the valley,
        //   write the robot's name and remaining energy level.

        cout << name() << endl;
        cout << energy() << endl;

bool Valley::step()
{
    //      TODO: implement step
    //      Have each robot in the valley step.  If any of them attempted to move,
    //      return true.  If none of them did, they're all dead, so return false.


for (int p = 0; p < m_nrobots; p++)
{
    if (m_robots[p].step)
        return true;
}
 return false;
}

        grid[r][c] = 'name()';   // TODO: Fix name() so only first char of name

	//    If at this spot there's another robot whose energy level is 0,
	//       then if we have at least SHARE_THRESHHOLD units of energy,
	//       transfer SHARE_AMOUNT units to that other robot.  (If there
	//       are two or more dead robots here, we donate to only one.)
	//    Return true, indicating the robot attempted to move.
	
		if ((otherRobotAt(Robot* rp)-> energy() == 0)
			&& (m_energy > SHARE_THRESHHOLD))
		{
			m_energy -= SHARE_AMOUNT;
			otherRobotAt(Robot* rp)-> energy() = SHARE_AMOUNT;
                        return true;
		}

grid[r][c] = 'name()'; // TODO: Fix name() so only first char of name

void Valley::display() const
{
	char grid[NROWS][NCOLS];
	int r, c;

	// fill the grid with dots
	for (r = 0; r < NROWS; r++)
	{
		for (c = 0; c < NCOLS; c++)
		{
			grid[r][c] = '.';
		// TODO:  mark each energy source with a star
		// for each energy source in the valley,
		//   set the appropriate element of the grid to '*'
			if (energySourceAt(r,c))
				grid[r][c] = '*';
		}
	}	
	
		// TODO:  indicate each robot's position
		// for each robot in the valley,
		//   set the appropriate element of the grid to the first character
		//          of the robot's name.
	for (int b = 0; b < m_nrobots; b++)
	{
		grid[r][c] = vp -> name()[0];   // TODO: Fix it so only first char of name
	
	}

      
  // TODO:  Write robot energy info
  // for each robot in the valley,
  //   write the robot's name and remaining energy level.

for (int c = 0; c < m_nrobots; c++)
{
cout << m_robot [c] -> name() << endl;
cout << m_robot [c] -> energy() << endl;
}

bool Valley::step()
{
    //      TODO: implement step
    //      Have each robot in the valley step.  If any of them attempted to move,
    //      return true.  If none of them did, they're all dead, so return false.


for (int p = 0; p < m_nrobots; p++)
{
    if (m_robots[p] -> step())
        return true;
}
 return false;
}

grid[r][c] = m_robots[b] -> name()[0];

cout << m_robots[c] -> name() << endl;
cout << m_robots[c] -> energy() << endl;

I don't understand. Are you saying that we're testing the same robotToReturn each time? Does this mean I need to test the i'th element of the robotToReturn?

if ((otherRobotAt(Robot* rp)-> energy() == 0)

m_energy -= SHARE_AMOUNT;
otherRobotAt(Robot* rp)-> energy() = SHARE_AMOUNT;