Search results for query: *

  1. 33rd Free Company

    33rd!!

  2. Dedicated server version error with 1.103

    Awesome, thanks for the quick reply!

  3. Dedicated server version error with 1.103

    Tried to update server. Running version I got from here: http://download.taleworlds.com/mb_warband_napoleonic_wars_dedicated_1157_nw_1103.zip Clients get this error: This server is running an older version (1.102) of the current module than the one you are running (1.103). Halp!

  4. Ban Request! 1stRddt_F33_Disgrntld

    I'd like to submit some more evidence. It seems that at the same time pets was capturing evidence of me being some kind of TK nuisance, I was capturing a screenshot of me
    nIu4v.jpg
    .

  5. Ban Request! 1stRddt_F33_Disgrntld

    If what you say is true, then surely there won't be a significant delay between the events, right?

    So lets just wait for the logs.

  6. Ban Request! 1stRddt_F33_Disgrntld

    I clearly apologized. Why would you think the "get owned" was directed towards you?

  7. Napoleonic Wars: Official Scening Contest - Vote Now!

    rapier17, I think you're missing a little bit of information about the game engines that would clear up your copyright concern and maybe allow you to appreciate my scene more. Namely, it is impossible to copy a map from the Half-Life or Source engine into the Mount and Blade engine.

    This is because, unlike most FPSs, Mount and Blade scenes don't make use of BSP to store a series of brushes. Mount and Blade maps are composed entirely of a heightmap and a series of entities. Furthermore, to add a custom entity, one has to create a separate mod. This means that to have a Napoleonic Wars-compatible scene, one is limited to only the Napoleonic Wars entities. It also means that things like indoor areas (aside from the pre-built house entities) are modelled inherently different than in most FPSs.

    So the nature of the work is fundamentally different, it literally can't share any amount of the copyrighted work, and it doesn't decrease the value of said work. Aside from the €25 I'm abiding by all four of the United States fair use doctrines and if need be I'll graciously refuse to be commercially compensated to be sure.

    Now as for arguing that the results of a community vote will be skewered, skewered towards whom? Won't the results be skewered proportionately towards the clans, gaming groups, etc. that constitute the community? If 20% of the votes are skewered towards one group, do you feel like somehow that group makes up less than 20% of the community or do you just think that certain groups' views aren't as important to consider?

  8. Napoleonic Wars: Official Scening Contest - Vote Now!

    9syRo.gif

  9. Napoleonic Wars: Official Scening Contest Submissions

    Name as you like it in the game credits: Levi Wiseman
    Contact information (Preferably steam): Disgrntld

    Information
    Scene Name: Dust2 Homage
    Description: Port of classic Counter-Strike map
    Supported Gamemodes: Battle, TDM, DM, Duel
    Download link: https://dl.dropbox.com/u/70112191/map/scn_mp_arabian_village.sco
    Codes as found in scenes.txt:
    Code: 
    scn_mp_arabian_village mp_arabian_village 256 none none 0.000000 0.000000 100.000000 100.000000 -100.000000 0x0000000050000000000310c4000000000000000000000000 
  0 
  0 
 outer_terrain_desert_b
    Link to topic: http://forums.taleworlds.com/index.php/topic,238775.0.html

    Showcase your map
    Birds Eye-View:
    eaPcy.jpg
    Others:
    oDnnD.jpg
    WvOcX.jpg
    QPPNF.jpg
    GeH2g.jpg

  10. [Map] Disgrntld's dust2 homage

    Haha, glad you approve! I'm sure there's still some bugs, but I thought it was time for some feedback.

  11. [Map] Disgrntld's dust2 homage

    Name as you like it in the game credits: Levi Wiseman Contact information (Preferably steam): Disgrntld Information Scene Name: Dust2 Homage Description: Port of classic Counter-Strike map Supported Gamemodes: Battle, TDM, DM, Duel Download link...

  12. DO NOT BUY THE MOUNT & BLADE COLLECTION PACK

    Of course it's fraud. Fraud: Wrongful or criminal deception intended to result in financial or personal gain. They offered a product and reneged on said offer after taking money. That said, it doesn't seem malicious and it doesn't really matter anyway seeing how we've only bought licenses from Steam and if you did anything serious about it (charge-back, file suit) they'd just revoke all your licenses (i.e. your entire Steam library).

    Welcome to the world of digital distribution!

  13. Scene .SCO Toolset - heightmap converters, object placers, and texture importers! Oh my!

    :lol: Thanks for the kind words, Swyter, but I'm still ignorant about a lot of the gory, projective space details. Specifically, I was trying to transform the stairs in the colosseum example into more of a trapazoidal shape so they would fit without gaps. As it stands, I just plugged the holes with barriers. :neutral:



    xenoargh, I agree, performance might suffer if we get too overzealous with objects. I haven't looked into generating BRFs that much because I don't know if we can add them to existing mods (which is what I'm interested in)? Also, that Recast sounds very close to what you were looking for with the AI mesh stuff! If I have some free time I might try to dive into mtarini's BRF domain and see how Recast might fit into all this.

  14. Scene .SCO Toolset - heightmap converters, object placers, and texture importers! Oh my!

    It was kind of a pain to fill out the mission_object_t structs so I added a matrix transformation API similar to OpenGL. However, I believe it's limited to affine transformations as we don't transform the vertices ourselves but rather define a frame for the Mount&Blade engine to transform them later. Since this frame is non-homogeneous, I think all projective transformations are lost in place_object. If someone who can math better than me would clear that up though, I'd really appreciate it.

    Anyway, here's the link and some examples:

    Colosseum -
    F7F4DF7B86CB6172C9D7ACFFE45A2288335788E8
    A9E0272C598240434581DE108E10650CCCD1CD5A
    D6A523F741E6E418D29E15C2159BD5B68B76FF35
    Code: 
    #include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "scoReader.h"
#include "scoWriter.h"
#include "affine.h"

int main(int argc, char **argv)
{
	if(argc < 3)
	{
		printf("Usage: %s input heightmap output\n", argv[0]);
		return EXIT_FAILURE;
	}

	FILE *in = fopen(argv[1], "rb");
	FILE *out = fopen(argv[2], "wb");

	if(!in || !out)
	{
		printf("ERROR: file(s) not found\n");
		return EXIT_FAILURE;
	}

	printf("Reading %s\n", argv[1]);
	sco_file_t sco_file;
	read_sco_file(in, &sco_file);

	stack_t *stack = affine_init();

	translate(stack, 310, 277, 33.23);
	rotate(stack, -11 * M_PI / 16, 0, 0, 1);
	int lcv1, lcv2;
	int n;
	int h;
	// facade
	n = 57;
	h = 3;
	for(lcv1 = 0; lcv1 < h; ++lcv1)
	{
		push_affine_matrix(stack);
			for(lcv2 = 0; lcv2 < n; ++lcv2)
			{
				push_affine_matrix(stack);
					rotate(stack, 2 * M_PI * lcv2 / n, 0, 0, 1);
					translate(stack, 50, 0, 9 * lcv1);
					rotate(stack, -M_PI / 2, 0, 0, 1);
					place_object(&sco_file, "spr_bridge_modular_a", stack);
				pop_affine_matrix(stack);
			}
		pop_affine_matrix(stack);
	}
	// walls
	n = 19;
	for(lcv1 = 0; lcv1 < n; ++lcv1)
	{
		push_affine_matrix(stack);
			rotate(stack, 2 * M_PI * lcv1 / n, 0, 0, 1);
			for(lcv2 = 0; lcv2 < 3; ++lcv2)
			{
				push_affine_matrix(stack);
					translate(stack, 49 - 8 * lcv2, 0, 19 - 6.4 * lcv2);
					rotate(stack, -M_PI / 2, 0, 0, 1);
					rotate(stack, M_PI / 2, 1, 0, 0);
					scale(stack, (49 - 8 * lcv2) / 100.0f, 0.5, 0.5);
					place_object(&sco_file, "spr_arena_wall_a", stack);
				pop_affine_matrix(stack);
				if(lcv2 == 2)
				{
					push_affine_matrix(stack);
						translate(stack, 32.5, 5.5, 10.77);
						scale(stack, 5, 5, 4);
						place_object(&sco_file, "spr_barrier_capsule", stack);
					pop_affine_matrix(stack);
				}
				if(lcv1 == 0 && lcv2 == 2)
					continue;
				push_affine_matrix(stack);
					translate(stack, 46 - 8 * lcv2, 0, 19 - 6.4 * lcv2);
					rotate(stack, -M_PI / 2, 0, 0, 1);
					scale(stack, 2, 1, 1);
					place_object(&sco_file, "spr_stairs_a", stack);
				pop_affine_matrix(stack);
				push_affine_matrix(stack);
					translate(stack, 50 - 8 * lcv2, 0, 20 - 6.4 * lcv2);
					rotate(stack, -M_PI / 2, 0, 0, 1);
					scale(stack, (50 - 8 * lcv2) / 100.0f, 0.5, 0.4);
					place_object(&sco_file, "spr_arena_wall_a", stack);
				pop_affine_matrix(stack);
			}
			if(lcv1 == 0)
				continue;
			for(lcv2 = 0; lcv2 < 2; ++lcv2)
			{
				push_affine_matrix(stack);
					translate(stack, 34, 0, 0.8 - 6.4 * lcv2);
					rotate(stack, -M_PI / 2, 0, 0, 1);
					scale(stack, 0.34, 0.5, 0.4);
					place_object(&sco_file, "spr_arena_wall_a", stack);
				pop_affine_matrix(stack);
			}
		pop_affine_matrix(stack);
	}
	// inner ring
	n = 12;
	for(lcv1 = 0; lcv1 < n; ++lcv1)
	{
		push_affine_matrix(stack);
			rotate(stack, 2 * M_PI * lcv1 / n, 0, 0, 1);
			translate(stack, 24, 0, 0);
			rotate(stack, -M_PI / 2, 0, 0, 1);
			place_object(&sco_file, "spr_arena_barrier_b", stack);
			translate(stack, 3, 0, 6.27);
			place_object(&sco_file, "spr_castle_f_wall_way_a", stack);
			translate(stack, -6, 0, 0);
			place_object(&sco_file, "spr_castle_f_wall_way_a", stack);
		pop_affine_matrix(stack);
		push_affine_matrix(stack);
			rotate(stack, 2 * M_PI * lcv1 / n, 0, 0, 1);
			translate(stack, 29, 0, 0);
			rotate(stack, -M_PI / 2, 0, 0, 1);
			place_object(&sco_file, "spr_arabian_wall_b", stack);
		pop_affine_matrix(stack);
	}
	// stairs
	push_affine_matrix(stack);
		translate(stack, 37.5, 5, -2);
		for(lcv1 = 0; lcv1 < 5; ++lcv1)
		{
			push_affine_matrix(stack);
				translate(stack, 0, -2.5 * lcv1, 0);
				rotate(stack, M_PI, 0, 0, 1);
				place_object(&sco_file, "spr_arabian_castle_stairs", stack);
			pop_affine_matrix(stack);
		}
	pop_affine_matrix(stack);

	affine_free(stack);

	printf("Writing %s\n", argv[2]);
	write_sco_file(out, &sco_file);

	return EXIT_SUCCESS;
}
    Jousting lanes -
    8F0B94CC1509CF7755999048C7BBB4F00FBEEAA4
    Code: 
    #include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "scoReader.h"
#include "scoWriter.h"
#include "affine.h"

int main(int argc, char **argv)
{
	if(argc < 3)
	{
		printf("Usage: %s input heightmap output\n", argv[0]);
		return EXIT_FAILURE;
	}

	FILE *in = fopen(argv[1], "rb");
	FILE *out = fopen(argv[2], "wb");

	if(!in || !out)
	{
		printf("ERROR: file(s) not found\n");
		return EXIT_FAILURE;
	}

	printf("Reading %s\n", argv[1]);
	sco_file_t sco_file;
	read_sco_file(in, &sco_file);

	stack_t *stack = affine_init();

	int w = 4;
	int l = 9;
	int lcv1, lcv2;
	translate(stack, 40, 130, 3.1);
	rotate(stack, (90 - 77) * M_PI / 180, 0, 0, 1);
	rotate(stack, asin(1.2 / (8 * l)), 1, 0, 0);
	// width
	push_affine_matrix(stack);
		translate(stack, 4, 0, 0);
		for(lcv1 = 0; lcv1 < w; ++lcv1)
		{
			for(lcv2 = 0; lcv2 < 2; ++lcv2)
			{
				push_affine_matrix(stack);
					translate(stack, 8 * lcv1, 8 * l * lcv2, 0);
					place_object(&sco_file, "spr_railing_a", stack);
				pop_affine_matrix(stack);
			}
		}
	pop_affine_matrix(stack);
	// length
	push_affine_matrix(stack);
		translate(stack, 0, 4, 0);
		for(lcv1 = 0; lcv1 < l; ++lcv1)
		{
			for(lcv2 = 0; lcv2 < 2; ++lcv2)
			{
				push_affine_matrix(stack);
					translate(stack, 8 * w * lcv2, 8 * lcv1, 0);
					rotate(stack, M_PI / 2, 0, 0, 1);
					place_object(&sco_file, "spr_railing_a", stack);
				pop_affine_matrix(stack);
			}
		}
		for(lcv1 = 0; lcv1 < w - 1; ++lcv1)
		{
			for(lcv2 = 0; lcv2 < l - 2; ++lcv2)
			{
				push_affine_matrix(stack);
					translate(stack, 8 * (lcv1 + 1), 8 * (lcv2 + 1), 0);
					rotate(stack, M_PI / 2, 0, 0, 1);
					place_object(&sco_file, "spr_railing_a", stack);
				pop_affine_matrix(stack);
			}
		}
	pop_affine_matrix(stack);

	affine_free(stack);

	printf("Writing %s\n", argv[2]);
	write_sco_file(out, &sco_file);

	return EXIT_SUCCESS;
}

  15. Scene .SCO Toolset - heightmap converters, object placers, and texture importers! Oh my!

    Awesome, cmpxchg8b! How'd you do that?!

  16. Scene .SCO Toolset - heightmap converters, object placers, and texture importers! Oh my!

    Yea, it's a pain, especially like in your case where you want to start from the generated terrain. One thing that could be done for people who want flat maps though, is generate a few different sized terrains, flatten them out, and package them with their code as a sort of starter pack. Who knows, maybe someone else can even help us decipher how to make our own generator that we could use for both workflows.

  17. Scene .SCO Toolset - heightmap converters, object placers, and texture importers! Oh my!

    We discussed ways around this earlier in the thread, xenoargh:
    From my understanding, the terrain code defines a procedurally-generated base terrain, call it A. The SCO file contains the modification terrain, B, that when added to A produces the final terrain, C. So, C = A + B.

    With scoWriter, we can modify B. However, we want our heightmap to define C. Well that sounds simple enough to fix, we think. We'll just subtract A from the heightmap before we dump it in (B = heightmap - A && C = A + B => C = heightmap). Alas, that's the rub. We don't have A. It's generated by code we're not privy to. This mean that there will be small undulations in C.

    I did think of a way around that, though. We use the Mount&Blade editor to flatten our terrain. These terrain modifications are stored in B, and the end result is B = -A.
    Click to expand...
    If you don't care about a completely flat base you can get pretty close by lowering hill height and not have to worry about creating -A.

  18. Scene .SCO Toolset - heightmap converters, object placers, and texture importers! Oh my!

    This is kind of World Machine specific, but try the following:
    Code: 
    // 100 is the max height in-game, 886 is the max height used in your terrain software, 2625 is the max height available in your terrain software, and 1 is the water depth
sco_file.ground_paint->layers[lcv].cells[x * sco_file.ground_paint->size_y + y] += 100.0f * 886.0f / 2625.0f * r / 255.0f - 1.0f;
    The idea is to convert discrete terrain generation values into the desired, continuous range in-game. Basically, after you've finished with your terrain in World Machine, add a Clamp device and click Find Extents to determine the max height used (886 in the example). Next, click the World Extents and Resolution button and the max height available will be under the General Setup tab. Then, right before your Height Output device, add an Equalizer device. This will allow you to use all the precision available.

    The ratio, 886/2625, will rescale the discrete, equalized values into the appropriate, continuous range from 0-1. Multiply by the range of height you want in-game (100 in this case, the units seem on par with meters), and subtract it to the water depth you want (I think below 2 is deep enough to fully submerge players).

  19. Scene .SCO Toolset - heightmap converters, object placers, and texture importers! Oh my!

    The main reason I wanted it, Comrade Temuzu, was to utilize terrain generation programs like World Machine.

    EDIT #1: For example, everything in this was made from this and the object placer example.

    EDIT #2: cmpxchg8b and Swyter, I applied for this to be moved to the Unofficial Editing Tools sub-forum. We're going to be famous! ;P

  20. Scene .SCO Toolset - heightmap converters, object placers, and texture importers! Oh my!

    Done, Swyter!

    Also, I dunno if you're interested in adding texture importing too, but here's what I used:
    Code: 
    void set_layer(ground_paint_t *ground_paint, int layer, tga_data_t *map)
{
	int max = ground_paint->size_x * ground_paint->size_y;

	if(ground_paint->layers[layer].cells == NULL) {
		ground_paint->layers[layer].continuity_count = malloc((max + 1) * sizeof(int));
		ground_paint->layers[layer].cells = malloc(max * sizeof(float));
	}

	ground_paint->layers[layer].continuity_count[0] = max;
	ground_paint->layers[layer].continuity_count[max] = 0;

	int x, y;
	for(y = 0; y < ground_paint->size_y; ++y)
	{
		for(x = 0; x < ground_paint->size_x; ++x)
		{
			int offset = (y * map->w + x) * map->depth / 8;
			short int r = map->data[offset];
			short int g = map->data[offset + 1];
			short int b = map->data[offset + 2];
			if(r != g || g != b) {
				printf("ERROR: map was not grayscale\n");
				return;
			}
			ground_paint->layers[layer].cells[x * ground_paint->size_y + y] = r / 255.0f;
		}
	}
}
    It doesn't make use of the autofill functionality yet, but it doesn't seem like that would affect performance that much, just file size. Also, it shows how to use the convention of adding the autofill number to the extra space I left at the end of continuity_count (which was why I modified scoReader, to be able to remember whether the read texture values were autofilled or not).
Back
Top Bottom