Ascii_physix

Télécharger le projet
Commenter

Description

Bonjour à tous ! Je vais vous présenter un jeu programmer par moi même: ASCII_PhysiX.

Pourquoi ce nom ? Tout simplement parce que c'est un simulateur physique en MS-DOS (console pour Windows).
ASCII car les différents éléments donc des caractères, et PhysiX (référence physique) car il y a un minimum de physique.

Il y a plusieurs sortes d'éléments, comme des murs, du sable, des grilles, des blocs qui défient les lois de la gravité et bien d'autres ! Il y a que très peu de lag, même avec des centaines de blocs sur la map. Il y a 3 différents classes: BLOCKS / WATER / DUST

La classe BLOCKS contient les murs, les blocs normaux et les grilles.
La classe WARER ne contient pour l'instant rien, mais elle est en cours de développement.
La classe DUST contient du sable, et des blocs soumis à la gravité inverse.

Pour modifier la bordure de la carte, l'intérieur ou même les dimensions, il existe un fichier "option.opt" pour les modifier.
On peut sauvegarder la map, l'ouvrir et l'effacer.

Bonnes choses:
- Pas de bug d'affichage sur les blocs qui tombent
- Gain énorme en performances (car j'utilise une technique qui n'affiche pas tout les blocs, qui permet donc d'avoir au moins 2x moins de lag)
- Plusieurs classes (pour plus de lisibilité et d’ergonomie) et blocs
- Personnalisable

Et les choses moins bonnes:
- Pas de couleurs (en cours)
- Pas tout le temps stable (en cours)

Pour exécuter ce programme, changez ASCII_PhysiX.ex_ en ASCII_PhysiX.exe

Source / Exemple : 


map.c:

#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <io.h>

#include "map.h"
#include "blocks.h"
#include "funct.h"
#include "debug.h"

void	map_create(void)
{
	map_alloc();
	map_fill();
	map_border();
}

void	map_alloc(void)
{
	__uint i = 0;

	_map.arr = (__byte**)malloc((_map.h + 1) * sizeof(__byte*));

	for(i = 0; i < _map.h; i++)
	{
		_map.arr[i]		= (__byte*)malloc((_map.w + 1) * sizeof(__byte));
		_map.arr[i][_map.w]	= NULL;
	}
	_map.arr[i] = NULL;
}

void	map_dealloc(void)
{
	__uint i = 0;

	for(i = 0; i < _map.h; i++)
		free(_map.arr[i]);
	free(_map.arr);
}
/////////////////////////
void	map_fill(void)
{
	point_t p = {0, 0};

	for(p.y = 0; p.y < _map.h; p.y++)
		for(p.x = 0; p.x < _map.w; p.x++)
			_map.arr[p.y][p.x] = _map.cfill;
}
void	map_border(void)
{
	point_t p = {0, 0};

	for(p.y = 0; p.y < _map.h; p.y++)
		for(p.x = 0; p.x < _map.w; p.x++)
			if(p.x == 0 || p.y == 0 || p.x == _map.w - 1 || p.y == _map.h - 1)
				_map.arr[p.y][p.x] = _map.cborder;
}

void	map_print(void)
{
	point_t p = {0, 0};

	for(p.y = 0; p.y < _map.h; p.y++)
	{
		_sleep(50);
		for(p.x = 0; p.x < _map.w; p.x++)
			putchar(_map.arr[p.y][p.x]);
		putchar('\n');
	}
}

void	map_refresh(linkedlist_t *_ll)
{
	__uint	where = 0;
	__byte	ch;
	point_t pos;
	int		need_updating = 0;

	for(where = 0; where < _ll->size; where++)
	{
		ch = ll_at(_ll, where, &pos);
		
		if(!PAUSE)
		{
			if(ch == block_id[SAND].ch)
				sand(_ll, &pos, where, &need_updating);
			else if(ch == block_id[REVERSE_BLOCK].ch)
				reverseblock(_ll, &pos, where, &need_updating);
			else if(ch == block_id[HEAVY_BLOCK].ch)
				heavyblock(_ll, &pos, where, &need_updating);
			else if(ch == block_id[WATER].ch)
				water(_ll, &pos, where, &need_updating);
			else if(ch == block_id[PISTON].ch)
				piston(_ll, &pos, where, &need_updating);
			else if(ch == block_id[GRID].ch)
				grid(_ll, &pos, where);
		}

		if(need_updating)
			need_updating = 0;
		else
		{
			gotoxy(pos);
			write(1, &ch, 1);
		}
	}
}

/////////////////////////
__byte	get_char_x(point_t _pos, __uint _add)
{
	return(_map.arr[_pos.y][_pos.x + _add]);
}
__byte	get_char_y(point_t _pos, __uint _add)
{
	return(_map.arr[_pos.y + _add][_pos.x]);
}

void	map_add_block(block_t _block, point_t _p, linkedlist_t *_ll)
{
	ll_add(_ll, _block, _p);

	if(!_block.can_fall)
		_map.arr[_p.y][_p.x] = _block.ch;
}

/////////////////////////

int	obstacle(point_t _p, __uint _add, dir_t _dir)
{
	__byte	ch;

	switch(_dir)
	{
	case DIR_N:
		ch = get_char_y(_p, -_add);
		break;
	case DIR_S:
		ch = get_char_y(_p, _add);
		break;
	case DIR_W:
		ch = get_char_x(_p, -_add);
		break;
	case DIR_E:
		ch = get_char_x(_p, _add);
		break;
	}
	return(ch != _map.cfill);
}

Conclusion :


C'est un petit programme pour la détente et s'amuser ! :)
Télécharger le projet

Codes Sources

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (Le_BuG63)