episodic.c

Go to the documentation of this file.

/****************************************************************

 episodic.c

 =============================================================

 Copyright 1996-2014 Tom Barbalet. All rights reserved.

 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation
 files (the "Software"), to deal in the Software without
 restriction, including without limitation the rights to use,
 copy, modify, merge, publish, distribute, sublicense, and/or
 sell copies of the Software, and to permit persons to whom the
 Software is furnished to do so, subject to the following
 conditions:

 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.

 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 OTHER DEALINGS IN THE SOFTWARE.

 This software and Noble Ape are a continuing work of Tom Barbalet,
 begun on 13 June 1996. No apes or cats were harmed in the writing
 of this software.

 ****************************************************************/

#include "entity.h"
#include "entity_internal.h"

#ifdef EPISODIC_ON

static n_console_output * local_logging;
static n_int local_social;

void episodic_logging(n_console_output * output_function, n_int social)
{
    local_logging = output_function;
    local_social = social;
}

static void episodic_intention_update(noble_simulation * local_sim, noble_being * local, n_int episode_index)
{
    noble_episodic * local_episodic = being_episodic(local);
    n_byte event;
    n_int learned_preference_index=-1;
    if (local_episodic == 0L)
    {
        return;
    }
    event = local_episodic[episode_index].event - EVENT_INTENTION;
    switch(event)
    {
    case EVENT_CHAT:
    {
        learned_preference_index = PREFERENCE_CHAT;
        break;
    }
    case EVENT_GROOM:
    {
        if ((local_episodic[episode_index].arg&2)!=0)
        {
            learned_preference_index = PREFERENCE_GROOM_MALE;
        }
        else
        {
            learned_preference_index = PREFERENCE_GROOM_FEMALE;
        }
        break;
    }
    }

    if (learned_preference_index>-1)
    {
        if ((local_episodic[episode_index].arg&1)!=0)
        {
            if (local->learned_preference[learned_preference_index]<255)
            {
                local->learned_preference[learned_preference_index]++;
            }
        }
        else
        {
            if (local->learned_preference[learned_preference_index]>0)
            {
                local->learned_preference[learned_preference_index]--;
            }
        }
    }
}

void episodic_cycle(noble_simulation * local_sim, noble_being * local_being, void * data)
{
    if (being_awake(local_sim, local_being) == 0) return;
    
    {
        n_int i;
        noble_episodic * local_episodic = being_episodic(local_being);
        n_genetics * genetics = being_genetics(local_being);

        if (!local_episodic) return;

        for (i=0; i<EPISODIC_SIZE; i++)
        {
            if (local_episodic[i].event == 0) continue;

            if (local_episodic[i].event >= EVENT_INTENTION)
            {
                if (being_name_comparison(local_being, local_episodic[i].first_name[BEING_MEETER], local_episodic[i].family_name[BEING_MEETER]))
                {
                    if (spacetime_before_now(&local_episodic[i].space_time, local_sim->land))
                    {
                        local_episodic[i].event = 0;
                        continue;
                    }
                }
                episodic_intention_update(local_sim, local_being, i);
            }

            if (local_episodic[i].affect < EPISODIC_AFFECT_ZERO)
            {
                if (EPISODIC_AFFECT_ZERO - local_episodic[i].affect > 16)
                {
                    local_episodic[i].affect+=(1+GENE_NEGATIVE_AFFECT_FADE(genetics));
                }
                else
                {
                    local_episodic[i].affect++;
                }
            }
            else
            {
                if (local_episodic[i].affect > EPISODIC_AFFECT_ZERO)
                {
                    if (local_episodic[i].affect - EPISODIC_AFFECT_ZERO > 16)
                    {
                        local_episodic[i].affect-=(1+GENE_POSITIVE_AFFECT_FADE(genetics));
                    }
                    else
                    {
                        local_episodic[i].affect--;
                    }
                }
            }
        }
    }
}

n_int episodic_met_being_celebrity(
    noble_simulation * local_sim,
    noble_being * meeter_being,
    noble_being * met_being)
{
    n_int i,j,celebrity=0,ctr,aff;
    noble_episodic * meeter_episodic = being_episodic(meeter_being);
    n_byte2 first_name = being_gender_name(met_being);
    n_byte2 family_name = being_family_name(met_being);

    if (!meeter_episodic) return 0;

    for (i=0; i<EPISODIC_SIZE; i++)
    {
        aff = (n_int)(meeter_episodic[i].affect) - EPISODIC_AFFECT_ZERO;
        if (aff>1) aff=1;
        if (aff<-1) aff=-1;

        for (j=BEING_MEETER; j<=BEING_MET; j++)
        {
            ctr=0;
            if (meeter_episodic[i].first_name[j]==first_name)
            {
                celebrity+=aff;
                ctr++;
            }
            if (meeter_episodic[i].family_name[j]==family_name)
            {
                celebrity+=aff;
                ctr++;
            }
            if (ctr==2)
            {
                celebrity+=aff*2;
            }
        }
    }

    if (celebrity>16) celebrity=16;
    if (celebrity<-16) celebrity=-16;
    return celebrity;
}

n_int episodic_first_person_memories_percent(
    noble_simulation * local_sim,
    noble_being * local,
    n_byte intention)
{
    n_int i,hits=0,memories=0;
    noble_episodic * local_episodic = being_episodic(local);
    if (local_episodic == 0L)
    {
        return 0;
    }

    for (i=0; i<EPISODIC_SIZE; i++)
    {
        if (local_episodic[i].event>0)
        {
            if (intention!=0)
            {
                if (local_episodic[i].event >= EVENT_INTENTION)
                {
                    hits++;
                }
            }
            else
            {
                if (being_name_comparison(local, local_episodic[i].first_name[BEING_MEETER], local_episodic[i].family_name[BEING_MEETER]))
                {
                    hits++;
                }
            }
            memories++;
        }
    }
    if (memories>0)
    {
        return hits*100/memories;
    }
    else
    {
        if (intention!=0)
        {
            return 0;
        }
        return 100;
    }
}

static n_int noble_episodic_replace_index(
    n_byte event,
    n_int affect,
    n_byte2 name1, n_byte2 family1,
    n_byte2 name2, n_byte2 family2,
    noble_being * local,
    noble_simulation * local_sim)
{
    n_int abs_aff = affect;
    n_int i;
    n_int replace=-1;
    n_int min;
    n_byte event_exists=0;

    noble_episodic * local_episodic = being_episodic(local);

    if (!local_episodic) return -1;

    abs_aff = ABS(abs_aff);
    min = abs_aff;
    for (i=0; i<EPISODIC_SIZE; i++)
    {
        if (local_episodic[i].event == event)
        {
            if ((local_episodic[i].first_name[BEING_MEETER]==name1) &&
                    (local_episodic[i].family_name[BEING_MEETER]==family1))
            {
                n_int aff1 = ABS((n_int)(local_episodic[i].affect)-EPISODIC_AFFECT_ZERO);
                event_exists = 1;
                if (aff1 <= min)
                {
                    min = aff1;
                    replace = i;
                }
            }
        }
    }

    if (event_exists==0)
    {
        for (i=0; i<EPISODIC_SIZE; i++)
        {
            if (local_episodic[i].event == 0)
            {
                return i;
            }
        }

        min = abs_aff;
        for (i=0; i<EPISODIC_SIZE; i++)
        {
            n_int aff1 = ABS((n_int)(local_episodic[i].affect)-EPISODIC_AFFECT_ZERO);
            if (aff1 < min)
            {
                min = aff1;
                replace = i;
            }
        }
    }

    return replace;
}

static void episodic_store_full(
    noble_being * local,
    n_byte event,
    n_int affect,
    noble_simulation * local_sim,
    n_byte2 name1, n_byte2 family1,
    n_byte2 name2, n_byte2 family2,
    n_byte2 arg,
    n_byte food)
{
    noble_episodic * local_episodic = being_episodic(local);
    n_int replace;
    n_byte  old_event;
    n_byte2 old_time;
    n_byte2 new_time;

    if (local_episodic == 0L)
    {
        return;
    }

    if (being_awake(local_sim, local)==FULLY_ASLEEP) return;

    replace = noble_episodic_replace_index(event,affect,name1,family1,name2,family2,local,local_sim);

    if (replace == -1) return;

    old_event = local_episodic[replace].event;
    old_time = local_episodic[replace].space_time.time;

    local_episodic[replace].event       = event;
    local_episodic[replace].affect      = (n_byte2)(affect+EPISODIC_AFFECT_ZERO);

    spacetime_set(&local_episodic[replace].space_time, local_sim->land, being_location(local));
    
    new_time = local_episodic[replace].space_time.time;
    
    local_episodic[replace].first_name[BEING_MEETER]=name1;
    local_episodic[replace].family_name[BEING_MEETER]=family1;
    local_episodic[replace].first_name[BEING_MET]=name2;
    local_episodic[replace].family_name[BEING_MET]=family2;
    local_episodic[replace].food=food;
    local_episodic[replace].arg=arg;

    if ((event == 0) || (event>=EVENTS))
    {
        (void)SHOW_ERROR("Event outside scope");
    }

    if (local_logging)
    {
        if ((old_event != event) || ((old_time+10) < (new_time))) 
        {
            n_string_block description = {0};
            n_string_block str = {0};
            n_string_block time = {0};
            n_string_block combination = {0};
            n_int social_event;
            
            being_name_simple(local, str);

            social_event = episode_description(local_sim, local, replace, description);

            if ((local_social == 1) && (social_event == 0))
            {
                return;
            }

            io_time_to_string(time, local_sim->land->time, local_sim->land->date);

            io_three_string_combination(combination, time, str, description, 35);

            (*local_logging)(combination);
        }
    }
}
void episodic_food(noble_simulation * local_sim, noble_being * local, n_int energy, n_byte food_type)
{
    episodic_store_full(local, EVENT_EAT, energy, local_sim,
                        being_gender_name(local), being_family_name(local),
                        0, 0, 0, food_type);
}

void episodic_store_memory(
    noble_being * local,
    n_byte event,
    n_int affect,
    noble_simulation * local_sim,
    n_byte2 name1, n_byte2 family1,
    n_byte2 name2, n_byte2 family2,
    n_byte2 arg)
{
    episodic_store_full(local,event,affect,local_sim,name1,family1,name2,family2, arg, 0);
}
void episodic_self(
    noble_simulation * local_sim,
    noble_being * local,
    n_byte event,
    n_int affect,
    n_byte2 arg)
{
    episodic_store_memory(local, event, affect, local_sim,
                          being_gender_name(local), being_family_name(local),
                          0, 0, arg);
}
void episodic_close(
    noble_simulation * local_sim,
    noble_being * local,
    noble_being * other,
    n_byte event,
    n_int affect,
    n_byte2 arg)
{
    episodic_store_memory(
        local, event, affect, local_sim,
        being_gender_name(other), being_family_name(other),
        0,0, arg);
}
void episodic_interaction(
    noble_simulation * local_sim,
    noble_being * local,
    noble_being * other,
    n_byte event,
    n_int affect,
    n_byte2 arg)
{
    episodic_store_memory(
        local, event, affect, local_sim,
        being_gender_name(local),being_family_name(local),
        being_gender_name(other),being_family_name(other), arg);
}

n_byte episodic_intention(
    noble_simulation * local_sim,
    noble_being * local,
    n_int episode_index,
    n_byte2 mins_ahead,
    n_byte args)
{
    n_int replace;
    n_byte2 time;
    n_byte4 date;
    noble_episodic * local_episodic = being_episodic(local);
    n_byte event;

    if (local_episodic == 0L)
    {
        return 0;
    }

    event = local_episodic[episode_index].event;

    if (event==0) return 0;

    time = local_sim->land->time + mins_ahead;
    date = local_episodic[episode_index].space_time.date;
    if (time >= TIME_DAY_MINUTES)
    {
        time %= TIME_DAY_MINUTES;
        date++;
    }

    if (event >= EVENT_INTENTION)
    {
        local_episodic[episode_index].space_time.time = time;
        local_episodic[episode_index].space_time.date = date;
        local_episodic[episode_index].arg = args;
        local_episodic[episode_index].first_name[BEING_MEETER] = being_gender_name(local);
        local_episodic[episode_index].family_name[BEING_MEETER] = being_family_name(local);
        return 1;
    }

    if (!((event==EVENT_GROOM) ||
            (event==EVENT_CHAT)))
    {
        return 0;
    }

    replace = noble_episodic_replace_index(
                  EVENT_INTENTION + event,
                  (n_int)(local_episodic[episode_index].affect)-EPISODIC_AFFECT_ZERO,
                  being_gender_name(local),
                  being_family_name(local),
                  local_episodic[episode_index].first_name[BEING_MET],
                  local_episodic[episode_index].family_name[BEING_MET],
                  local, local_sim);

    if (replace == -1) return 0;

    local_episodic[replace] = local_episodic[episode_index];
    local_episodic[replace].event = EVENT_INTENTION + event;
    local_episodic[replace].space_time.time = time;
    local_episodic[replace].space_time.date = date;
    local_episodic[replace].first_name[BEING_MEETER] = being_gender_name(local);
    local_episodic[replace].family_name[BEING_MEETER] = being_family_name(local);
    local_episodic[replace].arg = args;

    return 1;
}

n_byte episodic_anecdote(
    noble_simulation * local_sim,
    noble_being * local,
    noble_being * other)
{
    noble_episodic * local_episodic = being_episodic(local);
    noble_episodic * other_episodic = being_episodic(other);
    n_int affect;
    n_byte event;
    n_int replace,mult=1;

    if (local_episodic == 0L || other_episodic == 0L || local == other)
    {
        return 0;
    }

    affect = (n_int)(local_episodic[GET_A(local,ATTENTION_EPISODE)].affect)-EPISODIC_AFFECT_ZERO;
    event = local_episodic[GET_A(local,ATTENTION_EPISODE)].event;

    if ((event==0) ||
            (being_awake(local_sim, local) == FULLY_ASLEEP) ||
            (being_awake(local_sim, other) == FULLY_ASLEEP))
    {
        return 0;
    }

    if (being_awake(local_sim, local) != FULLY_AWAKE)
    {
        mult=2;
    }

    if (being_random(local) <
            (ANECDOTE_EVENT_MUTATION_RATE+
             (local->learned_preference[PREFERENCE_ANECDOTE_EVENT_MUTATION])*100)*mult)
    {
        event = (n_byte)(being_random(local) % EVENTS);
    }
    if (being_random(local) <
            (ANECDOTE_AFFECT_MUTATION_RATE+
             (local->learned_preference[PREFERENCE_ANECDOTE_AFFECT_MUTATION])*100)*mult)
    {
        affect = (affect * (64 + (n_int)(being_random(local) & 127))) / 128;
        if (affect<-32000) affect=-32000;
        if (affect>32000) affect=32000;
    }

    replace = noble_episodic_replace_index(
                  event,affect,
                  local_episodic[GET_A(local,ATTENTION_EPISODE)].first_name[BEING_MEETER],
                  local_episodic[GET_A(local,ATTENTION_EPISODE)].family_name[BEING_MEETER],
                  local_episodic[GET_A(local,ATTENTION_EPISODE)].first_name[BEING_MET],
                  local_episodic[GET_A(local,ATTENTION_EPISODE)].family_name[BEING_MET],
                  local,local_sim);

    if (replace==-1) return 0;

    other_episodic[replace] = local_episodic[GET_A(local,ATTENTION_EPISODE)];
    other_episodic[replace].event = event;
    other_episodic[replace].affect = (n_byte2)(affect+EPISODIC_AFFECT_ZERO);

    GET_A(local,ATTENTION_EPISODE) = (n_byte)replace;

    return 1;
}

#else

void episodic_store_memory(
    noble_being * local,
    n_byte event,
    n_int affect,
    noble_simulation * local_sim,
    n_byte2 name1, n_byte2 family1,
    n_byte2 name2, n_byte2 family2,
    n_byte2 arg)
{
}

#endif