<p><img alt="" src="https://cdngeneral.rentcafe.com//dmslivecafe/UploadedImages/8f1da378-47b2-4bb9-89a3-87d45e35a2b1.jpg" style="width: 360px; height: 175px;" /><br />
Swimming in the summertime is an age old past time. Here are some fun ideas to entertain everyone!</p>

<p><em>Marco Polo</em> &ndash; This age old game will never get old! If you have never played this game before, one person is at one end of the pool with their eyes closed, while trying to capture the other. The players yell Marco and Polo to find each other in the pool.</p>

<p><em>Pool Noodle Charades</em> &ndash; Players take turns playing this guessing game while using a pool noodle. Some ideas could be an elephant, glasses, or an airplane. Use your imagination!</p>

<p><em>Pool Volleyball</em> &ndash; Grab the volleyball and toss it around it the pool. It may sound simple but this will allow for hours of entertainment.</p>

<p>Providence Place Apartments hopes everyone has a fantastic summer and loads of fun using these fun ideas.</p>
