4. Snake-Spiel länge des Schwanzes

Snake-Spiel länge des Schwanzes

  • M

    Hallo Leute,

    ich programmier ein Snake-Spiel mit SFML und nun hab ich ein kleines Problem. Ich kriege es einfach nicht hin, den Schwanz der schlange, wenn sie eine Frucht einsammelt größer werden zulassen. Und dann soll der Schwanz der Schlange, die schlange auch noch richtig verfolgen! 😞

    Danke im voraus!

    0

  • Melwin K. schrieb:

    länge des Schwanzes

    Ferkel!

    // edit: dub di dub ...

    // ehedihit:

    snake.h

    #pragma once

#ifndef SNAKE_H_INCLUDED
#define SNAKE_H_INCLUDED SNAKE_H_INCLUDED

#include <list>

#include "tstring.h"
#include "coord.h"
#include "console_observer.h"

#include "food.h"

class snake_t
:	public keyboard_observer_t
{
	public:
		enum direction_t { up = 0, down = 1, left = 2, right = 3 };

		typedef std::list< coord_t > body_t;

	private:

		static coord_t const directions[ 4 ];

		coord_t const	bounds;		
		bool			alive;
		direction_t		direction;
		body_t			body;
		std::size_t		grow;
		std::size_t		score;
		std::size_t		level;

	public:

		snake_t( coord_t const & bounds );
		virtual ~snake_t() {};

		operator body_t const & () const;

		bool is_alive() const;
		body_t const & get_body() const;

		void keyboard_event( bool down, long unsigned control_key_state, tchar_t ch, short unsigned repeat_count, short unsigned virtual_key_code, short unsigned virtual_scan_code );

		snake_t& tick();

		bool try_eat( food_t &food );
		void do_grow();

		std::size_t get_length() const;
		std::size_t get_score() const;
		std::size_t get_level() const;

		void delay() const;
};

#endif	/* SNAKE_H_INCLUDED */

    snake.cpp

    #include "snake.h"

#include "make_list.h"
#include "coord.h"

coord_t const snake_t::directions[] = { coord_t( 0, -1 ), coord_t( 0, 1 ), coord_t( -1, 0 ), coord_t( 1, 0 ) };

snake_t::snake_t( coord_t const & bounds )
:	bounds		( bounds.x - 1, ( bounds.y - 2 ) * 2 + 1 ),
	alive		( true ),
	direction	( direction_t::right ),
	body		( ( make_list(
					coord_t( 31, 22 )), coord_t( 30, 22 ), coord_t( 29, 22 ), coord_t( 28, 22 ), coord_t( 27, 22 ),
					coord_t( 26, 22 ) , coord_t( 25, 22 ), coord_t( 24, 22 ), coord_t( 23, 22 ), coord_t( 22, 22 ) 
				) ),
	grow( 0 ),
	score( 0 ),
	level( 1 )
{
}

void snake_t::keyboard_event( bool down, long unsigned control_key_state, tchar_t ch, short unsigned repeat_count, short unsigned virtual_key_code, short unsigned virtual_scan_code )
{
	switch( virtual_key_code )
	{
		case VK_UP:		direction = direction != direction_t::down	? direction_t::up		: direction_t::down;	break;
		case VK_DOWN:	direction = direction != direction_t::up	? direction_t::down		: direction_t::up;		break;
		case VK_LEFT:	direction = direction != direction_t::right	? direction_t::left		: direction_t::right;	break;
		case VK_RIGHT:	direction = direction != direction_t::left	? direction_t::right	: direction_t::left;	break;
	}
}

snake_t::operator body_t const & () const
{
	return body;
}

bool snake_t::is_alive() const
{
	return alive;
}

snake_t& snake_t::tick()
{
	body.push_front( body.front() + directions[ direction ] );
	body.pop_back();

	auto it = std::find( body.begin(), body.end(), body.front() );
	it = std::find( ++it, body.end(), body.front() );

	if(  it != body.end() || body.begin()->x == 0 || body.begin()->y == 0 || body.begin()->x == bounds.x || body.begin()->y == bounds.y ) {

		alive = false;
	}

	return *this;
}

bool snake_t::try_eat( food_t &food )
{
	if( food.get_x() == body.front().x && (
		food.get_y() == body.front().y ||
		(  ( body.front().y % 2 ) && food.get_y() == body.front().y - 1 ) ||
		( !( body.front().y % 2 ) && food.get_y() == body.front().y + 1 ) ) ) {

		food.set_eaten();

		grow += 6;
		++score;

		if( score % 5 == 0 ) {

			++level;
		}

		return true;
	}

	return false;
}

void snake_t::do_grow()
{
	if( grow ) {

		body.push_back( body.back() );
		grow--;
	}
}

std::size_t snake_t::get_length() const
{
	return body.size();
}

std::size_t snake_t::get_score() const
{
	return score;
}

std::size_t snake_t::get_level() const
{
	return level;
}

void snake_t::delay() const
{
	Sleep( 100 - level * 4 );
}
    0
  • M

    Kommt etwas spät weil ich eine kurzweilige Pause gemacht habe, aber naja.
    Nun ist mein Problem das ich noch nicht ganz verstehe wie dieser Körper mit geht!
    Ich kann zwar sagen "Snake wird länger und länger und kann sich auch berwegen" aber dieses bewegen wie in snake also das der körper hinter erst nach einer Zeit die Kurve kriegt verseth ich noch nicht so ganz!

    0
Anmelden zum Antworten