@peceha, post #30

• Odpowiedz

@mschulz, post #12

A nie bylo pythona na os4/morphos-a?

Przerobiłem trochę program mschulza aby zadziałał na Blenderze. Co prawda pod OS4 jest jakiś zabytkowy Blender, ale pod MorphOS gdzie jest trochę nowszy powinno ruszyć. Niestety nie mam jak sprawdzić.

• Odpowiedz

@peceha, post #30

Nie wiem, nie kompilowałem. Jak było widać odpalane z interpretera, ale z ciekawości sprawdzę...

[Kilka minut później...]

9928 bajtów bez biblioteki AMOSa... Z biblioteką należy doliczyć jakieś 65kb albo lepiej, ale niestety takie uroki AMOSa

• Odpowiedz

@Mandi, post #33

• Odpowiedz

@mschulz, post #31

• Odpowiedz

@peceha, post #35

Ale ta binarka bez biblioteki AMOSa się nie wykona... Uroki AMOSa

• Odpowiedz

@mschulz, post #21

• Odpowiedz

@jubi, post #32

• Odpowiedz

@Goor, post #38

tak

Ostatnia aktualizacja: 25.09.2018 20:38:44 przez BULI

• Odpowiedz

@BULI, post #37

• Odpowiedz

@Krashan, post #19

Odnośnie asemblera, to w grze Benefactor jest używany fajny generator liczb pseudolosowych. W tej grze jest kilka elementów losowych jak skacząca żabka w Merry Winterland, czy wybuchające purchawki w Underworld.

Dune 2 też ma swój generator, choć tutaj raczej pochodzi z biblioteki standardowej C.

Ot, takie ciekawostki.

• Odpowiedz

@BULI, post #39

• Odpowiedz

@Krashan, post #40

Dzięki za wyjaśnienie

Swego czasu musiałem sobie taki "bardzo prosty generator" stworzyć do praktycznego pokazania szyfrowania z użyciem klucza publicznego. Skorzystałem z funkcji sczytywania czasu systemowego + jakieś wariacje na liczbach

@Hexmage960
Dobrze wiedzieć

• Odpowiedz

@Goor, post #42

• Odpowiedz

@Hexmage960, post #41

• Odpowiedz

@Hexmage960, post #41

• Odpowiedz

@MDW, post #46

add.l #1,seed ;

• Odpowiedz

@jubi, post #32

Z ciekawości spróbowałem odpalić ten skrypt na Blenderze 2.63 i niestety wywalił błąd przy drugiej linijce (import bmesh). Pech.

• Odpowiedz

@recedent, post #48

import bpy
import math
import random

def create_mesh(verts):
    mesh = bpy.data.meshes.new("mesh")
    mesh.from_pydata(verts, [], [])
    mesh.update()
    return mesh

def link_object(object):
    scene = bpy.context.scene
    scene.objects.link(object)

def create_object(object_name, verts):
    object = bpy.data.objects.new(object_name, create_mesh(verts))
    link_object(object)
    object.select = True

verts = []
scale_factor = 100

# Rozmiar planszy
(width, height) = (800, 800)

# Wysokosc trojkata
triangle_h = 600
triangle_a = int(triangle_h * 2 / math.sqrt(3))

# Koordynaty trojkata - zawsze na srodku okna
triangle = ((width/2, height/2-triangle_h/2), 
            (width/2 - triangle_a / 2, height / 2+triangle_h/2), 
            (width/2 + triangle_a / 2, height/2+triangle_h/2))

# Wylosuj pierwszy punkt
x = (random.randint(0, width-1), random.randint(0, height-1))

cnt = 0
running = True

# Glowna petla
while running:
  cnt = cnt + 1
  
  # Rysuj punkt
  verts.append((x[0]/scale_factor, x[1]/scale_factor, 0))
  
  # Wylosuj jeden z punktow trojkata
  tx = triangle[random.randint(0, 2)]

  # Oblicz nowe koordynaty
  x = ((x[0] + tx[0]) / 2, (x[1] + tx[1]) / 2)

  if cnt % 100000 == 0:
    running = False

create_object("Trojkat Sierpinskiego", verts)

• Odpowiedz

@MDW, post #46

Z tą przewidywalnością w przypadku liczb pseudo-losowych mam do czynienie praktycznie zawsze, tylko kwestia tego o czym wspomniał @asman

Wszystko zależy jaki rozkład mają mieć liczby "losowe" i jaki zakres.

Tak, że rzeczywiście, można "tym sterować".

Pamiętam, że pierwsza wersja mojego generator, tzw "ambitna", potrafiła zatkać Pentium3 800mhz na jakieś parę minut.. Wersja finalna, do prezentacji została zdegradowana tak, żeby wszystko nie trwało dłużej niż kilkadziesiąt sekund

• Odpowiedz

@jubi, post #49

Ta wersja zadziałała:

• Odpowiedz

@teh_KaiN, post #6

Wersja w E:

MODULE 	'intuition/intuition',
		'intuition/screens',
		'other/random'

ENUM 	ERR_SCREEN, ERR_WINDOW;
		
DEF wierzcholek, th, ta
DEF win_width, win_height, win_pos_x, win_pos_y;
  
DEF mywnd	= NIL:PTR TO window, myscr	= NIL:PTR TO screen, msg

OBJECT punkt
        x:INT
        y:INT
ENDOBJECT 

DEF punkty[3]:ARRAY OF punkt
DEF pStart:punkt

PROC main() HANDLE

	WriteF('Trojkat Sierpinskiego\n')
	seedRand()
	
	myscr:=LockPubScreen(NIL)
	IF myscr = NIL THEN Raise( ERR_SCREEN )
		
	win_width:=		myscr.width
	win_height:=	myscr.height - myscr.barheight - 1
	win_pos_y:=		myscr.barheight + 1
	win_pos_x:=		0
	
	UnlockPubScreen(NIL,myscr)

	th:= win_height-4
	ta:= ! 2.0 * th / 1.7320508
	
	punkty[0].x := win_width/2
	punkty[0].y := (win_height-th)/2
	
	punkty[1].x := (win_width-ta)/2+ta
	punkty[1].y := (win_height-th)/2+th
	
	punkty[2].x := (win_width-ta)/2
	punkty[2].y := (win_height-th)/2+th
	
	mywnd:=OpenW (	win_pos_x, win_pos_y, win_width, win_height ,
			IDCMP_RAWKEY, WFLG_ACTIVATE OR WFLG_BORDERLESS,
			NIL, NIL, 1, NIL)
			
	IF mywnd = NIL THEN Raise( ERR_WINDOW )
	
	pStart.x := getRandRange(win_width-1)
	pStart.y := getRandRange(win_height-1)
	
	REPEAT
		/* 	jedynym mozliwym messagem jest IDCMP_RAWKEY,
			wiec liczymy do pierwszego message'a 			*/
		msg:=GetMsg (mywnd.userport)
		
		wierzcholek := getRandRange(3)
		
		pStart.x := (pStart.x+punkty[wierzcholek].x)/2 
		pStart.y := (pStart.y+punkty[wierzcholek].y)/2
		
		Plot(pStart.x,pStart.y, 1)
	
	UNTIL msg <> NIL
	
	CloseW( mywnd )
	
  EXCEPT

	SELECT exception
		CASE ERR_SCREEN ; WriteF ('Error LockPubScreen()\n')
		CASE ERR_WINDOW ; WriteF ('Error OpenW()\n')
	ENDSELECT

    IF mywnd	<> NIL THEN CloseW(mywnd)
    IF myscr	<> NIL THEN UnlockPubScreen(NIL,myscr)
	
ENDPROC

Binarka z powyższego 2488 bajtów, jak najbardziej do optymalizacji, a i obsługa wyjątków pewnie niepotrzebna w takim zadaniu.



Ostatnia aktualizacja: 26.09.2018 22:19:54 przez vojo

• Odpowiedz

@vojo, post #52

• Odpowiedz

@peceha, post #53

• Odpowiedz

@peceha, post #53

• Odpowiedz

@retronav, post #55

• Odpowiedz

@peceha, post #56

Dobra panowie. Troche sie z kodem jeszcze pobawilem:

1. Zamienilem zmienna globalna SysBase na *(struct ExecBase **)4UL. Jest lepiej ale nieoptymalnie bo kompilator rozbija to na 2 instrukcje zamiast jednej.
2. Kod startowy zwraca wynik funkcji main do systemu
3. Generator liczb pseudolosowych zwraca typ UWORD zamiast ULONG
4. Struktura Punkt ma koordynaty typu LONG (Takiego oczekuje graphics.library w swoich funkcjach) zamiast UWORD
5. IntuiMessage->Class jest sprawdzane bezposrednio, dopiero potem jest ReplyMsg
6. Modulo zastapilem mnozeniem. Poniewaz mozna zalozyc ze liczby losowe pojawiaja sie z rownym prawdopodobienstwem mozna zamiast:

UWORD x = rand() % WINDOW_WIDTH;

napisac

UWORD x = (rand() * WINDOW_WIDTH) >> 16;

Dla takiej samej wartosci startowej seed rozklad bedzie inny ale powinien byc rownie prawdopodobny.

Po tych zmianach plik wynikowy sie skurczyl do 996 bajtow (nadal mozna uruchomic z workbencha). Do pobrania tutaj: link

Screenshot z programu:


Kod dalej wymaga 68020 z powodu generatora liczb losowych. Kompilowane za pomoca gcc od bebbo:

m68k-amigaos-gcc -noixemul -Os -m68020 -nostartfiles -fno-inline -o dywan main.c

Rozmiar binarki moze sie jeszcze zmniejszyc/zwiekszyc w zaleznosci od rozmiar otwartego okna. Jak rozmiar bedzie potega dwojki to binarka sie jeszcze skurczy do 964 bajtow...
Mozna by optymalizowac dalej ale juz mi sie nie chce :)

Kod:

#include <exec/types.h>
#include <exec/execbase.h>
#include <intuition/intuition.h>
#include <intuition/screens.h>
#include <workbench/startup.h>
#include <graphics/gfxbase.h>
#include <graphics/gfx.h>
#include <dos/dos.h>
#include <dos/dosextens.h>
#include <proto/exec.h>
#include <proto/graphics.h>
#include <proto/intuition.h>
#include <utility/tagitem.h>

#undef SysBase
#define SysBase (*(struct ExecBase **)4)

int main(void);

/* Minimalny kod startowy */
int _start(void)
{
    struct Process *p = NULL;
    struct WBStartup *wbmsg = NULL;
    int ret;

    p = (struct Process *)SysBase->ThisTask;

    if (p->pr_CLI == 0)
    {
        WaitPort(&p->pr_MsgPort);
        wbmsg = (struct WBStartup *)GetMsg(&p->pr_MsgPort);
    }

    ret = main();

    if (wbmsg)
    {
        Forbid();
        ReplyMsg((struct Message *)wbmsg);
    }

    return ret;
}

#define WINDOW_WIDTH    400
#define WINDOW_HEIGHT   400
#define TRIANGLE_H      (WINDOW_HEIGHT * 4 / 5)
#define TRIANGLE_A      (TRIANGLE_H * 2 * 1000 / 1732)

ULONG seed = 1;

UWORD rand(void)
{
    seed = ((seed * 1103515245) + 12345) & 0x7fffffff;
    return seed;
}

struct Point {
    LONG x;
    LONG y;
};

struct Point points[3] = {
    { WINDOW_WIDTH / 2, WINDOW_HEIGHT / 2 - TRIANGLE_H / 2 },
    { WINDOW_WIDTH / 2 - TRIANGLE_A / 2, WINDOW_HEIGHT / 2 + TRIANGLE_H / 2 },
    { WINDOW_WIDTH / 2 + TRIANGLE_A / 2, WINDOW_HEIGHT / 2 + TRIANGLE_H / 2 }
};

struct TagItem myWindowTags[] = {
    { WA_InnerWidth, WINDOW_WIDTH },
    { WA_InnerHeight, WINDOW_HEIGHT },
    { WA_DepthGadget, TRUE },
    { WA_CloseGadget, TRUE },
    { WA_DragBar, TRUE },
    { WA_Title, (Tag) "Dywan" },
    { WA_Activate, TRUE },
    { WA_GimmeZeroZero, TRUE },
    { WA_IDCMP, IDCMP_MOUSEBUTTONS | IDCMP_CLOSEWINDOW },
    { TAG_DONE, 0UL }
};

int main(void)
{
    struct IntuitionBase * IntuitionBase = NULL;
    struct GfxBase * GfxBase = NULL;

    IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library", 0);
    
    if (IntuitionBase != NULL)
    {
        GfxBase = (struct GfxBase *)OpenLibrary("graphics.library", 0);

        if (GfxBase != NULL)
        {
            struct Window *myWindow = OpenWindowTagList(0, myWindowTags);
            
            if (myWindow != NULL)
            {
                struct RastPort *rastPort = myWindow->RPort;
                BYTE running = TRUE;
                SetAPen(rastPort, 1);

                /* Wylosuj pierwszy punkt */
                ULONG x = (rand() * WINDOW_WIDTH) >> 16;
                ULONG y = (rand() * WINDOW_HEIGHT) >> 16;

                Move(rastPort, points[0].x, points[0].y);
                Draw(rastPort, points[1].x, points[1].y);
                Draw(rastPort, points[2].x, points[2].y);
                Draw(rastPort, points[0].x, points[0].y);

                do {
                    struct IntuiMessage *msg;

                    while ((msg = (struct IntuiMessage *)GetMsg(myWindow->UserPort)) != 0)
                    {
                        if (msg->Class == IDCMP_CLOSEWINDOW)
                        {
                            running = FALSE;
                        }

                        ReplyMsg((struct Message *)msg);
                    }

                    /* Wylosuj punkt trojkata */
                    UWORD p = (rand() * 3) >> 16;

                    x = (x + points[p].x) / 2;
                    y = (y + points[p].y) / 2;

                    WritePixel(rastPort, x, y);

                } while(running == TRUE);

                CloseWindow(myWindow);
            }

            CloseLibrary((struct Library *)GfxBase);
        }

        CloseLibrary((struct Library *)IntuitionBase);
    }

    return 0;
}

Ostatnia aktualizacja: 27.09.2018 09:24:14 przez mschulz

• Odpowiedz

@mschulz, post #57

• Odpowiedz

@mschulz, post #58

• Odpowiedz

@mschulz, post #57

if (IntuitionBase != NULL)
    {
        GfxBase = (struct GfxBase *)OpenLibrary("graphics.library", 0);

        if (GfxBase != NULL)
        {
            struct Window *myWindow = OpenWindowTagList(0, myWindowTags);
            
            if (myWindow != NULL)
            {

• Odpowiedz