How do I have numbers increment slowly over a course of time throughout runtime

Question

I am trying to make a text based game in which the user is a pilot in space. I want to create a movement system but am unsure how to do it. I want the user to be able to put in the desired grid coordinates, and his vehicle will begin to change its grid coords to get closer and closer to the ones he inputted.

Now, to do this I will probably need multithreading and a time element. But I am unsure how I can use a time element. Any advice is greatly appreciate, i'm just trying to learn here. Thanks guys!

from Gundam2 import Mobilesuits

#Main Variable/Object declarations:

Leo1=Mobilesuits(100,100,"Leo","leo desc","dockpit desc",100,[100,100,100])
Leo2=Mobilesuits(100,100,"Leo","leo desc","dockpit desc",100,[300,100,100])
Leo3=Mobilesuits(100,100,"Leo","leo desc","dockpit desc",100,[100,150,100])
currentmobilesuit=Leo1

#Main Function declarations               
def commands(user_input,currentmobilesuit):
    if user_input == "radar":
        currentmobilesuit.radar()
    elif user_input == "commands":
        print("Command list:\nradar")
    else:
        print("Invalid command\nType 'commands' for a list of valid commands")


#Main execution
while True:
    commands(raw_input(),currentmobilesuit)



class Mobilesuits:
    #class global variables/methods here
    instances = [] #grid cords here
    def __init__(self,armor,speed,name,description,cockpit_description,\
                 radar_range, coordinates):
        Mobilesuits.instances.append(self)
        self.armor=armor
        self.speed=speed
        self.name=name
        self.description=description
        self.cockpit_description=cockpit_description
        self.radar_range=radar_range
        self.coordinates=coordinates



    def can_detect(self, other):
        for own_coord, other_coord in zip(self.coordinates, other.coordinates):
            if abs(own_coord - other_coord) > self.radar_range:
                return False
            return True

    def radar(self):
        for other in Mobilesuits.instances:
            if other is not self  and self.can_detect(other):
                print "%s detected at %s" % (other.description, other.coordinates)

Answer 1

You can use non-blocking I/O. This will help you avoid the complications of threading. Here's your sample code implemented with a non-blocking read of stdin:

#!/usr/bin/python
import sys
import select
call_count = 0
#Main Function declarations
def commands(user_input):
   global call_count
   if len(user_input) > 0:
      print('call count: ' + str(call_count) + ' user entered: ' + user_input)

def raw_input_no_block():
   global call_count
   call_count = call_count + 1
   input_avail = select.select([sys.stdin], [], [], 0.1)[0] #wait for 0.1 seconds
   if input_avail:
      return sys.stdin.readline()
   else:
      return ''

#Main execution
while True:
    commands(raw_input_no_block())

Answer 2

Games typically have a "master loop" of some kind; yours does here:

#Main execution
while True:
    commands(raw_input(),currentmobilesuit)

The simplest thing to do is to count in the loop:

#Main execution
turn_count = 0
while True:
    commands(raw_input(),currentmobilesuit)
    turn_count += 1

If you wanted the real time taken to have some impact on the counter, or be the counter, you can get the current time from the time module calling time.time().

#Main execution
import time
time_start = time.time()
time_elapsed = 0
while True:
    commands(raw_input(),currentmobilesuit)
    time_elapsed = time.time() - time_start

A couple other thoughts:

Make a Game class, and put the turn counter and game loop in that.

Have the commands function return a number that is the number of time units that took place during the command; for example, entering an invalid command might take 0 turns, while repairing a robot might take 5.

#Main execution
turn_count = 0
while True:
    turns_taken = commands(raw_input(),currentmobilesuit)
    turn_count += turns_taken