Skip to content

Commit 311f0cf

Browse files
CaptainDreamcastCaptainDreamcast
committed
[Feature] add functionality used in Eye of the Medusa: Ultimate Frontier
2 parents d76403a + 1400936 commit 311f0cf

31 files changed

+1271
-45
lines changed

‎.gitignore‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1 @@
1+
*.o

‎Makefile‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,7 @@
11
TARGET = libtari.a
22
OBJS = animation.o physics.o framerate.o drawing.o texture.o \
3-
collision.o input.o pvr.o framerateselect.o \
3+
collision.o input.o pvr.o framerateselect.o file.o math.o geometry.o \
4+
system.o log.o timer.o optionhandler.o datastructures.o \
45
quicklz.o
56

67
defaultall: create_addons_link $(OBJS) subdirs linklib

‎animation.c‎

Lines changed: 163 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -1,27 +1,182 @@
11
#include "include/animation.h"
22

33
#include "include/framerate.h"
4+
#include "include/log.h"
5+
#include "include/datastructures.h"
6+
7+
static struct {
8+
int mIsPaused;
9+
10+
} gData;
11+
12+
int getDurationInFrames(Duration tDuration){
13+
return tDuration * getInverseFramerateFactor();
14+
}
415

516
int handleDurationAndCheckIfOver(Duration* tNow, Duration tDuration) {
17+
if(gData.mIsPaused) return 0;
618
(*tNow)++;
7-
if ((*tNow) >= (tDuration * getInverseFramerateFactor())) {
19+
if ((*tNow) >= getDurationInFrames(tDuration)) {
820
return 1;
921
}
1022

1123
return 0;
1224
}
1325

26+
AnimationResult animateWithoutLoop(Animation* tAnimation) {
27+
AnimationResult ret = ANIMATION_CONTINUING;
28+
if (handleDurationAndCheckIfOver(&tAnimation->mNow, tAnimation->mDuration)) {
29+
tAnimation->mNow = 0;
30+
tAnimation->mFrame++;
31+
if (tAnimation->mFrame >= tAnimation->mFrameAmount) {
32+
tAnimation->mFrame = tAnimation->mFrameAmount-1;
33+
tAnimation->mNow = getDurationInFrames(tAnimation->mDuration);
34+
ret = ANIMATION_OVER;
35+
}
36+
}
37+
38+
return ret;
39+
}
40+
1441
void animate(Animation* tAnimation) {
15-
if (handleDurationAndCheckIfOver(&tAnimation->mNow, tAnimation->mDuration)) {
16-
tAnimation->mNow = 0;
17-
tAnimation->mFrame++;
18-
if (tAnimation->mFrame >= tAnimation->mFrameAmount) {
19-
tAnimation->mFrame = 0;
20-
}
21-
}
42+
AnimationResult ret = animateWithoutLoop(tAnimation);
43+
if(ret == ANIMATION_OVER){
44+
resetAnimation(tAnimation);
45+
}
2246
}
2347

48+
49+
2450
void resetAnimation(Animation* tAnimation) {
2551
tAnimation->mNow = 0;
2652
tAnimation->mFrame = 0;
2753
}
54+
55+
Animation createEmptyAnimation(){
56+
Animation ret;
57+
ret.mFrame = 0;
58+
ret.mFrameAmount = 0;
59+
ret.mNow = 0;
60+
ret.mDuration = 1000000000;
61+
return ret;
62+
}
63+
64+
65+
Animation createOneFrameAnimation(){
66+
Animation ret = createEmptyAnimation();
67+
ret.mFrameAmount = 1;
68+
return ret;
69+
}
70+
71+
72+
void pauseDurationHandling() {
73+
gData.mIsPaused = 1;
74+
}
75+
void resumeDurationHandling() {
76+
gData.mIsPaused = 0;
77+
}
78+
79+
typedef struct AnimationElement_internal {
80+
81+
void* mCaller;
82+
AnimationPlayerCB mCB;
83+
84+
Position mPosition;
85+
Rectangle mTexturePosition;
86+
TextureData* mTextureData;
87+
Animation mAnimation;
88+
int mIsLooped;
89+
90+
struct AnimationElement_internal* mPrev;
91+
struct AnimationElement_internal* mNext;
92+
93+
} AnimationElement;
94+
95+
typedef struct {
96+
int mSize;
97+
AnimationElement* mFirst;
98+
AnimationElement* mLast;
99+
} AnimationList;
100+
101+
static struct{
102+
List mList;
103+
104+
} gAnimationHandler;
105+
106+
void setupAnimationHandler(){
107+
if(list_size(&gAnimationHandler.mList) > 0){
108+
logWarning("Setting up non-empty animation handler; Cleaning up.");
109+
shutdownAnimationHandler();
110+
}
111+
112+
gAnimationHandler.mList = new_list();
113+
}
114+
115+
static int updateAndRemoveCB(void* tCaller, void* tData) {
116+
(void) tCaller;
117+
AnimationElement* cur = tData;
118+
AnimationResult res = animateWithoutLoop(&cur->mAnimation);
119+
if(res == ANIMATION_OVER) {
120+
if(cur->mIsLooped) {
121+
resetAnimation(&cur->mAnimation);
122+
} else {
123+
if(cur->mCB != NULL) {
124+
cur->mCB(cur->mCaller);
125+
}
126+
return 1;
127+
}
128+
}
129+
return 0;
130+
}
131+
132+
void updateAnimationHandler(){
133+
list_remove_predicate(&gAnimationHandler.mList, updateAndRemoveCB, NULL);
134+
}
135+
136+
static void drawAnimationHandlerCB(void* tCaller, void* tData) {
137+
(void) tCaller;
138+
AnimationElement* cur = tData;
139+
int frame = cur->mAnimation.mFrame;
140+
drawSprite(cur->mTextureData[frame], cur->mPosition, cur->mTexturePosition);
141+
}
142+
143+
void drawHandledAnimations() {
144+
list_map(&gAnimationHandler.mList, drawAnimationHandlerCB, NULL);
145+
}
146+
147+
static void emptyAnimationHandler(){
148+
list_empty(&gAnimationHandler.mList);
149+
}
150+
151+
static int playAnimationInternal(Position tPosition, TextureData* tTextures, Animation tAnimation, Rectangle tTexturePosition, AnimationPlayerCB tOptionalCB, void* tCaller, int tIsLooped){
152+
153+
AnimationElement* e = malloc(sizeof(AnimationElement));
154+
e->mCaller = tCaller;
155+
e->mCB = tOptionalCB;
156+
e->mIsLooped = tIsLooped;
157+
158+
e->mPosition = tPosition;
159+
e->mTexturePosition = tTexturePosition;
160+
e->mTextureData = tTextures;
161+
e->mAnimation = tAnimation;
162+
163+
return list_push_front_owned(&gAnimationHandler.mList, (void*)e);
164+
}
165+
166+
167+
int playAnimation(Position tPosition, TextureData* tTextures, Animation tAnimation, Rectangle tTexturePosition, AnimationPlayerCB tOptionalCB, void* tCaller){
168+
return playAnimationInternal(tPosition, tTextures, tAnimation, tTexturePosition, tOptionalCB, tCaller, 0);
169+
170+
}
171+
172+
int playAnimationLoop(Position tPosition, TextureData* tTextures, Animation tAnimation, Rectangle tTexturePosition){
173+
return playAnimationInternal(tPosition, tTextures, tAnimation, tTexturePosition, NULL, NULL, 1);
174+
}
175+
176+
void removeHandledAnimation(int tID) {
177+
list_remove(&gAnimationHandler.mList, tID);
178+
}
179+
180+
void shutdownAnimationHandler(){
181+
emptyAnimationHandler();
182+
}

‎collision.c‎

Lines changed: 94 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -49,3 +49,97 @@ int checkCollision(CollisionRect tRect1, CollisionRect tRect2) {
4949
return 1;
5050
}
5151

52+
53+
int checkCollisionCirc(CollisionCirc tCirc1, CollisionCirc tCirc2){
54+
Vector3D delta;
55+
delta.x = tCirc1.mCenter.x - tCirc2.mCenter.x;
56+
delta.y = tCirc1.mCenter.y - tCirc2.mCenter.y;
57+
delta.z = tCirc1.mCenter.z - tCirc2.mCenter.z;
58+
double l = vecLength(delta);
59+
60+
return l < tCirc1.mRadius+tCirc2.mRadius;
61+
}
62+
63+
int checkCollisionCircRect(CollisionCirc tCirc, CollisionRect tRect){
64+
return checkIntersectCircRect(tCirc, tRect);
65+
}
66+
67+
CollisionObjectRect makeCollisionObjectRect(Position tTopLeft, Position tBottomRight, PhysicsObject* tPhysics){
68+
CollisionObjectRect ret;
69+
70+
ret.mIsPositionInColRelative = 1;
71+
ret.mCol.mTopLeft = tTopLeft;
72+
ret.mCol.mBottomRight = tBottomRight;
73+
ret.mPhysics = tPhysics;
74+
75+
return ret;
76+
}
77+
78+
CollisionObjectCirc makeCollisionObjectCirc(Position tCenter, double tRadius, PhysicsObject* tPhysics){
79+
CollisionObjectCirc ret;
80+
81+
ret.mIsPositionInColRelative = 1;
82+
ret.mCol.mCenter = tCenter;
83+
ret.mCol.mRadius = tRadius;
84+
ret.mPhysics = tPhysics;
85+
86+
return ret;
87+
88+
89+
}
90+
91+
CollisionRect makeCollisionRect(Position tTopLeft, Position tBottomRight){
92+
CollisionRect ret;
93+
ret.mTopLeft = tTopLeft;
94+
ret.mBottomRight = tBottomRight;
95+
return ret;
96+
}
97+
98+
CollisionCirc makeCollisionCirc(Position tCenter, double tRadius){
99+
CollisionCirc ret;
100+
ret.mCenter = tCenter;
101+
ret.mRadius = tRadius;
102+
return ret;
103+
}
104+
105+
CollisionCirc adjustCollisionObjectCirc(CollisionObjectCirc* tObj){
106+
CollisionCirc c = tObj->mCol;
107+
if(tObj->mIsPositionInColRelative) {
108+
c.mCenter = vecAdd(tObj->mCol.mCenter, tObj->mPhysics->mPosition);
109+
}
110+
return c;
111+
}
112+
113+
int checkCollisionObjectCirc(CollisionObjectCirc tObj1, CollisionObjectCirc tObj2){
114+
115+
CollisionCirc c1 = adjustCollisionObjectCirc(&tObj1);
116+
CollisionCirc c2 = adjustCollisionObjectCirc(&tObj2);
117+
118+
return checkCollisionCirc(c1, c2);
119+
}
120+
121+
CollisionRect adjustCollisionObjectRect(CollisionObjectRect* tObj){
122+
CollisionRect c = tObj->mCol;
123+
if(tObj->mIsPositionInColRelative) {
124+
c.mTopLeft = vecAdd(tObj->mCol.mTopLeft, tObj->mPhysics->mPosition);
125+
c.mBottomRight = vecAdd(tObj->mCol.mBottomRight, tObj->mPhysics->mPosition);
126+
}
127+
return c;
128+
}
129+
130+
int checkCollisionObjectRect(CollisionObjectRect tObj1, CollisionObjectRect tObj2){
131+
132+
CollisionRect c1 = adjustCollisionObjectRect(&tObj1);
133+
CollisionRect c2 = adjustCollisionObjectRect(&tObj2);
134+
135+
return checkCollision(c1, c2);
136+
}
137+
138+
139+
int checkCollisionObjectCircRect(CollisionObjectCirc tObj1, CollisionObjectRect tObj2){
140+
141+
CollisionCirc c1 = adjustCollisionObjectCirc(&tObj1);
142+
CollisionRect c2 = adjustCollisionObjectRect(&tObj2);
143+
144+
return checkCollisionCircRect(c1, c2);
145+
}

0 commit comments

Comments
 (0)