Code from Will Wright!/Blog (SoCoder)

Created 27 January 2009 | Last Edited 27 January 2009)

Development Diary : Code from Will Wright!
The Soul Of The Sims

A while ago I stumbled upon some code written by Will Wright as a prototype for generating AI-motives for The Sims.
Yesterday and today I spent a couple hours converting it to C# (had to type it all by hand since it was a picture of a printout).

Original source can be found here.

Here's my port as of right now:

Motive.cs

using System;
using System.Collections.Generic;
using System.Text;

namespace SimsMotives
{
    public enum MotiveState : int
    {
        HappyLife = 0,
        HappyWeek = 1,
        HappyDay = 2,
        HappyNow = 3,

        Physical = 4,
        Energy = 5,
        Comfort = 6,
        Hunger = 7,
        Hygiene = 8,
        Bladder = 9,

        Mental = 10,
        Alertness = 11,
        Stress = 12,
        Environment = 13,
        Social = 14,
        Entertained = 15
    }

    /// <summary>
    /// Represents a Sim's motive. Ported from original Mac source by Will Wright, available at:
    /// http://www.donhopkins.com/home/images/Sims/
    /// </summary>
    public class Motive
    {
        private float[] m_Motive = new float[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
        private float[] m_OldMotive = new float[16] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

        private int m_ClockH = 8; //Hours.
        private int m_ClockM = 0; //Minutes.

        private int m_DAYTICKS = 720;   //1 tick = 2 minutes gametime
        private int m_WEEKTICKS = 5040;

        public Motive()
        {
            m_Motive[(int)MotiveState.Energy] = 70;
            m_Motive[(int)MotiveState.Alertness] = 20;
            m_Motive[(int)MotiveState.Hunger] = -40;
        }

        /// <summary>
        /// Simulates internal motive changes.
        /// </summary>
        public void SimulateMotives()
        {
            float Tmp;
            int Z;

            //m_ClockM += 2; //Commented for running in a loop.
            if (m_ClockM > 58)
            {
                m_ClockM = 0;
                m_ClockH++;

                if (m_ClockH > 24)
                    m_ClockH = 1;
            }

            //Energy
            if (m_Motive[(int)MotiveState.Energy] > 0)
            {
                if (m_Motive[(int)MotiveState.Alertness] > 0)
                    m_Motive[(int)MotiveState.Energy] -= (m_Motive[(int)MotiveState.Alertness] / 100);
                else
                    m_Motive[(int)MotiveState.Energy] -= (m_Motive[(int)MotiveState.Alertness] / 100) *
                        ((100 - m_Motive[(int)MotiveState.Energy]) / 50);
            }
            else
            {
                if (m_Motive[(int)MotiveState.Alertness] > 0)
                    m_Motive[(int)MotiveState.Energy] -= (m_Motive[(int)MotiveState.Alertness] / 100) *
                        ((100 + m_Motive[(int)MotiveState.Energy]) / 50);
                else
                    m_Motive[(int)MotiveState.Energy] -= (m_Motive[(int)MotiveState.Alertness] / 100);
            }

            //I had some food.
            if (m_Motive[(int)MotiveState.Hunger] > m_OldMotive[(int)MotiveState.Hunger])
            {
                Tmp = m_Motive[(int)MotiveState.Hunger] - m_OldMotive[(int)MotiveState.Hunger];
                m_Motive[(int)MotiveState.Energy] += Tmp / 4;
            }

            //Comfort
            if (m_Motive[(int)MotiveState.Bladder] < 0)
                m_Motive[(int)MotiveState.Comfort] += m_Motive[(int)MotiveState.Bladder] / 10; //Max -10
            if (m_Motive[(int)MotiveState.Hygiene] < 0)
                m_Motive[(int)MotiveState.Comfort] += m_Motive[(int)MotiveState.Hygiene] / 20; //Max -5
            if (m_Motive[(int)MotiveState.Hunger] < 0)
                m_Motive[(int)MotiveState.Comfort] += m_Motive[(int)MotiveState.Hunger] / 20; //Max -5

            //Decide a max 100/cycle in a cubed curve (seek zero)
            m_Motive[(int)MotiveState.Comfort] -= (m_Motive[(int)MotiveState.Comfort] * m_Motive[(int)MotiveState.Comfort] *
                m_Motive[(int)MotiveState.Comfort]) / 10000;

            //Hunger
            Tmp = ((m_Motive[(int)MotiveState.Alertness] + 100) / 200) *
                ((m_Motive[(int)MotiveState.Hunger] + 100) / 100); //^alert * hunger^0
            m_Motive[(int)MotiveState.Hunger] -= Tmp;

            if (m_Motive[(int)MotiveState.Stress] < 0) //stress -> hunger
            {
                m_Motive[(int)MotiveState.Hunger] += (m_Motive[(int)MotiveState.Stress] / 100) *
                    ((m_Motive[(int)MotiveState.Hunger] + 100) / 100);
            }
            if (m_Motive[(int)MotiveState.Hunger] < -99)
            {
                Console.WriteLine("\nYou have starved to death!");
                m_Motive[(int)MotiveState.Hunger] = 80;
            }

            //Hygiene
            if (m_Motive[(int)MotiveState.Alertness] > 0)
                m_Motive[(int)MotiveState.Hygiene] -= 3;
            else
                m_Motive[(int)MotiveState.Hygiene] -= .1f;
            if (m_Motive[(int)MotiveState.Hygiene] < -97) //Hit limit, bath
            {
                Console.WriteLine("\nYou smell very bad, mandatory bath.");
                m_Motive[(int)MotiveState.Hygiene] = 80;
            }

            //Bladder
            if (m_Motive[(int)MotiveState.Alertness] > 0)
                m_Motive[(int)MotiveState.Bladder] -= .4f; //Bladder fills faster while awake
            else
                m_Motive[(int)MotiveState.Bladder] -= .2f;
            //Food eaten goes into bladder.
            if (m_Motive[(int)MotiveState.Hunger] > m_OldMotive[(int)MotiveState.Hunger])
            {
                Tmp = m_Motive[(int)MotiveState.Hunger] - m_OldMotive[(int)MotiveState.Hunger];
                m_Motive[(int)MotiveState.Bladder] -= Tmp / 4;
            }
            if(m_Motive[(int)MotiveState.Bladder] < -97)
            {
                if (m_Motive[(int)MotiveState.Alertness] > 0)
                    Console.WriteLine("\nYou have wet your bed!");
                else
                    Console.WriteLine("\nYou have soiled the carpet!");

                m_Motive[(int)MotiveState.Bladder] = 90;
            }

            //Alertness
            if (m_Motive[(int)MotiveState.Alertness] > 0)
                Tmp = (100 - m_Motive[(int)MotiveState.Alertness]) / 50; //Max delta at zero
            else
                Tmp = (m_Motive[(int)MotiveState.Alertness] + 100) / 50;
            if(m_Motive[(int)MotiveState.Energy] > 0)
            {
                if (m_Motive[(int)MotiveState.Alertness] > 0)
                    m_Motive[(int)MotiveState.Alertness] += (m_Motive[(int)MotiveState.Energy] / 100) * Tmp;
                else
                    m_Motive[(int)MotiveState.Alertness] += (m_Motive[(int)MotiveState.Energy] / 100);
            }
            else
            {
                if (m_Motive[(int)MotiveState.Alertness] > 0)
                    m_Motive[(int)MotiveState.Alertness] += (m_Motive[(int)MotiveState.Energy] / 100);
                else
                    m_Motive[(int)MotiveState.Alertness] += (m_Motive[(int)MotiveState.Energy] / 100) * Tmp;
            }

            m_Motive[(int)MotiveState.Alertness] += (m_Motive[(int)MotiveState.Entertained] / 300) * Tmp;

            if (m_Motive[(int)MotiveState.Bladder] < -50)
                m_Motive[(int)MotiveState.Alertness] -= (m_Motive[(int)MotiveState.Bladder] / 100) * Tmp;

            //Stress
            m_Motive[(int)MotiveState.Stress] += m_Motive[(int)MotiveState.Comfort] / 10;       //Max -10
            m_Motive[(int)MotiveState.Stress] += m_Motive[(int)MotiveState.Entertained] / 10;   //Max -10
            m_Motive[(int)MotiveState.Stress] += m_Motive[(int)MotiveState.Environment] / 15;   //Max -7
            m_Motive[(int)MotiveState.Stress] += m_Motive[(int)MotiveState.Social] / 20;        //Max -5

            if (m_Motive[(int)MotiveState.Stress] < 0) //Cut stress while asleep
                m_Motive[(int)MotiveState.Stress] = m_Motive[(int)MotiveState.Stress] / 3;

            //Dec a max 100/cycle in a cubed curve (seek zero)
            m_Motive[(int)MotiveState.Stress] -= (m_Motive[(int)MotiveState.Stress] * 
                m_Motive[(int)MotiveState.Stress] * m_Motive[(int)MotiveState.Stress]) / 10000;

            if (m_Motive[(int)MotiveState.Stress] < 0)
            {
                Random Rnd = new Random();
                if (Rnd.Next(30) - 100 > m_Motive[(int)MotiveState.Stress])
                {
                    if (Rnd.Next(30) - 100 > m_Motive[(int)MotiveState.Stress])
                    {
                        Console.WriteLine("\nYou have lost your temper!");
                        ChangeMotive((int)MotiveState.Stress, 20);
                    }
                }
            }

            //Environment

            //Social

            //Entertained
            if (m_Motive[(int)MotiveState.Alertness] > 0) //Cut entertained while asleep
                m_Motive[(int)MotiveState.Entertained] = m_Motive[(int)MotiveState.Entertained] / 2;

            //Calc physical
            Tmp = m_Motive[(int)MotiveState.Energy];
            Tmp += m_Motive[(int)MotiveState.Comfort];
            Tmp += m_Motive[(int)MotiveState.Hunger];
            Tmp += m_Motive[(int)MotiveState.Hygiene];
            Tmp += m_Motive[(int)MotiveState.Bladder];
            Tmp = Tmp / 5;

            if (Tmp > 0) //Map the linear average into squared curve
            {
                Tmp = 100 - Tmp;
                Tmp = (Tmp * Tmp) / 100;
                Tmp = 100 - Tmp;
            }
            else
            {
                Tmp = 100 + Tmp;
                Tmp = (Tmp * Tmp) / 100;
                Tmp = 100 - Tmp;
            }
            m_Motive[(int)MotiveState.Physical] = Tmp;

            //Calc mental
            Tmp += m_Motive[(int)MotiveState.Stress]; //Stress counts * 2
            Tmp += m_Motive[(int)MotiveState.Stress];
            Tmp += m_Motive[(int)MotiveState.Environment];
            Tmp += m_Motive[(int)MotiveState.Social];
            Tmp += m_Motive[(int)MotiveState.Entertained];
            Tmp = Tmp / 5;

            if (Tmp > 0) //Map the linear average into squared curve
            {
                Tmp = 100 - Tmp;
                Tmp = (Tmp * Tmp) / 100;
                Tmp = 100 - Tmp;
            }
            else
            {
                Tmp = 100 + Tmp;
                Tmp = (Tmp * Tmp) / 100;
                Tmp = Tmp - 100;
            }
            m_Motive[(int)MotiveState.Mental] = Tmp;

            //Calc average happiness
            //Happy = mental + physical
            m_Motive[(int)MotiveState.HappyNow] = 
                (m_Motive[(int)MotiveState.Physical] + m_Motive[(int)MotiveState.Mental]) / 2;
            m_Motive[(int)MotiveState.HappyDay] = ((m_Motive[(int)MotiveState.HappyDay] * (m_DAYTICKS - 1)) +
                m_Motive[(int)MotiveState.HappyNow]) / m_DAYTICKS;
            m_Motive[(int)MotiveState.HappyWeek] = ((m_Motive[(int)MotiveState.HappyDay] * (m_WEEKTICKS - 1)) +
                m_Motive[(int)MotiveState.HappyNow]) / m_WEEKTICKS;
            m_Motive[(int)MotiveState.HappyLife] = ((m_Motive[(int)MotiveState.HappyLife] * 9) + 
                m_Motive[(int)MotiveState.HappyWeek]) / 10;

            for (Z = 0; Z < 16; Z++)
            {
                if (m_Motive[Z] > 100) //Check for over/under flow
                    m_Motive[Z] = 100;
                if (m_Motive[Z] < -100)
                    m_Motive[Z] = -100;

                m_OldMotive[Z] = m_Motive[Z]; //Save set in m_OldMotive (for delta tests)
            }
        }

        /// <summary>
        /// Use this to change motives (checks overflow).
        /// </summary>
        /// <param name="Motive">The motivestate to change.</param>
        /// <param name="Value">The new motive-value.</param>
        private void ChangeMotive(int Motive, float Value)
        {
            m_Motive[Motive] += Value;

            if (m_Motive[Motive] > 100)
                m_Motive[Motive] = 100;
            if (m_Motive[Motive] < -100)
                m_Motive[Motive] = -100;
        }

        /// <summary>
        /// Increases time and randomly changes motives.
        /// </summary>
        public void SimJob()
        {
            m_ClockH += 9;
            if (m_ClockH > 24)
                m_ClockH -= 24;

            Random Rnd = new Random();

            m_Motive[(int)MotiveState.Energy] = ((m_Motive[(int)MotiveState.Energy] + 100) * .3f) - 100;
            m_Motive[(int)MotiveState.Hunger] = -60 + Rnd.Next(20);
            m_Motive[(int)MotiveState.Hygiene] = -70 + Rnd.Next(30);
            m_Motive[(int)MotiveState.Bladder] = -50 + Rnd.Next(50);
            m_Motive[(int)MotiveState.Alertness] = 10 + Rnd.Next(10);
            m_Motive[(int)MotiveState.Stress] = -50 + Rnd.Next(50);
        }

        /// <summary>
        /// The number of milliseconds to wait before
        /// updating gamestate.
        /// </summary>
        public int DayTicks
        {
            get { return m_DAYTICKS; }
        }

        /// <summary>
        /// Number of milliseconds in a week.
        /// </summary>
        public int WeekTicks
        {
            get { return m_WEEKTICKS; }
        }

        public float Energy
        {
            get { return m_Motive[(int)MotiveState.Energy]; }
        }

        public float Hygiene
        {
            get { return m_Motive[(int)MotiveState.Hygiene]; }
        }

        public float Alertness
        {
            get { return m_Motive[(int)MotiveState.Alertness]; }
        }

        public float Stress
        {
            get { return m_Motive[(int)MotiveState.Stress]; }
        }

        public float Social
        {
            get { return m_Motive[(int)MotiveState.Social]; }
        }

        public float Entertained
        {
            get { return m_Motive[(int)MotiveState.Entertained]; }
        }
    }
}

-->

using System;
using System.Collections.Generic;
using System.Text;
using System.Timers;
using System.Threading;

namespace SimsMotives
{
    class Program
    {
        private static System.Timers.Timer m_Timer;
        private static Motive m_Motives = new Motive();

        static void Main(string[] args)
        {
            m_Timer = new System.Timers.Timer();
            m_Timer.Interval = m_Motives.DayTicks;
            m_Timer.Elapsed += new ElapsedEventHandler(m_Timer_Elapsed);
            m_Timer.Start();

            while (true)
            {
                Thread.Sleep(100);
            }
        }

        static void m_Timer_Elapsed(object sender, ElapsedEventArgs e)
        {
            Console.WriteLine("\nNew Day!");
            m_Motives.SimJob();
            m_Motives.SimulateMotives();

            Console.WriteLine("Energy: " + m_Motives.Energy.ToString());
            Console.WriteLine("Alertness: " + m_Motives.Alertness.ToString());
            Console.WriteLine("Hygiene: " + m_Motives.Hygiene.ToString());
            Console.WriteLine("Social: " + m_Motives.Social.ToString());
            Console.WriteLine("Stress: " + m_Motives.Stress.ToString());
            Console.WriteLine("Entertained: " + m_Motives.Entertained.ToString() + "\n");
        }
    }
}

-->

If anyone can think of a better way to actually run the SimJob() and SimulateMotives() functions, feel free to comment!
Also, I might make this into some kind of windows program when I feel like it... it seems there are a couple of function definitions in the original source for graphing functions, but they haven't been fleshed out as of yet.
That said, this is an interesting example of advanced AI... it seems you can run the simulation for up to several months without the sims becoming too dirty or loosing their temper. That might be because of the very dense timespan, though.

There are no comments for this entry.