D:/WorkAround/prequengine/trunk/src/actor.c

Go to the documentation of this file.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "actor.h"
#include "lbaengine.h"
#include "scene.h"
#include "hqrdepack.h"
#include "resources.h"

void preload_sprites()
{
        int i;
        int numEntries = hqr_num_entries(HQR_SPRITES_FILE)-1;

        for(i=0; i<numEntries; i++)
        {
                // load sprite from file
                spriteSizeTable[i] = hqr_entry_size(HQR_SPRITES_FILE,i);
                if(spriteTable[i])
                        free(spriteTable[i]);
                spriteTable[i] = (unsigned char*)malloc(spriteSizeTable[i]);
                if(!spriteTable[i])
                {
                        printf("SPRITE WARNING: unable to allocate brick memory!!\n");
                        return;
                }
                hqr_get_entry(spriteTable[i], HQR_SPRITES_FILE, i);
        }
}

void init_sprite_actor(int spriteIdx, int actorIdx)
{
        ActorStruct *localActor = &sceneActors[actorIdx];

        if (localActor->staticFlags.bIsSpriteActor && spriteIdx != -1 && localActor->entity != spriteIdx)
        {
                short int *ptr = (short int *) (spriteBoundingBoxPtr + spriteIdx * 16 + 4);

                localActor->entity = spriteIdx;
                localActor->boudingBox.X.bottomLeft = *(ptr++);
                localActor->boudingBox.X.topRight = *(ptr++);
                localActor->boudingBox.Y.bottomLeft = *(ptr++);
                localActor->boudingBox.Y.topRight = *(ptr++);
                localActor->boudingBox.Z.bottomLeft = *(ptr++);
                localActor->boudingBox.Z.topRight = *(ptr++);
        }
}

void init_actor(short int actorIdx)
{
        ActorStruct *localActor = &sceneActors[actorIdx];

        if (localActor->staticFlags.bIsSpriteActor) // if sprite actor
        {
                if (localActor->strengthOfHit != 0)
                {
                        localActor->dinamicFlags.bUnk0002 = 1;
                }

                localActor->entity = -1;

                init_sprite_actor(localActor->sprite, actorIdx);

                set_actor_angle_safe(0, 0, 0, &localActor->time);

                if (localActor->staticFlags.bUsesClipping)
                {
                        localActor->lastX = localActor->X;
                        localActor->lastY = localActor->Y; // Z
                        localActor->lastZ = localActor->Z; // Y
                }

        }
        // TODO: 3D model actors
        else
        {
                localActor->entity = -1;

                //InitBody(localActor->body, actorIdx);

                localActor->previousAnimIdx = -1;
                localActor->field_78 = 0;

                if (localActor->entity != -1)
                {
                //      InitAnim(localActor->anim, 0, 255, actorIdx);
                }

                set_actor_angle_safe(localActor->angle, localActor->angle, 0, &localActor->time);
        }

        localActor->positionInMoveScript = -1;
        localActor->labelIdx = -1;
        localActor->positionInActorScript = 0;
}


void set_actor_angle_safe(short int startAngle, short int endAngle, short int stepAngle, TimeStruct * timePtr)
{
        timePtr->from = startAngle & 0x3FF;
        timePtr->to = endAngle & 0x3FF;
        timePtr->numOfStep = stepAngle & 0x3FF;
        timePtr->timeOfChange = lbaTime;
}

void clear_real_angle(ActorStruct * ptr)
{
        set_actor_angle_safe(ptr->angle, ptr->angle, 0, &ptr->time);
}

void set_actor_angle(short int startAngle, short int endAngle, short int stepAngle, TimeStruct * timePtr)
{
        timePtr->from = startAngle;
        timePtr->to = endAngle;
        timePtr->numOfStep = stepAngle;
        timePtr->timeOfChange = lbaTime;
}


int get_real_angle(TimeStruct * angleData)
{
        int timePassed;
        int remainingAngle;

        if (angleData->numOfStep)
        {
                timePassed = lbaTime - angleData->timeOfChange;

                if (timePassed >= angleData->numOfStep) // rotation is finished
                {
                        angleData->numOfStep = 0;
                        return (angleData->to);
                }

                remainingAngle = angleData->to - angleData->from;

                if (remainingAngle < -0x200)
                {
                        remainingAngle += 0x400;
                }
                else if (remainingAngle > 0x200)
                {
                        remainingAngle -= 0x400;
                }

                remainingAngle *= timePassed;
                remainingAngle /= angleData->numOfStep;
                remainingAngle += angleData->from;

                return (remainingAngle);
        }

        return (angleData->to);
}

int get_real_value(TimeStruct * angleData)
{
        int tempAngle;

        if (!angleData->numOfStep)
                return (angleData->to);

        if (!(lbaTime - angleData->timeOfChange < angleData->numOfStep))
        {
                angleData->numOfStep = 0;
                return (angleData->to);
        }

        tempAngle = angleData->to - angleData->from;
        tempAngle *= lbaTime - angleData->timeOfChange;
        tempAngle /= angleData->numOfStep;

        return (tempAngle + angleData->from);
}

---