One of the problems I wanted to solve was how to animate a simple windup walking toy in POV-Ray. The biggest problem was getting the feet to move in an orderly fashion, and that's what I'll start explaining. Lets start by declaring to simple blocks for "feet":

  #declare LeftFoot = box { <-1,0,-0.5> <-0.5,0.1,0.5> pigment { rgb 1 } }
  #declare RightFoot = box { <0.5,0,-0.5> <1,0.1,0.5> pigment { rgb 1 } }

Lets declare a few variables to play with :

#declare step_duration = 0.5;
#declare step_height = 0.5;
#declare step_length = 1;

#declare anim_clock = clock;
#declare step_clock = anim_clock/step_duration;
#declare pi_clock = step_clock * pi;
#declare normal_clock = step_clock - int(step_clock);

#declare left_start = 0;
#declare right_start = -step_length/2;

 The first three items, step_duration,step_height, and step_length all detail facts about each step. Step_duration describes how much time (in clock values) each step is, so the pattern will be move for one step_duration, pause for the next step_duration, move for the next, and so on.
 As a rule, I use anim_clock in all my animations. I can set it to a specific number as well as assigning it to the clock variable. I think it's more flexible.
step_clock is an altered value of the anim_clock, so if step_duration is 0.75, then when anim_clock is at 0.75, step_clock is at 1, and when anim_clock is at 1.5, step_clock will be at 2.
I'll discuss the rest as they become part of the whole.

 Unfortunately POV-Ray does not have a native Odd function to tell you if a number is odd or even, so I had to write one:

#macro Odd(a)
  #local o = true;
  #local i = int(a)/2;
  #if ( i = (int(i)) ) 
    #local o = false;
  #end
  o 
#end

#declare foot_Y = abs(sin(pi_clock)*step_height);

#if (Odd(step_clock))
  #declare left_height = abs(sin(pi_clock)*step_height);
  #declare right_height = 0;
#else
  #declare left_height = 0;
  #declare right_height = abs(sin(pi_clock)*step_height);
#end

object { RightFoot translate right_height*y }
object { LeftFoot translate left_height*y }

Now that the feet are moving up and down properly, lets get the horizontal movement started. The left foot is starting off first, so first we have to set the left foot back half a step. A more advanced version of this would let both feet be even and the first step only take half as long, but that can be more work than I want to go through right now. Starting the left foot back half a step corrects for this.

The next big problem we face is when to move each foot. We want to use step_clock to control when each foot moves. The chart on the left shows the horizontal position of each foot based on the value of step_clock.

Now there are some obvious patterns here. When step_clock is odd, the left foot moves from one half the integer value of step_clock, or int(step_clock)/2 + err, well, we need to get a normalized value of zero to one. Of course step_clock minus the integer value of step_clock will work; so (int(step_clock) - 1)*0.5 + normal_clock. When the left foot isn't moving, we can use int(step_clock)*0.5 to find the proper position.

The right foot moves when step_clock is even, and therefore we need to use a slightly different algorithm to find the right footing. When it's not moving, it looks like one half the integer value of step clock will work, so (int(step_clock) +1)/2. When it's moving, lets hazard one half the step_clock value minus one. So int(step_clock)*0.5 + normal_clock

Here is the code:

#if (Odd(step_clock))
  #declare left_height = abs(sin(pi_clock)*step_height);
  #declare right_height = 0;
  #declare left_dist = (int(step_clock) - 1)*0.5 + normal_clock;
  #declare right_dist = (int(step_clock) +1)/2;
#else
  #declare left_height = 0;
  #declare right_height = abs(sin(pi_clock)*step_height);
  #declare left_dist = int(step_clock)*0.5; // change
  #declare right_dist = int(step_clock)*0.5 + normal_clock;
#end

#declare right_dist = right_dist * step_length + right_start;
#declare left_dist = (left_dist * step_length) + left_start;

object { RightFoot translate <0,right_height,right_dist> }
object { LeftFoot translate <0,left_height,left_dist> }