ZombieApostate fucked around with this message at 17:20 on Feb 8, 2023

Ihmemies fucked around with this message at 17:54 on Feb 8, 2023

jizzy sillage fucked around with this message at 23:10 on Feb 8, 2023

public class Pinsetter : MonoBehaviour
{

    public GameObject pinPrefab;
    public List<Transform> spawnPoints = new List<Transform>();
    private Vector3 offet = new Vector3(5.32f, -2.5f, -1.2f);


    public void spawnNewPins()
    {

        foreach(Transform spawnPoint in spawnPoints)
        GameObject.Instantiate(pinPrefab, (spawnPoint.position + offet), Quaternion.Euler(0,90,0));
       

    }


        
}

public class Joints : MonoBehaviour
{

    public ConfigurableJoint joint;
    private List<Transform> pinList;

    void Start()
    {
        var pinsetter = new Pinsetter();
    }


    void OnCollisionEnter(Collision col)
    {

        if(col.gameObject.CompareTag("ball"))
        {

            JointDrive jointDrive = joint.angularYZDrive;
            jointDrive.positionDamper = 70f;
            jointDrive.positionSpring = 5f;
            joint.angularYZDrive = jointDrive;
            
            //remove item from list from pinsetter here
            //so Remove(this.transform.root.gameObject) from the list here. 

        }

        if(col.gameObject.CompareTag("deahplane"))
        {

            Destroy(this.transform.root.gameObject);

        }

    }
    
}

Dr Jankenstein fucked around with this message at 04:22 on Feb 9, 2023

var go = GameObject.Instantiate(somePrefab);
var pinsetter = go.GetComponent<Pinsetter>();

var pinsetter = go.AddComponent<Pinsetter>();

public Pinsetter pinsetter;

void Awake()
{
    pinsetter = GameObject.Find("NameOfSomeObjInTheScene").GetComponent<Pinsetter>();
}

full point fucked around with this message at 07:17 on Feb 9, 2023

# the ontological concept of "lists" are, in python, an object of type "type"
>>> list
<class 'list'>
>>> list.__class__
<class 'type'>

# in python you can instantiate a thing by ()ing it, which calls its constructor, which in python is __init__ / __new__
>>> list()
[]
# the result of initializing it is an instance of it
>>> list().__class__
<class 'list'>

var pinsetter = GameObject.AddComponent<Pinsetter>(); // your code, GameObject here is "the concept  of GameObject"

// https://docs.unity3d.com/ScriptReference/GameObject-ctor.html
// you probably want to call "the GameObject constructor" which will return an instance of GameObject
GameObject yourThing = new GameObject();
yourThing.AddComponent<Pinsetter>();

12 rats tied together fucked around with this message at 23:00 on Feb 9, 2023

Ihmemies fucked around with this message at 23:08 on Feb 9, 2023

Ihmemies fucked around with this message at 09:02 on Feb 10, 2023

func generate_biomes() -> void:
    var fnl = FastNoiseLite.new()
    fnl.noise_type = FastNoiseLite.TYPE_PERLIN
    fnl.seed = randi()
    fnl.frequency = 0.1
    fnl.fractal_type = FastNoiseLite.FRACTAL_FBM
    fnl.fractal_octaves = 3
    fnl.fractal_lacunarity = 1
    fnl.fractal_gain = 1.746
  
    var water_next_to_tile:bool = false
  
    for y in map_tile_data.size():
        for x in map_tile_data[y].size():      
              
            # replace non-water with biomes          
            if map_tile_data[y][x] > 0:  
                water_next_to_tile = false
              
                # don't put forest next to water
                for dir in directions:
                    if (y+dir.y >= Globals.map_image_size.y) or (x+dir.x >= Globals.map_image_size.x):
                        continue
                    if map_tile_data[y+dir.y][x+dir.x] == Globals.TILE_WATER:
                        water_next_to_tile = true
              
                # if there's no water next to a land tile, it can be replaced with forest
                if !water_next_to_tile:
                    var noise_sample = fnl.get_noise_2d(x,y)
                    if noise_sample < 0.1:
                        count += 1
                        map_tile_data[y][x] = Globals.TILE_FOREST   

Ihmemies fucked around with this message at 16:33 on Feb 10, 2023

Ihmemies fucked around with this message at 13:17 on Feb 12, 2023

func generate_chunk() -> void:	
	for row in Globals.CHUNK_SIZE:
		for col in Globals.CHUNK_SIZE:
			var tile_data: Array = var tile_data: Array = Globals.map_tile_data[row+y*Globals.CHUNK_SIZE][col+x*Globals.CHUNK_SIZE]
			# layer | tile coords at tilemap | tilemap id | coords of the tile at tileset | alternative tile
			self.set_cell(
				Globals.LAYER_TERRAIN,
				Vector2i(col, row),
				0,
				tile_data[0],
				tile_data[1]
			)

[(25, 0), 0] 0 0
[(20, 0), 0] 0 1
[(5, 0), 0] 0 2
[(1, 0), 2] 0 3
[(0, 0), 2] 1 0
[(18, 0), 0] 1 1
[(1, 0), 1] 1 2
[(1, 0), 2] 1 3
[(19, 0), 0] 2 0
[(1, 0), 3] 2 1
[(1, 0), 3] 2 2
[(1, 0), 1] 2 3
[(18, 0), 0] 3 0
[(1, 0), 0] 3 1
[(13, 0), 0] 3 2
[(1, 0), 2] 3 3

	var ts: TileSet = load("res://scenes/Chunk.tres")
	self.set_tileset(ts)

Ihmemies fucked around with this message at 22:23 on Feb 12, 2023

var chunk_queue:Array = []
var mutex:Mutex
var thread:Thread

func _ready():
	mutex = Mutex.new()
	thread = Thread.new()
	thread.start(test_func(), Thread.PRIORITY_NORMAL)

func test_func():
	while true:
		if chunk_queue.size() > 0:
			mutex.lock()
			var vars = chunk_queue.pop_back()
			mutex.unlock()
			add_chunk(vars.x, vars.y)

mutex.lock()
chunk_queue.push_front(Vector2i(x, y))
mutex.unlock()

Ihmemies fucked around with this message at 20:38 on Feb 13, 2023

Ihmemies fucked around with this message at 09:48 on Feb 14, 2023