credits.cpp

Go to the documentation of this file.

//
// Das Tank - Copyright (C) 2006, 2007 Windsor Schmidt <windsor@windsorworld.net>
//
// This program is free software; you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by the Free
// Software Foundation; either version 2 of the License, or (at your option)
// any later version.
//
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
// more details.
//
// You should have received a copy of the GNU General Public License along with
// this program; if not, write to the Free Software Foundation, Inc., 59 Temple
// Place, Suite 330, Boston, MA 02111-1307 USA
//


#ifndef STDAFX
#include "stdafx.h"
#endif

int Credits(gcn::OpenGLGraphics* graphics, gcn::ImageFont* font)
{
       Uint32 oldTime;
       Uint32 currentTime;
       Uint32 timeDelta;

       oldTime = 0;
       currentTime = SDL_GetTicks();

       glDisable(GL_TEXTURE_2D);
       glClearColor(0.2,0.2,0.2,0);

       int menuInput;

       char page_A[PAGE_WIDTH*PAGE_HEIGHT]; // memory for page buffers
       char page_B[PAGE_WIDTH*PAGE_HEIGHT];

       float a_pos = 0; // keep track of page buffers' position on-screen
       float b_pos = SCREEN_HEIGHT;

       FILE * file; // credits file
       int iX, iY; // index vars
       int lineHeight = SCREEN_HEIGHT/PAGE_HEIGHT;
       int screenMiddle = SCREEN_WIDTH/2;

       float boxAX = 0;
       float boxAY = 0;
       float boxAZ = 10;
       float boxBX = 0;
       float boxBY = 0;
       float boxBZ = 10;
       float boxCX = 0;
       float boxCY = 0;
       float boxCZ = 10;

       float camX = 0;
       float camY = 0;
       float camZ = 0;

       float lookX = 10;
       float lookY = 10;
       float lookZ = 10;

       int boxNext = 0;
       int boxNextOld = 0;

       int boxRand;

       int boxTimer = 600;

       float angle = 0;

       fopen_s(&file, "dat\\credits", "r" ); // open the credits file
       if (file == NULL) return DAS_ERROR;

       graphics->setFont(font);

       creditsReadPage(file, page_A); // load up the initial page buffers with text
       creditsReadPage(file, page_B);

       // per-frame loop starts here
       while(1)
       {
              menuInput = GetMenuInput();

              switch(menuInput)
              {
              case MENUINPUT_ESCAPE: // exit credit screen
                     fclose(file);
                     PlaySound(SOUNDID_MENUSELECT);
                     return 0;
                     break;
              }

              // draw background graphics
              glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);            // Clear The Screen And The Depth Buffer

              glLoadIdentity();                                                                   // Reset The View

              gluLookAt(camX,camY,camZ,lookX,lookY,lookZ,0,1,0);
              
              glColor4f(0.35,0.30,0.15,1.0); // army brown

              glPushMatrix();
              glTranslatef(0,0,10);
              glScalef(30,30,30);
              glutWireDodecahedron();
              glPopMatrix();

              if(boxAX<camX)camX-=.002;
              if(boxAX>camX)camX+=.002;
              if(boxAY<camY)camY-=.002;
              if(boxAY>camY)camY+=.002;
              if(boxAZ<camZ)camZ-=.002;
              if(boxAZ>camZ)camZ+=.002;

              if(boxCX<lookX)lookX-=.002;
              if(boxCX>lookX)lookX+=.002;
              if(boxCY<lookY)lookY-=.002;
              if(boxCY>lookY)lookY+=.002;
              if(boxCZ<lookZ)lookZ-=.002;
              if(boxCZ>lookZ)lookZ+=.002;

              glColor3f(0.30,0.35,0.21); // army green

              glPushMatrix();
              glTranslatef(boxAX,boxAY,boxAZ);
              glutWireCube(1);
              glPopMatrix();

              glPushMatrix();
              glTranslatef(boxBX,boxBY,boxBZ);
              glutWireCube(1);
              glPopMatrix();

              glPushMatrix();
              glTranslatef(boxCX,boxCY,boxCZ);
              glutWireCube(1);
              glPopMatrix();

              switch(boxNextOld) // draw oldstick
              {
              case 0:
                     glPushMatrix();
                     glTranslatef(boxCX,boxCY-1,boxCZ);
                     glScalef(.2,1,.2);
                     glutWireCube(1);
                     glPopMatrix();
                     break;
              case 1:
                     glPushMatrix();
                     glTranslatef(boxCX,boxCY+1,boxCZ);
                     glScalef(.2,1,.2);
                     glutWireCube(1);
                     glPopMatrix();
                     break;
              case 2:
                     glPushMatrix();
                     glTranslatef(boxCX+1,boxCY,boxCZ);
                     glScalef(1,.2,.2);
                     glutWireCube(1);
                     glPopMatrix();
                     break;
              case 3:
                     glPushMatrix();
                     glTranslatef(boxCX-1,boxCY,boxCZ);
                     glScalef(1,.2,.2);
                     glutWireCube(1);
                     glPopMatrix();
                     break;
              case 4:
                     glPushMatrix();
                     glTranslatef(boxCX,boxCY,boxCZ-1);
                     glScalef(.2,.2,1);
                     glutWireCube(1);
                     glPopMatrix();
                     break;
              case 5:
                     glPushMatrix();
                     glTranslatef(boxCX,boxCY,boxCZ+1);
                     glScalef(.2,.2,1);
                     glutWireCube(1);
                     glPopMatrix();
                     break;
              }

              if(boxTimer<300) // draw new stick
              {
                     switch(boxNext)
                     {
                     case 0:
                            glPushMatrix();
                            glTranslatef(boxCX,boxCY+1,boxCZ);
                            glScalef(.2,1,.2);
                            glutWireCube(1);
                            glPopMatrix();
                            break;
                     case 1:
                            glPushMatrix();
                            glTranslatef(boxCX,boxCY-1,boxCZ);
                            glScalef(.2,1,.2);
                            glutWireCube(1);
                            glPopMatrix();
                            break;
                     case 2:
                            glPushMatrix();
                            glTranslatef(boxCX-1,boxCY,boxCZ);
                            glScalef(1,.2,.2);
                            glutWireCube(1);
                            glPopMatrix();
                            break;
                     case 3:
                            glPushMatrix();
                            glTranslatef(boxCX+1,boxCY,boxCZ);
                            glScalef(1,.2,.2);
                            glutWireCube(1);
                            glPopMatrix();
                            break;
                     case 4:
                            glPushMatrix();
                            glTranslatef(boxCX,boxCY,boxCZ+1);
                            glScalef(.2,.2,1);
                            glutWireCube(1);
                            glPopMatrix();
                            break;
                     case 5:
                            glPushMatrix();
                            glTranslatef(boxCX,boxCY,boxCZ-1);
                            glScalef(.2,.2,1);
                            glutWireCube(1);
                            glPopMatrix();
                            break;
                     }

              }


              boxTimer--; // tick timer
              if(boxTimer<0) // if timer has expired
              {
                     boxTimer = 600; // reset timer

                     boxAX = boxBX;
                     boxAY = boxBY;
                     boxAZ = boxBZ;

                     boxBX = boxCX;
                     boxBY = boxCY;
                     boxBZ = boxCZ;

                     switch(boxNext)
                     {
                     case 0:
                            boxCY+=2;
                            break;
                     case 1:
                            boxCY-=2;
                            break;
                     case 2:
                            boxCX-=2;
                            break;
                     case 3:
                            boxCX+=2;
                            break;
                     case 4:
                            boxCZ+=2;
                            break;
                     case 5:
                            boxCZ-=2;
                            break;
                     }

                     boxNextOld=boxNext;

                     while (5 <= (boxRand = rand() / (RAND_MAX/5)));
                     if (boxRand != boxNext) boxNext = boxRand;

              }

              // update / draw credits text

              // recycle text pages, moving to the bottom of the screen and loading on new text
              if(a_pos < SCREEN_HEIGHT * -1)
              {
                     creditsReadPage(file, page_A);
                     a_pos = SCREEN_HEIGHT;
              }

              if(b_pos < SCREEN_HEIGHT * -1)
              {
                     creditsReadPage(file, page_B);
                     b_pos = SCREEN_HEIGHT;
              }

              graphics->_beginDraw();

              // draw page A
              for(iY=0; iY<PAGE_HEIGHT; iY++)
              {
                     graphics->drawText(&page_A[iY*PAGE_WIDTH],screenMiddle,a_pos+iY*(lineHeight),gcn::Graphics::CENTER);
              }

              // draw page B
              for(iY=0; iY<PAGE_HEIGHT; iY++)
              {
                     graphics->drawText(&page_B[iY*PAGE_WIDTH],screenMiddle,b_pos+iY*(lineHeight),gcn::Graphics::CENTER);
              }

              // scroll both text pages up a bit
              oldTime = currentTime;
              currentTime = SDL_GetTicks();
              timeDelta = currentTime - oldTime;

              a_pos-=timeDelta * 0.06;
              b_pos-=timeDelta * 0.06;

              graphics->_endDraw();

              // swap buffers to display
              SDL_GL_SwapBuffers();
       }

       fclose(file); // close credits file
       return 0;
}


int creditsReadPage(FILE * file, char * page)
{
       char currentChar;
       int charsRead;
       int iX, iY; // index vars

       for(iY=0; iY < PAGE_HEIGHT; iY++) // read in a page, line by line
       {
              for(iX=0; iX < PAGE_WIDTH; iX++) // read in a line
              {
                     charsRead = fread(&currentChar, 1, 1, file);
                     if(charsRead < 1)
                     {
                            fseek(file, 0, SEEK_SET); // loop to beginning if at the end of file
                            charsRead = fread(&currentChar, 1, 1, file);
                            if(charsRead < 1) return DAS_ERROR; // couldn't read from file? return error
                     }

                     if(currentChar == 10) // newline
                     {

                            page[iX+iY*PAGE_WIDTH] = 0; // set null char at the end of this line
                            iX = PAGE_WIDTH; // move to end of line to start new line next loop iteration
                     }
                     else
                     {
                            page[iX+iY*PAGE_WIDTH] = currentChar; // add current char to page buffer
                     }
              }
       }
       return 0;
}


int boxOpposite(int boxDir)
{
       switch(boxDir)
       {
       case 0:
              return 1;
              break;
       case 1:
              return 0;
              break;
       case 2:
              return 3;
              break;
       case 3:
              return 2;
              break;
       case 4:
              return 5;
              break;
       case 5:
              return 4;
              break;
       }
       return 0;
}

 

Copyright Windsor Schmidt 2006 - All rights reserved.