예제 #1
0
void noFigure::DrawWalking(int x, int y)
{
    // Figurentyp unterscheiden
    switch(job_)
    {
        case JOB_PACKDONKEY:
        {
            // Wenn wir warten, ani-step 2 benutzen
            unsigned ani_step = waiting_for_free_node ? 2 : GAMECLIENT.Interpolate(ASCENT_ANIMATION_STEPS[ascent], current_ev) % 8;

            // Wenn man wartet, stehend zeichnen, es sei denn man wartet mittem auf dem Weg!
            if(!waiting_for_free_node || pause_walked_gf)
                CalcFigurRelative(x, y);

            // Esel
            LOADER.GetMapImageN(2000 + ((GetCurMoveDir() + 3) % 6) * 8 + ani_step)->Draw(x, y);
            // Schatten des Esels
            LOADER.GetMapImageN(2048 + GetCurMoveDir() % 3)->Draw(x, y, 0, 0, 0, 0, 0, 0, COLOR_SHADOW);
        } return;
        case JOB_CHARBURNER:
        {
            DrawWalking(x, y, "charburner_bobs", 53);
        } return;
        default:
        {
            DrawWalkingBobJobs(x, y, job_);
        } return;
    }


}
예제 #2
0
void nofTradeDonkey::Draw(int x, int y)
{

	if(job == JOB_PACKDONKEY)
	{
		// Wenn wir warten auf ein freies Plätzchen, müssen wir den stehend zeichnen!
		// Wenn event = 0, dann sind wir mittem auf dem Weg angehalten!
		unsigned ani_step = GAMECLIENT.Interpolate(ASCENT_ANIMATION_STEPS[ascent],current_ev)%8;
		
		CalcFigurRelative(x,y);

		// Läuft normal mit oder ohne Ware

		// Esel
		LOADER.GetMapImageN(2000+((dir+3)%6)*8+ani_step)->Draw(x,y);
		// Schatten des Esels
		LOADER.GetMapImageN(2048+dir%3)->Draw(x,y,0,0,0,0,0,0,COLOR_SHADOW);

		if(gt != GD_NOTHING)
		{
			// Ware im Korb zeichnen
			LOADER.GetMapImageN(2350+gt)
				->Draw(x+WARE_POS_DONKEY[dir*16+ani_step*2],y+WARE_POS_DONKEY[dir*16+ani_step*2+1]);
		}
	}
	else
		DrawWalking(x,y);
}
예제 #3
0
void noFigure::DrawWalkingBobCarrier(int x, int y, unsigned int ware, bool fat)
{
    // Wenn wir warten auf ein freies Plätzchen, müssen wir den stehend zeichnen!
    unsigned ani_step = waiting_for_free_node ? 2 : GAMECLIENT.Interpolate(ASCENT_ANIMATION_STEPS[ascent], current_ev) % 8;

    // Wenn man wartet, stehend zeichnen, es sei denn man wartet mittem auf dem Weg!
    if(!waiting_for_free_node || pause_walked_gf)
        CalcFigurRelative(x, y);

    LOADER.carrier_cache[ware][GetCurMoveDir()][ani_step][fat].draw(x, y, COLOR_WHITE, COLORS[gwg->GetPlayer(player).color]);
}
예제 #4
0
/// Zeichnet standardmäßig die Figur, wenn sie läuft aus einem bestimmten normalen LST Archiv
void noFigure::DrawWalking(int x, int y, const char* const file, unsigned int id)
{
    // Wenn wir warten, ani-step 2 benutzen
    unsigned ani_step = waiting_for_free_node ? 2 : GAMECLIENT.Interpolate(ASCENT_ANIMATION_STEPS[ascent], current_ev) % 8;

    // Wenn man wartet, stehend zeichnen, es sei denn man wartet mittem auf dem Weg!
    if(!waiting_for_free_node || pause_walked_gf)
        CalcFigurRelative(x, y);

    LOADER.GetImageN(file, id + ((GetCurMoveDir() + 3) % 6) * 8 + ani_step)->Draw(x, y, 0, 0, 0, 0, 0, 0, COLOR_WHITE, COLORS[gwg->GetPlayer(player).color]);
    DrawShadow(x, y, ani_step, GetCurMoveDir());
}
예제 #5
0
void noFigure::DrawWalking(int x, int y, glArchivItem_Bob* file, unsigned int id, bool fat, bool waitingsoldier)
{
    // Wenn wir warten auf ein freies Plätzchen, müssen wir den stehend zeichnen!
    unsigned ani_step = waiting_for_free_node || waitingsoldier ? 2 : GAMECLIENT.Interpolate(ASCENT_ANIMATION_STEPS[ascent], current_ev) % 8;

    // Wenn man wartet, stehend zeichnen, es sei denn man wartet mittem auf dem Weg!
    if(!waitingsoldier && (!waiting_for_free_node || pause_walked_gf))
        CalcFigurRelative(x, y);
    if(file)
        file->Draw(id, GetCurMoveDir(), fat, ani_step, x, y, COLORS[gwg->GetPlayer(player).color]);
    DrawShadow(x, y, ani_step, GetCurMoveDir());

    /*char number[256];
    sprintf(number,"%u",obj_id);
    NormalFont->Draw(x,y,number,0,0xFFFF0000);*/
}
예제 #6
0
void noFigure::DrawWalkingBobJobs(int x, int y, unsigned int job)
{
    if ((job == JOB_SCOUT) || ((job >= JOB_PRIVATE) && (job <= JOB_GENERAL)))
    {
        DrawWalking(x, y, LOADER.GetBobN("jobs"), JOB_CONSTS[job].jobs_bob_id + NATION_RTTR_TO_S2[gwg->GetPlayer(player).nation] * 6, false);
        return;
    }

    // Wenn wir warten auf ein freies Plätzchen, müssen wir den stehend zeichnen!
    unsigned ani_step = waiting_for_free_node ? 2 : GAMECLIENT.Interpolate(ASCENT_ANIMATION_STEPS[ascent], current_ev) % 8;

    // Wenn man wartet, stehend zeichnen, es sei denn man wartet mittem auf dem Weg!
    if(!waiting_for_free_node || pause_walked_gf)
        CalcFigurRelative(x, y);

    LOADER.bob_jobs_cache[gwg->GetPlayer(player).nation][job][GetCurMoveDir()][ani_step].draw(x, y, 0xFFFFFFFF, COLORS[gwg->GetPlayer(player).color]);
}
예제 #7
0
/**
 *
 *
 *  @author OLiver
 */
void nofCarrier::Draw(int x, int y)
{
    // Unterscheiden, um was für eine Art von Träger es sich handelt
    switch(ct)
    {
        case CT_NORMAL:
        {
            if(state == CARRS_WAITFORWARE || (waiting_for_free_node && !pause_walked_gf && !carried_ware))
            {
                bool animation = false;

                // Ist es schon Zeit für eine Animation?
                unsigned current_gf = GAMECLIENT.GetGFNumber();

                if(current_gf >= next_animation)
                {
                    // Animationstype bestimmen
                    unsigned animation_id = next_animation % 4;

// <Silvesteregg>
                    // day of year, 0-365, accuracy about 1/4 day
                    int doy = (TIME.CurrentTime() % 31556925) / 86400;

                    // last hours of last or first day of year
                    if ((doy > 364) || (doy < 1))
                    {
                        animation_id = next_animation % 5;
                    }
// </Silvesteregg>

                    // Ist die Animation schon vorbei?
                    if (((animation_id < 4) && (current_gf >= next_animation + ANIMATION_FRAME_LENGTHS[fat ? 1 : 0][animation_id]*FRAME_GF)) ||
                            ((animation_id == 4) && (current_gf >= next_animation + 32 * 3)))
                    {
                        // Neuen nächsten Animationszeitpunkt bestimmen
                        SetNewAnimationMoment();
                    }
                    else
                    {
                        animation = true;

                        if (animation_id < 4)
                        {
                            // Nein, dann Animation abspielen
                            LOADER.GetImageN("rom_bobs", ANIMATION[fat ? 1 : 0][animation_id][(current_gf - next_animation) / FRAME_GF])
                            ->Draw(x, y, 0, 0, 0, 0, 0, 0, COLOR_WHITE, COLORS[gwg->GetPlayer(player)->color]);
                        }
                        else if (animation_id == 4)     // Silvesteregg
                        {
                            glArchivItem_Bitmap* bmp = LOADER.GetImageN("firework", (current_gf - next_animation) / 3 + 1);

                            if (bmp)
                            {
                                bmp->Draw(x - 26, y - 104, 0, 0, 0, 0, 0, 0, COLOR_WHITE, COLORS[gwg->GetPlayer(player)->color]);
                            }
                            else
                            {
                                SetNewAnimationMoment();
                                animation = false;
                            }
                        }
                    }
                }

                if(!animation)
                {
                    Loader::bob_jobs_cache[gwg->GetPlayer(player)->nation][fat ? JOB_TYPES_COUNT : 0][GetCurMoveDir()][2].draw(x, y, COLOR_WHITE, COLORS[gwg->GetPlayer(player)->color]);
                }
                else
                    // Steht und wartet (ohne Ware)
//                  LOADER.GetBobN("jobs")->Draw(0,dir,fat,2,x,y,COLORS[gwg->GetPlayer(player)->color]);

                    DrawShadow(x, y, 0, GetCurMoveDir());
            }
            else if(state == CARRS_WAITFORWARESPACE || (waiting_for_free_node && !pause_walked_gf && carried_ware))
            {
                // Steht und wartet (mit Ware)
                Loader::carrier_cache[carried_ware->type][GetCurMoveDir()][2][fat].draw(x, y, COLOR_WHITE, COLORS[gwg->GetPlayer(player)->color]);

                // Japaner-Schild-Animation existiert leider nicht --> Römerschild nehmen
//              LOADER.GetBobN("carrier")->Draw((carried_ware->type==GD_SHIELDJAPANESE)?GD_SHIELDROMANS:carried_ware->type,
//                  dir,fat,2,x,y,COLORS[gwg->GetPlayer(player)->color]);
//              DrawShadow(x,y,0,dir);
            }
            else
            {
                // Läuft normal mit oder ohne Ware
                if(carried_ware)
                    DrawWalkingBobCarrier(x, y, carried_ware->type, fat);
//                  DrawWalking(x,y,LOADER.GetBobN("carrier"),(carried_ware->type==GD_SHIELDJAPANESE)?GD_SHIELDROMANS:carried_ware->type,fat);
                else
                    DrawWalkingBobJobs(x, y, fat ? JOB_TYPES_COUNT : 0);
            }
        } break;
        case CT_DONKEY:
        {

            if(state == CARRS_WAITFORWARE || (waiting_for_free_node && !pause_walked_gf && !carried_ware))
            {
                // Steht und wartet (ohne Ware)

                // Esel
                Loader::donkey_cache[GetCurMoveDir()][0].draw(x, y);
            }
            else if(state == CARRS_WAITFORWARESPACE || (waiting_for_free_node && !pause_walked_gf && carried_ware))
            {
                //// Steht und wartet (mit Ware)
                //// Japaner-Schild-Animation existiert leider nicht --> Römerschild nehmen

                // Esel
                Loader::donkey_cache[GetCurMoveDir()][0].draw(x, y);

                // Ware im Korb zeichnen
                LOADER.GetMapImageN(2350 + carried_ware->type)->Draw(x + WARE_POS_DONKEY[GetCurMoveDir() * 16], y + WARE_POS_DONKEY[GetCurMoveDir() * 16 + 1]);
            }
            else
            {
                // Wenn wir warten auf ein freies Plätzchen, müssen wir den stehend zeichnen!
                // Wenn event = 0, dann sind wir mittem auf dem Weg angehalten!
                unsigned ani_step = waiting_for_free_node ? 2 : GAMECLIENT.Interpolate(ASCENT_ANIMATION_STEPS[ascent], current_ev) % 8;

                CalcFigurRelative(x, y);

                // Läuft normal mit oder ohne Ware

                // Esel
                Loader::donkey_cache[GetCurMoveDir()][ani_step].draw(x, y);

                if(carried_ware)
                {
                    // Ware im Korb zeichnen
                    LOADER.GetMapImageN(2350 + carried_ware->type)->Draw(x + WARE_POS_DONKEY[GetCurMoveDir() * 16 + ani_step * 2], y + WARE_POS_DONKEY[GetCurMoveDir() * 16 + ani_step * 2 + 1]);
                }
            }

        } break;
        case CT_BOAT:
        {
            if(state == CARRS_FIGUREWORK)
            {
                // Beim normalen Laufen Träger mit Boot über den Schultern zeichnen
                DrawWalkingBobCarrier(x, y, GD_BOAT, fat);
//              DrawWalking(x,y,LOADER.GetBobN("carrier"),GD_BOAT,fat);
            }
            else if(state == CARRS_WAITFORWARE || (waiting_for_free_node && !pause_walked_gf && !carried_ware))
            {
                Loader::boat_cache[GetCurMoveDir()][0].draw(x, y, 0xFFFFFFFF, COLORS[gwg->GetPlayer(player)->color]);
            }
            else if(state == CARRS_WAITFORWARESPACE || (waiting_for_free_node && !pause_walked_gf && carried_ware))
            {
                Loader::boat_cache[GetCurMoveDir()][0].draw(x, y, 0xFFFFFFFF, COLORS[gwg->GetPlayer(player)->color]);

                // Ware im Boot zeichnen
                LOADER.GetMapImageN(2350 + carried_ware->type)->Draw(x + WARE_POS_BOAT[GetCurMoveDir() * 2], y + WARE_POS_BOAT[GetCurMoveDir() * 2 + 1]);
            }
            else
            {
                // Wenn wir warten auf ein freies Plätzchen, müssen wir den (fest)stehend zeichnen!
                // Wenn event = 0, dann sind wir mittem auf dem Weg angehalten!
                unsigned ani_step = waiting_for_free_node ? 2 : GAMECLIENT.Interpolate(ASCENT_ANIMATION_STEPS[ascent], current_ev) % 8;

                CalcFigurRelative(x, y);

                // ruderndes Boot zeichnen
                Loader::boat_cache[GetCurMoveDir()][ani_step].draw(x, y, 0xFFFFFFFF, COLORS[gwg->GetPlayer(player)->color]);

                // Läuft normal mit oder ohne Ware
                if(carried_ware)
                    // Ware im Boot zeichnen
                    LOADER.GetMapImageN(2350 + carried_ware->type)->Draw(x + WARE_POS_BOAT[GetCurMoveDir() * 2], y + WARE_POS_BOAT[GetCurMoveDir() * 2 + 1]);

                // Sound ggf. abspielen
                if(ani_step == 2)
                    SOUNDMANAGER.PlayNOSound(84, this, 0);

                last_id = ani_step;
            }

        } break;
    }
}